Tutorial D-Settlement

1. The model data should be set. This can be done by initializing the class DSettlementModel.

import geolib as gl

dm = gl.DSettlementModel()

2. The constitutive model, the consolidation model and the options are defined using the function set_model(). Here the calculation model options can be set.

dm.set_model(
    constitutive_model=gl.models.dsettlement.internal.SoilModel.ISOTACHE,
    consolidation_model=gl.models.dsettlement.internal.ConsolidationModel.DARCY,
    is_two_dimensional=True,
    strain_type=gl.models.dsettlement.internal.StrainType.LINEAR,
    is_vertical_drain=True,
    is_fit_for_settlement_plate=False,
    is_probabilistic=False,
    is_horizontal_displacements=False,
    is_secondary_swelling=False
)

3. Then the geometry of the model should be defined by setting up the points which will make up the full geometry.

# points for the geometry
p1 = gl.geometry.Point(x=-50, z=0.0)
p2 = gl.geometry.Point(x=-10, z=0.0)
p3 = gl.geometry.Point(x=0, z=2)
p4 = gl.geometry.Point(x=10, z=2)
p5 = gl.geometry.Point(x=30, z=0.0)
p6 = gl.geometry.Point(x=50, z=0.0)
p7 = gl.geometry.Point(x=-50, z=-5)
p8 = gl.geometry.Point(x=50, z=-5)
p9 = gl.geometry.Point(x=-50, z=-10)
p10 = gl.geometry.Point(x=50, z=-10)
p11 = gl.geometry.Point(x=-50, z=-20)
p12 = gl.geometry.Point(x=50, z=-20)
p15 = gl.geometry.Point(x=-50, z=-30)
p16 = gl.geometry.Point(x=-20, z=-30)
p17 = gl.geometry.Point(x=-10, z=-30)
p18 = gl.geometry.Point(x=0, z=-30)
p19 = gl.geometry.Point(x=10, z=-30)
p20 = gl.geometry.Point(x=20, z=-30)
p21 = gl.geometry.Point(x=25, z=-30)
p22 = gl.geometry.Point(x=30, z=-30)
p23 = gl.geometry.Point(x=35, z=-30)
p24 = gl.geometry.Point(x=40, z=-30)
p25 = gl.geometry.Point(x=45, z=-30)
p26 = gl.geometry.Point(x=50, z=-30)

After defining the first points the boundaries of the geometry can be defined. This is done by calling the function add_boundary(). A boundary is represented as a list of points.

b1 = dm.add_boundary([p11, p12])
b2 = dm.add_boundary([p9, p10])
b3 = dm.add_boundary([p7, p8])
b4 = dm.add_boundary([p1, p2, p5, p6])
b5 = dm.add_boundary([p1, p2, p3, p4, p5, p6])
b6 = dm.add_boundary(
    [p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26]
)

Then define the calculation verticals from the function set_verticals().

dm.set_verticals([p21])

Define the points for the headline and set these points as input in the function add_head_line().

# headline points
p13 = gl.geometry.Point(x=-50, z=-2)
p14 = gl.geometry.Point(x=50, z=-2)

pl_id = dm.add_head_line([p13, p14], is_phreatic=True)

4. After the basic geometry is inputted the soils can be defined. An example is appended below.

soil = gl.soils.Soil(name="Sand")
soil.soil_weight_parameters.saturated_weight.mean = 17
soil.soil_weight_parameters.unsaturated_weight.mean = 15
soil.soil_weight_parameters.saturated_weight.standard_deviation = 0.7
soil.soil_weight_parameters.unsaturated_weight.standard_deviation = 0.8
soil.storage_parameters.vertical_consolidation_coefficient.mean = 1.00e-12
soil.storage_parameters.vertical_consolidation_coefficient.standard_deviation = (
    5.00e-13
)
soil.soil_state.pop_layer.mean = 5
soil.isotache_parameters.precon_isotache_type = StateType.POP
soil.isotache_parameters.reloading_swelling_constant_a = StochasticParameter(
    mean=1.000e-02, standard_deviation=2.500e-03, correlation_coefficient=0.01
)
soil.isotache_parameters.primary_compression_constant_b = StochasticParameter(
    mean=1.000e-01, standard_deviation=2.500e-03
)
soil.isotache_parameters.secondary_compression_constant_c = StochasticParameter(
    mean=5.000e-03, standard_deviation=1.250e-03, correlation_coefficient=0.01
)
s1 = dm.add_soil(soil)

After the soils have been added, layers can be defined with the function add_layer(). Note that we refer to the soils by name.

l1 = dm.add_layer(
    material_name="Sand",
    head_line_top=pl_id,
    head_line_bottom=pl_id,
    boundary_top=b1,
    boundary_bottom=b2,
)
l2 = dm.add_layer(
    material_name="Sand",
    head_line_top=pl_id,
    head_line_bottom=pl_id,
    boundary_top=b2,
    boundary_bottom=b3,
)
l3 = dm.add_layer(
    material_name="Sand",
    head_line_top=pl_id,
    head_line_bottom=pl_id,
    boundary_top=b3,
    boundary_bottom=b4,
)
l4 = dm.add_layer(
    material_name="Sand",
    head_line_top=pl_id,
    head_line_bottom=pl_id,
    boundary_top=b4,
    boundary_bottom=b5,
)
l5 = dm.add_layer(
    material_name="Sand",
    head_line_top=pl_id,
    head_line_bottom=pl_id,
    boundary_top=b5,
    boundary_bottom=b6,
)

5. After the complete geometry is defined other inputs can be set. For example the vertical drains. Initialise class VerticalDrain. And add it to the model using set_vertical_drain()

from datetime import timedelta
test_drain = gl.models.dsettlement.drains.VerticalDrain(
    drain_type=gl.models.dsettlement.drain_types.DrainType.COLUMN,
    range_from=0.1,
    range_to=1.5,
    bottom_position=-10,
    center_to_center=4,
    diameter=0.1,
    grid=gl.models.dsettlement.drains.DrainGridType.RECTANGULAR,
    schedule=gl.models.dsettlement.drains.ScheduleValuesSimpleInput(
        start_of_drainage=timedelta(days=0.1),
        phreatic_level_in_drain=2,
        begin_time=1,
        end_time=100,
        underpressure=55,
        tube_pressure_during_dewatering=10,
        water_head_during_dewatering=12,
    ),
)
# set vertical drains
dm.set_vertical_drain(test_drain)

6. To perform a D-Settlement calculation at least one load should be defined. In this case a non uniform load is added to the model.

from datetime import timedelta
# set up the point list
point3 = gl.geometry.Point(label="1", x=-50, y=0, z=0)
point4 = gl.geometry.Point(label="2", x=-50, y=0, z=2)
point5 = gl.geometry.Point(label="3", x=-10, y=0, z=2)
point6 = gl.geometry.Point(label="4", x=-10, y=0, z=0)
pointlist = [point3, point4, point5, point6]
# Add first uniform load
dm.add_non_uniform_load(
    name="My First Load",
    points=pointlist,
    time_start=timedelta(days=0),
    time_end=timedelta(days=100),
    gamma_dry=20.02,
    gamma_wet=21.02,
)

7. To run the model first the model needs to be serialised. To do that define a output file name and call the function geolib.models.dsettlement.dsettlement_model.DSettlementModel.serialize().

from pathlib import Path
input_test_file = Path("Tutorial.sli")
dm.serialize(input_test_file)

8. Finally the execute function can be called to run the model in D-Settlement console.

dm.filename = input_test_file
dm.execute()