geolib.models.dstability.internal

The internal data model structure.

Classes

AnalysisType

alias of AnalysisTypeEnum

AnalysisTypeEnum(value[, names, module, ...])

BishopBruteForceReliabilityResult(**data)

BishopBruteForceResult(**data)

BishopReliabilityResult(**data)

BishopResult(**data)

BishopSlipCircleResult(**data)

CalculationSettings(**data)

calculationsettings/calculationsettings_x.json

CalculationType

alias of CalculationTypeEnum

CalculationTypeEnum(value[, names, module, ...])

DStabilityBaseModelStructure(**data)

DStabilityStructure(**data)

Highest level DStability class that should be parsed to and serialized from.

DStabilitySubStructure(**data)

Decorations(**data)

decorations/decorations_x.json.

EmbankmentSoilScenarioEnum(value[, names, ...])

ForeignKeys(**data)

A dataclass that store the connections between the various unique Ids used in DStability.

Geometry(**data)

geometries/geometry_x.json

InternalStateTypeEnum(value[, names, ...])

Loads(**data)

loads/loads_x.json

NailProperties(**data)

nailpropertiesforsoils.json

NullablePersistablePoint(**data)

OptionsType

alias of OptionsTypeEnum

OptionsTypeEnum(value[, names, module, ...])

PersistableBishopBruteForceSettings(**data)

PersistableBishopSettings(**data)

PersistableBondStress(**data)

PersistableCalculation(**data)

PersistableCalculationContribution(**data)

PersistableCircle(**data)

PersistableConsolidation(**data)

PersistableDitchCharacteristics(**data)

PersistableEarthquake(**data)

PersistableElement(**data)

PersistableElevation(**data)

PersistableEmbankmentCharacteristics(**data)

PersistableExcavation(**data)

PersistableForbiddenLine(**data)

PersistableGeneticSlipPlaneConstraints(**data)

PersistableGeotextile(**data)

PersistableGridEnhancements(**data)

PersistableHeadLine(**data)

PersistableLayer(**data)

PersistableLayerLoad(**data)

PersistableLineLoad(**data)

PersistableMohrCoulombAdvancedShearStrengthModel(**data)

PersistableMohrCoulombClassicShearStrengthModel(**data)

PersistableNail(**data)

PersistableNailPropertiesForSoil(**data)

PersistablePoint(**data)

PersistableReferenceLine(**data)

PersistableSearchArea(**data)

PersistableSearchGrid(**data)

PersistableShadingTypeEnum(value[, names, ...])

PersistableSigmaTauTable(**data)

PersistableSigmaTauTablePoint(**data)

PersistableSlice(**data)

PersistableSlipPlaneConstraints(**data)

PersistableSoil(**data)

PersistableSoilContribution(**data)

PersistableSoilCorrelation(**data)

PersistableSoilLayer(**data)

PersistableSoilVisualization(**data)

PersistableSpencerGeneticSettings(**data)

PersistableSpencerSettings(**data)

PersistableSpencerSlice(**data)

PersistableStateCorrelation(**data)

PersistableStateLine(**data)

PersistableStateLinePoint(**data)

PersistableStateLinePointContribution(**data)

PersistableStatePoint(**data)

PersistableStatePointContribution(**data)

PersistableStochasticParameter(**data)

PersistableStress(**data)

PersistableStressAtDistance(**data)

PersistableSuShearStrengthModel(**data)

PersistableSuTable(**data)

PersistableSuTablePoint(**data)

PersistableTangentArea(**data)

PersistableTangentLines(**data)

PersistableTree(**data)

PersistableTwoCirclesOnTangentLine(**data)

PersistableUniformLoad(**data)

PersistableUpliftVanParticleSwarmSettings(**data)

PersistableUpliftVanSettings(**data)

PersistableWaterMeshProperties(**data)

ProjectInfo(**data)

projectinfo.json.

Reinforcements(**data)

reinforcements/reinforcements_x.json

Scenario(**data)

scenarios/scenario_x.json

ShearStrengthModelTypePhreaticLevelInternal(value)

Shear Strength Model Type.

SoilCollection(**data)

soils.json

SoilCorrelation(**data)

soilcorrelations.json

SoilLayerCollection(**data)

soillayers/soillayers_x.json

SoilVisualisation(**data)

SpencerGeneticAlgorithmReliabilityResult(**data)

SpencerGeneticAlgorithmResult(**data)

SpencerReliabilityResult(**data)

SpencerResult(**data)

SpencerSlipPlaneResult(**data)

Stage(**data)

stages/stage_x.json

State(**data)

states/states_x.json

StateCorrelation(**data)

statecorrelations/statecorrelations_1.json

UpliftVanParticleSwarmReliabilityResult(**data)

UpliftVanParticleSwarmResult(**data)

UpliftVanReliabilityResult(**data)

UpliftVanResult(**data)

UpliftVanSlipCircleResult(**data)

WaterDefinitionType

alias of WaterDefinitionTypeEnum

WaterDefinitionTypeEnum(value[, names, ...])

WaterMesh(**data)

watermeshes/watermeshes_x.json.

WaterMeshNode(**data)

Waternet(**data)

waternets/waternet_x.json.

WaternetCreatorSettings(**data)

waternetcreatorsettings/waternetcreatorsettings_x.json
geolib.models.dstability.internal.AnalysisType

alias of AnalysisTypeEnum

class geolib.models.dstability.internal.AnalysisTypeEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
BISHOP = 'Bishop'
BISHOP_BRUTE_FORCE = 'BishopBruteForce'
SPENCER = 'Spencer'
SPENCER_GENETIC = 'SpencerGenetic'
UPLIFT_VAN = 'UpliftVan'
UPLIFT_VAN_PARTICLE_SWARM = 'UpliftVanParticleSwarm'
class geolib.models.dstability.internal.BishopBruteForceReliabilityResult(**data)
Parameters:

data (Any)

CalculationContributions: Optional[list[Optional[PersistableCalculationContribution]]]
Circle: Optional[PersistableCircle]
Converged: Optional[bool]
DistanceToConvergence: UnionType[float, str, None]
FailureProbability: UnionType[float, str, None]
Id: Optional[str]
ReliabilityIndex: UnionType[float, str, None]
ResultThreshold: UnionType[float, str, None]
SlipPlaneResults: Optional[list]
SoilContributions: Optional[list[Optional[PersistableSoilContribution]]]
StateLinePointContributions: Optional[list[Optional[PersistableStateLinePointContribution]]]
StatePointContributions: Optional[list[Optional[PersistableStatePointContribution]]]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

BishopSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.BishopBruteForceResult(**data)
Parameters:

data (Any)

Circle: Optional[PersistableCircle]
FactorOfSafety: UnionType[float, str, None]
Id: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
ResultThreshold: UnionType[float, str, None]
Slices: Optional[list[Optional[PersistableSlice]]]
SlipPlaneResults: Optional[list]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

BishopSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.BishopReliabilityResult(**data)
Parameters:

data (Any)

