Input for DAM engine

DamInput

class dampythoninterface.input.DamInput(*, SurfaceLines: List[dampythoninterface.surface_line.SurfaceLine] = [], Soils: List[dampythoninterface.soil.Soil] = [], StabilityParameters: dampythoninterface.stability_parameters.StabilityParameters = None, SoilProfiles1D: List[dampythoninterface.soilprofile1D.SoilProfile1D] = [], Segments: List[dampythoninterface.segment.Segment] = [], Locations: List[dampythoninterface.location.Location] = [], FailureMechanismSystemType: dampythoninterface.input.FailureMechanismSystem, StabilityModelType: dampythoninterface.input.StabilityType, ProjectPath: pathlib.Path, CalculationMap: pathlib.Path = None, MaxCalculationCores: int = 1)

Class that contains all inputs for the DAM engine xml.

Parameters

  • SurfaceLines – List of surface lines for different profiles.

  • Soils – List of available soils

  • StabilityParameters – Stability parameters

  • Locations – List of locations

  • FailureMechanismSystemType – FailureMechanismSystem

  • Segments – List of segments

  • SoilProfiles1D – List of soil 1D profiles

  • StabilityModelType – StabilityType

  • ProjectPath – Path to the project folder

  • MaxCalculationCores – Maximum number of cores selected for the calculation

  • __xmlns_xsi__ – Default parameter that has to do with the xml format

  • __xmlns_xsd__ – Default parameter that has to do with the xml format

  • __DamProjectType__ – Project type

  • __AnalysisType__ – Analysis type

  • CalculationMap – Path to calculation map

CalculationMap: Optional[pathlib.Path]
ExportToXml(xml_file: pathlib.Path) → None

Function that export the DamInput dataclass to an xml that can be used as input of the DAMengine.

FailureMechanismSystemType: dampythoninterface.input.FailureMechanismSystem
Locations: List[dampythoninterface.location.Location]
MaxCalculationCores: Optional[int]
ProjectPath: pathlib.Path
Segments: List[dampythoninterface.segment.Segment]
SoilProfiles1D: List[dampythoninterface.soilprofile1D.SoilProfile1D]
Soils: List[dampythoninterface.soil.Soil]
StabilityModelType: dampythoninterface.input.StabilityType
StabilityParameters: Optional[dampythoninterface.stability_parameters.StabilityParameters]
SurfaceLines: List[dampythoninterface.surface_line.SurfaceLine]
execute(xml_input_file: pathlib.Path, xml_output_file: Optional[pathlib.Path] = None) → int

Function that runs xml file with the DAM.

classmethod segment_contains_existing_profile(v, values, **kwargs)
classmethod soil_profiles_contain_soils(v, values, **kwargs)
class dampythoninterface.input.FailureMechanismSystem(value)

An enumeration.

HorizontalBalance = 3
Piping = 2
StabilityInside = 0
StabilityOutside = 1
class dampythoninterface.input.StabilityType(value)

An enumeration.

Bishop = 'Bishop'
BishopUpliftVan = 'BishopUpliftVan'
UpliftVan = 'UpliftVan'
UpliftVanWti = 'UpliftVanWti'

SurfaceLine

class dampythoninterface.surface_line.Point(*, X: float, Z: float, PointType: dampythoninterface.surface_line.PointTypeEnum)

Dataclass that contains characteristic point corresponding to the SurfaceLine class.

Parameters

  • X – X coordinate.

  • Z – Z coordinate.

  • PointType – type of the characteristic point.

PointType: dampythoninterface.surface_line.PointTypeEnum
X: float
Z: float
class dampythoninterface.surface_line.PointTypeEnum(value)

Enumeration class for the characteristic point type.

BottomDitchDikeSide = 17
BottomDitchPolderSide = 18
DikeLine = 9
DikeToeAtPolder = 15
DikeToeAtRiver = 5
DikeTopAtPolder = 12
DikeTopAtRiver = 8
DitchDikeSide = 16
DitchPolderSide = 19
NONE = 0
ShoulderBaseInside = 13
ShoulderBaseOutside = 7
ShoulderTopInside = 14
ShoulderTopOutside = 6
SurfaceLevelInside = 25
SurfaceLevelOutside = 1
TrafficLoadInside = 11
TrafficLoadOutside = 10
class dampythoninterface.surface_line.SurfaceLine(*, Name: str, Points: List[dampythoninterface.surface_line.Point] = [])

