MPM

• 1: Background
• 2: Examples
• 2.1: Example 0: run a simulation
• 2.2: Example 1: granular collapse
• 2.3: Example 2: heat transfer on 2d plate
• 3: Python Class Reference

1 - Background

A brief introduction to the Material Point Method

The material point method (MPM) proposed by Sulsky et al. is one of the mesh-free approaches for coping with large deformation problems. The solution domain of the MPM is discretized and classified into Lagrangian (material Points) and Eulerian (background Grid) components. Moreover, the MPM calculation cycle is driven by mapping the kinematics and dynamics between the material points and background nodes.

As shown in the Fig. \ref{fig:mpmloop}, five procedures will be conducted within one MPM iteration step.

1. Boundary condition (BC): the corresponding boundary condition will be applied to the material points or nodes, and the type of boundary condition can be: displacement BC, velocity BC, body force BC, traction force BC and temperature BC (if thermal task considered).

2. P2G: kinematic will be mapped from Particles to Grid nodes depends on the shape function. The kinematics consist of the mass, volume, moment, force/stress and the material field state variables including the volume gradient and displacement vector (if multi-material mode is activated).

3. Newton Integration: update the dynamics (moment and velocity) of background nodes using the kinematics expolated from the material points. Additional heat flux and temperature will be integrated once thermal task is run.

4. G2P: update all the state variables of material points assisted by the dynamics interpolated from background nodes. The calculation scheme of the stress and velocity/displacement of material points determined by the user-defined settings. For example, the stress update option governs if USF (Update Stress First) Bardenhagen or USL (Update Stress Late, Sulsky et al.) scheme will be executed. As for the velocity/position update, two options are also available as FLIP (FLuid Implicit Particle method, Brackbill and Ruppel) and PIC (Particle In Cell, Harlow). Moreover, the USF and mixture format of FLIP and PIC would be recommended by the authors.

5. Reset Grid: all the information of nodes will be reset. However, the state variable of material points will be transferred into the next step. The resetting process can avoid mesh distortion, which is why MPM can handle significant deformation problems.

MPM2D

MPM2D is designed to model large deformation problems employing the material point method. The whole program is written in C++ and further encapsulated by python to provide a user-friendly interface. Note that **GUI} utility is also developed and suggested for easily pre-processing and results rendering.

Minimal example python script for MPM2D-GUI is shown as follows:

An example for MPM2D-GUI python script.

## GUI settings for MPM2D
app.core.setAnalysisType(AnalysisType = "MPM")

## Some model settings

## Run the mpm simulation
app.run(1) 

The framework of MPM2D

Five main classes are exposed to the python interface (Fig. \ref{fig:mpmframework}):

• Analysis class is the core of MPM2D, it provides the platform for the communication among other members of MPM2D and navigates the whole simulation task.

• Grid class depicts the geometry of the solution domain and maintains the hierarchical structure of elements and nodes.

• Shape classes are responsible for the material points initialization and management. Clusters of the material points are created within a specific shape object. User-defined settings and boundary condition will not be assigned to the material points directly but is delegated to the functions of shapes instead.

• Material classes affect the mechanical behaviour of material points. MPM2D supports the following material types: elastic material, Mohr-Coulomb material, Neo-Hookean material and Newton liquid.

• Archiver class will dump the calculation result to a certain file format (binary or ASCII) as simple as possible to decrease the computation cost. When the simulation finishes, users can parse the raw results to the VTK file using the MPM2D extraction tool.

The MPM2D GUI

MPM2D GUI is always recommended to integrate with MPM tasks, and its snapshot is shown in Fig. \ref{fig:mpmgui}. Essential operation to run an MPM script is:

1. Click the button \includegraphics[scale=0.5]{open.png} and choose the directory path for the MPM script.

2. Double-click the target MPM script, e.g., the highlighted biaxial.py.

3. Click the gear button \includegraphics[scale=0.5]{run.png} and the MPM script has been pasted in the right-corner shell.

4. Type the command app.run(1) at the right-corner shell to start the task.

2 - Examples

We prepared several examples to show a quick start of using MPM2D.

2.1 - Example 0: run a simulation

This example will show : to do.

Here is the script of ‘example0.py’:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

import sys

## You may need to specify the MPM package path
## if it is not installed in PYTHONPATH
sys.path.append("/path/to/your/mpm/package")

## GUI settings
app.core.setAnalysisType(AnalysisType = "MPM")
    
## Import MPM python package
import mpm as task

## Initialization of the core: Analysis object
sim=app.core.sim

## Initialization of the grid: Grid object
grid = sim.grid

## Dimension of the grid
## Arguments: (xmin, xmax, ymin, ymax)
grid.setRange(0, 2.6, 0, 2.6)

## Element numbers
## Arguments: (numberx, numbery)
grid.setNumEle(26, 26)

## Print necessary information of grid
grid.printInfo()

## Element size
elemsize = 0.1

## Dampings
pdamping = 0.1   ## particle damping
gdamping = 0.    ## node damping
pic = 0.1        ## PIC fraction for mixed format 
                 ## between FLIP and PIC
                 ## 0 for pure FLIP, 1 for pure PIC

## Target stress for the consolidation stage
q = -1e5

## Material 1: Mohr-Coulomb material model 
mat1 = task.Mc()
mat1.rho = 1                  ## density (kg/m3)
mat1.infinistate = False      ## True:  finite strain theory adopted
                              ## False: infinitesimal starin theory adopted
                            
## Material 2: Mohr-Coulomb material model
phi = 20         ## friction angle (deg)
c = 0.1          ## cohesive (Pa)
psi = 10         ## dilation angle (deg)

mat2 = task.Mc()
mat2.rho = 2650               ## density (kg/m3)
mat2.E = 1e5                  ## Young's modulus (Pa)
mat2.nu = 0.2                 ## Poisson's ratio
mat2.c = c                    ## cohesive (Pa)
mat2.phi = phi                ## friction angle (deg)
mat2.psi = psi                ## dilation angle (deg)
mat2.tension = 0.2            ## tension cut off (Pa)
mat2.infinistate = False      ## True:  finite strain theory adopted
                              ## False: infinitesimal starin theory adopted

