How to Set Up the

Fluidity Parameter γ of
the Hoek-Brown Model
with the Softening Model

Richard Witasse
Principal Product Manager,
Geotechnical,
Bentley Systems
Introduction
In the framework of numerical analyses of geomaterials, one of the classical problems for modeling the
development of shear bands is the pathological mesh-dependence of the computed solution which
implies failure without energy dissipation. To avoid this unphysical behavior, an internal length must be
introduced to govern the evolution of the shear band thickness in the post-peak regime of the material
response.

More specifically, it is well known that introducing too large a difference between the dilatancy angle
𝜓𝜓𝑚𝑚𝑚𝑚𝑚𝑚 and the equivalent friction angle 𝜑𝜑𝑒𝑒𝑒𝑒 will lead to a mesh-dependent solution which then will be
almost systematically associated with:

• Numerical convergence difficulties, and

• Potentially convergence toward an incorrect solution.

The numerical solution then becomes ill-posed and the conditioning of the numerical solution further
worsens as the difference between the dilatancy angle and the friction angle increases or as the element
size in which shear bands develop as a result of shear failure becomes smaller.

In this context, the Hoek-Brown with softening (HBS) model uniquely proposes a feature to restore
the mesh-objectivity of the numerical solution through a visco-plastic regularization based on the
over-stress theory of Perzyna, thus enabling the introduction of an internal length through a temporal
gradient. The use of the viscous regularization technique in the Hoek-Brown model with softening
is a definite advantage when one wants to consider a high level of non-associativity and maintained
mesh-objective solution as shear plastic strains further develop.

This modeling technique requires the introduction of:

• A loading rate which is created by associating a physical time duration in the calculation phase
this technique is introduced.
• An extra model parameter called the fluidity γ (which is the inverse of a viscosity) that needs to
be properly calibrated in relation to the previously introduced rate of loading.

The idea is to simulate a circular tunnel excavation in an infinite Hoek-Brown medium subjected to an
in-situ isotropic stress field 𝜎𝜎0 . Using a given set of HBS model parameters, this simple excavation
analysis will be run multiple times, each time with a different value for the fluidity γ (all other model
parameters remaining constant, of course). Once all runs are terminated, the radial stress evolution
over the radius can be plotted and the influence of the fluidity parameter in terms of stress
development can be properly evaluated and quantified.

Most specifically, we are interested in the computation of the stress evolution over the plastic radius
surrounding the excavated area. The plastic radius can be evaluated from the closed form solution
provided by Carranza-Torres and Fairhurst (1999).

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 2

The scaled far-field stresses, S0, and scaled internal pressure, Pi, are determined by:

𝜎𝜎0 𝑠𝑠 𝑝𝑝𝑖𝑖 𝑠𝑠
𝑆𝑆0 = + 2 and 𝑃𝑃𝑖𝑖 = + 2
𝑚𝑚𝑏𝑏 𝜎𝜎𝑐𝑐𝑐𝑐 𝑚𝑚𝑏𝑏 𝑚𝑚𝑏𝑏 𝜎𝜎𝑐𝑐𝑐𝑐 𝑚𝑚𝑏𝑏

Where 𝜎𝜎0 is the initial stress in the rock and 𝑝𝑝𝑖𝑖 the support pressure onto the excavation circular
contour. Then the scaled critical internal pressure, 𝑃𝑃𝑖𝑖𝑐𝑐𝑐𝑐 , at which the elastic limit of the stress state
is reached, can be calculated as:

1 2
𝑃𝑃𝑖𝑖𝑐𝑐𝑐𝑐 = �1 − �1 + 16𝑆𝑆0 �
16

The critical internal pressure, 𝑝𝑝𝑖𝑖𝑐𝑐𝑐𝑐 , is then:

𝑠𝑠
𝑝𝑝𝑖𝑖𝑐𝑐𝑐𝑐 = �𝑃𝑃𝑖𝑖𝑐𝑐𝑐𝑐 − � 𝑚𝑚𝑏𝑏 𝜎𝜎𝑐𝑐𝑐𝑐
𝑚𝑚𝑏𝑏2

A plastic region developing uniformly around the hole will develop only if 𝑝𝑝𝑖𝑖𝑐𝑐𝑐𝑐 is larger than the
supporting pressure. The extent of the failure zone is:

𝑟𝑟𝑝𝑝𝑝𝑝 = 𝑟𝑟.exp �2 ��𝑃𝑃𝑖𝑖𝑐𝑐𝑐𝑐 − �𝑃𝑃𝑖𝑖 ��

Setting up the PLAXIS model

The PLAXIS model created will be an axisymmetric model corresponding to a very thin slice of the
cylindrical hole in the rock mass (see Figure 1). A thickness of 0.1 m is perfectly sufficient. The idea is to
have a calculation that runs as quickly as possible. The tunnel will be placed vertically, but as the initial
stresses will be set by the stress field feature, there will be no need for gravity forces to be accounted
for during initial stress definition, and unit weight for the rock mass could be set to 0. A circular tunnel
of radius r will then be excavated with an applied supporting pressure pi.

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 3

The radius r corresponds to the equivalent radius of the considered tunnel cross section (which might
not necessarily be circular). In that case, if A is the excavated area of the real tunnel, then:

𝑟𝑟 = �𝐴𝐴⁄𝜋𝜋

R has to be sufficiently large to avoid boundary effects. For instance, R = 5 rpl could be accounted for.

pi

Figure 1: Model geometry of axisymmetric tunnel analysis.

Project properties will define the model contour ranging from xmin = 0 to xmax = R. For the vertical model
extent, one can define ymin = -0.1 to ymax = 0.

One soil borehole containing a single layer ranging from 0 down to -0.1 m could then be introduced.
Place the water level at an arbitrary low level to ensure the soil formation will remain dry (for instance,
Head = -1 m).

Soil material properties are defined using the user-defined soil model HB-GSM or HB-SSM contained in
the hbs64.dll. The drainage type will be Drained. It is important to set both saturated and unsaturated
unit weight to zero as previously explained. Model parameters should then be defined by the user.
Note that each fluidity value that the user is willing to investigate should lead to the definition of a
new material set (such that there are as many material sets as fluidity values to be considered).

In the Structures mode, it is important to partition the geometry and introduce geometry lines at:

• x = r for the definition of the excavated area.

• x = rpl to facilitate the post-processing and make clear the consideration of the plastic zone in
PLAXIS output.

Boundary conditions are defined by prescribing fixed vertical direction over the bottom and top
horizontal lines and fixed horizontal displacement at x = R. A distributed load should also be applied
at x = r to represent the (optional) supporting pressure (see Figure 2a).

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 4

The mesh should be generated by making sure that there will be just one element in the thickness
direction (y-axis) for the model run to perform as quickly as possible (see Figure 2b).

(a) Geometry

(b) Mesh

Figure 2: PLAXIS 2D model presentation.

In the calculation mode, initial stresses are defined during the initial phase by means of field stress with
a uniform state of stress σ1 = σ2 = σ3 = -σ0. Then, as many plastic analyses should be independently
created (from the initial phase) as there are fluidity parameters (and, therefore, independent material
sets) to be investigated (see Figure 1). For each calculation phase, it is important to:

• Deactivate the excavated soil cluster,

• Activate for each calculation phase the prescribed displacement along with the distributed load
if non-zero.

It is also very important to associate to each calculation phase a duration Δt = 10 days that will define
the rate of loading. Ultimately, the loading rate effect will solely be a function of γ×Δt. Still, we prefer
to give to Δt a reasonable physical meaning, although it would not be necessarily required, as finally
γ×Δt = (10γ) × (Δt/10)!

Finally, by setting to just 1 the maximum number of cores to be used for each phase (numerical control
parameters → max core to use), then independent calculation phases could be run simultaneously,
resulting in an even shorter overall calculation time.

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 5

 Figure 3: Phase definition.

Once the calculation has terminated, one can enter PLAXIS Output, only displaying the plastic area
cluster (by hiding the other soil cluster from x = rpl to x = R) and visualize the Cartesian Total Stress σxx
(radial stress) as shown in Figure 4.

Figure 4: Contour plots of Cartesian total radial stress.

Then one can draw a cross section from x = r to x = rpl and then apply the cross section tool that will
require the selection of the last steps of each plastic calculation phase (as shown in Figure 5).

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 6

 Figure 5: Step selection for curves.

Results obtained in this context are displayed in Figure 6 from which it can be evaluated the effect of
introducing fluidity onto the stress development around the excavated zone.

Figure 6: Radial stress evolution in the plastic zone as a function of the fluidity parameter γ.

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 7

Automation and Python scripting

The process documented in the previous section has been fully automated in a Python script called
fluidityVariationStudy.py. All functions being called are presented in the Appendix.