Dataclass that contains geometry information for a profile

Parameters

  • Name – Name of the surface line.

  • Points – geometry information of a profile.

Name: str
Points: List[dampythoninterface.surface_line.Point]
classmethod check_that_necessary_points_exist(values: tuple) → tuple

Property validator of Points of the SurfaceLine class. Required characteristic points are:

  • Surface level outside

  • Dike toe at river

  • Dike top at river

  • Dike top at polder

  • Dike toe at polder

  • Surface level inside

static is_type_in_list(list_of_points: dampythoninterface.surface_line.Point, required_point_type: dampythoninterface.surface_line.Point) → bool
static raise_error_if_point_does_not_exist(list_of_points: dampythoninterface.surface_line.Point, name: str, required_point_type: dampythoninterface.surface_line.Point) → None
serialize() → lxml.etree.Element

Soil

class dampythoninterface.soil.DilatancyTypeModel(value)
MinusPhi = 'MinusPhi'
Phi = 'Phi'
Zero = 'Zero'
class dampythoninterface.soil.ShearStrengthModelType(value)

Enum class that contains different shear strength models of D-Stability.

CPhi = 'CPhi'
CPhiOrSuCalculated = 'CPhiOrSuCalculated'
NONE = 'None'
PseudoValues = 'PseudoValues'
StressTable = 'StressTable'
SuCalculated = 'SuCalculated'
SuCalculatedWithYield = 'SuCalculatedWithYield'
SuGradient = 'SuGradient'
SuMeasured = 'SuMeasured'
class dampythoninterface.soil.Soil(*, Name: str, BeddingAngle: float = 37, DiameterD70: float = 208, PermeabKx: float = None, WhitesConstant: float = 0.25, DiameterD90: float = None, AbovePhreaticLevel: float = None, BelowPhreaticLevel: float = None, DryUnitWeight: float = None, ShearStrengthModel: dampythoninterface.soil.ShearStrengthModelType = ShearStrengthModelType.NONE, UseDefaultShearStrengthModel: bool = False, Cohesion: float = None, FrictionAngle: float = None, Ocr: float = None, SlopeRestProfile: float = None, DilatancyType: dampythoninterface.soil.DilatancyTypeModel = DilatancyTypeModel.Zero, RRatio: float = None, StrengthIncreaseExponent: float = None, RatioCuPc: float = None)

Dataclass that contains soil parameters.

Parameters

  • Name – Name of the soil

  • BeddingAngle – bedding angle

  • DiameterD70 – 70%-fractile of the aquifer’s grain size distribution

  • PermeabKx – Permeability of soil

  • WhitesConstant – White’s constant

  • DiameterD90 – 90%-fractile of the aquifer’s grain size distribution

  • AbovePhreaticLevel – unit weight above phreatic line

  • BelowPhreaticLevel – unit weight below phreatic line

  • DryUnitWeight – dry unit weight of soil

  • ShearStrengthModel – shear strength model of the soil for D-Stability calculation

  • UseDefaultShearStrengthModel – option that determines if the default shear strength model should be used

  • Cohesion – cohesion of the soil

  • FrictionAngle – friction angle

  • Ocr – Overconsolidation ratio

  • SlopeRestProfile – outdated value that determines the slope of the resting profile

  • DilatancyType – dilatancy type model

  • RRatio – outdated value of R ratio

  • StrengthIncreaseExponent – strength increase exponent m

  • RatioCuPc – ratio between Cu and Pc

AbovePhreaticLevel: Optional[float]
BeddingAngle: Optional[float]
BelowPhreaticLevel: Optional[float]
Cohesion: Optional[float]
DiameterD70: Optional[float]
DiameterD90: Optional[float]
DilatancyType: Optional[dampythoninterface.soil.DilatancyTypeModel]
DryUnitWeight: Optional[float]
FrictionAngle: Optional[float]
Name: str
Ocr: Optional[float]
PermeabKx: Optional[float]
RRatio: Optional[float]
RatioCuPc: Optional[float]
ShearStrengthModel: Optional[dampythoninterface.soil.ShearStrengthModelType]
SlopeRestProfile: Optional[float]
StrengthIncreaseExponent: Optional[float]
UseDefaultShearStrengthModel: Optional[bool]
WhitesConstant: Optional[float]
serialize_soil() → lxml.etree.Element