## Material array as member of Analysis object
sim.mats = [mat1, mat2]

## Ids for each material
sim.mats[-1].setIndex(len(sim.mats)-1)
sim.mats[-2].setIndex(len(sim.mats)-2)

## Shape objects:
## Derived classes of shape are: Rectangle, Disk, Ring, Polygon and DemPolygon

## Rectangle
## Arguments: (xmin, xmax, ymin, ymax, boundary_shape)
left = task.Rectangle(0.8, 0.85, 0.3, 2.3, task.MPTTRACSHAPE)

## MPTTRACSHAPE means that tranction boundary condition 
## will be applied to material points inside the left object
## Arguments: (faceid, direction, signed_magnitude)

## Face id:
## --3--
## |   |
## 4   2
## --1--

## Direction options: XDIR, YDIR, NORMALDIR, TAGENTDIR
## For NORMALDIR, negative q means compression and positive q for tension

left.setTracBc(4, task.NORMALDIR, q)

## Predefined consolidation stress
## Arguments: (consolidation_stress_x, consolidation_stress_y)
left.setConsolidation(q, q)

## Bind the material points to material objects
## Arguments: 
## (material_type, material_id, material_points_number_per_element)
left.setMatProperty(task.MCMAT, 1, 2)

## Dampings for material points
## Arguments: (particle_damping, node_damping, PIC_fraction)
left.setDamping(pdamping, gdamping, pic)

right = task.Rectangle(1.75, 1.8, 0.3, 2.3, task.MPTTRACSHAPE)
right.setTracBc(2, task.NORMALDIR, q)
right.setConsolidation(q, q)
right.setMatProperty(task.MCMAT, 1, 2)
right.setDamping(pdamping, gdamping, pic)

## Boundary condition is not always necessary
## NONEBC denotes no boundary BC provided
soil = task.Rectangle(0.85, 1.75, 0.3, 2.3, task.NONEBC)
soil.setMatProperty(task.MCMAT, 1, 2)
soil.setConsolidation(q, q)
soil.setDamping(pdamping, gdamping, pic)

## RIGIDSHAPE claims particular material points: rigid material points
## Rigid material points only serve the boundary condition,
## they ARE NOT involved in any mechanical calculations
## Arguments: (xmin, xmax, ymin, ymax, RIGIDSHAPE)
bot = task.Rectangle(0.7, 1.9, 0.2, 0.3, task.RIGIDSHAPE)

## SetBc controls if the velocity in x or y direction are fixed
## Arguments: (isxfixed, velx_value, isyfixed, vely_value)
bot.setBc(True, 0, True, 0)
bot.setMatProperty(task.RIGIDMAT, 0, 2)

top = task.Rectangle(0.7, 1.9, 2.3, 2.4, task.RIGIDSHAPE)
top.setBc(True, 0, True, -0.02)
top.setMatProperty(task.RIGIDMAT, 0, 2)

## Summary: left and right shapes provide the stress servo
##          and top shape is the shear loading plate
##          bot for the fixed velocity boundary condition
##          soil is the sample undertaking the shear loading

## Shapes array as a member of Analysis object
sim.shapes = [left, right, top, bot, soil]

## Analysis settings

## CPU cores (at least 1)
## SetNumThreads must be called explicitly,
## otherwise undeifned behaviour will appear
sim.setNumThreads(1)

## Set the total time elapsed and timestep
## Arguments: (tottal_time, timestep)
sim.setTimeDt(15., 1e-3)

## MPM interpolation method,
## options: LINEAR, GIMP, LINEARCPDI, BSPLINECPDI
sim.setMethod(task.GIMP)

## Simulation resutl archive
## When to start the archive (sec)
sim.writer.setStartTime(0)     
 
## Time to stop the archive (sec)                                
sim.writer.setEndTime(17)      

## Frequency for the file archive (sec)                                 
sim.writer.setIntervalTime(0.1)       

## Where to store the archived datas
## Arguments: (directory_name, file_name)                          
sim.writer.setDir("./Results/", 'biaxial')                          
   
## Simulation task, options: MANAL, TANAL, PHASEANAL
## MANAL: mechanical simulation
## TANAL: thermal simulation
## PHASEANAL: phase transition simulation
sim.simTypeMasks = task.MANAL                                    

## Before the calculation,
## run PreAnalysis to initialize the analysis core
sim.PreAnalysis()

## Run specific steps
## If GUI is activated,
## app.run(1)
## else:
## sim.run(1) 

2.2 - Example 1: granular collapse

This example will show : to do.

Here is the script of ‘example0.py’:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

import sys

## You may need to specify the MPM package path
## if it is not installed in PYTHONPATH
sys.path.append("/path/to/your/mpm/package")

## GUI settings
app.core.setAnalysisType(AnalysisType = "MPM")
    
## Import MPM python package
import mpm as task

## Initialization of the core: Analysis object
sim=app.core.sim

## Geometry of mesh
elemsize = 0.25
width = 10
height = 5

## Initialization of the grid: Grid object
grid = sim.grid

## Dimension of the grid
## Arguments: (xmin, xmax, ymin, ymax)
grid.setRange(0, width, 0, height)

## Element numbers
## Arguments: (numberx, numbery)
grid.setNumEle(40, 20)

## Material 1: Mohr-Coulomb material model 
mat1 = task.Mc()
mat1.rho = 1                   
mat1.infinistate = False       

## Material 2: Mohr-Coulomb material model
mat2 = task.Mc()
mat2.rho = 1300.
mat2.E = 5e5
mat2.nu = 0.4
mat2.c = 0.
mat2.phi = 22
mat2.psi = 0.01
mat2.tension = 0.01
mat2.infinistate = False 

## Contact stiffness for the frictional base
mat2.Kn = 5e8                ## normal contact stiffness
mat2.Ks = 2.5e7              ## shear contact stiffness
mat2.friction = 0.5          ## friction coefficient
   