CalculationContributions: Optional[list[Optional[PersistableCalculationContribution]]]
Circle: Optional[PersistableCircle]
Converged: Optional[bool]
DistanceToConvergence: UnionType[float, str, None]
FailureProbability: UnionType[float, str, None]
Id: Optional[str]
ReliabilityIndex: UnionType[float, str, None]
SoilContributions: Optional[list[Optional[PersistableSoilContribution]]]
StateLinePointContributions: Optional[list[Optional[PersistableStateLinePointContribution]]]
StatePointContributions: Optional[list[Optional[PersistableStatePointContribution]]]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

BishopSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.BishopResult(**data)
Parameters:

data (Any)

Circle: Optional[PersistableCircle]
FactorOfSafety: UnionType[float, str, None]
Id: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
Slices: Optional[list[Optional[PersistableSlice]]]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

BishopSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.BishopSlipCircleResult(**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].

radius: float
x: float
z: float
class geolib.models.dstability.internal.CalculationSettings(**data)

calculationsettings/calculationsettings_x.json

Parameters:

data (Any)

AnalysisType: Optional[AnalysisTypeEnum]
Bishop: Optional[PersistableBishopSettings]
BishopBruteForce: Optional[PersistableBishopBruteForceSettings]
CalculationType: Optional[CalculationTypeEnum]
ContentVersion: Optional[str]
Id: Optional[str]
ModelFactorMean: Optional[float]
ModelFactorStandardDeviation: Optional[float]
Spencer: Optional[PersistableSpencerSettings]
SpencerGenetic: Optional[PersistableSpencerGeneticSettings]
UpliftVan: Optional[PersistableUpliftVanSettings]
UpliftVanParticleSwarm: Optional[PersistableUpliftVanParticleSwarmSettings]
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].

set_bishop(bishop_settings)
Parameters:

bishop_settings (PersistableBishopSettings)

Return type:

None

set_bishop_brute_force(bishop_brute_force_settings)
Parameters:

bishop_brute_force_settings (PersistableBishopBruteForceSettings)

Return type:

None

set_spencer(spencer_settings)
Parameters:

spencer_settings (PersistableSpencerSettings)

Return type:

None

set_spencer_genetic(spencer_genetic_settings)
Parameters:

spencer_genetic_settings (PersistableSpencerGeneticSettings)

Return type:

None

set_uplift_van(uplift_van_settings)
Parameters:

uplift_van_settings (PersistableUpliftVanSettings)

Return type:

None

set_uplift_van_particle_swarm(uplift_van_particle_swarm_settings)
Parameters:

uplift_van_particle_swarm_settings (PersistableUpliftVanParticleSwarmSettings)

Return type:

None

classmethod transform_id_to_str(value)
Return type:

str

geolib.models.dstability.internal.CalculationType

alias of CalculationTypeEnum

class geolib.models.dstability.internal.CalculationTypeEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
DESIGN = 'Design'
DETERMINISTIC = 'Deterministic'
MEAN = 'Mean'
PROBABILISTIC = 'Probabilistic'
class geolib.models.dstability.internal.DStabilityBaseModelStructure(**data)
Parameters:

data (Any)

dict(*args, **kwargs)
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.models.dstability.internal.DStabilityStructure(**data)

Highest level DStability class that should be parsed to and serialized from.

The list[] items (one for each stage in the model) will be stored in a subfolder to multiple json files. Where the first (0) instance has no suffix, but the second one has (1 => _1) etc.

Also parses the outputs which are part of the json files

Parameters:

data (Any)

add_default_calculation(scenario_index, label, notes, unique_start_id=None)

Add a new default (empty) calculation to DStability.

Parameters:

  • scenario_index (int)

  • label (str)

  • notes (str)

  • unique_start_id (Optional[int])

Return type:

tuple[int, int]

add_default_scenario(label, notes, unique_start_id=None)

Add a new default (empty) scenario to DStability.

Parameters:

  • label (str)

  • notes (str)

  • unique_start_id (Optional[int])

Return type:

tuple[int, int]

add_default_stage(scenario_index, label, notes, unique_start_id=None)

Add a new default (empty) stage to DStability.

Parameters:

  • scenario_index (int)

  • label (str)

  • notes (str)

  • unique_start_id (Optional[int])

Return type:

tuple[int, int]

bishop_bruteforce_reliability_results: list[BishopBruteForceReliabilityResult]
bishop_bruteforce_results: list[BishopBruteForceResult]
bishop_reliability_results: list[BishopReliabilityResult]
bishop_results: list[BishopResult]
calculationsettings: list[CalculationSettings]
decorations: list[Decorations]
ensure_validity_foreign_keys()
geometries: list[Geometry]
get_result_substructure(analysis_type, calculation_type)
Parameters:
Return type:

list[UnionType[UpliftVanResult, UpliftVanParticleSwarmResult, UpliftVanReliabilityResult, UpliftVanParticleSwarmReliabilityResult, SpencerGeneticAlgorithmResult, SpencerReliabilityResult, SpencerGeneticAlgorithmReliabilityResult, SpencerResult, BishopBruteForceResult, BishopReliabilityResult, BishopBruteForceReliabilityResult, BishopResult, None]]

get_unique_id()

Return unique id that can be used in DStability. Finds all existing ids, takes the max and does +1.

Return type:

int

has_calculation(scenario_index, calculation_index)
Parameters:

  • scenario_index (int)

  • calculation_index (int)

Return type:

bool

has_loads(scenario_index, stage_index)
Parameters:

  • scenario_index (int)

  • stage_index (int)

Return type:

bool

has_reinforcements(scenario_index, stage_index)
Parameters:

  • scenario_index (int)

  • stage_index (int)

Return type:

bool

has_result(scenario_index, calculation_index)
Parameters:

  • scenario_index (int)

  • calculation_index (int)

Return type:

bool

has_scenario(scenario_index)
Parameters:

scenario_index (int)

Return type:

bool

has_soil_layer(scenario_index, stage_index, soil_layer_id)
Parameters:

  • scenario_index (int)

  • stage_index (int)

  • soil_layer_id (int)

Return type:

bool

has_soil_layers(scenario_index, stage_index)
Parameters:

  • scenario_index (int)

  • stage_index (int)

Return type:

bool

has_stage(scenario_index, stage_index)
Parameters:

  • scenario_index (int)

  • stage_index (int)

Return type:

bool

loads: list[Loads]
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].

nailproperties: NailProperties
projectinfo: ProjectInfo
reinforcements: list[Reinforcements]
scenarios: list[Scenario]
soilcorrelation: SoilCorrelation
soillayers: list[SoilLayerCollection]
soils: SoilCollection
soilvisualizations: SoilVisualisation
spencer_genetic_algorithm_reliability_results: list[SpencerGeneticAlgorithmReliabilityResult]
spencer_genetic_algorithm_results: list[SpencerGeneticAlgorithmResult]
spencer_reliability_results: list[SpencerReliabilityResult]
spencer_results: list[SpencerResult]
statecorrelations: list[StateCorrelation]
states: list[State]
uplift_van_particle_swarm_reliability_results: list[UpliftVanParticleSwarmReliabilityResult]
uplift_van_particle_swarm_results: list[UpliftVanParticleSwarmResult]
uplift_van_reliability_results: list[UpliftVanReliabilityResult]
uplift_van_results: list[UpliftVanResult]
validator()