Function that serializes the Soil class.

Stability Parameters

class dampythoninterface.stability_parameters.BishopTangentLinesDefinitionType(value)

An enumeration.

OnBoundaryLines = 0
Specified = 1
class dampythoninterface.stability_parameters.GridDeterminationType(value)

An enumeration.

Automatic = 0
Specified = 1
class dampythoninterface.stability_parameters.SearchMethodType(value)

An enumeration.

Calculationgrid = 0
GeneticAlgorithm = 1
class dampythoninterface.stability_parameters.StabilityParameters(*, SearchMethod: dampythoninterface.stability_parameters.SearchMethodType = SearchMethodType.Calculationgrid, GridDetermination: dampythoninterface.stability_parameters.GridDeterminationType = GridDeterminationType.Automatic, BishopTangentLinesDefinition: dampythoninterface.stability_parameters.BishopTangentLinesDefinitionType = BishopTangentLinesDefinitionType.OnBoundaryLines, BishopTangentLinesDistance: float = None, BishopGridVerticalPointsCount: int = None, BishopGridVerticalPointsDistance: float = None, BishopGridHorizontalPointsCount: int = None, BishopGridHorizontalPointsDistance: float = None, UpliftVanGridLeftVerticalPointsCount: int = None, UpliftVanGridLeftVerticalPointsDistance: float = None, UpliftVanGridLeftHorizontalPointsCount: int = None, UpliftVanGridLeftHorizontalPointsDistance: float = None, UpliftVanGridRightVerticalPointsCount: int = None, UpliftVanGridRightVerticalPointsDistance: float = None, UpliftVanGridRightHorizontalPointsCount: int = None, UpliftVanGridRightHorizontalPointsDistance: float = None, UpliftVanTangentLinesDefinition: dampythoninterface.stability_parameters.UpliftVanTangentLinesDefinitionType = UpliftVanTangentLinesDefinitionType.OnBoundaryLines, UpliftVanTangentLinesDistance: float = None)

Dataclass that contains stability parameters.

Parameters

  • SearchMethod – Type of search method for stability

  • GridDetermination – Type of grid determination method

  • BishopTangentLinesDefinition – Types of tangent lines for the Bishop model

  • BishopTangentLinesDistance – Distance between tangent lines

  • BishopGridVerticalPointsCount – Number of points contained on the Bishop grid on the vertical direction

  • BishopGridVerticalPointsDistance – Distance between points contained on the Bishop grid on the vertical direction

  • BishopGridHorizontalPointsCount – Number of points contained on the Bishop grid on the horizontal direction

  • BishopGridHorizontalPointsDistance – Distance between points contained on the Bishop grid on the horizontal direction

  • UpliftVanGridLeftVerticalPointsCount – Number of point for the left side of the Uplift van Grid model on the vertical direction

  • UpliftVanGridLeftVerticalPointsDistance – Distance between points for the left side of the Uplift van Grid model on the vertical direction

  • UpliftVanGridLeftHorizontalPointsCount – Number of point for the left side of the Uplift van Grid model on the horizontal direction

  • UpliftVanGridLeftHorizontalPointsDistance – Distance between points for the left side of the Uplift van Grid model on the horizontal direction

  • UpliftVanGridRightVerticalPointsCount – Number of point for the right side of the Uplift van Grid model on the vertical direction

  • UpliftVanGridRightVerticalPointsDistance – Distance between points for the right side of the Uplift van Grid model on the vertical direction

  • UpliftVanGridRightHorizontalPointsCount – Number of point for the right side of the Uplift van Grid model on the horizontal direction

  • UpliftVanGridRightHorizontalPointsDistance – Number of point for the right side of the Uplift van Grid model on the vertical direction

  • UpliftVanTangentLinesDefinition – Types of tangent lines for the Uplift van Grid model

  • UpliftVanTangentLinesDistance – Distance between tangent lines for the Uplift van Grid model

