What is Geolib?

Geolib is an open source Python library that can be found on Github. It allows the generation, execution and parsing of several D-Serie numerical models. Geolib is a product realized in the years 2020-2021 in collaboration with different parties within the scope of a TKI project led by Deltares. CEMS was one of the contributing parties and actively followed further development.

The project

The route N243 comprises the provincial road through the municipalities of Alkmaar, Beemster and Koggenland and has a length of approximately 15.4 kilometers. The provincial road is characterized as a narrow road with a lot of traffic, a number of busy intersections and many direct road connections to homes and businesses. The province wants to make the N243 safer, improve traffic flow and, where possible, enhance the spatial characteristics of the area by redesigning the N243 and constructing roundabouts at a number of intersections.

The assignment for CRUX was to design the sheet pile wall along the road. CEMS helped CRUX to optimize the design using GEOLIB.

The data

For this project were initially available:

• 32 surface lines (cross sections)
• 77 cpts

The surface lines were available as Autocad drawings, we extracted them as .csv files and reduced the geometry points to a maximum of 15 (the maximum number of points allowed by DSheetPiling), to do so we used the Ramer-Douglas-Peucker Algorithm. The cpt's have been automatically classified by using the CEMS cpt-model, we generated the lithological profiles to check the schematization and correct it where needed.

Each surface line has been calculated with multiple cpt's and each combination of the cpt-surface line has been calculated for multiple sheet pile tip levels (np.arange(-6, -11, -0.25)), hence the 5000 calculations mentioned at the beginning.

The realization: some coding

The coding part has certainly been fun to do! Using the Geolib in a project like this, really showed the potential of automation when the right tools are available. The script is rather long, not really fitting for a blog post, so I will try to write about the most important steps.

As mentioned before we calculated multiple combinations of surface line/cpt/sheet pile level, so the logic looked something like this:

for id_, profile_name in enumerate(df_profiles["profile"]):
    for cpt_id in df_profiles.loc[id_, "cpt_id"]:
        for bottom_sheet in bottom_levels_sheet:

For each combination we define the model:

model = DSheetPilingModel()
modeltype = SheetModelType(
    verification=True,
    check_vertical_balance=False,
    trildens_calculation=False,
    method=LateralEarthPressureMethod(1),
            )
model.set_model(modeltype)

Defined multiple stages (initial, design, excavation, load ) and for each stage:

• Added the surface lines

ground_level_surface_left = Surface(name="surface_left",points=points_left)
ground_level_surface_right=Surface(name="surface_right",points=points_right)
model.add_surface(
    surface=ground_level_surface_left,
    side=Side.LEFT,
    stage_id=stage_id_inital,
            )
model.add_surface(
    surface=ground_level_surface_right,
    side=Side.RIGHT,
    stage_id=stage_id_inital,
            )

• Added soil materials

for soil_idx in df_soil_materials.index:
    soil = Soil(
           name=str(df_soil_materials.loc[soil_idx, "layer"]),
           color=Color(df_soil_materials.loc[soil_idx, "color"]),
               )
    soil.soil_weight_parameters.unsaturated_weight =df_soil_materials.loc[
                    soil_idx, "gamma"
                ]
    soil.soil_weight_parameters.saturated_weight = df_soil_materials.loc[
                    soil_idx, "gamma_sat"
                ]
    …

    model.add_soil(soil)

• Added soil layers
• Defined the sheet pile with multiple materials at different levels to take corrosion and combined sections into account

elements = []
for i, bottom in enumerate(bottom_levels):
    sheet_pile_properties = SheetPileProperties(
        material_type=df_sheet_piles.loc[i, 'material_type'],
        section_bottom_level=bottom,
        elastic_stiffness_ei=df_sheet_piles.loc[i, "elastic_stiffness_ei"],
        acting_width=df_sheet_piles.loc[i, "acting_width"],
        mr_char_el=df_sheet_piles.loc[i, "mr_char_el"],
        ...
    )
    sheet_element = Sheet(
        name=df_sheet_piles.loc[i, "name"],
        sheet_pile_properties=sheet_pile_properties,
    )
    elements.append(sheet_element)

model.set_construction(top_level=level_top, elements=elements)

• Defined the water levels
• Added loads, if present in the stage

We then calculated all the input files using all the available cores by using the multiprocessing Python library:

from multiprocessing import Pool, cpu_count

def calculate(file_name):
    model = DSheetPilingModel()
    model.parse(Path(f"{file_name}"))
    model.execute()

# Calculate
input_files = []
tasks = [*zip(input_files)]
with Pool(cpu_count()) as pool:
    pool.starmap(calculate, iterable=tasks)

Then we parsed all the output files with the parsing method of the model

model = DSheetPilingModel()
model.parse(Path(f"./{folder}/{file_name}.shd"))

and created summary tables and plots to make the results as visual as possible and allow the human mind to comprehend the large amount of information.

The figure below shows an example of the visualization. Each cross section (vertical dashed line) has been calculated for multiple cpts (horizontal lines of the same color), the horizontal line represents the bottom of the sheet pile at the minimum level required to meet the condition of displacement at the ULS <= max accepted value.

Conclusions

This project demonstrated how powerful automation can be in the search for the optimal design in a short amount of time. Without automation we wouldn't have been able to get to the same conclusions, because we simply wouldn't have the time for all the different calculations. By focusing on defining the correct process, rather than spending time setting up many calculations manually, we had the time to focus on analyzing results, executing extra calculations if needed and reducing mistakes in the process. For example by checking what would have happened if we used different parameters for the soil.

However, automation without a deep knowledge of the geotechnical processes is like a fancy empty cover case. The collaboration between me (CEMS) and Jefta Bouma (CRUX Engineering) has been crucial and necessary to tackle all the details and never compromise quality over quantity. Here a quote from Jefta about the collaboration within this project:

"The automation of the sheet pile calculations proved to be very beneficial for the project. It saved a lot of calculation time, which was especially beneficial when there was a change in the geometry of the cross sections. Because of the large number of calculations, which could be performed in a matter of hours, we were really able to optimize the sheet pile design."

I hope that this blog inspired you in doing more automation in your projects. If you liked this post make sure to follow us on LinkedIn to stay up-do-date!