geolib.soils.soil

Classes

BjerrumParameters(**data)	Bjerrum parameters class
ConeResistance(**data)	Cone resistance class
DistributionType(value[, names, module, ...])
EarthPressureCoefficients(**data)
EarthPressureCoefficientsType(value[, ...])
GrainType(value[, names, module, qualname, ...])
HorizontalBehaviour(**data)	Horizontal behaviour class
HorizontalBehaviourType(value[, names, ...])
IsotacheParameters(**data)
KoppejanParameters(**data)
LambdaType(value[, names, module, qualname, ...])
ModulusSubgradeReaction(value[, names, ...])
MohrCoulombParameters(**data)	Mohr Coulomb parameters class
ShearStrengthModelTypePhreaticLevel(value[, ...])	Shear Strength Model Type.
Soil(**data)	Soil Material.
SoilBaseModel(**data)
SoilClassificationParameters(**data)	Soil classification class
SoilState(**data)
SoilStiffnessParameters(**data)
SoilType(value[, names, module, qualname, ...])
SoilWeightParameters(**data)
StateLine(**data)	TODO Decide if we want to keep state in soil class TODO decide if we want cross-dependency to geometry class
StatePoint(**data)
StateType(value[, names, module, qualname, ...])
StochasticParameter(**data)	Stochastic parameters class
StorageParameters(**data)	In this case vertical_permeability has a unit of [m/day].
StorageTypes(value[, names, module, ...])
SuTablePoint(**data)
SubgradeReactionParameters(**data)
UndrainedParameters(**data)	Undrained shear strength parameters class.

class geolib.soils.soil.BjerrumParameters(**data)

Bjerrum parameters class

input_type_is_comp_ratio: [bool] is true when compression input mode is “compression ratio”, false when compression

input mode is “Compression index”

If input_type_is_comp_ratio is true, the following parameters are used as input:

reloading_swelling_RR compression_ratio_CR coef_secondary_compression_Ca

If input_type_is_comp_ratio is false, the following parameters are used as input:

reloading_swelling_index_Cr compression_index_Cc coef_secondary_compression_Ca

Parameters:

data (Any)

coef_secondary_compression_Ca: Union[float, StochasticParameter, None]

compression_index_Cc: Union[float, StochasticParameter, None]

compression_ratio_CR: Union[float, StochasticParameter, None]

correlation_reload_primary_compression_ratio: Optional[float]

input_type_is_comp_ratio: Optional[bool]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

primary_compression_index: Union[float, StochasticParameter, None]

primary_compression_ratio: Union[float, StochasticParameter, None]

reloading_index: Union[float, StochasticParameter, None]

reloading_ratio: Union[float, StochasticParameter, None]

reloading_swelling_RR: Union[float, StochasticParameter, None]

reloading_swelling_index_Cr: Union[float, StochasticParameter, None]

class geolib.soils.soil.ConeResistance(**data)

Cone resistance class

Parameters:

data (Any)

max_cone_resistance: Optional[float]

max_cone_resistance_type: Optional[Enum]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class geolib.soils.soil.DistributionType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Deterministic = 4

LogNormal = 3

Normal = 2

Undefined = 0

class geolib.soils.soil.EarthPressureCoefficients(**data)

Parameters:

data (Any)

active: Optional[float]

earth_pressure_coefficients_type: Optional[EarthPressureCoefficientsType]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

neutral: Optional[float]

passive: Optional[float]

class geolib.soils.soil.EarthPressureCoefficientsType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

BRINCHHANSEN = 1

MANUAL = 0

class geolib.soils.soil.GrainType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

COARSE = 1

FINE = 0

class geolib.soils.soil.HorizontalBehaviour(**data)

Horizontal behaviour class

Parameters:

data (Any)

horizontal_behavior_type: Optional[HorizontalBehaviourType]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

soil_default_elasticity: Optional[bool]

soil_elasticity: Optional[float]

class geolib.soils.soil.HorizontalBehaviourType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Elastic = 2

Foundation = 3

Stiff = 1

class geolib.soils.soil.IsotacheParameters(**data)

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

precon_isotache_type: Optional[StateType]

primary_compression_constant_b: Union[float, StochasticParameter, None]

reloading_swelling_constant_a: Union[float, StochasticParameter, None]

secondary_compression_constant_c: Union[float, StochasticParameter, None]

class geolib.soils.soil.KoppejanParameters(**data)

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