BishopGridHorizontalPointsCount: Optional[int]
BishopGridHorizontalPointsDistance: Optional[float]
BishopGridVerticalPointsCount: Optional[int]
BishopGridVerticalPointsDistance: Optional[float]
BishopTangentLinesDefinition: Optional[dampythoninterface.stability_parameters.BishopTangentLinesDefinitionType]
BishopTangentLinesDistance: Optional[float]
GridDetermination: dampythoninterface.stability_parameters.GridDeterminationType
SearchMethod: dampythoninterface.stability_parameters.SearchMethodType
UpliftVanGridLeftHorizontalPointsCount: Optional[int]
UpliftVanGridLeftHorizontalPointsDistance: Optional[float]
UpliftVanGridLeftVerticalPointsCount: Optional[int]
UpliftVanGridLeftVerticalPointsDistance: Optional[float]
UpliftVanGridRightHorizontalPointsCount: Optional[int]
UpliftVanGridRightHorizontalPointsDistance: Optional[float]
UpliftVanGridRightVerticalPointsCount: Optional[int]
UpliftVanGridRightVerticalPointsDistance: Optional[float]
UpliftVanTangentLinesDefinition: Optional[dampythoninterface.stability_parameters.UpliftVanTangentLinesDefinitionType]
UpliftVanTangentLinesDistance: Optional[float]
serialize()

Function that serializes the StabilityParameters class.

class dampythoninterface.stability_parameters.UpliftVanTangentLinesDefinitionType(value)

An enumeration.

OnBoundaryLines = 0
Specified = 1

Soil profile 1D

class dampythoninterface.soilprofile1D.Layer1D(*, Name: str, SoilName: str, TopLevel: float, IsAquifer: bool, WaterpressureInterpolationModel: dampythoninterface.soilprofile1D.WaterpressureInterpolationModelType)

Dataclass that contains a 1D layer

Parameters

  • Name – name of the layer

  • SoilName – soil name that is assigned in the soil layer

  • TopLevel – top level of the soil layer

  • IsAquifer – value that determines if an aquifer is contained in the layer

  • WaterpressureInterpolationModel – water pressure interpolation method

IsAquifer: bool
Name: str
SoilName: str
TopLevel: float
WaterpressureInterpolationModel: dampythoninterface.soilprofile1D.WaterpressureInterpolationModelType
serialize() → lxml.etree.Element

Function that serializes the Layer1D class.

class dampythoninterface.soilprofile1D.SoilProfile1D(*, Name: str, BottomLevel: float, Layers1D: List[dampythoninterface.soilprofile1D.Layer1D] = [])

Dataclass that contains a 1D soil profile

Parameters

  • Name – name of the soil profile

  • BottomLevel – bottom level of the whole soil profile

  • Layers1D – list of layers included in the soil profile

BottomLevel: float
Layers1D: List[dampythoninterface.soilprofile1D.Layer1D]
Name: str
serialize() → lxml.etree.Element

Function that serializes the class SoilProfile1D class.

class dampythoninterface.soilprofile1D.WaterpressureInterpolationModelType(value)
Automatic = 0
Hydrostatic = 1

Segment

class dampythoninterface.segment.Segment(*, Name: str, SoilGeometryProbability: List[dampythoninterface.segment.SoilGeometryProbabilityElement] = [])

Dataclass for a segment

Parameters

  • Name – name of the segment

  • SoilGeometryProbability – List of SoilGeometryProbabilityElement

Name: str
SoilGeometryProbability: List[dampythoninterface.segment.SoilGeometryProbabilityElement]
serialize() → lxml.etree.Element

Function that serializes the Segment dataclass.

class dampythoninterface.segment.SegmentFailureMechanismTypeClass(value)
All = 0
Liquefaction = 3
Piping = 2
Stability = 1
class dampythoninterface.segment.SoilGeometryProbabilityElement(*, SoilProfileName: str, SoilProfileType: dampythoninterface.segment.SoilProfileTypeClass, SegmentFailureMechanismType: dampythoninterface.segment.SegmentFailureMechanismTypeClass = SegmentFailureMechanismTypeClass.Stability, Probability: float)

Dataclass that contains the propability and the failure mechanism type of an occuring profile.

Parameters

  • SoilProfileName – name of the selected soil profile

  • SoilProfileType – geometry type of the selected soil profile

  • SegmentFailureMechanismType – type of failure mechanism selected for a profile

  • Probability – probability of selected geometry

Probability: float
SegmentFailureMechanismType: Optional[dampythoninterface.segment.SegmentFailureMechanismTypeClass]
SoilProfileName: str
SoilProfileType: dampythoninterface.segment.SoilProfileTypeClass
serialize() → lxml.etree.Element

Function that serializes the SoilGeometryProbabilityElement dataclass.