Set the Validator class.

watermeshes: list[WaterMesh]
waternetcreatorsettings: list[WaternetCreatorSettings]
waternets: list[Waternet]
class geolib.models.dstability.internal.DStabilitySubStructure(**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].

classmethod structure_name()
class geolib.models.dstability.internal.Decorations(**data)

decorations/decorations_x.json.

Parameters:

data (Any)

ContentVersion: Optional[str]
Elevations: Optional[list[Optional[PersistableElevation]]]
Excavations: Optional[list[Optional[PersistableExcavation]]]
Id: Optional[str]
add_excavation(excavation)
Parameters:

excavation (PersistableExcavation)

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.EmbankmentSoilScenarioEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
CLAY_EMBANKMENT_ON_CLAY = 'ClayEmbankmentOnClay'
CLAY_EMBANKMENT_ON_SAND = 'ClayEmbankmentOnSand'
SAND_EMBANKMENT_ON_CLAY = 'SandEmbankmentOnClay'
SAND_EMBANKMENT_ON_SAND = 'SandEmbankmentOnSand'
class geolib.models.dstability.internal.ForeignKeys(**data)

A dataclass that store the connections between the various unique Ids used in DStability. These can be seen as (implicit) foreign keys.

Parameters:

data (Any)

property class_fields: dict[str, list[str]]

Return a mapping in the form: classname: [fields]

mapping: dict[str, tuple[str, ...]]
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.models.dstability.internal.Geometry(**data)

geometries/geometry_x.json

Parameters:

data (Any)

ContentVersion: Optional[str]
Id: Optional[str]
Layers: list[PersistableLayer]
add_layer(id, label, notes, points)

Add a new layer to the model. Layers are expected; 1. to contain at least 3 point (non closed polygons) 2. the points need to be in clockwise order 3. the polygon needs to be convex (no intersections with itsself)

Parameters:

  • id (str) – id of the layer

  • label (str) – label of the layer

  • notes (str) – notes for the layers

  • points (list[Points]) – list of Point classes

Returns:

the layer as a persistable object

Return type:

PersistableLayer

contains_point(point)

Check if the given point is on one of the points of the layers

Parameters:

point (Point) – A point type

Returns:

True if this point is found on a layer, False otherwise

Return type:

bool

Todo

Take x, z accuracy into account

get_layer(id)
Parameters:

id (int)

Return type:

PersistableLayer

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.InternalStateTypeEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
OCR = 'Ocr'
POP = 'Pop'
YIELD_STRESS = 'YieldStress'
class geolib.models.dstability.internal.Loads(**data)

loads/loads_x.json

Parameters:

data (Any)

ContentVersion: Optional[str]
Earthquake: Optional[PersistableEarthquake]
Id: Optional[str]
LayerLoads: Optional[list[Optional[PersistableLayerLoad]]]
LineLoads: Optional[list[Optional[PersistableLineLoad]]]
Trees: Optional[list[Optional[PersistableTree]]]
UniformLoads: Optional[list[Optional[PersistableUniformLoad]]]
add_layer_load(soil_layer_id, consolidations)
Parameters:

  • soil_layer_id (int)

  • consolidations (list[Consolidation])

Return type:

PersistableLayerLoad

add_load(load, consolidations)
Parameters:

  • load (DStabilityLoad)

  • consolidations (list[Consolidation])

Return type:

PersistableUniformLoad | PersistableLineLoad | PersistableLayerLoad | PersistableTree

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.NailProperties(**data)

nailpropertiesforsoils.json

Parameters:

data (Any)

ContentVersion: Optional[str]
NailPropertiesForSoils: Optional[list[Optional[PersistableNailPropertiesForSoil]]]
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].

classmethod structure_name()
Return type:

str

class geolib.models.dstability.internal.NullablePersistablePoint(**data)
Parameters:

data (Any)

X: UnionType[float, str, None]
Z: UnionType[float, str, 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].

geolib.models.dstability.internal.OptionsType

alias of OptionsTypeEnum

class geolib.models.dstability.internal.OptionsTypeEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
DEFAULT = 'Default'
THOROUGH = 'Thorough'
class geolib.models.dstability.internal.PersistableBishopBruteForceSettings(**data)
Parameters:

data (Any)

GridEnhancements: Optional[PersistableGridEnhancements]
SearchGrid: Optional[PersistableSearchGrid]
SlipPlaneConstraints: Optional[PersistableSlipPlaneConstraints]
TangentLines: Optional[PersistableTangentLines]
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.models.dstability.internal.PersistableBishopSettings(**data)
Parameters:

data (Any)

Circle: Optional[PersistableCircle]
Label: Optional[str]
Notes: Optional[str]
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.models.dstability.internal.PersistableBondStress(**data)
Parameters:

data (Any)

Sigma: UnionType[float, str, None]
Tau: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableCalculation(**data)
Parameters:

data (Any)

CalculationSettingsId: Optional[str]
Id: Optional[str]
Label: Optional[str]
Notes: Optional[str]
ResultId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableCalculationContribution(**data)
Parameters:

data (Any)

Alpha: UnionType[float, str, None]
CalculationId: Optional[str]
Property: Optional[str]
UncorrelatedAlpha: UnionType[float, str, None]
Value: UnionType[float, str, 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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableCircle(**data)
Parameters:

data (Any)

Center: Optional[PersistablePoint]
Radius: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableConsolidation(**data)
Parameters:

data (Any)

Degree: UnionType[float, str, None]
LayerId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableDitchCharacteristics(**data)
Parameters:

data (Any)

DitchBottomEmbankmentSide: UnionType[float, str, None]
DitchBottomLandSide: UnionType[float, str, None]
DitchEmbankmentSide: UnionType[float, str, None]
DitchLandSide: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableEarthquake(**data)
Parameters:

data (Any)

Consolidations: Optional[list[Optional[PersistableConsolidation]]]
FreeWaterFactor: Optional[float]
HorizontalFactor: Optional[float]
IsEnabled: Optional[bool]
Label: Optional[str]
Notes: Optional[str]
VerticalFactor: 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.models.dstability.internal.PersistableElement(**data)
Parameters:

data (Any)

WaterMeshNodes: Optional[list[WaterMeshNode]]
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.models.dstability.internal.PersistableElevation(**data)
Parameters:

data (Any)

AddedLayerId: Optional[str]
Label: Optional[str]
Notes: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableEmbankmentCharacteristics(**data)
Parameters:

data (Any)

EmbankmentToeLandSide: UnionType[float, str, None]
EmbankmentToeWaterSide: UnionType[float, str, None]
EmbankmentTopLandSide: UnionType[float, str, None]
EmbankmentTopWaterSide: UnionType[float, str, None]
ShoulderBaseLandSide: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableExcavation(**data)
Parameters:

data (Any)

Label: Optional[str]
Notes: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
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.models.dstability.internal.PersistableForbiddenLine(**data)
Parameters:

data (Any)

End: Optional[PersistablePoint]
Label: Optional[str]
Notes: Optional[str]
Start: Optional[PersistablePoint]
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.models.dstability.internal.PersistableGeneticSlipPlaneConstraints(**data)
Parameters:

data (Any)

IsEnabled: Optional[bool]
MinimumAngleBetweenSlices: Optional[float]
MinimumThrustLinePercentageInsideSlices: 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.models.dstability.internal.PersistableGeotextile(**data)
Parameters:

data (Any)

End: Optional[PersistablePoint]
Label: Optional[str]
Notes: Optional[str]
ReductionArea: UnionType[float, str, None]
Start: Optional[PersistablePoint]
TensileStrength: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableGridEnhancements(**data)
Parameters:

data (Any)

ExtrapolateSearchSpace: 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.models.dstability.internal.PersistableHeadLine(**data)
Parameters:

data (Any)

Id: Optional[str]
Label: Optional[str]
Notes: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableLayer(**data)
Parameters:

data (Any)

Id: Optional[str]
Label: Optional[str]
Notes: Optional[str]
Points: Annotated[list[PersistablePoint]]
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].