## Material array as member of Analysis object
sim.mats = [mat1, mat2]
## Assign the id for each material
sim.mats[-1].setIndex(len(sim.mats)-1)
sim.mats[-2].setIndex(len(sim.mats)-2)

## Dampings
pdamping = 1.0
gdamping = 1.0
pic = 1.0

## Timestep
dt = 1e-4

## Shape objects:

## GRAVITYSHAPE defines a gravity BC, all the material points
## inside the shape will bear a body force = [0, -9.8]

soil = task.Rectangle(2.*elemsize, 2.*elemsize+2, 2.*elemsize, 2.*elemsize + 4, task.GRAVITYSHAPE)

## SetBC for the GRAVITYSHAPE is:
## Arguments: (isxsetgravity, gravity_x, isysetgravity, gravity_y)
soil.setBc(False, 0, True, -9.8)
soil.setMatProperty(task.MCMAT, 1, 2)
soil.setDamping(pdamping, gdamping, pic)

left = task.Rectangle(elemsize, 2.*elemsize, 2.*elemsize, 2.*elemsize + 5, task.RIGIDSHAPE)
left.setBc(True, 0, False, 0)
left.setMatProperty(task.RIGIDMAT, 0, 1)

right = task.Rectangle(2.*elemsize+2, 3.*elemsize+2, 2.*elemsize, 2.*elemsize + 5, task.RIGIDSHAPE)
right.setBc(True, 0, False, 0)
right.setMatProperty(task.RIGIDMAT, 0, 1)

## DemPolygon DOES NOT hold any material points,
## but it will impose the contact boundary conditions.
## Force between material points and DemPolygon stands on their
## penetration and the relative veloicty, 
## which is similar to DEM contact law

## Create a DemPoly by inputing all their vertex 
## in anti-clockwise or clock-wise order
## Make sure the vertexes follow the same direction
## Any intersection between two lines formed by three adjacenting
## material points is not allowed
pts = [0, elemsize, width, elemsize, width, 2.*elemsize, 0., 2.*elemsize]

## Constructor of DemPolygon:
## Arguments:
## (timestep, search_range, update_iteration, normal_contact_stiffness, 
## shear_contact_stiffness, friction_coefficient)
foot = task.DemPolygon(dt, 10, 100, 5e6, 5e6, 0.5);

## Set the vertex array
foot.setPts(pts)

## UsePolygonContact determines if material points is regarded
## as sphere or polygon
## True: polygon False: sphere
foot.usePolygonContact(False)

## Set the DemPolygon velocity boundary condition
foot.setBc(True, 0, True, 0)
foot.setMatProperty(task.RIGIDMAT, 0, 1)

## Summary: left and right shape to provide the fixed velocity 
##            or displacement constraint, the bot works like 
##            a friction base and only apply a vertical displacement
##            constraint. And soil is the samples that will suffer 
##            from a collapse

## Shapes array as a member of Analysis object
sim.shapes = [soil, left, foot, right]


## Analysis settings

## CPU cores (at least 1)
## SetNumThreads must be called explicitly,
## otherwise undeifned behaviour will appear
sim.setNumThreads(1)

## Set the total time elapsed and timestep
## Arguments: (tottal_time, timestep)
sim.setTimeDt(1, dt)

## Simulation resutl archive
## When to start the archive (sec)
sim.writer.setStartTime(0)     
 
## Time to stop the archive (sec)                                
sim.writer.setEndTime(10)      

## Frequency for the file archive (sec)                                 
sim.writer.setIntervalTime(0.1)  

## Where to store the archived datas
## (directory_name, file_name)                          
sim.writer.setDir("./Results/", 'granular_collapse')  

## MPM interpolation method,
## options: LINEAR, GIMP, LINEARCPDI, BSPLINECPDI
sim.setMethod(task.GIMP)

## Simulation task, options: MANAL, TANAL, PHASEANAL
## MANAL: mechanical simulation
## TANAL: thermal simulation
## PHASEANAL: phase transition simulation
sim.simTypeMasks = task.MANAL   


def gravityHookFunc(steps = 100):
    ## Get the current iteration steps by sim.iter()
    partg = -9.8*sim.iter()/float(steps)

    ## Try to print information to app, use the app.print
    app.print('Current g:', partg)
    
    ## Set the accumulated increasing gravity
    soil.setBc(False, 0, True, partg)
    

## The PyHook allows the user to run the customized task 
## after each MPM cycle
pyhook1 = task.PyHook()

## State the hooked function by string
pyhook1.command = 'gravityHookFunc()'

## Set the hook task interval and total_runnings
## Arguments: (interval, total_runnings)
## The elapsed iteration = interval * total_runnings
pyhook1.reset(iterPeriod = 1, totalRuns = 100)

## Dead=True indicates the hook stopped, False means activated
pyhook1.dead = False


def removeRightWall():
    ## Note that the rigidshape can be removed at any time
    ## by setting the bool flag to false
    right.setBc(False, 0, False, 0)

    ## Set all the damping to 0 to capture a dynamic simulation
    soil.setDamping(0, 0, 0)


## Before the calculation,
## run PreAnalysis to initialize the analysis core
sim.PreAnalysis()

## Run specific steps
## If GUI is activated,
## app.run(1)
## else:
## sim.run(1) 

2.3 - Example 2: heat transfer on 2d plate

This example will show : to do.

Here is the script of ‘example0.py’:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

import sys

## You may need to specify the MPM package path
## if it is not installed in PYTHONPATH
sys.path.append("/path/to/your/mpm/package")

## GUI settings
app.core.setAnalysisType(AnalysisType = "MPM")
    
## Import MPM python package
import mpm as task

## Initialization of the core: Analysis object
sim=app.core.sim

## Geometry of mesh
length = 1.0
eleNum = 20
elemsize = length / eleNum
pic = 2
xrange = [0, length+2.0*elemsize]
yrange = xrange

## Dimension of the grid
## Arguments: (xmin, xmax, ymin, ymax)
sim.grid.setRange(xrange[0], xrange[1], yrange[0], yrange[1])