class dampythoninterface.segment.SoilProfileTypeClass(value)
ProfileType1D = 0
ProfileType2D = 1
ProfileTypeStiFile = 2

Location

class dampythoninterface.location.DesignOptions(*, RedesignDikeHeight: bool, RedesignDikeShoulder: bool, ShoulderEmbankmentMaterial: str, StabilityShoulderGrowSlope: float, StabilityShoulderGrowDeltaX: float, StabilitySlopeAdaptionDeltaX: float, SlopeAdaptionStartCotangent: float, SlopeAdaptionEndCotangent: float, SlopeAdaptionStepCotangent: float, NewDikeTopWidth: float = None, NewDikeSlopeInside: float = None, NewDikeSlopeOutside: float = None, NewShoulderTopSlope: float = None, NewShoulderBaseSlope: float = None, NewMaxHeightShoulderAsFraction: float = None, NewMinDistanceDikeToeStartDitch: float = None, UseNewDitchDefinition: bool, NewWidthDitchBottom: float = None, NewSlopeAngleDitch: float = None, NewDepthDitch: float = None, StabilityDesignMethod: dampythoninterface.location.StabilityDesignMethodType)

Dataclass of DesignOptions

Parameters

  • RedesignDikeHeight – redesign value of the dike height

  • RedesignDikeShoulder – redesign value of the dike shoulder

  • ShoulderEmbankmentMaterial – material of the dike shoulder

  • StabilityShoulderGrowSlope – slope of the shoulder grow for stability

  • StabilityShoulderGrowDeltaX – delta(x) of the shoulder grow for stability

  • StabilitySlopeAdaptionDeltaX – delta(x) of the slope adaptation for stability

  • SlopeAdaptionStartCotangent – cotangent start for the slope adaptation

  • SlopeAdaptionEndCotangent – cotangent end for the slope adaptation

  • SlopeAdaptionStepCotangent – cotangent step for the slope adaptation

  • NewDikeTopWidth – new dike top width

  • NewDikeSlopeInside – new dike slope inside

  • NewDikeSlopeOutside – new dike slope outside

  • NewShoulderTopSlope – slope of top for new shoulder

  • NewShoulderBaseSlope – slope of base for new shoulder

  • NewMaxHeightShoulderAsFraction – new maximum height of shoulder inputted as fraction

  • NewMinDistanceDikeToeStartDitch – new minimum distance of dike toe at the start of the ditch

  • UseNewDitchDefinition – is the new ditch definition used

  • NewWidthDitchBottom – new width of the bottom for ditch

  • NewSlopeAngleDitch – new slope angle for ditch

  • NewDepthDitch – new depth for ditch

  • StabilityDesignMethod – stability design method

NewDepthDitch: Optional[float]
NewDikeSlopeInside: Optional[float]
NewDikeSlopeOutside: Optional[float]
NewDikeTopWidth: Optional[float]
NewMaxHeightShoulderAsFraction: Optional[float]
NewMinDistanceDikeToeStartDitch: Optional[float]
NewShoulderBaseSlope: Optional[float]
NewShoulderTopSlope: Optional[float]
NewSlopeAngleDitch: Optional[float]
NewWidthDitchBottom: Optional[float]
RedesignDikeHeight: bool
RedesignDikeShoulder: bool
ShoulderEmbankmentMaterial: str
SlopeAdaptionEndCotangent: float
SlopeAdaptionStartCotangent: float
SlopeAdaptionStepCotangent: float
StabilityDesignMethod: dampythoninterface.location.StabilityDesignMethodType
StabilityShoulderGrowDeltaX: float
StabilityShoulderGrowSlope: float
StabilitySlopeAdaptionDeltaX: float
UseNewDitchDefinition: bool
class dampythoninterface.location.DesignScenario(*, Id: str, RiverLevel: float, RiverLevelLow: float = None, DikeTableHeight: float = None, PlLineOffsetBelowDikeTopAtRiver: float, PlLineOffsetBelowDikeTopAtPolder: float, PlLineOffsetBelowShoulderBaseInside: float, PlLineOffsetBelowDikeToeAtPolder: float, PlLineOffsetBelowDikeCrestMiddle: float = None, PlLineOffsetFactorBelowShoulderCrest: float = None, HeadPl3: float = None, HeadPl4: float = None, UpliftCriterionStability: float, UpliftCriterionPiping: float, RequiredSafetyFactorStabilityInnerSlope: float, RequiredSafetyFactorStabilityOuterSlope: float, RequiredSafetyFactorPiping: float, PolderLevel: float, HeadPl2: float = None)