fluidityVariationStudy.py
from plxscripting.easy import *
from getInputAxiTunnel import param
from tunnelAxiModel import createAndRunModel
from postProcessFluidity import displayResults

import os, subprocess

password = "9>a>LNFyt4CGvcWh"
discretization = 50
#
# Check if no fluidity is defined. If not add it
if 0 not in param['Fluidity']:
param['Fluidity'].append(0)
param['Fluidity'].sort()

# Initialize input scripting server

s_i, g_i = new_server('localhost', 10000, password = password)

# Check if plasticity will develop (otherwise solution remains elastic and there is no
point doing sensitivity analysis)
if param['pcr_i'] < param['supportPressure']:
sys.exit("The solution of the excavation problem will remain elastic!")

# Create and run PLAXIS 2D axisymmetrical model

createAndRunModel(s_i, g_i, param)

# Post-process and display results

output_port = g_i.view(g_i.Phases[-1])
s_o, g_o = new_server('localhost', output_port, password = password)
displayResults (s_o, g_o, param, discretization)

g_o.close()

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 8

What the script basically does is the same as what has been presented in the previous section. It finally
displays the radial stress evolution through the plastic zone as a function of the fluidity parameter γ.
Additionally, it computes the relative area under the stress-radius curves to quantify the difference
between each fluidity parameters value (see Figure 6).

Figure 7: Automated presentation of the radial stress evolution in the plastic zone as a function of the
fluidity parameter γ.

References

Carranza-Torres, C., and Fairhurst, C. (1999). “The elasto-plastic response of underground excavations in
rock masses that satisfy the Hoek-Brown failure criterion” - International Journal of Rock Mechanics and
Mining Sciences, 36(6), 777-809.

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 9

Appendix

The input parameters are summarized in a dictionary param being defined by the user in
getInputAxiTunnel.py.

getInputAxiTunnel.py
import math

param = {}

# USER_INPUT

# Geometry, initial conditions and support loading

param['eqRadius'] = 6.

param['sigIni'] = 13e3 # positive in compression here

param['supportPressure'] = 0.

param['excavationTime'] = 10.

# Material properties

param['Fluidity'] = [0.5, 1, 2, 5, 10, 100]

param['E'] = 7.8e6

param['v'] = 0.3

param['k'] = -1

param['sig_ci'] = 80e3

param['m_i'] = 18

param['GSI'] = 49

param['D'] = 0.2

param['alpha'] = 1

param['m_psi0'] = 0.

param['softeningType'] = "GSM" #to be chosen between GSM and SSM

param['GSI_res'] = 49

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 10

param['B_GSI'] = 0.04

param['F_psi'] = 1

#param['softeningType'] = SSM #to be chosen between GSM and SSM

#param['m_res'] = 9

#param['s_res'] = 1

#param['m_psi_res'] = 1

#param['B_mb'] = 9

#param['B_s'] = 1

#param['B_psi'] = 1

# DERIVED PARAMETERS. MUST NOT BE CHANGED

#

# Derive elementary HB failure criterion parameters

param['m_b'] = param['m_i']*math.exp((param['GSI']-100.)/(28.-14.*param['D']))

param['s'] = math.exp((param['GSI']-100.)/(9.-3.*param['D']))

param['a'] = 0.5 + 1./6.*(math.exp(-param['GSI']/15.)-math.exp(-20./3.))

# Further calculation for calculating the analytical solution for HB elasto-plastic

(no fluidity)

param['S_0'] = param['sigIni']/(param['m_b']*param['sig_ci']) +
param['s']/(param['m_b']*param['m_b']) # scaled far-field stress

param['P_i'] = param['supportPressure']/(param['m_b']*param['sig_ci']) +
param['s']/(param['m_b']*param['m_b']) # scaled internal pressure

param['Pcr_i'] = 1./16.*(1.-math.sqrt(1.+16.*param['S_0']))**2 # scaled critical

internal pressure

param['pcr_i'] = (param['Pcr_i'] -
param['s']/(param['m_b']*param['m_b']))*param['m_b']*param['sig_ci'] # critical
internal pressure

param['b_pl'] = param['eqRadius']*math.exp(2.*(math.sqrt(param['Pcr_i'])-
math.sqrt(param['P_i']))) # extend of the failure zone

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 11

The createAndRunModel function constructs the PLAXIS 2D calculation model based on the user-defined
set of parameters and runs the calculation. It can be found in tunnelAxiModel.py.