## Element numbers
## Arguments: (numberx, numbery)
sim.grid.setNumEle(eleNum+2, eleNum+2)
sim.grid.printInfo()


mc=task.Mc()
mc.rho = 1
mc.E = 5e5

## Thermal properties: specific heat and 
## conductivity coefficient tensor, K
## Arguments: (specific_heat, conduction tensor K)

## The use can initialize the K by four arguments [Kxx, Kxy, Kyx, Kyy]
## If only two arguments are given for the tensor
## they are for Kxx and Kyy, [Kxx, 0., 0., Kyy]
mc.setThermalProp(10.0, [1.0,1.0])

## Material array as member of Analysis object
sim.mats=[mc]

## Ids for each material
sim.mats[-1].setIndex(len(sim.mats)-1)

## Shapes:
left = task.Rectangle(0*elemsize, 1.*elemsize, 1*elemsize, (eleNum+1)*elemsize, task.RIGIDSHAPE)

## Thermal boundary condition, temperature
left.setThermalBc(100.0)
left.setMatProperty(task.RIGIDMAT,0, pic)

right = task.Rectangle(xrange[1] - 1.*elemsize, xrange[1]-0*elemsize, 1*elemsize, (eleNum+1)*elemsize, task.RIGIDSHAPE)
right.setThermalBc(100.0)
right.setMatProperty(task.RIGIDMAT, 0, pic)

bot = task.Rectangle(0*elemsize, xrange[1] -0*elemsize, 0*elemsize, 1.*elemsize, task.RIGIDSHAPE)
bot.setThermalBc(100.0)
bot.setMatProperty(task.RIGIDMAT, 0, pic)

top = task.Rectangle(0*elemsize, xrange[1] -0*elemsize, yrange[1]-1*elemsize, yrange[1]-0.*elemsize, task.RIGIDSHAPE)
top.setThermalBc(100.0)
top.setMatProperty(task.RIGIDMAT, 0, pic)

soil = task.Rectangle(1*elemsize, xrange[1] - 1.*elemsize, 1.*elemsize, (eleNum+1)*elemsize, task.NONEBC)
soil.setMatProperty(task.MCMAT, 0, pic)
soil.setDamping(0.2, 0, 0.1)

## Summary: four sides are imposed by fixing temperature boundary condition
## as 100 Celsius, and soil has a initial temperature as 0 Celsius

## Shapes array as a member of Analysis object
sim.shapes = [left, right, bot, top, soil]

## Analysis settings

## CPU cores (at least 1)
## SetNumThreads must be called explicitly,
## otherwise undeifned behaviour will appear
sim.setNumThreads(1)

## Set the total time elapsed and timestep
## Arguments: (tottal_time, timestep)
sim.setTimeDt(1, 1e-4)

## Simulation resutl archive
## When to start the archive (sec)
sim.writer.setStartTime(0)

## Time to stop the archive (sec) 
sim.writer.setEndTime(10)

## Frequency for the file archive (sec)  
sim.writer.setIntervalTime(0.1)

## MPM interpolation method,
## options: LINEAR, GIMP, LINEARCPDI, BSPLINECPDI
sim.setMethod(task.GIMP)

## Simulation task, options: MANAL, TANAL, PHASEANAL
## MANAL: mechanical simulation
## TANAL: thermal simulation
## PHASEANAL: phase transition simulation
sim.simTypeMasks = task.TANAL

## Where to store the archived datas
## (directory_name, file_name)   
sim.writer.setDir("./Results", "thermal2d")

## Before the calculation,
## run PreAnalysis to initialize the analysis core
sim.PreAnalysis()

## Run specific steps
## If GUI is activated,
## app.run(1)
## else:
## sim.run(1) 

3 - Python Class Reference

MPM2D

Classes

• Analysis
• Grid
• Node
  • PhaseTrsfNode
• MptsBase
  • Mpts
  • PhaseTrsfMpts
  • RigidMpts
• Material
  • Dp
  • Elastic
  • Ghostmat
  • Mc
  • McOrigin
  • NeoHookean
  • NewtonLiquid
• Shape
  • DemPolygon
  • DemSphere
  • Polygon
  • Rectangle
  • Ring
  • Sphere
• ContactEngine
• MpmWriter
• PeriodicHook
  • PyHook

Enumerations

• BCDIR
• BCFIXSTATE
• MatType
• MPMETHOD
• ShapeType
• SIMTYPEMASK

Detailed API

class Analysis

  Methods:

• Analysis() -> void

  Default constructor function of MPM core.

• NodesPos() -> list <float>

  Get positions of all nodes, and size of list is 2 x material_nodes_num.

• NodesTemperature() -> list <float>

  Get the temperature of all nodes, and size of list is material_nodes_num.

• PreAnalysis() -> void

  PreAnalysis initializes all the variables and states for Analysis before you call the Run method.

• PtsMeanStress() -> list <float>

  Get the mean stress for all particles, especially for gui view. Size of list is material_points_num and the mean stress defined in 2D is 0.5 x (Sxx + Syy).

• PtsPos() -> list <float>

  Get positions of all mateial points, and size of list is 2 x material_points_num.

• PtsShearStrain() -> list <float>

  Get shear strain for all particles, especially for gui view. And size of list is 2 x material_points_num.

• PtsStressYY() -> list <float>

  Get the yy-component stress for all particles, especially for gui view. And size of list is 2 x material_points_num.

• PtsTemperature() -> list <float>

  Get the temperature for all particles, especially for gui view. And size of list is 2 x material_points_num.

• PtsTemperatureRemapped() -> list <float>

  Get the remapped temperature for all particles, especially for gui view. And size of list is 2 x material_points_num. Note that the remapped temperature is interpolated from the nodes instead of one from material points.

• Run() Overloaded function.

  1. Run() -> void

     Run the simulation until reaching the tottime.

  2. Run(int runstep) -> void

     Run the simulation with n steps.

• RunPthread(int threadnum) -> void

  Run the simulation for n steps with detached threads.