Dataclass of DesignScenario

Parameters

  • Id – id of design scenario

  • RiverLevel – river level

  • RiverLevelLow – lowest river level

  • DikeTableHeight – table of height of dike

  • PlLineOffsetBelowDikeTopAtRiver – PlLine offset below dike at the top of river

  • PlLineOffsetBelowDikeTopAtPolder – PlLine offset below dike at the top of polder

  • PlLineOffsetBelowShoulderBaseInside – PlLine offset below shoulder of the base inside

  • PlLineOffsetBelowDikeToeAtPolder – PlLine offset below dike at the toe of polder

  • PlLineOffsetBelowDikeCrestMiddle – PlLine offset below the middle of the dike crest

  • PlLineOffsetFactorBelowShoulderCrest – PlLine offset factor below the shoulder crest

  • HeadPl3 – Water pressure in the lower aquifer

  • HeadPl4 – Water pressure in an aquifer intermediate layer

  • UpliftCriterionStability – uplift criterion for stability

  • UpliftCriterionPiping – uplift criterion for piping

  • RequiredSafetyFactorStabilityInnerSlope – safety factor for stability of inner slope

  • RequiredSafetyFactorStabilityOuterSlope – safety factor for stability of outer slope

  • RequiredSafetyFactorPiping – safety factor for piping

  • PolderLevel – polder level

  • HeadPl2 – The pore pressure at the top of the intrusion zone

DikeTableHeight: Optional[float]
HeadPl2: Optional[float]
HeadPl3: Optional[float]
HeadPl4: Optional[float]
Id: str
PlLineOffsetBelowDikeCrestMiddle: Optional[float]
PlLineOffsetBelowDikeToeAtPolder: float
PlLineOffsetBelowDikeTopAtPolder: float
PlLineOffsetBelowDikeTopAtRiver: float
PlLineOffsetBelowShoulderBaseInside: float
PlLineOffsetFactorBelowShoulderCrest: Optional[float]
PolderLevel: float
RequiredSafetyFactorPiping: float
RequiredSafetyFactorStabilityInnerSlope: float
RequiredSafetyFactorStabilityOuterSlope: float
RiverLevel: float
RiverLevelLow: Optional[float]
UpliftCriterionPiping: float
UpliftCriterionStability: float
class dampythoninterface.location.DikeSoilScenarioType(value)
ClayDikeOnClay = 'ClayDikeOnClay'
ClayDikeOnSand = 'ClayDikeOnSand'
SandDikeOnClay = 'SandDikeOnClay'
SandDikeOnSand = 'SandDikeOnSand'
class dampythoninterface.location.General(*, Description: str, HeadPL2: float = None, HeadPL3: float = None, HeadPL4: float = None)

Dataclass of General settings

Parameters

  • Description – description

  • HeadPL2 – The pore pressure at the top of the intrusion zone

  • HeadPL3 – Water pressure in the lower aquifer

  • HeadPL4 – Water pressure in an aquifer intermediate layer

Description: str
HeadPL2: Optional[float]
HeadPL3: Optional[float]
HeadPL4: Optional[float]
class dampythoninterface.location.IntrusionVerticalWaterPressureType(value)
FullHydroStatic = 'FullHydroStatic'
HydroStatic = 'HydroStatic'
Linear = 'Linear'
SemiTimeDependent = 'SemiTimeDependent'
Standard = 'Standard'
class dampythoninterface.location.Location(*, SurfaceLineName: str, SegmentName: str, Name: str, DikeEmbankmentMaterial: str, XSoilGeometry2DOrigin: float = 0, DistanceToEntryPoint: float = 0, DesignOptions: dampythoninterface.location.DesignOptions = None, General: dampythoninterface.location.General = None, DesignScenarios: List[dampythoninterface.location.DesignScenario], StabilityOptions: dampythoninterface.location.StabilityOptions = None, WaternetOptions: dampythoninterface.location.WaternetOptions = None)

Dataclass of Location

Parameters

  • SurfaceLineName – surface line that is assigned to location

  • SegmentName – segment that is assigned to location

  • Name – name of the location

  • DikeEmbankmentMaterial – dike embankment material that is assigned to location

  • XSoilGeometry2DOrigin – origin of soil of 2D geometry

  • DistanceToEntryPoint – distance to entry point

  • DesignOptions – design options

  • General – general options

  • DesignScenarios – list of design scenarios

  • StabilityOptions – stability options

  • WaternetOptions – waternet options