precon_koppejan_type: Optional[StateType]

preconsolidation_pressure: Union[float, StochasticParameter, None]

primary_Ap: Union[float, StochasticParameter, None]

primary_Asec: Union[float, StochasticParameter, None]

primary_Cp: Union[float, StochasticParameter, None]

primary_Cp_point: Union[float, StochasticParameter, None]

secular_Cs: Union[float, StochasticParameter, None]

secular_Cs_point: Union[float, StochasticParameter, None]

soil_ap_as_approximation_by_Cp_Cs: Optional[bool]

class geolib.soils.soil.LambdaType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

KOTTER = 2

MANUAL = 0

MULLERBRESLAU = 1

class geolib.soils.soil.ModulusSubgradeReaction(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

MANUAL = 0

MENARD = 1

class geolib.soils.soil.MohrCoulombParameters(**data)

Mohr Coulomb parameters class

Parameters:

data (Any)

cohesion: Union[float, StochasticParameter, None]

cohesion_and_friction_angle_correlated: Optional[bool]

dilatancy_angle: Union[float, StochasticParameter, None]

friction_angle: Union[float, StochasticParameter, None]

friction_angle_interface: Union[float, StochasticParameter, None]

is_delta_angle_automatically_calculated: Optional[bool]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class geolib.soils.soil.ShearStrengthModelTypePhreaticLevel(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Shear Strength Model Type. These types represent the shear strength model that can be found in the UI of the D-Stability program.

MOHR_COULOMB = 'Mohr_Coulomb'

NONE = 'None'

SHANSEP = 'SHANSEP'

SUTABLE = 'SuTable'

transform_shear_strength_model_type_to_internal()

class geolib.soils.soil.Soil(**data)

Soil Material.

Parameters:

data (Any)

bjerrum_parameters: Optional[BjerrumParameters]

code: Optional[str]

color: Color

cone_resistance: Optional[ConeResistance]

earth_pressure_coefficients: Optional[EarthPressureCoefficients]

horizontal_behaviour: Optional[HorizontalBehaviour]

id: Optional[str]

is_drained: Optional[bool]

is_probabilistic: Optional[bool]

isotache_parameters: Optional[IsotacheParameters]

koppejan_parameters: Optional[KoppejanParameters]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mohr_coulomb_parameters: Optional[MohrCoulombParameters]

name: Optional[str]

set_all_stochastic_parameters()

Loop over all fields in soil class, and converts floats to stochastic parameters if necessary

Returns:

static set_stochastic_parameters(input_class)

Converts float to stochastic parameter, where the mean is set as the input float value :type input_class: object :param input_class:

Returns:

shear_strength_model_above_phreatic_level: Optional[ShearStrengthModelTypePhreaticLevel]

shear_strength_model_below_phreatic_level: Optional[ShearStrengthModelTypePhreaticLevel]

shell_factor: Optional[float]

soil_classification_parameters: Optional[SoilClassificationParameters]

soil_state: Optional[SoilState]

soil_stiffness_parameters: Optional[SoilStiffnessParameters]

soil_type_nl: Optional[SoilType]

soil_type_settlement_by_vibrations: Optional[SoilType]

soil_weight_parameters: Optional[SoilWeightParameters]

storage_parameters: Optional[StorageParameters]

subgrade_reaction_parameters: Optional[SubgradeReactionParameters]

classmethod transform_id_to_str(value)

Return type:

str

undrained_parameters: Optional[UndrainedParameters]

use_probabilistic_defaults: Optional[bool]

use_tension: Optional[bool]

class geolib.soils.soil.SoilBaseModel(**data)

Parameters:

data (Any)

classmethod fail_on_infinite(v, _)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class geolib.soils.soil.SoilClassificationParameters(**data)

Soil classification class

Parameters:

data (Any)

d_50: Optional[float]

grain_type: Optional[GrainType]

initial_void_ratio: Union[float, StochasticParameter, None]

max_void_ratio: Optional[float]

min_void_ratio: Optional[float]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

porosity: Union[float, StochasticParameter, None]

relative_density: Optional[float]

class geolib.soils.soil.SoilState(**data)

Parameters:

data (Any)

equivalent_age: Optional[float]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

ocr_layer: Union[float, StochasticParameter, None]

pop_layer: Union[float, StochasticParameter, None]

secondary_swelling_factor: Optional[float]

secondary_swelling_reduced: Optional[bool]

state_lines: Optional[StateLine]

state_points: Optional[StatePoint]

unloading_stress_ratio: Optional[float]

use_equivalent_age: Optional[bool]

yield_stress_layer: Union[float, StochasticParameter, None]

class geolib.soils.soil.SoilStiffnessParameters(**data)

Parameters:

data (Any)

emod_menard: Optional[float]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class geolib.soils.soil.SoilType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

CLAY = 3

CLAYEYSAND = 7

GRAVEL = 0

LOAM = 2

PEAT = 4

SAND = 1

SANDY_LOAM = 5

TERTCLAY = 6

class geolib.soils.soil.SoilWeightParameters(**data)

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

saturated_weight: Union[float, StochasticParameter, None]

unsaturated_weight: Union[float, StochasticParameter, None]

class geolib.soils.soil.StateLine(**data)

TODO Decide if we want to keep state in soil class TODO decide if we want cross-dependency to geometry class

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

state_line_points: Optional[List[Point]]

class geolib.soils.soil.StatePoint(**data)

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

state_layer_id: Optional[str]

state_point_id: Optional[str]

state_point_is_probabilistic: Optional[bool]

state_point_type: Optional[StateType]

class geolib.soils.soil.StateType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

OCR = 'OCR'

POP = 'POP'

YIELD_STRESS = 'yield_stress'

class geolib.soils.soil.StochasticParameter(**data)

Stochastic parameters class

Parameters:

data (Any)

correlation_coefficient: Optional[float]

distribution_type: Optional[DistributionType]

high_characteristic_value: Optional[float]

high_design_value: Optional[float]

is_probabilistic: bool

low_characteristic_value: Optional[float]

low_design_value: Optional[float]

mean: Optional[float]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

standard_deviation: Optional[float]

class geolib.soils.soil.StorageParameters(**data)

In this case vertical_permeability has a unit of [m/day]. In GUI of the D-Settlement this value is displayed as [m/s].

Parameters:

data (Any)

horizontal_permeability: Union[float, StochasticParameter, None]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

permeability_horizontal_factor: Union[float, StochasticParameter, None]

permeability_strain_type: Union[float, StochasticParameter, None]

storage_type: Optional[StorageTypes]

vertical_consolidation_coefficient: Union[float, StochasticParameter, None]

vertical_permeability: Union[float, StochasticParameter, None]

class geolib.soils.soil.StorageTypes(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

constant_permeability = 1

strain_dependent_permeability = 2

vertical_consolidation_coefficient = 0

class geolib.soils.soil.SuTablePoint(**data)

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

stress: float

su: float

class geolib.soils.soil.SubgradeReactionParameters(**data)

Parameters:

data (Any)

k_1_bottom: Optional[float]

k_1_bottom_side: Optional[float]

k_1_top: Optional[float]

k_1_top_side: Optional[float]

k_2_bottom: Optional[float]

k_2_bottom_side: Optional[float]

k_2_top: Optional[float]

k_2_top_side: Optional[float]

k_3_bottom: Optional[float]

k_3_bottom_side: Optional[float]

k_3_top: Optional[float]

k_3_top_side: Optional[float]

k_4_bottom: Optional[float]

k_4_top: Optional[float]

k_o_bottom: Optional[float]

k_o_top: Optional[float]

lambda_type: Optional[LambdaType]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

modulus_subgrade_reaction_type: Optional[ModulusSubgradeReaction]

tangent_secant_1: Optional[float]

tangent_secant_2: Optional[float]

tangent_secant_3: Optional[float]

class geolib.soils.soil.UndrainedParameters(**data)

Undrained shear strength parameters class. This class includes the SU Table and SHANSEP model variables included in D-Stability.

Parameters:

data (Any)

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'forbid', 'ser_json_inf_nan': 'constants', 'validate_assignment': True, 'validate_default': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

probabilistic_su_table: Optional[bool]

s_and_m_correlated: Optional[bool]

shear_strength_ratio: Union[float, StochasticParameter, None]

shear_strength_ratio_and_shear_strength_exponent_correlated: Optional[bool]

strength_increase_exponent: Union[float, StochasticParameter, None]

su_table: Optional[List[SuTablePoint]]

su_table_variation_coefficient: Optional[float]

to_su_table_points()

undrained_shear_strength: Optional[float]

undrained_shear_strength_bearing_capacity_factor: Optional[float]

undrained_shear_strength_bottom: Optional[float]

undrained_shear_strength_top: Optional[float]