• addMats(mpm.Material matobj) -> void

  Push back the defined material into the Analysis.mats.

• addShapes(mpm.Shape shapeobj) -> void

  Push back the defined material into the Analysis.shapes.

• getElements() -> list <mpm.Element>

  Get all the element python-binded-objects of Analysis, and size of list is material_elements_num. More properties can be accessed by the element objects returned by this method.

• getNodeById(int nodeid) -> mpm.Node

  Get the node python-binded-objects with ID specified.

• getNodes() -> list <mpm.Node>

  Get all the node python-binded-objects of Analysis, and size of list is material_nodes_num. More properties can be accessed by the node objects returned by this method.

• getNonrPts() -> list <mpm.Mpts>

  Get all the non-rigid material points python-binded-objects of Analysis, and size of list is material_nonrigid_material_points_num. More properties can be accessed by the nonrigid-material-points objects returned by this method. Note that two types of material points, nonrigid and rigid are defined in this code.

• getParById(int particleid) -> mpm.Mpts / mpm.RigidPts

  Get material points by id. Either nonrigid or rigid material points can be returned by their ID. Note: nonrigid and rigid material points are stored in different containers. Order is as nonrigid material points are followed by rigid material points. Assume there are 5 nonrigid ones and 5 rigid ones. Give the ID = 4 you will get the nonrigid one with ID = 4, but if input is 7, you will get the rigid one with ID = 2.

• getRigidPts() -> list <mpm.RigidPts>

  Get all the rigid material points python-binded-objects of Analysis, and size of list is material_rigid_material_points_num. More properties can be accessed by the rigid-material-points objects returned by this method. Note that two types of material points, nonrigid and rigid are defined in this code.

• getShapeReactForce(int shapeid, int forcedir) -> float

  Get the reactforce of specific shape. If the shape does not include any rigid material points, 0 will be returned. Otherwise, the corresponding reaction force coming from the boundary condition will be obtained.

• getThermalCriticalTimeStep() -> float

  Get the critical time step for the thermal analysis.

• getTimeStep() -> float

  Get the current time step in the simulation.

• getTrElements() -> list <mpm.TriElement>

  The hierarchical elements objects. And this function has not been tested yet.

• getTrNodes() -> list <mpm.Node>

  The hierarchical nodes objects. And this function has not been tested yet.

• gravityLoad() -> bool

  Check if the nonrigid-material-points is under the equilibrium state.

• isRunning() -> bool

  Get the isRunnning flag to check if the core simulation is running.

• iter() -> int

  Get the current iteration step.

• pause() -> void

  Pause the simulation.

• printNodesTemperature() -> void

  Print temperature at all nodes to the shell or GUI.

• saveCurrentMesh() -> void

  Save current mesh file to a vtk file.

• saveCurrentPtsBin(string savename) -> void

  Save current pts states to a binary file.

• setHigherPicOrder(int picorder) -> void setHigherPicOrder(self: mpm.Analysis, arg0: int) -> None

  Activate the XPIC engine with specific order.

• setMethod()

  Overloaded function.

  1. setMethod(int mpm.METHOD) -> void

     Set mpm interpolation method.

  2. setMethod(int mpm.METHOD, bool autoadjust) -> void

     Set mpm interpolation method and adjust the interpolation automatically.

• setNumThreads(int threadnum) -> void

  Set the number of threads in parallel. You should alway call this method explicitly, even only 1 thread is needed.

• setPicEngineIterperiod(int picfrequency) -> void

  Set the frequency to call the XPIC engine.

• setTimeDt(float totaltime, float timestep) -> void

  Set total elapsed time and time step.

• useContact() -> void

  Activate the DEM-driven contact algorithm for nonrigid-nonrigid contact.

• useNFGrid() -> void

  Activate the non-uniform grid. This function has not been tested yet.

• usePtSplit(bool ison) -> void

  Activate the material points split algorithm. This function has not been tested yet.

• writePtsPos(string savename) -> void

  Save the material points states into binary file. This method will be deprecated and you are alway suggested to use saveCurrentPtsBin.

  Properties:

• USL

  Flag for if the update-stress-late scheme is activated.

• contactengine

  Contact engine for nonrigid-nonrigid contact algorithm.

• demstep

  Flag for if the DEM substep is activated.

• dt

  Time step.

• grid

  Python-binded-object for Analysis.grid

• hooks

  Python-binded-object for Analysis.hook. Users can add their own function to the MPM loop using the hooks.

• mapOnce

  Flag for pure thermal mpm.task. On this condition, the mapping between the nodes and the material points will only run once for efficiency.

• mats

  Python-binded-object for Analysis.materials.

• nrpts

  Python-binded-object for Analysis.nonrigid-material-points.

• rigidpts

  Python-binded-object for Analysis.rigid-material-points.

• shapes

  Python-binded-object for Analysis.shapes.

• simTypeMasks

  Mask for simulation type. MANAL or TANAL corresponds to the mechanical task and thermal task.

• trgrid

  Python-binded-object for Analysis.treegrid. This function has not been tested yet.

• writer

  Python-binded-object for Analysis.writer for archiving and post-process.

class Grid

  Methods:

• Grid() -> void

  Note that: users are not allowed to call this constructor in the python script.

• getNumEle() -> list <int> [numx, numy]

  Get the number of elements along x and y directions.

• getSpace() -> list <float> [spacex, spacey]

  Get the space of the grid.

• getXrange() -> list <float> [xmin, xmax]

  Get xrange of the grid.

• getYrange() -> list <float> [ymin, tmax]

  Get yrange of the grid.

• printElements() -> void

  Print all the elements debug information.

• printInfo() -> void

  Print the grid debug information.

• setContactDisratio(float ratio) -> void

  Set the contact detection ratio for traditional contact algorithm.

• setFriction(float friction) -> void

  Set the frictoin for traditional contact algorithm.

• setNumEle(int numx, int numy) -> void

  Element dimensions in x and y direction.