DesignOptions: Optional[dampythoninterface.location.DesignOptions]
DesignScenarios: List[dampythoninterface.location.DesignScenario]
DikeEmbankmentMaterial: str
DistanceToEntryPoint: Optional[float]
General: Optional[dampythoninterface.location.General]
Name: str
SegmentName: str
StabilityOptions: Optional[dampythoninterface.location.StabilityOptions]
SurfaceLineName: str
WaternetOptions: Optional[dampythoninterface.location.WaternetOptions]
XSoilGeometry2DOrigin: Optional[float]
serialize() → lxml.etree.Element

Function that serializes the Location class.

class dampythoninterface.location.PhreaticLineCreationMethodType(value)
ExpertKnowledgeLinearInDike = 'ExpertKnowledgeLinearInDike'
ExpertKnowledgeRRD = 'ExpertKnowledgeRRD'
GaugesWithFallbackToExpertKnowledgeRRD = 'GaugesWithFallbackToExpertKnowledgeRRD'
NONE = 'NONE'
Sensors = 'Sensors'
class dampythoninterface.location.StabilityDesignMethodType(value)
OptimizedSlopeAndShoulderAdaption = 'OptimizedSlopeAndShoulderAdaption'
SlopeAdaptionBeforeShoulderAdaption = 'SlopeAdaptionBeforeShoulderAdaption'
class dampythoninterface.location.StabilityOptions(*, MapForSoilgeometries2D: str = '', SoilDatabaseName: str = '', ZoneType: dampythoninterface.location.ZoneTypeClass, ForbiddenZoneFactor: float = 0, ZoneAreaRestSlopeCrestWidth: float = 0, TrafficLoad: float = 0, MinimumCircleDepth: float = 0, TrafficLoadDegreeOfConsolidation: float = 0)

Dataclass of StabilityOptions

Parameters

  • MapForSoilgeometries2D – map for soil for 2D geometry

  • SoilDatabaseName – soil database name

  • ZoneType – zone type

  • ForbiddenZoneFactor – factor for forbidden zone

  • ZoneAreaRestSlopeCrestWidth – zone area slope of the crest width

  • TrafficLoad – traffic load

  • MinimumCircleDepth – minimum circle depth

  • TrafficLoadDegreeOfConsolidation – degree of consolidation relating to traffic load

ForbiddenZoneFactor: Optional[float]
MapForSoilgeometries2D: Optional[str]
MinimumCircleDepth: Optional[float]
SoilDatabaseName: Optional[str]
TrafficLoad: Optional[float]
TrafficLoadDegreeOfConsolidation: Optional[float]
ZoneAreaRestSlopeCrestWidth: Optional[float]
ZoneType: dampythoninterface.location.ZoneTypeClass
class dampythoninterface.location.WaternetOptions(*, PhreaticLineCreationMethod: dampythoninterface.location.PhreaticLineCreationMethodType, DampingFactorPl3: float, DampingFactorPl4: float, PenetrationLength: float, SlopeDampingFactor: float, IntrusionVerticalWaterPressure: dampythoninterface.location.IntrusionVerticalWaterPressureType, DikeSoilScenario: dampythoninterface.location.DikeSoilScenarioType)

Dataclass of WaternetOptions

Parameters

  • PhreaticLineCreationMethod – phreatic line creation method

  • DampingFactorPl3 – damping factor for PL3

  • DampingFactorPl4 – damping factor for PL4

  • PenetrationLength – penetration length

  • SlopeDampingFactor – slope damping factor

  • IntrusionVerticalWaterPressure – intrusion of vertical water pressure

  • DikeSoilScenario – dike soil layering scenario

DampingFactorPl3: float
DampingFactorPl4: float
DikeSoilScenario: dampythoninterface.location.DikeSoilScenarioType
IntrusionVerticalWaterPressure: dampythoninterface.location.IntrusionVerticalWaterPressureType
PenetrationLength: float
PhreaticLineCreationMethod: dampythoninterface.location.PhreaticLineCreationMethodType
SlopeDampingFactor: float
class dampythoninterface.location.ZoneTypeClass(value)
ForbiddenZones = 2
NoZones = 0
ZoneAreas = 1