A Python module to generate CB-Geo MPM’s input files

[SchDvr]

Hello everyone,

I'm a PhD student at Aix-Marseille University and INRAE institute (south of France) working on coupling MPM with DEM, under the supervision of Jerome Duriez, Pierre Philippe and Stephane Bonelli.

Using CB-Geo MPM (thank you for this code !), I felt it would be appropriate to have a Python module that would automatically generate CB-Geo MPM’s input files. I then created one, named PyCBG, documented and packaged it and I would like to share it with you.

Hoping this is the right place for such things, any feedback / discussion for a greater integration into your repository would be much welcome.

Where to find PyCBG Python module

A repository of the module source code is found here, with an automatic build of the doc there.

It has been uploaded to PyPI so it can be easily installed with pip install pycbg.

Also, PyCBG was published on Zenodo :

What it does

It enables a Python generation of expected .json input files, offering all Python capabilities to CB-Geo MPM users for this preprocessing stage.

Typing a few Python lines is usually enough for a user to define all necessary ingredients for a MPM simulation:

• generate the mesh (using gmsh)
• generate the particles
• define the entity sets
• create boundary conditions
• set the analysis' parameters
• setup batch of simulations (the documentation doesn't mention it yet but the function pycbg.preprocessing.setup_batch has a complete docstring)

While PyCBG is primarily designed to generate input files, it is also able to read the results from the hdf5 files and organize them in a Python object. For this reason, the module was splitted into two parts: preprocessing and postprocessing.

An example

Simulation of a settling column made with two different materials would be Python-defined as follows:

import pycbg.preprocessing as utl

# The usual start of a PyCBG script:
sim = utl.Simulation(title="Two_materials_column")

# Creating the mesh:
sim.create_mesh(dimensions=(1.,1.,10.), ncells=(1,1,10))

# Creating Material Points, could have been done by filling an array manually:
sim.create_particles(npart_perdim_percell=1)

# Creating entity sets (the 2 materials), using lambda functions:
sim.init_entity_sets()
lower_particles = sim.entity_sets.create_set(lambda x,y,z: z<5, typ="particle")
upper_particles = sim.entity_sets.create_set(lambda x,y,z: z>=5, typ="particle")

# The materials properties:
sim.materials.create_MohrCoulomb3D(pset_id=lower_particles)
sim.materials.create_Newtonian3D(pset_id=upper_particles)

# Boundary conditions on nodes entity sets (blocked displacements):
walls = []
walls.append([sim.entity_sets.create_set(lambda x,y,z: x==lim, typ="node") for lim in [0, sim.mesh.l0]])
walls.append([sim.entity_sets.create_set(lambda x,y,z: y==lim, typ="node") for lim in [0, sim.mesh.l1]])
walls.append([sim.entity_sets.create_set(lambda x,y,z: z==lim, typ="node") for lim in [0, sim.mesh.l2]])
for direction, sets in enumerate(walls): _ = [sim.add_velocity_condition(direction, 0., es) for es in sets]

# Other simulation parameters (gravity, number of iterations, time step, ..):
sim.set_gravity([0,0,-9.81])
nsteps = 1.5e5
sim.set_analysis_parameters(dt=1e-3, nsteps=nsteps, output_step_interval=nsteps/100)

# Save user defined parameters to be reused at the postprocessing stage:
sim.add_custom_parameters({"lower_particles": lower_particles,
                           "upper_particles": upper_particles,
                           "walls": walls})

# Final generation of input files:
sim.write_input_file()

This creates in the working directory a folder Two_materials_column where all the necessary input files are located. The paths of the input files are automatically chosen so the simulation can be started from the working directory with the following bash command:

<path_to_cbgeompm_executable> -f "$(pwd)/" -i Two_materials_column/input_file.json

And the simulation's results could eventually be Python-postprocessed (also from the working directory) as follows:

import pycbg.postprocessing as utl

# Load the results 
results = utl.ResultsReader("Two_materials_column")

# User's preprocessing parameters can be used in the postprocessing script 
sim = results.load_simulation()
print(sim.custom_params)

# Manipulate the results as you wish:
all_max_z = [max(pos[:,2]) for pos in results.ppositions]
print("Final height of the column: {:.2f} m".format(all_max_z[-1]))

[jgiven100]

Hi @SchDvr - this looks like a great addition and an easy way to make some straight-forward MPM input files. I'll give this a try.

[SchDvr]

Thanks ! Please tell me if you find the documentation unclear or incomplete.

[kks32]

Hi @SchDvr This is great! Really appreciate your work!! I'm planning to host the MPM code on https://designsafe-ci.org/ to run large-scale problems on HPC easily. DesignSafe supports Jupyter/Python and having your Python package for generating code and then launching it directly from a Jupyter notebook would be a wonderful addition.

Does this support both normal and GIMP meshes?

[SchDvr]

Thank you for your enthusiasm about this module !

I just pushed to PyCBG's repo some changes that enables support for ED3H20 and ED3H64 elements (it was a work in progress). I could re-upload PyCBG to PyPI to make the update easier, if necessary.

I haven't fully tried it though (I simply checked the mesh file for a 1 cell mesh), if you have any trouble please tell me.