• setRange(float xmin, float xmax, float ymin, float ymax) -> void

  Set xmin, xmax, ymin, ymax for grid.

  Properties:

• nodes

  All the python-binded-objects for nodes.

class Node

  Methods:

• Node() -> void

  Note that: users are not allowed to call this constructor in the python script.

• getId() -> int

  Get the node index.

• getParNum() -> int

  Get particle number associated with this node.

• getTemperature() -> float

  Get the temperature at the node.

• printInfo() -> void

  Print the debug information.

• printMatfInfo() -> void

  Print the debug information for multiple material fields.

  Properties:

• pos

  Position of node.

class PhaseTrsfNode -> Node

  Methods:

• PhaseTrsfNode() -> void

  Note that: users are not allowed to call this constructor in the python script.

  All the methods and properties, please refer to the Node class.

class MptsBase

  Methods:

• MptsBase() -> void

  Note that: users are not allowed to call this constructor in the python script.

• getIndex() -> int

  Get the unique ID of this particle.

• getNodeList() -> list <int>

  Get the list of node indexes associated with this particle.

• getNodeSF() -> list <float>

  Get the shape function of nodes associated with this particle.

• getPos() -> list <float> [posx, posy]

  Get particle position in 2D.

• getRemappedT() -> float

  Get the remapped temperature on the particle. This temerature is interpolated from the nodes and it is different from the internal temperature.

• getShearStrain() -> float

  Get the shear equivalent strain.

• getStrain() -> list <float> [strainxx, strainxy, strainyy]

  Get strain component on this material point.

• getStress() -> list <float> [stressxx, stressxy, stressyy]

  Get stress component on this material point.

• getTemperature() -> float

  Get the temperature on this material point.

• getThermalConductivity() -> list <float> [Kxx, Kxy; Kyx, Kyy]

  Get thermal conductivity tensor on this material point.

• getVel() -> list <float> [velx, vely]

  Get particle velocity in 2D.

• getVol() -> float

  Get particle volume in 2D.

• printInfo() -> void

  Print debug information.

  Properties:

• heatCapacity

  Specific heat capacity

• heatSource

  Heat source or sink for thermal and phase transoformation task.

• mass

  Particle mass.

• temperature

  Particle temperature.

class Mpts -> MptsBase

  Methods:

• Mpts() -> void

  Note that: users are not allowed to call this constructor in the python script.

• getDeformMatrix() -> list <float> [Fxx, Fxy; Fyx, Fyy]

  Get deformation matrix of material point.

• getInitPos() -> list <float> [initpx, initpy]

  Get the initial position of particle in 2D.

• getStrainEnergy() -> float

  Get strain energy of non-rigid pts.

• printMatInfo() -> void

  Print debug information for material object.

• setVel(float velx, float vely) -> void

  Set velocity.

class PhaseTrsfMpts -> Mpts

  Methods:

• PhaseTrsfMpts() -> void

  Note that: users are not allowed to call this constructor in the python script.

• getCurrentWaterFraction() -> float

  Get current volumetric fraction of liquid.

• getDIcefractionDTemp(float temperature) -> float

  Get the derivative of the ice volumetric fraction against the current temperature.

• getPhaseFraction(int phaseid) -> float

  Get the the volumetric fraction of given phase.

• getPhaseState() -> float

  Current phase state: melting or freezing.

class RigidMpts

  Methods:

• RigidMpts -> void

  Note that: users are not allowed to call this constructor in the python script.

class Material

  Methods:

• Material() -> void

  Default constructor for mpm.Material.

  This is a pure virtual class, and users must initialize its child class instead of itself.

• setIndex() -> void

  Set the unique ID for material object.

• setInitDensity(float solidrho, float icerho, float waterrho) -> void

  Initialie the density for solid, ice and water when phase transformation task is activated.

• setInitFraction(float solidfraction, float icefraction, float waterfraction) -> void

  Initialie the volume fraction for solid, ice and water when phase transformation task is activated.

• setThermalProp() -> void

  Overloaded function.

  1. setThermalProp(float hc, list <float> conductivity) -> void

     Set themal properties: hc for heat capacity.

     The size of list conductivity can be 1 2 for 4.

     If 1, conductivity matrix will be [k, 0; 0, k].

     If 2, conductivity matrix will be [k1, 0; 0, k2].

     If 4, conductivity matrix will be [k1, k2; k3, k4].

  2. setThermalProp(list <float> hc, list <float> conductivity) -> void

     Set themal properties: hc for heat capacity under phase transformation condition.

     The size of list hc must be 6, and the size of list conductivity must be 6.

     Heat capacity will be assigned to solid, ice and liquid phase, while conductivity matrix for different phase will be [ki, 0; 0, ki+1], i = 0, 2, 4.

  Properties:

• Kn

  Contact normal stiffness

• Ks

  Contact tangential stiffness

• Tres

  The residual temperature for ice melting (for phase transformation).

• coarsegrain

  If soil is coarse or fine, which determines different volume function against the temperature for phase transformation.

• freezepoint

  Liquid freeze point for phase transformation.

• friction

  Contact friction coefficient (DEM-drive contact algorithm).

• heatCapacity

  Heat capacity.

• infinistate

  Determines if we use finite strain theory to update the transformation matrix and strain.

• latentratio

  Latent ratio for phase transformation.

• planestrain

  Determine whether plane strain or plane stress.

• rho

  Density.

• unfrozenlimit

  Maximal unfrozen water volumetric fraction for fine soils transoformation model.

• unfrozenratio

  Unfrozen ratio for fine soils transoformation model.

• usecontentfrozen

  Determine whether user volumetric fraction or mass fraction.

class Dp -> Material

  Methods:

• Dp() -> void

  Default constructor for mpm.Dp.

• getStress(list <float> [oldsxx, oldsyy, oldszz, oldsxy], list <float> [dstxx, dstyy, dstxy]) -> list <float> [sxx, syy, szz, sxy]

  Unit test for this model.

• printInfo() -> void

  Print the debug information.

• printSState() -> void

  Print the debug information for unit test.

  Properties:

• E

  Young’s modulous

• c

  cohesion

• nu

  Poisson’s ratio

• phi

  friction angle

• psi

  dilation angle

class Elastic -> Material

  Methods:

• Elastic() -> void

  Default constructor for mpm.Elastic.

• printInfo() -> void

  Print the debug information.

  Properties:

• E

  Young’s modulous

• nu

  Poisson’s ratio

class Ghostmat -> Material

  Methods:

• Ghostmat() -> void

  Default constructor for mpm.Elastic.

• printInfo() -> void

  Print the debug information.

  Properties:

• thermalResistance

  The parameter for thermal simulation. (Not activated in mpm task.)

class Mc -> Material

  Methods:

• Mc() -> void

  Default constructor for mpm.Mc.

• getStress(list <float> [oldsxx, oldsyy, oldszz, oldsxy], list <float> [dstxx, dstyy, dstxy]) -> list <float> [sxx, syy, szz, sxy]

  Unit test for this model.

• printInfo() -> void

  Print the debug information.

  Properties:

• E

  Young’s modulous

• c

  cohesion

• nu

  Poisson’s ratio

• phi

  friction angle

• psi

  dilation angle

• tension

  tension cut-off

class McOrigin -> Material

  Methods:

• McOrigin() -> void

  Default constructor for mpm.McOrigin.

• getStress(list <float> [oldsxx, oldsyy, oldszz, oldsxy], list <float> [dstxx, dstyy, dstxy]) -> list <float> [sxx, syy, szz, sxy]

  Unit test for this model.

• printInfo() -> void

  Print the debug information.

  Properties:

• E
  Young’s modulous

• c
  cohesion

• nu
  Poisson’s ratio

• phi
  friction angle

• psi
  dilation angle

• tension
  tension cut-off

class NeoHookean -> Material

  Methods:

• NeoHookean() -> void

  Default constructor for mpm.NeoHookean.

• printInfo()

  Print the debug information.

  Properties:

• E

  Young’s modulous

• nu

  Poisson’s ratio

• uopt

  Different way to calculate the strain energy.

class NewtonLiquid -> Material

  Methods:

• NewtonLiquid() -> void

  Default constructor for mpm.NewtonLiquid.

• printInfo() -> void

  Print the debug information.

  Properties:

• bulk

  Bulk modulus

• visco

  Dynamic viscosity

class Shape

  Methods:

• Shape() -> void

  Note that: users are not allowed to call this constructor in the python script.

• setBc() -> void

  Overloaded function.

  1. setBc(int xon, float valuex, int yon, float valuey) -> void

     Set boundary flag and boundary value for x and y direction.

     Boundary value will be effective if and only if either xon or yon is True.

  2. setBc(int xon, string valuexexpr, int yon, float valueyexpr) -> void

     Set boundary flag and boundary value for x and y direction.

     Boundary value will be effective if and only if either xon or yon is True.

     Meanwhile, the expression for the boundary value will be parsed according to the currrent time.

     Say you can enter sin(t), which means a value will change following the sin function.

  3. setBc(int xon, string valuexexpr, bool fixposx, int yon, float valueyexpr, bool fixposy) -> void

     Set boundary flag and boundary value for x and y direction.

     Boundary value will be effective if and only if either xon or yon is True.

     If the fixposx or fixposy is true, RigidPts will only update the velocity not for position.

• setConsolidation() -> void Overloaded function.

  1. setConsolidation(float sxx, float yy) -> void

     Set initial consolidation stress.

  2. setConsolidation(string sxx, string yy) -> void

     Set initial consolidation stress with string, which will be parsed as numerical value.

• setDamping(float pdamping, float gdamping, float PIC) -> void

  Set the damping: particle damping, grid damping and PIC fraction.

• setInitTemperature(float temp) -> void

  Set the initial temperature.

• setMethod(int method, bool isfixed) -> void

  Overried the interpolation method set by mpm.Analysis.

  If isfixed is True, it means that the method will not be changed automatically.

• setThermalBc() -> void

  Set the prescribed temperature on Dirichlet BC for thermal field.

• setTracBc() -> void

  Overloaded function.

  1. setTracBc(int face, int dir, float value) -> void

     Set the traction force boundary condition.

     The face is from 0 - 3, starting from the bottom surface and in the anti-clock wise.

     Dir refer to the BCDIR enumeration.

     And the value is constant.

  2. setTracBc(int face, int dir, string value) -> void

     Set the traction force boundary condition.

     The face is from 0 - 3, starting from the bottom surface and in the anti-clock wise.

     Dir refer to the BCDIR enumeration.

     And the value will be parsed based on the current time.

• setUserContactNormal(float nx, float ny) -> void

  Set user defined contact normal for traditional contact algorithm.

• unsetThermalBc() -> void

  Cancel the thermal boundary condition.

class DemPolygon -> Shape

  Method:

• DemPolygon(float timestep, int searchrange, int callfrequency, float contactKn, float contactKs, float friction) -> void

  Constructor for the DemPolygon.

  Input arguments are: timestep, the radius searching range, the neighbourlist updating interval, normal contact stiffness, shear contact stiffness and the friction.

• addForce2Pt(bool applyforceonpt) -> void

  How the dem polygon add the force. True: add to pt, False: add to nodes.

• addPts(float px, float py) -> void

  Add one point to polygon.

• getDemForce() -> list <float> [forcex, forcey]

  Get reaction force in the horizontal and vertical direction.

• getPts() -> list <float>

  Get all the vertex coorinates of polygon.

• getReactionForce() -> list <float> [forcex, forcey]

  Get reaction force.

• printInfo() -> void

  Print the debug information.

• setDt(float timestep) -> void

  Set timestep for dempolygon

• setForceNormalDir(int axis, int forcestate) -> void

  Set the fixed contact normal direction. Axis 0 for horizontal direction, and 1 for vertical direction. Forcestate 0 for positive normal [0, 1], and 1 for negative normal [0, -1].

• setGravity(float gravityx, float gravityy) -> void

  Set the gravity.