classmethod polygon_chack_validator(points)

Todo

Find a way to check the validity of the given points

classmethod polygon_checks(points)

Todo

Find a way to check the validity of the given points

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableLayerLoad(**data)
Parameters:

data (Any)

Consolidations: Optional[list[Optional[PersistableConsolidation]]]
LayerId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableLineLoad(**data)
Parameters:

data (Any)

Angle: UnionType[float, str, None]
Consolidations: Optional[list[Optional[PersistableConsolidation]]]
Label: Optional[str]
Location: Optional[PersistablePoint]
Magnitude: UnionType[float, str, None]
Notes: Optional[str]
Spread: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableMohrCoulombAdvancedShearStrengthModel(**data)
Parameters:

data (Any)

Cohesion: Optional[float]
CohesionAndFrictionAngleCorrelated: bool
CohesionStochasticParameter: PersistableStochasticParameter
Dilatancy: Optional[float]
DilatancyStochasticParameter: PersistableStochasticParameter
FrictionAngle: Optional[float]
FrictionAngleStochasticParameter: PersistableStochasticParameter
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.models.dstability.internal.PersistableMohrCoulombClassicShearStrengthModel(**data)
Parameters:

data (Any)

Cohesion: Optional[float]
CohesionAndFrictionAngleCorrelated: bool
CohesionStochasticParameter: PersistableStochasticParameter
FrictionAngle: Optional[float]
FrictionAngleStochasticParameter: PersistableStochasticParameter
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.models.dstability.internal.PersistableNail(**data)
Parameters:

data (Any)

BendingStiffness: Optional[float]
CriticalAngle: Optional[float]
Diameter: UnionType[float, str, None]
Direction: Optional[float]
GroutDiameter: Optional[float]
HorizontalSpacing: Optional[float]
Key: Optional[int]
Label: Optional[str]
LateralStresses: Optional[list[Optional[PersistableStressAtDistance]]]
Length: UnionType[float, str, None]
Location: Optional[PersistablePoint]
MaxPullForce: Optional[float]
Notes: Optional[str]
PlasticMoment: Optional[float]
ShearStresses: Optional[list[Optional[PersistableStressAtDistance]]]
UseFacing: Optional[bool]
UseLateralStress: Optional[bool]
UseShearStress: 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.models.dstability.internal.PersistableNailPropertiesForSoil(**data)
Parameters:

data (Any)

AreBondStressesActive: Optional[bool]
BondStresses: Optional[list[Optional[PersistableBondStress]]]
CompressionRatio: UnionType[float, str, None]
RheologicalCoefficient: UnionType[float, str, None]
SoilId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistablePoint(**data)
Parameters:

data (Any)

X: UnionType[float, str, None]
Z: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableReferenceLine(**data)
Parameters:

data (Any)

BottomHeadLineId: Optional[str]
Id: Optional[str]
Label: Optional[str]
Notes: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
TopHeadLineId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableSearchArea(**data)
Parameters:

data (Any)

Height: Optional[float]
Label: Optional[str]
Notes: Optional[str]
TopLeft: Optional[NullablePersistablePoint]
Width: 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.models.dstability.internal.PersistableSearchGrid(**data)
Parameters:

data (Any)

BottomLeft: Optional[NullablePersistablePoint]
Label: Optional[str]
Notes: Optional[str]
NumberOfPointsInX: Optional[int]
NumberOfPointsInZ: Optional[int]
Space: 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.models.dstability.internal.PersistableShadingTypeEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
DIAGONAL_A = 'DiagonalA'
DIAGONAL_B = 'DiagonalB'
DIAGONAL_C = 'DiagonalC'
DIAGONAL_D = 'DiagonalD'
DOT_A = 'DotA'
DOT_B = 'DotB'
DOT_C = 'DotC'
DOT_D = 'DotD'
HORIZONTAL_A = 'HorizontalA'
HORIZONTAL_B = 'HorizontalB'
NONE = 'None'
class geolib.models.dstability.internal.PersistableSigmaTauTable(**data)
Parameters:

data (Any)

IsSigmaTauTableProbabilistic: bool
SigmaTauTablePoints: list[PersistableSigmaTauTablePoint]
SigmaTauTableVariationCoefficient: 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].

to_global_sigma_tau_table()
class geolib.models.dstability.internal.PersistableSigmaTauTablePoint(**data)
Parameters:

data (Any)

EffectiveStress: float
ShearStrength: 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.models.dstability.internal.PersistableSlice(**data)
Parameters:

data (Any)