import math, os, soilmat_set_parameters

def HBSParam(param):

i = 0

matSetList = []

for fluidity in param['Fluidity']:

if param['softeningType'] == "GSM":

matset = [("MaterialName", "HBS_" + str(i)),

("Colour", 16761441),

("SoilModel", 100),

("UserDLLName", "hbs64.dll"),

("UserModel", "HB-GSM"),

("DrainageType", 0),

("gammaUnsat", 0.),

("gammaSat", 0.),

("User1", param['E']),

("User2", param['v']),

("User3", param['D']),

("User4", param['GSI']),

("User5", param['alpha']),

("User6", param['m_i']),

("User7", param['m_psi0']),

("User8", param['GSI_res']),

("User9", param['sig_ci']),

("User10", param['B_GSI']),

("User11", param['F_psi']),

("User12", param['Fluidity'][i]),

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 12

 ("User13", param['k']),

("EoedRef", param['E']),

("cref", 1),

("phi", 30),

("K0Primary", 1),

("K0Secondary", 1),

("UDPower", 0),

("UDPRef", 100)]

else:

matset = [("MaterialName", "HBS_" + str(i)),

("Colour", 16761441),

("SoilModel", 100),

("UserDLLName", "hbs64.dll"),

("UserModel", "HB-SSM"),

("DrainageType", 0),

("gammaUnsat", 0.),

("gammaSat", 0.),

("User1", param['E']),

("User2", param['v']),

("User3", param['D']),

("User4", param['GSI']),

("User5", param['alpha']),

("User6", param['m_i']),

("User7", param['m_psi0']),

("User8", param['m_res']),

("User9", param['s_res']),

("User10", param['m_psi_res']),

("User11", param['sig_ci']),

("User12", param['B_mb']),

("User13", param['B_s']),

("User14", param['B_psi']),

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 13

 ("User15", param['Fluidity'][i]),

("User16", param['k']),

("EoedRef", param['E']),

("cref", 1),

("phi", 30),

("K0Primary", 1),

("K0Secondary", 1),

("UDPower", 0),

("UDPRef", 100)]

i = i + 1

matSetList.append(matset)

return matSetList

def createAndRunModel (s, g, param):

soilLayerThickness = 0.1

# Start a new project

s.new()

# Project properties

projecttitle = 'Sensitivity analysis fluidity'

g.Project.setproperties("Title", projecttitle,

"UnitForce", "kN",

"UnitLength", "m",

"UnitTime", "day",

"ModelType", "Axisymmetry")

# Create soil geometries

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 14

 modelWidth = 5. * param['b_pl']

g.Soilcontour.initializerectangular(0, 0, modelWidth, 1)

# Create soil materials

matSetList = HBSParam(param)

# nMat = len(matSetList)

for mat in matSetList:

soilmat_set_parameters.make_soilmat(g, mat)

# SOIL

firstBorehole = g.borehole(0)

firstBorehole.Head.set(-1)

# Create soil layer

g.soillayer(1)

g.setsoillayerlevel(firstBorehole, 0, 0)

g.setsoillayerlevel(firstBorehole, 1, -soilLayerThickness)

g.setmaterial(g.Soils[-1], g.Materials[0])

# STRUCTURES

g.gotostructures()

beginPt, endPt, topLine = g.line(0., 0., modelWidth, 0.)

topLineDispl = g.linedispl(topLine)

g.set(topLineDispl.Displacement_x, "Free")

g.set(topLineDispl.Displacement_y, "Fixed")

g.arrayr(topLine, 2, 0, -soilLayerThickness)

topPt_1, bottomPt_1, pressureLine = g.line(param['eqRadius'], 0.,

param['eqRadius'], -soilLayerThickness)

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 15

 pressureLoad = g.lineload(pressureLine)

g.set(pressureLoad.qx_start, param['supportPressure'])

g.set(pressureLoad.qy_start, 0.)

topPt_2, bottomPt_2, elasPlasLine = g.line(param['b_pl'], 0., param['b_pl'], -

soilLayerThickness)

topPt_3, bottomPt_3, bcLine = g.line(modelWidth, 0., modelWidth, -

soilLayerThickness)

bcDispl = g.linedispl(bcLine)

g.set(bcDispl.Displacement_y, "Free")

g.set(bcDispl.Displacement_x, "Fixed")

# MESH

g.gotomesh()

g.mesh(0.06)