• setInterval(int updateiters) -> void

  Set interval of neighbour list update.

• setPts(list <float>) -> void

  Set points array to polygon.

• setRange(int searchrange) -> void

  Set search range for updating the material points neighbour list.

• setRotFix(bool) -> void

  Set if the rotation of the DemPolygon is fixed.

• setShapeErr(float gjkerr) -> void

  Set the resolution for GJK contact detection.

• usePolygonContact(bool ispolygon) -> void

  Set the way that DemPolygon treats the material points. True: for polygon and False: disk.

class DemSphere -> Shape

  Method:

• DemSphere(float timestep, int searchrange, int callfrequency, float contactKn, float contactKs, float friction ) -> void

  Constructor for the DemSphere.

  Input arguments are: timestep, the radius searching range, the neighbourlist updating interval, normal contact stiffness, shear contact stiffness and the friction.

• addForce2Pt(bool applyforceonpt) -> void

  How the dem polygon add the force. True: add to pt, False: add to nodes.

• getPts() -> list <float>

  Get all the vertex coorinates of polygon.

• getReactionForce() -> list <float> [forcex, forcey]

  Get reaction force.

• printInfo() -> void

  Print the debug information.

• setArc() -> void

  Cut a arc from sphere.

• setPts(list <float>) -> void

  Set points array to polygon.

class Polygon -> Shape

  Methods:

• Polygon(int) -> void

  Input argument: shape type. Please refer to shapetype enumeration for details.

• setPts(list <float>) -> void

  Set the vertex for this polygon.

class Rectangle -> Shape

  Methods:

• Rectangle(float xmin, float xmax, float ymin, float ymax, int shapetype) -> void

  Input arguments: xmin, xmax, ymin, ymax. Shape type please refer to the SHAPETYPE enumeration.

class Ring -> Shape

  Methods:

• Ring(float px, float py, float inra, float outra, int shapetype ) -> void

  Input arguments: position x, position y, internal radius, external radius and shape type.

class Sphere -> Shape

  Methods:

• Sphere() -> void

  Overloaded function.

  1. Sphere(float xmin, float xmax, float ymin, float ymax, int shape type) -> void

     Input arguments: xmin, xmax, ymin, ymax. Shape type please refer to the SHAPETYPE enumeration.

  2. Sphere(float px, float py, float radius, int shape type) -> void

     Input arguments: position x and y, and radius. Shape type please refer to the SHAPETYPE enumeration.

class ContactEngine

  Properties:

• addforce2pt

  Add force to material points directly. Otherwise force will be applied on the nodes.

• potential

  The contact potential energy.

• radiusscale

  Ratio to scale the radius of material points used by the contact algorithm.

class MpmWriter

  Methods:

• MpmWriter() -> void

  Default constructor for mpm.Writer.

• setDir() -> void

  Set the top directory and current directory name for saving result files.

• setEndTime() -> void

  End time of writing result files.

• setIntervalTime() -> void

  Interval time of writing result files.

• setStartTime() -> void

  Start time of writing result files.

class PeriodicHook

  Methods:

• PeriodicHook() -> void

  Default constructor for mpm.Hook.

• reset() -> void

  Reset the period of the hook

  Properties:

• dead

  The hook is dead (True) or not.

• iterLast

  Iteration of last run.

• iterPeriod

  Iter Periodicity.

• realLast

  Real time of last run.

• realPeriod

  Real Periodicity.

• totalRuns

  The total runs for the hook.

• virtLast

  Virtual time of last run.

• virtPeriod

  Virtual Periodicity.

class PyHook -> PeriodicHook

  Properties:

• command

  command for the pyhook. WARNING: you cannot use the print function in the hook, or else it may encounter a crash in detached multi-threads. FIXEME in the future. As a workaround, we use app.print in GUI.

Enumeration BCDIR

  Members:

• XDIR

  Horizontal direction enumeration.

• YDIR

  Vertical direction enumeration.

• NORMALDIR

  Normal direction enumeration;

• TANGENTDIR

  Tangential direction enumeration;

Enumeration BCFIXSTATE

  Members:

• BCFREE

  Cancel boundary condition enumeration.

• BCFIXALL

  Fix boundary condition enumeration.

• BCFIXPLUS

  Fix positive direction only enumeration.

• BCFIXMINUS

  Fix negative direction only enumeration.

Enumeration MPMETHOD

  Members:

• NONEMETHOD

  No mpm method set.

• LINEAR

  Linear interpolation method.

• GIMP

  Generalized interpolation method.

• LINEARCPDI

  Linear covect particle domain interpolation method.

• MIXMETHOD

  Mixed interpolation method between GIMP and CPDI.

• BSPLINECPDI

  B-spline interpolation method (as same as affine mpm).

Enumeration MatType

  Members:

• RIGIDMAT

  Only for rigid material points.

• ELASTICMAT

  Elastic material.

• MCMAT

  Mohr-Coulomb material.

• GHOSTMAT

  Only for rigid matrial points. Refer to the examples for the difference between the RIGIDMAT and GHOSTMAT.

• NEOMAT

  Neo-Hookean material.

• NEWTONMAT

  Newton liquid material.

• DPMAT

  Drucker Prager material.

Enumeration SIMTYPEMASK

  Members:

• MANAL

  Mechanical simulation task.

• TANAL

  Thermal simulation task.

• PHASEANAL

  Phase transformation task.

Enumeration ShapeType

  Members:

• NONEBC

  No boundary condition will be set.

• NDSHAPE

  Node velocity boundary condition.

• MPTLOADSHAPE

  Body force load boundary condition for particles.

• MPTTRACSHAPE

  Traction force boundary condition for particles.

• RIGIDSHAPE

  Displacement or velocity boundary condition for rigid particles.

• GRAVITYSHAPE

  Gravity boundary condition for particles.

• DEMSHAPE

  Shapes for DEM-driven contact algorithm.

• MPTVELSHAPE

  Velocity boundary condition for particles.

• NDHEATSHAPE

  Thermal boundary condition for nodes.