ArcLength: UnionType[float, str, None]
BottomAngle: UnionType[float, str, None]
BottomLeft: Optional[PersistablePoint]
BottomRight: Optional[PersistablePoint]
CohesionInput: UnionType[float, str, None]
CohesionOutput: UnionType[float, str, None]
DegreeOfConsolidationLoadPorePressure: UnionType[float, str, None]
DegreeOfConsolidationPorePressure: UnionType[float, str, None]
DilatancyInput: UnionType[float, str, None]
DilatancyOutput: UnionType[float, str, None]
EffectiveStress: UnionType[float, str, None]
HorizontalPorePressure: UnionType[float, str, None]
HorizontalSoilQuakeStress: UnionType[float, str, None]
HydrostaticPorePressure: UnionType[float, str, None]
InputShearStress: UnionType[float, str, None]
Label: Optional[str]
LoadStress: UnionType[float, str, None]
MInput: UnionType[float, str, None]
NormalStress: UnionType[float, str, None]
Ocr: UnionType[float, str, None]
OutputShearStress: UnionType[float, str, None]
PhiInput: UnionType[float, str, None]
PhiOutput: UnionType[float, str, None]
PiezometricPorePressure: UnionType[float, str, None]
Pop: UnionType[float, str, None]
ResultantForce: UnionType[float, str, None]
ResultantMoment: UnionType[float, str, None]
SInput: UnionType[float, str, None]
ShearStrengthModelType: Optional[ShearStrengthModelTypePhreaticLevelInternal]
ShearStress: UnionType[float, str, None]
SuInput: UnionType[float, str, None]
SuOutput: UnionType[float, str, None]
SurfacePorePressure: UnionType[float, str, None]
TopAngle: UnionType[float, str, None]
TopLeft: Optional[PersistablePoint]
TopRight: Optional[PersistablePoint]
TotalPorePressure: UnionType[float, str, None]
TotalStress: UnionType[float, str, None]
UpliftFactor: UnionType[float, str, None]
VerticalPorePressure: UnionType[float, str, None]
VerticalSoilQuakeStress: UnionType[float, str, None]
WaterQuakeStress: UnionType[float, str, None]
Weight: UnionType[float, str, None]
Width: UnionType[float, str, None]
YieldStress: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableSlipPlaneConstraints(**data)
Parameters:

data (Any)

IsSizeConstraintsEnabled: Optional[bool]
IsZoneAConstraintsEnabled: Optional[bool]
IsZoneBConstraintsEnabled: Optional[bool]
MinimumSlipPlaneDepth: Optional[float]
MinimumSlipPlaneLength: Optional[float]
WidthZoneA: Optional[float]
WidthZoneB: Optional[float]
XLeftZoneA: Optional[float]
XLeftZoneB: 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.models.dstability.internal.PersistableSoil(**data)
Parameters:

data (Any)

Code: str
Id: str
IsProbabilistic: bool
MohrCoulombAdvancedShearStrengthModel: PersistableMohrCoulombAdvancedShearStrengthModel
MohrCoulombClassicShearStrengthModel: PersistableMohrCoulombClassicShearStrengthModel
Name: Optional[str]
Notes: Optional[str]
ShearStrengthModelTypeAbovePhreaticLevel: ShearStrengthModelTypePhreaticLevelInternal
ShearStrengthModelTypeBelowPhreaticLevel: ShearStrengthModelTypePhreaticLevelInternal
SigmaTauTable: PersistableSigmaTauTable
SuShearStrengthModel: PersistableSuShearStrengthModel
SuTable: PersistableSuTable
VolumetricWeightAbovePhreaticLevel: float
VolumetricWeightBelowPhreaticLevel: 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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableSoilContribution(**data)
Parameters:

data (Any)

Alpha: UnionType[float, str, None]
Property: Optional[str]
SoilId: Optional[str]
UncorrelatedAlpha: UnionType[float, str, None]
Value: UnionType[float, str, 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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableSoilCorrelation(**data)
Parameters:

data (Any)

CorrelatedSoilIds: Optional[list[str]]
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].

classmethod transform_id_to_str(values)
Return type:

str

class geolib.models.dstability.internal.PersistableSoilLayer(**data)
Parameters:

data (Any)

LayerId: Optional[str]
SoilId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableSoilVisualization(**data)
Parameters:

data (Any)

Color: Optional[str]
PersistableShadingType: Optional[PersistableShadingTypeEnum]
SoilId: Optional[str]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableSpencerGeneticSettings(**data)
Parameters:

data (Any)

Label: Optional[str]
Notes: Optional[str]
OptionsType: Optional[OptionsTypeEnum]
SlipPlaneA: Optional[list[Optional[PersistablePoint]]]
SlipPlaneB: Optional[list[Optional[PersistablePoint]]]
SlipPlaneConstraints: Optional[PersistableGeneticSlipPlaneConstraints]
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.models.dstability.internal.PersistableSpencerSettings(**data)
Parameters:

data (Any)

Label: Optional[str]
Notes: Optional[str]
SlipPlane: Optional[list[Optional[PersistablePoint]]]
SlipPlaneConstraints: Optional[PersistableGeneticSlipPlaneConstraints]
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.models.dstability.internal.PersistableSpencerSlice(**data)
Parameters:

data (Any)

ArcLength: UnionType[float, str, None]
BottomAngle: UnionType[float, str, None]
BottomLeft: Optional[PersistablePoint]
BottomRight: Optional[PersistablePoint]
CohesionInput: UnionType[float, str, None]
CohesionOutput: UnionType[float, str, None]
DegreeOfConsolidationLoadPorePressure: UnionType[float, str, None]
DegreeOfConsolidationPorePressure: UnionType[float, str, None]
DilatancyInput: UnionType[float, str, None]
DilatancyOutput: UnionType[float, str, None]
EffectiveStress: UnionType[float, str, None]
HorizontalPorePressure: UnionType[float, str, None]
HorizontalSoilQuakeStress: UnionType[float, str, None]
HydrostaticPorePressure: UnionType[float, str, None]
InputShearStress: UnionType[float, str, None]
Label: Optional[str]
LeftForce: UnionType[float, str, None]
LeftForceAngle: UnionType[float, str, None]
LeftForceY: UnionType[float, str, None]
LoadStress: UnionType[float, str, None]
MInput: UnionType[float, str, None]
NormalStress: UnionType[float, str, None]
Ocr: UnionType[float, str, None]
OutputShearStress: UnionType[float, str, None]
PhiInput: UnionType[float, str, None]
PhiOutput: UnionType[float, str, None]
PiezometricPorePressure: UnionType[float, str, None]
Pop: UnionType[float, str, None]
ResultantForce: UnionType[float, str, None]
ResultantMoment: UnionType[float, str, None]
RightForce: UnionType[float, str, None]
RightForceAngle: UnionType[float, str, None]
RightForceY: UnionType[float, str, None]
SInput: UnionType[float, str, None]
ShearStrengthModelType: Optional[ShearStrengthModelTypePhreaticLevelInternal]
ShearStress: UnionType[float, str, None]
SuInput: UnionType[float, str, None]
SuOutput: UnionType[float, str, None]
SurfacePorePressure: UnionType[float, str, None]
TopAngle: UnionType[float, str, None]
TopLeft: Optional[PersistablePoint]
TopRight: Optional[PersistablePoint]
TotalPorePressure: UnionType[float, str, None]
TotalStress: UnionType[float, str, None]
UpliftFactor: UnionType[float, str, None]
VerticalPorePressure: UnionType[float, str, None]
VerticalSoilQuakeStress: UnionType[float, str, None]
WaterQuakeStress: UnionType[float, str, None]
Weight: UnionType[float, str, None]
Width: UnionType[float, str, None]
YieldStress: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableStateCorrelation(**data)
Parameters:

data (Any)

CorrelatedStateIds: Optional[list[Optional[str]]]
IsFullyCorrelated: 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].

classmethod transform_id_to_str(values)
Return type:

str