# STAGED CONSTRUCTION

g.gotostages()

# Initial phase: Field stress

initialPhase = g.Phases[0]

g.set(initialPhase.DeformCalcType, "Field stress")

g.set(g.FieldStress.sig1, initialPhase, -param['sigIni'])

g.set(g.FieldStress.sig2, initialPhase, -param['sigIni'])

g.set(g.FieldStress.sig3, initialPhase, -param['sigIni'])

for mat in g.Materials:

if mat.TypeName == "SoilMat":

excavationPhase = g.phase(g.InitialPhase)

g.set(excavationPhase.MaxCores, 1)

if mat.UserModel == "HB-GSM":

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 16

 if (mat.User12.value == 0):

g.set(excavationPhase.Identification, "No fluidity")

else:

g.set(excavationPhase.Identification, "Fluidity = " +

str(mat.User12))

else:

if (mat.User12.value == 0):

g.set(excavationPhase.Identification, "No fluidity")

else:

g.set(excavationPhase.Identification, "Fluidity = " +

str(mat.User15))

g.set(excavationPhase.TimeInterval, param['excavationTime'])

g.set(excavationPhase.Deform.UseDefaultIterationParams, False)

g.set(excavationPhase.Deform.MaxLoadFractionPerStep, 0.1)

for soil in g.Soils:

g.set(soil.Material, excavationPhase, mat)

g.deactivate(g.Soils[0], excavationPhase)

g.deactivate(g.Deformations, excavationPhase)

g.activate(g.LineDisplacements, excavationPhase)

g.activate(g.LineLoads, excavationPhase)

g.calculate()

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 17

The material sets are created based on a special function called make_soilmat to be found in
soilmat_set_parameters.py.

soilmat_set_parameters.py
"""

A module to define soilmat datasets using a wrapper function.

When using the soilmat command (or setproperties command) not all defined

properties could be applied:

- there is a dependency and order in the parameters

- some parameters are derived parameters, and in the soilmat command these are

not set

The function make_soilmat will try to overcome this by using the soilmat

command and then checks if each of the defined parameter values are set

correctly.

Disclaimer

This Python script is made available as a service to PLAXIS users and can

only be used in combination with a PLAXIS VIP license.

You use this Python script at your own responsibility and you are solely

responsible for its results and the use thereof. Plaxis does not accept

any responsibility nor liability for the use of this Python script nor

do we provide support on its use.

"""

def make_soilmat(g_i, parameters, material=None):

""" Creates or updates a soil material dataset with the defined parameter

values.

overcoming the interdependencies of parameters and the issues

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 18

 of derived parameters

g_i: Plaxis global object

parameters: a list of tuples, each: ("parameter name", value)

optional: material. When defined, it will update this material object

"""

# add required parameters to tuple when not present

# to be expanded

# create material

if material is None:

material = g_i.soilmat(*parameters)

else:

# update properties:

g_i.setproperties(material, *parameters)

# force to check parameters and execute manually when needed

soil_attributes = dir(material)

for item in parameters:

param_name = item[0]

param_value = item[1]

# check presence of parameter in material object (case insensitive)

paramname_input = None

for soil_attribute_name in soil_attributes:

if soil_attribute_name.lower() == param_name.lower():

paramname_input = soil_attribute_name

if paramname_input and hasattr(material, paramname_input):

param_obj = getattr(material, paramname_input)

try:

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 19

 if param_obj.value != param_value:

# print("Old value {} = {} => {}".format(param_name,

# param_obj.value,

# param_value))

param_obj.set(param_value)

except:

print("Could not set: {}".format(param_name))

return material

def trial(g_i):

matset = [("MaterialName", "Gravel"),

("Colour", 16761441),

("SoilModel", 3),

("DrainageType", 0),

("cref", 0.1),

("phi", 37.5),

("psi", 0),

("gammaUnsat", 18.5),

("gammaSat", 19.5),

("DilatancyCutoff", True),

("einit", 0.49),

("emin", 0.43),

("emax", 0.87),

("Rinter", 0.67),

("OCR", 1),

("POP", 0),

("DefaultValuesAdvanced", True),

("nu", 0.2),

("E50ref", 60000),

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 20

 ("EoedRef", 60000),

("Gref", 240000 / (2*(1+0.2))),

("powerm", 0.5),

("K0nc", 0.3912)

material = make_soilmat(g_i, matset)

def trial2(g_i):

""" testing a user defined soil model """

matset = [("MaterialName", "Veen"),

("Colour", 9323),

("SoilModel", 100),

("UserDLLName", "shansep64.dll"),

("UserModel", "MC Shansep"),

("DrainageType", 1),

("gammaUnsat", 10.1),

("gammaSat", 10.1),

("Gref", 22.7272727272727),

("User1", 250),

("User2", 0.25),

("User3", 2.5),

("User4", 15),

("User5", 0),

("User6", 0),

("User7", 0.45),

("User8", 0.85),

("User9", 20),

("User10", 3.15),

("User11", 1),

("EoedRef", 250),

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 21

 ("cref", 5),

("phi", 15),

("K0Primary", 0.741180954897479),

("K0Secondary", 0.741180954897479),

("UDPower", 0),

("UDPRef", 100)]

material = make_soilmat(g_i, matset)

if __name__ == "__main__":

# USING BOILERPLATE PLAXIS 2D 2017 #

from plxscripting.easy import *

s_i, g_i = new_server('localhost', 10000, password='YOUR PASSWORD')

trial2(g_i)

Finally, post-processing functions are defined in postProcessFluidity.py.

postProcessFluidity.py
from plxscripting.easy import *

import math

from matplotlib.font_manager import FontProperties

import matplotlib.pyplot as plt

def area(rVal, stressVal):

A = 0.

for i in range(len(stressVal)-1):

A = A + abs(rVal[i+1]-rVal[i])*(stressVal[i]+stressVal[i+1])/2

return A

def fetch_soil_results_2D(g, phase, resType, end, start, sample_count):

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 22

 soilResults = g.ResultTypes.Soil

step = [(e - s) / (sample_count - 1) for e, s in zip(end, start)]

resultsX = []

resultsY = []

for i in range(sample_count):

position = (start[0] + i * step[0],

start[1] + i * step[1])

result_string = g.getsingleresult(phase, resType, position)

# check if position lies outside the mesh

if result_string == "not found":

raise Exception("Used getsingleresult for point outside mesh.")

resultsX.append(position[0])

resultsY.append(float(result_string))

return resultsX, resultsY

def displayResults(s_o, g_o, param, discretization):

beginPoint = (param['eqRadius'], 0.0)

endPoint = (param['b_pl'], 0.0)

SRR_Res = []

Table_Arel = []

column_labels = ["Fluidity", "\u0394A / A_ref"]

plt.style.use('seaborn-bright')

plt.figure(figsize=(18, 9))

plot_left = plt.subplot2grid((1, 3), (0, 0), colspan=2)

plot_right = plt.subplot2grid((1, 3), (0, 2))

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 23

 plot_left.set_title("Radial stress over plastic region")

plot_left.set_xlabel("Radius")

plot_left.set_ylabel("Radial Stress")

for phase in g_o.Phases[1:]:

print(phase.Identification)

SXX = g_o.ResultTypes.Soil.SigxxT

R, SRR = fetch_soil_results_2D(g_o, phase, SXX, endPoint, beginPoint,

discretization)

SRR_Res.append(SRR)

Decomp = phase.Identification.value.split()

if Decomp[0] == 'No':

label = "No fluidity"

plot_left.scatter(R, SRR, label=label, marker='o', c='black')

A_ref = area(R, SRR)

else:

label = "Fluidity = " + str(Decomp[2])

plot_left.plot(R, SRR, label=label)

A = area(R, SRR)

A_rel = '%.2f' % (100. * abs((A - A_ref) / A_ref))

Table_Arel.append([Decomp[2], str(A_rel) + " %"])

leg = plot_left.legend(prop={"size": 14})

plot_right.axis('off')

table = plot_right.table(cellText=Table_Arel,

colLabels=column_labels,

cellLoc='center',

loc='center')

table.scale(1.2, 3.)

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 24

 table.auto_set_font_size(False)

for key, cell in table.get_celld().items():

if key[0] == 0:

cell.set_fontsize(14)

else:

cell.get_text().set_fontstyle('italic')

cell.set_fontsize(12)

plt.show()

© 2022 Bentley Systems Incorporated. Bentley, the Bentley Logo, and PLAXIS are either registered or unregistered trademarks or service marks of Bentley Systems, Incorporated, or one of
its direct or indirect wholly-owned subsidiaries. Other brands and product names are trademarks of their respective owners.

Fluidity Parameter γ of the Hoek-Brown Model with the Softening Model 25