class geolib.models.dstability.internal.PersistableStateLine(**data)
Parameters:

data (Any)

Points: Optional[list[Optional[PersistablePoint]]]
Values: Optional[list[Optional[PersistableStateLinePoint]]]
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.models.dstability.internal.PersistableStateLinePoint(**data)
Parameters:

data (Any)

Above: Optional[PersistableStress]
Below: Optional[PersistableStress]
Id: Optional[str]
IsAboveAndBelowCorrelated: Optional[bool]
IsProbabilistic: Optional[bool]
Label: Optional[str]
Notes: Optional[str]
X: UnionType[float, str, 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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableStateLinePointContribution(**data)
Parameters:

data (Any)

Alpha: UnionType[float, str, None]
Property: Optional[str]
StateLinePointId: Optional[str]
UncorrelatedAlpha: UnionType[float, str, None]
Value: UnionType[float, str, 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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableStatePoint(**data)
Parameters:

data (Any)

Id: Optional[str]
IsProbabilistic: Optional[bool]
Label: Optional[str]
LayerId: Optional[str]
Notes: Optional[str]
Point: Optional[PersistablePoint]
Stress: Optional[PersistableStress]
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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableStatePointContribution(**data)
Parameters:

data (Any)

Alpha: UnionType[float, str, None]
Property: Optional[str]
StatePointId: Optional[str]
UncorrelatedAlpha: UnionType[float, str, None]
Value: UnionType[float, str, 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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.PersistableStochasticParameter(**data)
Parameters:

data (Any)

IsProbabilistic: bool
Mean: float
StandardDeviation: 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.models.dstability.internal.PersistableStress(**data)
Parameters:

data (Any)

Ocr: float
Pop: float
PopStochasticParameter: PersistableStochasticParameter
StateType: Optional[InternalStateTypeEnum]
YieldStress: 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.models.dstability.internal.PersistableStressAtDistance(**data)
Parameters:

data (Any)

Distance: UnionType[float, str, None]
Stress: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableSuShearStrengthModel(**data)
Parameters:

data (Any)

ShearStrengthRatio: Optional[float]
ShearStrengthRatioAndShearStrengthExponentCorrelated: bool
ShearStrengthRatioStochasticParameter: PersistableStochasticParameter
StrengthIncreaseExponent: Optional[float]
StrengthIncreaseExponentStochasticParameter: PersistableStochasticParameter
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.models.dstability.internal.PersistableSuTable(**data)
Parameters:

data (Any)

IsSuTableProbabilistic: bool
StrengthIncreaseExponent: float
StrengthIncreaseExponentStochasticParameter: PersistableStochasticParameter
SuTablePoints: list[PersistableSuTablePoint]
SuTableVariationCoefficient: 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].

to_global_su_table()
class geolib.models.dstability.internal.PersistableSuTablePoint(**data)
Parameters:

data (Any)

EffectiveStress: float
Su: 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.models.dstability.internal.PersistableTangentArea(**data)
Parameters:

data (Any)

Height: Optional[float]
Label: Optional[str]
Notes: Optional[str]
TopZ: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableTangentLines(**data)
Parameters:

data (Any)

BottomTangentLineZ: UnionType[float, str, None]
Label: Optional[str]
Notes: Optional[str]
NumberOfTangentLines: Optional[int]
Space: 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.models.dstability.internal.PersistableTree(**data)
Parameters:

data (Any)

Force: UnionType[float, str, None]
Label: Optional[str]
Location: Optional[PersistablePoint]
Notes: Optional[str]
RootZoneWidth: UnionType[float, str, None]
Spread: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableTwoCirclesOnTangentLine(**data)
Parameters:

data (Any)

FirstCircleCenter: Optional[NullablePersistablePoint]
FirstCircleRadius: UnionType[float, str, None]
SecondCircleCenter: Optional[NullablePersistablePoint]
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.models.dstability.internal.PersistableUniformLoad(**data)
Parameters:

data (Any)

Consolidations: Optional[list[Optional[PersistableConsolidation]]]
End: UnionType[float, str, None]
Label: Optional[str]
Magnitude: UnionType[float, str, None]
Notes: Optional[str]
Spread: UnionType[float, str, None]
Start: UnionType[float, str, 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].

class geolib.models.dstability.internal.PersistableUpliftVanParticleSwarmSettings(**data)
Parameters:

data (Any)

Label: Optional[str]
Notes: Optional[str]
OptionsType: Optional[OptionsTypeEnum]
SearchAreaA: Optional[PersistableSearchArea]
SearchAreaB: Optional[PersistableSearchArea]
SlipPlaneConstraints: Optional[PersistableSlipPlaneConstraints]
TangentArea: Optional[PersistableTangentArea]
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.models.dstability.internal.PersistableUpliftVanSettings(**data)
Parameters:

data (Any)

Label: Optional[str]
Notes: Optional[str]
SlipPlane: Optional[PersistableTwoCirclesOnTangentLine]
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.models.dstability.internal.PersistableWaterMeshProperties(**data)
Parameters:

data (Any)

CalculationName: Optional[str]
Date: Optional[str]
FileName: Optional[str]
ScenarioName: Optional[str]
Time: Optional[str]
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.models.dstability.internal.ProjectInfo(**data)

projectinfo.json.

Parameters:

data (Any)

Analyst: Optional[str]
ApplicationCreated: Optional[str]
ApplicationModified: Optional[str]
ContentVersion: Optional[str]
Created: Optional[date]
CrossSection: Optional[str]
Date: Optional[date]
IsDataValidated: Optional[bool]
LastModified: Optional[date]
LastModifier: Optional[str]
Path: Optional[str]
Project: Optional[str]
Remarks: Optional[str]
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].

classmethod nltime(date)
Parameters:

date (date | str)

Return type:

date

classmethod nltime_validator(date)
Parameters:

date (date | str)

Return type:

date

class geolib.models.dstability.internal.Reinforcements(**data)

reinforcements/reinforcements_x.json

Parameters:

data (Any)

ContentVersion: Optional[str]
ForbiddenLines: list[PersistableForbiddenLine]
Geotextiles: list[PersistableGeotextile]
Id: Optional[str]
Nails: list[PersistableNail]
add_reinforcement(reinforcement)
Parameters:

reinforcement (DStabilityReinforcement)

Return type:

PersistableForbiddenLine | PersistableGeotextile | PersistableNail

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.Scenario(**data)

scenarios/scenario_x.json

Parameters:

data (Any)

Calculations: Optional[list[PersistableCalculation]]
ContentVersion: Optional[str]
Id: Optional[str]
Label: Optional[str]
Notes: Optional[str]
Stages: Optional[list[Stage]]
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].

classmethod structure_name()
Return type:

str

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.ShearStrengthModelTypePhreaticLevelInternal(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

Shear Strength Model Type. These types represent the types that are internally defined in the json files of D-Stability.

MOHR_COULOMB_ADVANCED = 'MohrCoulombAdvanced'
MOHR_COULOMB_CLASSIC = 'MohrCoulombClassic'
NONE = 'None'
SIGMATAUTABLE = 'SigmaTauTable'
SU = 'Su'
SUTABLE = 'SuTable'
to_global_shear_strength_model()
class geolib.models.dstability.internal.SoilCollection(**data)

soils.json

Parameters:

data (Any)

ContentVersion: Optional[str]
Soils: list[PersistableSoil]
add_soil(soil)

Add a new soil to the model.

Parameters:

soil (Soil) – a new soil

Return type:

PersistableSoil

Returns:

None

get_global_soil(code)

Get soil by the given code.

Parameters:

code (str) – code of the soil

Returns:

the soil object

Return type:

Soil

get_soil(code)

Get soil by the given code.

Parameters:

code (str) – code of the soil

Returns:

the soil object

Return type:

Soil

get_soil_by_name(name)

Get soil by the given name.

Parameters:

  • code (str) – name of the soil

  • name (str)

Returns:

the soil object

Return type:

Soil

has_soil_code(code)

Checks if the soilcode is available in the current soil list.

Parameters:

code (str) – code of the soil

Returns:

True if found, False if not

Return type:

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].

classmethod structure_name()
Return type:

str

class geolib.models.dstability.internal.SoilCorrelation(**data)

soilcorrelations.json

Parameters:

data (Any)

ContentVersion: Optional[str]
SoilCorrelations: Optional[list[Optional[PersistableSoilCorrelation]]]
add_soil_correlation(list_correlated_soil_ids)

Add a new soil correlation to the model.

Parameters:

list_correlated_soil_ids (list[str]) – a list of soil ids that are correlated

Returns:

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].

classmethod structure_name()
Return type:

str

class geolib.models.dstability.internal.SoilLayerCollection(**data)

soillayers/soillayers_x.json

Parameters:

data (Any)

ContentVersion: Optional[str]
Id: Optional[str]
SoilLayers: list[PersistableSoilLayer]
add_soillayer(layer_id, soil_id)
Parameters:

  • layer_id (str)

  • soil_id (str)

Return type:

PersistableSoilLayer

get_ids(exclude_soil_layer_id)
Parameters:

exclude_soil_layer_id (Optional[int])

Return type:

set[str]

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].

classmethod structure_name()
Return type:

str

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.SoilVisualisation(**data)
Parameters:

data (Any)

ContentVersion: Optional[str]
SoilVisualizations: Optional[list[Optional[PersistableSoilVisualization]]]
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].

classmethod structure_name()
Return type:

str

class geolib.models.dstability.internal.SpencerGeneticAlgorithmReliabilityResult(**data)
Parameters:

data (Any)

CalculationContributions: Optional[list[Optional[PersistableCalculationContribution]]]
Converged: Optional[bool]
DistanceToConvergence: UnionType[float, str, None]
FailureProbability: UnionType[float, str, None]
Id: Optional[str]
ReliabilityIndex: UnionType[float, str, None]
SlipPlane: Optional[list[Optional[PersistablePoint]]]
SoilContributions: Optional[list[Optional[PersistableSoilContribution]]]
StateLinePointContributions: Optional[list[Optional[PersistableStateLinePointContribution]]]
StatePointContributions: Optional[list[Optional[PersistableStatePointContribution]]]
get_slipplane_output()

Get condensed slipplane data

Return type:

SpencerSlipPlaneResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.SpencerGeneticAlgorithmResult(**data)
Parameters:

data (Any)

FactorOfSafety: UnionType[float, str, None]
Id: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
ResultThreshold: UnionType[float, str, None]
Slices: Optional[list[Optional[PersistableSpencerSlice]]]
SlipPlane: Optional[list[Optional[PersistablePoint]]]
SlipPlaneResults: Optional[list]
get_slipplane_output()

Get condensed slipplane data

Return type:

SpencerSlipPlaneResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.SpencerReliabilityResult(**data)
Parameters:

data (Any)

CalculationContributions: Optional[list[Optional[PersistableCalculationContribution]]]
Converged: Optional[bool]
DistanceToConvergence: UnionType[float, str, None]
FailureProbability: UnionType[float, str, None]
Id: Optional[str]
ReliabilityIndex: UnionType[float, str, None]
SlipPlane: Optional[list[Optional[PersistablePoint]]]
SoilContributions: Optional[list[Optional[PersistableSoilContribution]]]
StateLinePointContributions: Optional[list[Optional[PersistableStateLinePointContribution]]]
StatePointContributions: Optional[list[Optional[PersistableStatePointContribution]]]
get_slipplane_output()

Get condensed slipplane data

Return type:

SpencerSlipPlaneResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.SpencerResult(**data)
Parameters:

data (Any)

FactorOfSafety: UnionType[float, str, None]
Id: Optional[str]
Points: Optional[list[Optional[PersistablePoint]]]
Slices: Optional[list[Optional[PersistableSpencerSlice]]]
SlipPlane: Optional[list[Optional[PersistablePoint]]]
get_slipplane_output()

Get condensed slipplane data

Return type:

SpencerSlipPlaneResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.SpencerSlipPlaneResult(**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].

slipplane: list[Point]
class geolib.models.dstability.internal.Stage(**data)

stages/stage_x.json

Parameters:

data (Any)

DecorationsId: Optional[str]
GeometryId: Optional[str]
Id: Optional[str]
Label: Optional[str]
LoadsId: Optional[str]
Notes: Optional[str]
ReinforcementsId: Optional[str]
SoilLayersId: Optional[str]
StateCorrelationsId: Optional[str]
StateId: Optional[str]
WaterDefinitionType: Optional[WaterDefinitionTypeEnum]
WaterMeshId: Optional[str]
WaternetCreatorSettingsId: Optional[str]
WaternetId: Optional[str]
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].

classmethod structure_name()
Return type:

str

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.State(**data)

states/states_x.json

Parameters:

data (Any)

ContentVersion: Optional[str]
Id: Optional[str]
StateLines: list[PersistableStateLine]
StatePoints: list[PersistableStatePoint]
add_state_line(points, state_points)
Parameters:
Return type:

PersistableStateLine

add_state_point(state_point)
Parameters:

state_point (PersistableStatePoint)

Return type:

None

get_state(state_id)
Parameters:

state_id (int)

Return type:

PersistableStatePoint | PersistableStateLine

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].

classmethod structure_name()
Return type:

str

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.StateCorrelation(**data)

statecorrelations/statecorrelations_1.json

Parameters:

data (Any)

ContentVersion: Optional[str]
Id: Optional[str]
StateCorrelations: Optional[list[Optional[PersistableStateCorrelation]]]
add_state_correlation(state_correlation)
Parameters:

state_correlation (PersistableStateCorrelation)

Return type:

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].

classmethod structure_name()
Return type:

str

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.UpliftVanParticleSwarmReliabilityResult(**data)
Parameters:

data (Any)

CalculationContributions: Optional[list[Optional[PersistableCalculationContribution]]]
Converged: Optional[bool]
DistanceToConvergence: UnionType[float, str, None]
FailureProbability: UnionType[float, str, None]
Id: Optional[str]
LeftCenter: Optional[PersistablePoint]
ReliabilityIndex: UnionType[float, str, None]
ResultThreshold: UnionType[float, str, None]
RightCenter: Optional[PersistablePoint]
SlipPlaneResults: Optional[list]
SoilContributions: Optional[list[Optional[PersistableSoilContribution]]]
StateLinePointContributions: Optional[list[Optional[PersistableStateLinePointContribution]]]
StatePointContributions: Optional[list[Optional[PersistableStatePointContribution]]]
TangentLine: UnionType[float, str, None]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

UpliftVanSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.UpliftVanParticleSwarmResult(**data)
Parameters:

data (Any)

FactorOfSafety: UnionType[float, str, None]
Id: Optional[str]
LeftCenter: Optional[PersistablePoint]
Points: Optional[list[Optional[PersistablePoint]]]
ResultThreshold: UnionType[float, str, None]
RightCenter: Optional[PersistablePoint]
Slices: Optional[list[Optional[PersistableSlice]]]
SlipPlaneResults: Optional[list]
TangentLine: UnionType[float, str, None]
get_slipcircle_output()

Get condensed slipplane data

Return type:

UpliftVanSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.UpliftVanReliabilityResult(**data)
Parameters:

data (Any)

CalculationContributions: Optional[list[Optional[PersistableCalculationContribution]]]
Converged: Optional[bool]
DistanceToConvergence: UnionType[float, str, None]
FailureProbability: UnionType[float, str, None]
Id: Optional[str]
LeftCenter: Optional[PersistablePoint]
ReliabilityIndex: UnionType[float, str, None]
RightCenter: Optional[PersistablePoint]
SoilContributions: Optional[list[Optional[PersistableSoilContribution]]]
StateLinePointContributions: Optional[list[Optional[PersistableStateLinePointContribution]]]
StatePointContributions: Optional[list[Optional[PersistableStatePointContribution]]]
TangentLine: UnionType[float, str, None]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

UpliftVanSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.UpliftVanResult(**data)
Parameters:

data (Any)

FactorOfSafety: UnionType[float, str, None]
Id: Optional[str]
LeftCenter: Optional[PersistablePoint]
Points: Optional[list[Optional[PersistablePoint]]]
RightCenter: Optional[PersistablePoint]
Slices: Optional[list[Optional[PersistableSlice]]]
TangentLine: UnionType[float, str, None]
get_slipcircle_output()

Get condensed slipcircle data

Return type:

UpliftVanSlipCircleResult

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].

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.UpliftVanSlipCircleResult(**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].

x_left: float
x_right: float
z_left: float
z_right: float
z_tangent: float
geolib.models.dstability.internal.WaterDefinitionType

alias of WaterDefinitionTypeEnum

class geolib.models.dstability.internal.WaterDefinitionTypeEnum(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)
WATERLINES = 'WaterLines'
WATERMESH = 'WaterMesh'
class geolib.models.dstability.internal.WaterMesh(**data)

watermeshes/watermeshes_x.json.

Parameters:

data (Any)

ContentVersion: Optional[str]
Elements: Optional[list[PersistableElement]]
Id: Optional[str]
UnitWeightWater: Optional[float]
WaterMeshProperties: Optional[PersistableWaterMeshProperties]
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].

classmethod structure_name()
Return type:

str

class geolib.models.dstability.internal.WaterMeshNode(**data)
Parameters:

data (Any)

Point: Optional[PersistablePoint]
TotalPorePressure: 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.models.dstability.internal.Waternet(**data)

waternets/waternet_x.json.

Parameters:

data (Any)

ContentVersion: Optional[str]
HeadLines: list[PersistableHeadLine]
Id: Optional[str]
PhreaticLineId: Optional[str]
ReferenceLines: list[PersistableReferenceLine]
UnitWeightWater: Optional[float]
add_head_line(head_line_id, label, notes, points, is_phreatic_line)
Parameters:

  • head_line_id (str)

  • label (str)

  • notes (str)

  • points (list[Point])

  • is_phreatic_line (bool)

Return type:

PersistableHeadLine

add_reference_line(reference_line_id, label, notes, points, bottom_head_line_id=None, top_head_line_id=None)
Parameters:

  • reference_line_id (str)

  • label (str)

  • notes (str)

  • points (list[Point])

  • bottom_head_line_id (Optional[str])

  • top_head_line_id (Optional[str])

Return type:

PersistableReferenceLine

get_head_line(head_line_id)
Parameters:

head_line_id (str)

Return type:

PersistableHeadLine

get_reference_line(reference_line_id)
Parameters:

reference_line_id (str)

Return type:

PersistableReferenceLine

has_head_line_id(head_line_id)
Parameters:

head_line_id (str)

Return type:

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].

classmethod structure_name()
Return type:

str

classmethod transform_id_to_str(value)
Return type:

str

class geolib.models.dstability.internal.WaternetCreatorSettings(**data)

waternetcreatorsettings/waternetcreatorsettings_x.json

Parameters:

data (Any)

AdjustForUplift: Optional[bool]
AquiferInsideAquitardLayerId: Optional[str]
AquiferLayerId: Optional[str]
AquiferLayerInsideAquitardLeakageLengthInwards: UnionType[float, str, None]
AquiferLayerInsideAquitardLeakageLengthOutwards: UnionType[float, str, None]
AquitardHeadLandSide: UnionType[float, str, None]
AquitardHeadWaterSide: UnionType[float, str, None]
ContentVersion: Optional[str]
DitchCharacteristics: Optional[PersistableDitchCharacteristics]
DrainageConstruction: Optional[PersistablePoint]
EmbankmentCharacteristics: Optional[PersistableEmbankmentCharacteristics]
EmbankmentSoilScenario: EmbankmentSoilScenarioEnum
Id: Optional[str]
InitialLevelEmbankmentTopLandSide: UnionType[float, str, None]
InitialLevelEmbankmentTopWaterSide: UnionType[float, str, None]
IntrusionLength: UnionType[float, str, None]
IsAquiferLayerInsideAquitard: Optional[bool]
IsDitchPresent: Optional[bool]
IsDrainageConstructionPresent: Optional[bool]
MeanWaterLevel: UnionType[float, str, None]
NormativeWaterLevel: UnionType[float, str, None]
OffsetEmbankmentToeLandSide: UnionType[float, str, None]
OffsetEmbankmentTopLandSide: UnionType[float, str, None]
OffsetEmbankmentTopWaterSide: UnionType[float, str, None]
OffsetShoulderBaseLandSide: UnionType[float, str, None]
PleistoceneLeakageLengthInwards: UnionType[float, str, None]
PleistoceneLeakageLengthOutwards: UnionType[float, str, None]
UseDefaultOffsets: Optional[bool]
WaterLevelHinterland: UnionType[float, str, 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].

transform_id_to_str(value)
Return type:

str