RS2Scripting 11.23.0__py3-none-any.whl

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/hydraulic/BrooksWaterContent.py

@@ -0,0 +1,24 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class BrooksWaterContent(PropertyProxy):
+	def getPoreSizeIndex(self) -> float:
+		return self._getDoubleProperty("MP_PORE_SIZE_INDEX_THERMAL")
+	def setPoreSizeIndex(self, value: float):
+		return self._setDoubleProperty("MP_PORE_SIZE_INDEX_THERMAL", value)
+	def getBubblingPressure(self) -> float:
+		return self._getDoubleProperty("MP_BUBBLING_PRESSURE_THERMAL")
+	def setBubblingPressure(self, value: float):
+		return self._setDoubleProperty("MP_BUBBLING_PRESSURE_THERMAL", value)
+	def setProperties(self, PoreSizeIndex : float = None, BubblingPressure : float = None):
+		if PoreSizeIndex is not None:
+			self._setDoubleProperty("MP_PORE_SIZE_INDEX_THERMAL", PoreSizeIndex)
+		if BubblingPressure is not None:
+			self._setDoubleProperty("MP_BUBBLING_PRESSURE_THERMAL", BubblingPressure)
+	def getProperties(self):
+		return {
+		"PoreSizeIndex" : self.getPoreSizeIndex(), 
+		"BubblingPressure" : self.getBubblingPressure(), 
+		}

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/hydraulic/FredlundWaterContent.py

@@ -0,0 +1,31 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class FredlundWaterContent(PropertyProxy):
+	def getA(self) -> float:
+		return self._getDoubleProperty("MP_FREDLUND_XING_A_THERMAL")
+	def setA(self, value: float):
+		return self._setDoubleProperty("MP_FREDLUND_XING_A_THERMAL", value)
+	def getB(self) -> float:
+		return self._getDoubleProperty("MP_FREDLUND_XING_B_THERMAL")
+	def setB(self, value: float):
+		return self._setDoubleProperty("MP_FREDLUND_XING_B_THERMAL", value)
+	def getC(self) -> float:
+		return self._getDoubleProperty("MP_FREDLUND_XING_C_THERMAL")
+	def setC(self, value: float):
+		return self._setDoubleProperty("MP_FREDLUND_XING_C_THERMAL", value)
+	def setProperties(self, A : float = None, B : float = None, C : float = None):
+		if A is not None:
+			self._setDoubleProperty("MP_FREDLUND_XING_A_THERMAL", A)
+		if B is not None:
+			self._setDoubleProperty("MP_FREDLUND_XING_B_THERMAL", B)
+		if C is not None:
+			self._setDoubleProperty("MP_FREDLUND_XING_C_THERMAL", C)
+	def getProperties(self):
+		return {
+		"A" : self.getA(), 
+		"B" : self.getB(), 
+		"C" : self.getC(), 
+		}

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/hydraulic/GardnerWaterContent.py

@@ -0,0 +1,24 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class GardnerWaterContent(PropertyProxy):
+	def getA(self) -> float:
+		return self._getDoubleProperty("MP_GARDNER_A_THERMAL")
+	def setA(self, value: float):
+		return self._setDoubleProperty("MP_GARDNER_A_THERMAL", value)
+	def getN(self) -> float:
+		return self._getDoubleProperty("MP_GARDNER_N_THERMAL")
+	def setN(self, value: float):
+		return self._setDoubleProperty("MP_GARDNER_N_THERMAL", value)
+	def setProperties(self, A : float = None, N : float = None):
+		if A is not None:
+			self._setDoubleProperty("MP_GARDNER_A_THERMAL", A)
+		if N is not None:
+			self._setDoubleProperty("MP_GARDNER_N_THERMAL", N)
+	def getProperties(self):
+		return {
+		"A" : self.getA(), 
+		"N" : self.getN(), 
+		}

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/hydraulic/GenuchtenWaterContent.py

@@ -0,0 +1,38 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class GenuchtenWaterContent(PropertyProxy):
+	def getAlpha(self) -> float:
+		return self._getDoubleProperty("MP_VAN_GENUCHTEN_ALPHA_THERMAL")
+	def setAlpha(self, value: float):
+		return self._setDoubleProperty("MP_VAN_GENUCHTEN_ALPHA_THERMAL", value)
+	def getN(self) -> float:
+		return self._getDoubleProperty("MP_VAN_GENUCHTEM_N_THERMAL")
+	def setN(self, value: float):
+		return self._setDoubleProperty("MP_VAN_GENUCHTEM_N_THERMAL", value)
+	def getCustomM(self) -> bool:
+		return self._getBoolProperty("MP_VAN_USE_CUSTOM_M_THERMAL")
+	def setCustomM(self, value: bool):
+		return self._setBoolProperty("MP_VAN_USE_CUSTOM_M_THERMAL", value)
+	def getM(self) -> float:
+		return self._getDoubleProperty("MP_VAN_CUSTOM_M_THERMAL")
+	def setM(self, value: float):
+		return self._setDoubleProperty("MP_VAN_CUSTOM_M_THERMAL", value)
+	def setProperties(self, Alpha : float = None, N : float = None, CustomM : bool = None, M : float = None):
+		if Alpha is not None:
+			self._setDoubleProperty("MP_VAN_GENUCHTEN_ALPHA_THERMAL", Alpha)
+		if N is not None:
+			self._setDoubleProperty("MP_VAN_GENUCHTEM_N_THERMAL", N)
+		if CustomM is not None:
+			self._setBoolProperty("MP_VAN_USE_CUSTOM_M_THERMAL", CustomM)
+		if M is not None:
+			self._setDoubleProperty("MP_VAN_CUSTOM_M_THERMAL", M)
+	def getProperties(self):
+		return {
+		"Alpha" : self.getAlpha(), 
+		"N" : self.getN(), 
+		"CustomM" : self.getCustomM(), 
+		"M" : self.getM(), 
+		}

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/hydraulic/HydraulicModel.py

@@ -0,0 +1,37 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.hydraulic.SimpleWaterContent import SimpleWaterContent
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.hydraulic.FredlundWaterContent import FredlundWaterContent
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.hydraulic.GenuchtenWaterContent import GenuchtenWaterContent
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.hydraulic.BrooksWaterContent import BrooksWaterContent
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.hydraulic.GardnerWaterContent import GardnerWaterContent
+class HydraulicModel(PropertyProxy):
+	"""
+	:ref:`Material Property Thermal Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID):
+		self.SimpleWaterContent = SimpleWaterContent(client, ID, documentProxyID)
+		self.FredlundWaterContent = FredlundWaterContent(client, ID, documentProxyID)
+		self.GenuchtenWaterContent = GenuchtenWaterContent(client, ID, documentProxyID)
+		self.BrooksWaterContent = BrooksWaterContent(client, ID, documentProxyID)
+		self.GardnerWaterContent = GardnerWaterContent(client, ID, documentProxyID)
+		super().__init__(client, ID, documentProxyID)
+	def getFrozenTemperature(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE")
+	def setFrozenTemperature(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE", value)
+	def getSelectHydraulicModel(self) -> GroundWaterModes:
+		return GroundWaterModes(self._getEnumEGroundWaterModesProperty("MP_THERMAL_SELECT_HYDRAULIC_MODEL"))
+	def setSelectHydraulicModel(self, value: GroundWaterModes):
+		return self._setEnumEGroundWaterModesProperty("MP_THERMAL_SELECT_HYDRAULIC_MODEL", value)
+	def getWCSat(self) -> float:
+		return self._getDoubleProperty("MP_WC_SAT_THERMAL")
+	def setWCSat(self, value: float):
+		return self._setDoubleProperty("MP_WC_SAT_THERMAL", value)
+	def getWCRes(self) -> float:
+		return self._getDoubleProperty("MP_WC_RES_THERMAL")
+	def setWCRes(self, value: float):
+		return self._setDoubleProperty("MP_WC_RES_THERMAL", value)

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/hydraulic/SimpleWaterContent.py

@@ -0,0 +1,17 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class SimpleWaterContent(PropertyProxy):
+	def getSoilType(self) -> EnhancedSimpleSoilTypes:
+		return EnhancedSimpleSoilTypes(self._getEnumEEnhancedSimpleSoilTypesProperty("MP_SOIL_TYPE_THERMAL"))
+	def setSoilType(self, value: EnhancedSimpleSoilTypes):
+		return self._setEnumEEnhancedSimpleSoilTypesProperty("MP_SOIL_TYPE_THERMAL", value)
+	def setProperties(self, SoilType : EnhancedSimpleSoilTypes = None):
+		if SoilType is not None:
+			self._setEnumEEnhancedSimpleSoilTypesProperty("MP_SOIL_TYPE_THERMAL", SoilType)
+	def getProperties(self):
+		return {
+		"SoilType" : self.getSoilType(), 
+		}

rs2/modeler/properties/pile/Beam.py

@@ -0,0 +1,34 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2._common.documentProxy import DocumentProxy
+class Beam(PropertyProxy):
+	def getLinerProperty(self) -> str:
+		return self._callFunction("getBeamLinerProperty", [])
+	def setLinerProperty(self, linerName: str):
+		"""
+		Resets the mesh if it exists.
+		"""
+		response = self._callFunction("setBeamLinerProperty", [linerName])
+		DocumentProxy(self._client, self.documentProxyID).rebuildAndPostProcessPiles()
+		return response
+	def getBeamSegment(self) -> tuple[list[float], list[str]]:
+		return self._callFunction("getBeamSegment", [])
+	def defineBeamSegment(self, Locations: list[float], Liners: list[str]):
+		"""
+		Resets the mesh if it exists.
+		"""
+		response = self._callFunction("defineBeamSegment", [Locations, Liners])
+		DocumentProxy(self._client, self.documentProxyID).rebuildAndPostProcessPiles()
+		return response
+	def setApplication(self, method: PileApplicationType):
+		"""
+		Resets the mesh if it exists.
+		"""
+		response = self._callFunction("setBeamApplication", [method.value])
+		DocumentProxy(self._client, self.documentProxyID).rebuildAndPostProcessPiles()
+		return response
+	def getApplication(self) -> PileApplicationType:
+		return PileApplicationType(self._callFunction("getBeamApplication", []))

rs2/modeler/properties/pile/Elastic.py

@@ -0,0 +1,45 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Elastic(PropertyProxy):
+	def getShearStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_STIFFNESS")
+	def setShearStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_STIFFNESS", value)
+	def getNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_NORMAL_STIFFNESS")
+	def setNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_NORMAL_STIFFNESS", value)
+	def getUseBaseResistance(self) -> bool:
+		return self._getBoolProperty("PFP_USE_BASE_RESISTANCE")
+	def setUseBaseResistance(self, value: bool):
+		return self._setBoolProperty("PFP_USE_BASE_RESISTANCE", value)
+	def getBaseNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_NORMAL_STIFFNESS")
+	def setBaseNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", value)
+	def getBaseForceResistance(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_FORCE_RESISTANCE")
+	def setBaseForceResistance(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", value)
+	def setProperties(self, ShearStiffness : float = None, NormalStiffness : float = None, UseBaseResistance : bool = None, BaseNormalStiffness : float = None, BaseForceResistance : float = None):
+		if ShearStiffness is not None:
+			self._setDoubleProperty("PFP_SHEAR_STIFFNESS", ShearStiffness)
+		if NormalStiffness is not None:
+			self._setDoubleProperty("PFP_NORMAL_STIFFNESS", NormalStiffness)
+		if UseBaseResistance is not None:
+			self._setBoolProperty("PFP_USE_BASE_RESISTANCE", UseBaseResistance)
+		if BaseNormalStiffness is not None:
+			self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", BaseNormalStiffness)
+		if BaseForceResistance is not None:
+			self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", BaseForceResistance)
+	def getProperties(self):
+		return {
+		"ShearStiffness" : self.getShearStiffness(), 
+		"NormalStiffness" : self.getNormalStiffness(), 
+		"UseBaseResistance" : self.getUseBaseResistance(), 
+		"BaseNormalStiffness" : self.getBaseNormalStiffness(), 
+		"BaseForceResistance" : self.getBaseForceResistance(), 
+		}

rs2/modeler/properties/pile/ForceDisplacement.py

@@ -0,0 +1,59 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2._common.ProxyObject import ProxyObject
+from rs2.modeler.properties.AbsoluteStageFactorInterface import AbsoluteStageFactorInterface
+class ForceDisplacementStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getXFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["PFP_FORCE_DISPLACEMENT_X", self.propertyID], proxyArgumentIndices=[1])
+	def getYFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["PFP_FORCE_DISPLACEMENT_Y", self.propertyID], proxyArgumentIndices=[1])
+class ForceDisplacementDefinedStageFactor(ForceDisplacementStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setXFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["PFP_FORCE_DISPLACEMENT_X", value, self.propertyID], proxyArgumentIndices=[2])
+	def setYFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["PFP_FORCE_DISPLACEMENT_Y", value, self.propertyID], proxyArgumentIndices=[2])
+class ForceDisplacement(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID):
+		super().__init__(client, ID, documentProxyID)
+		stageFactorInterfaceID = self._callFunction("getStageFactorInterface", [], keepReturnValueReference=True)
+		self.stageFactorInterface = AbsoluteStageFactorInterface[ForceDisplacementDefinedStageFactor, ForceDisplacementStageFactor](self._client, stageFactorInterfaceID, ID, ForceDisplacementDefinedStageFactor, ForceDisplacementStageFactor)
+	def getApply(self) -> PileEndCondition:
+		return PileEndCondition(self._getEnumEPileEndConditionProperty("PFP_FORCE_DISPLACEMENT_TYPE"))
+	def setApply(self, value: PileEndCondition):
+		return self._setEnumEPileEndConditionProperty("PFP_FORCE_DISPLACEMENT_TYPE", value)
+	def getApplyOn(self) -> PileForceApplicationPoint:
+		return PileForceApplicationPoint(self._getEnumEPileForceDisplacemtnApplicationPointProperty("PFP_FORCE_DISPLACEMENT_APPLY_ON"))
+	def setApplyOn(self, value: PileForceApplicationPoint):
+		return self._setEnumEPileForceDisplacemtnApplicationPointProperty("PFP_FORCE_DISPLACEMENT_APPLY_ON", value)
+	def getX(self) -> float:
+		return self._getDoubleProperty("PFP_FORCE_DISPLACEMENT_X")
+	def setX(self, value: float):
+		return self._setDoubleProperty("PFP_FORCE_DISPLACEMENT_X", value)
+	def getY(self) -> float:
+		return self._getDoubleProperty("PFP_FORCE_DISPLACEMENT_Y")
+	def setY(self, value: float):
+		return self._setDoubleProperty("PFP_FORCE_DISPLACEMENT_Y", value)
+	def setProperties(self, Apply : PileEndCondition = None, ApplyOn : PileForceApplicationPoint = None, X : float = None, Y : float = None):
+		if Apply is not None:
+			self._setEnumEPileEndConditionProperty("PFP_FORCE_DISPLACEMENT_TYPE", Apply)
+		if ApplyOn is not None:
+			self._setEnumEPileForceDisplacemtnApplicationPointProperty("PFP_FORCE_DISPLACEMENT_APPLY_ON", ApplyOn)
+		if X is not None:
+			self._setDoubleProperty("PFP_FORCE_DISPLACEMENT_X", X)
+		if Y is not None:
+			self._setDoubleProperty("PFP_FORCE_DISPLACEMENT_Y", Y)
+	def getProperties(self):
+		return {
+		"Apply" : self.getApply(), 
+		"ApplyOn" : self.getApplyOn(), 
+		"X" : self.getX(), 
+		"Y" : self.getY(), 
+		}

rs2/modeler/properties/pile/Linear.py

@@ -0,0 +1,59 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Linear(PropertyProxy):
+	def getShearStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_STIFFNESS")
+	def setShearStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_STIFFNESS", value)
+	def getNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_NORMAL_STIFFNESS")
+	def setNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_NORMAL_STIFFNESS", value)
+	def getMaxTractionAtTheTop(self) -> float:
+		return self._getDoubleProperty("PFP_MAX_TRACTION_TOP")
+	def setMaxTractionAtTheTop(self, value: float):
+		return self._setDoubleProperty("PFP_MAX_TRACTION_TOP", value)
+	def getMaxTractionAtTheBottom(self) -> float:
+		return self._getDoubleProperty("PFP_MAT_TRACTION_BOTTOM")
+	def setMaxTractionAtTheBottom(self, value: float):
+		return self._setDoubleProperty("PFP_MAT_TRACTION_BOTTOM", value)
+	def getUseBaseResistance(self) -> bool:
+		return self._getBoolProperty("PFP_USE_BASE_RESISTANCE")
+	def setUseBaseResistance(self, value: bool):
+		return self._setBoolProperty("PFP_USE_BASE_RESISTANCE", value)
+	def getBaseNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_NORMAL_STIFFNESS")
+	def setBaseNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", value)
+	def getBaseForceResistance(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_FORCE_RESISTANCE")
+	def setBaseForceResistance(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", value)
+	def setProperties(self, ShearStiffness : float = None, NormalStiffness : float = None, MaxTractionAtTheTop : float = None, MaxTractionAtTheBottom : float = None, UseBaseResistance : bool = None, BaseNormalStiffness : float = None, BaseForceResistance : float = None):
+		if ShearStiffness is not None:
+			self._setDoubleProperty("PFP_SHEAR_STIFFNESS", ShearStiffness)
+		if NormalStiffness is not None:
+			self._setDoubleProperty("PFP_NORMAL_STIFFNESS", NormalStiffness)
+		if MaxTractionAtTheTop is not None:
+			self._setDoubleProperty("PFP_MAX_TRACTION_TOP", MaxTractionAtTheTop)
+		if MaxTractionAtTheBottom is not None:
+			self._setDoubleProperty("PFP_MAT_TRACTION_BOTTOM", MaxTractionAtTheBottom)
+		if UseBaseResistance is not None:
+			self._setBoolProperty("PFP_USE_BASE_RESISTANCE", UseBaseResistance)
+		if BaseNormalStiffness is not None:
+			self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", BaseNormalStiffness)
+		if BaseForceResistance is not None:
+			self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", BaseForceResistance)
+	def getProperties(self):
+		return {
+		"ShearStiffness" : self.getShearStiffness(), 
+		"NormalStiffness" : self.getNormalStiffness(), 
+		"MaxTractionAtTheTop" : self.getMaxTractionAtTheTop(), 
+		"MaxTractionAtTheBottom" : self.getMaxTractionAtTheBottom(), 
+		"UseBaseResistance" : self.getUseBaseResistance(), 
+		"BaseNormalStiffness" : self.getBaseNormalStiffness(), 
+		"BaseForceResistance" : self.getBaseForceResistance(), 
+		}

rs2/modeler/properties/pile/MaterialDependentPile.py

@@ -0,0 +1,87 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class MaterialDependentPile(PropertyProxy):
+	def getInterfaceCoefficient(self) -> float:
+		return self._getDoubleProperty("PFP_INTERFACE_COEFFICIENT")
+	def setInterfaceCoefficient(self, value: float):
+		return self._setDoubleProperty("PFP_INTERFACE_COEFFICIENT", value)
+	def getUseStiffnessMaterialDependent(self) -> bool:
+		return self._getBoolProperty("PFP_USE_MAT_DEPENDENT")
+	def setUseStiffnessMaterialDependent(self, value: bool):
+		return self._setBoolProperty("PFP_USE_MAT_DEPENDENT", value)
+	def getStiffnessCoefficient(self) -> float:
+		return self._getDoubleProperty("PFP_INTERFACE_STIFFNESS")
+	def setStiffnessCoefficient(self, value: float):
+		return self._setDoubleProperty("PFP_INTERFACE_STIFFNESS", value)
+	def getShearStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_STIFFNESS")
+	def setShearStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_STIFFNESS", value)
+	def getNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_NORMAL_STIFFNESS")
+	def setNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_NORMAL_STIFFNESS", value)
+	def getUseShearResistanceCutoff(self) -> bool:
+		return self._getBoolProperty("PFP_USE_SHEAR_RESISTANCE_CUTOFF")
+	def setUseShearResistanceCutoff(self, value: bool):
+		return self._setBoolProperty("PFP_USE_SHEAR_RESISTANCE_CUTOFF", value)
+	def getShearResistanceCutoff(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_RESISTANCE_CUTOFF")
+	def setShearResistanceCutoff(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_RESISTANCE_CUTOFF", value)
+	def getPerimeter(self) -> float:
+		return self._getDoubleProperty("PFP_PERIMETER")
+	def setPerimeter(self, value: float):
+		return self._setDoubleProperty("PFP_PERIMETER", value)
+	def getUseBaseResistance(self) -> bool:
+		return self._getBoolProperty("PFP_USE_BASE_RESISTANCE")
+	def setUseBaseResistance(self, value: bool):
+		return self._setBoolProperty("PFP_USE_BASE_RESISTANCE", value)
+	def getBaseNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_NORMAL_STIFFNESS")
+	def setBaseNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", value)
+	def getBaseForceResistance(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_FORCE_RESISTANCE")
+	def setBaseForceResistance(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", value)
+	def setProperties(self, InterfaceCoefficient : float = None, UseStiffnessMaterialDependent : bool = None, StiffnessCoefficient : float = None, ShearStiffness : float = None, NormalStiffness : float = None, UseShearResistanceCutoff : bool = None, ShearResistanceCutoff : float = None, Perimeter : float = None, UseBaseResistance : bool = None, BaseNormalStiffness : float = None, BaseForceResistance : float = None):
+		if InterfaceCoefficient is not None:
+			self._setDoubleProperty("PFP_INTERFACE_COEFFICIENT", InterfaceCoefficient)
+		if UseStiffnessMaterialDependent is not None:
+			self._setBoolProperty("PFP_USE_MAT_DEPENDENT", UseStiffnessMaterialDependent)
+		if StiffnessCoefficient is not None:
+			self._setDoubleProperty("PFP_INTERFACE_STIFFNESS", StiffnessCoefficient)
+		if ShearStiffness is not None:
+			self._setDoubleProperty("PFP_SHEAR_STIFFNESS", ShearStiffness)
+		if NormalStiffness is not None:
+			self._setDoubleProperty("PFP_NORMAL_STIFFNESS", NormalStiffness)
+		if UseShearResistanceCutoff is not None:
+			self._setBoolProperty("PFP_USE_SHEAR_RESISTANCE_CUTOFF", UseShearResistanceCutoff)
+		if ShearResistanceCutoff is not None:
+			self._setDoubleProperty("PFP_SHEAR_RESISTANCE_CUTOFF", ShearResistanceCutoff)
+		if Perimeter is not None:
+			self._setDoubleProperty("PFP_PERIMETER", Perimeter)
+		if UseBaseResistance is not None:
+			self._setBoolProperty("PFP_USE_BASE_RESISTANCE", UseBaseResistance)
+		if BaseNormalStiffness is not None:
+			self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", BaseNormalStiffness)
+		if BaseForceResistance is not None:
+			self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", BaseForceResistance)
+	def getProperties(self):
+		return {
+		"InterfaceCoefficient" : self.getInterfaceCoefficient(), 
+		"UseStiffnessMaterialDependent" : self.getUseStiffnessMaterialDependent(), 
+		"StiffnessCoefficient" : self.getStiffnessCoefficient(), 
+		"ShearStiffness" : self.getShearStiffness(), 
+		"NormalStiffness" : self.getNormalStiffness(), 
+		"UseShearResistanceCutoff" : self.getUseShearResistanceCutoff(), 
+		"ShearResistanceCutoff" : self.getShearResistanceCutoff(), 
+		"Perimeter" : self.getPerimeter(), 
+		"UseBaseResistance" : self.getUseBaseResistance(), 
+		"BaseNormalStiffness" : self.getBaseNormalStiffness(), 
+		"BaseForceResistance" : self.getBaseForceResistance(), 
+		}

rs2/modeler/properties/pile/MohrCoulombPile.py

@@ -0,0 +1,94 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class MohrCoulombPile(PropertyProxy):
+	def getShearStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_STIFFNESS")
+	def setShearStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_STIFFNESS", value)
+	def getNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_NORMAL_STIFFNESS")
+	def setNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_NORMAL_STIFFNESS", value)
+	def getFrictionAngle(self) -> float:
+		return self._getDoubleProperty("PFP_FRICTION_ANGLE")
+	def setFrictionAngle(self, value: float):
+		return self._setDoubleProperty("PFP_FRICTION_ANGLE", value)
+	def getResidualFrictionAngle(self) -> float:
+		return self._getDoubleProperty("PFP_FRICTION_ANGLE_RES")
+	def setResidualFrictionAngle(self, value: float):
+		return self._setDoubleProperty("PFP_FRICTION_ANGLE_RES", value)
+	def getCohesion(self) -> float:
+		return self._getDoubleProperty("PFP_COHESION")
+	def setCohesion(self, value: float):
+		return self._setDoubleProperty("PFP_COHESION", value)
+	def getResidualCohesion(self) -> float:
+		return self._getDoubleProperty("PFP_RESIDUAL_COHESION")
+	def setResidualCohesion(self, value: float):
+		return self._setDoubleProperty("PFP_RESIDUAL_COHESION", value)
+	def getUseShearResistanceCutoff(self) -> bool:
+		return self._getBoolProperty("PFP_USE_SHEAR_RESISTANCE_CUTOFF")
+	def setUseShearResistanceCutoff(self, value: bool):
+		return self._setBoolProperty("PFP_USE_SHEAR_RESISTANCE_CUTOFF", value)
+	def getShearResistanceCutoff(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_RESISTANCE_CUTOFF")
+	def setShearResistanceCutoff(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_RESISTANCE_CUTOFF", value)
+	def getPerimeter(self) -> float:
+		return self._getDoubleProperty("PFP_PERIMETER")
+	def setPerimeter(self, value: float):
+		return self._setDoubleProperty("PFP_PERIMETER", value)
+	def getUseBaseResistance(self) -> bool:
+		return self._getBoolProperty("PFP_USE_BASE_RESISTANCE")
+	def setUseBaseResistance(self, value: bool):
+		return self._setBoolProperty("PFP_USE_BASE_RESISTANCE", value)
+	def getBaseNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_NORMAL_STIFFNESS")
+	def setBaseNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", value)
+	def getBaseForceResistance(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_FORCE_RESISTANCE")
+	def setBaseForceResistance(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", value)
+	def setProperties(self, ShearStiffness : float = None, NormalStiffness : float = None, FrictionAngle : float = None, ResidualFrictionAngle : float = None, Cohesion : float = None, ResidualCohesion : float = None, UseShearResistanceCutoff : bool = None, ShearResistanceCutoff : float = None, Perimeter : float = None, UseBaseResistance : bool = None, BaseNormalStiffness : float = None, BaseForceResistance : float = None):
+		if ShearStiffness is not None:
+			self._setDoubleProperty("PFP_SHEAR_STIFFNESS", ShearStiffness)
+		if NormalStiffness is not None:
+			self._setDoubleProperty("PFP_NORMAL_STIFFNESS", NormalStiffness)
+		if FrictionAngle is not None:
+			self._setDoubleProperty("PFP_FRICTION_ANGLE", FrictionAngle)
+		if ResidualFrictionAngle is not None:
+			self._setDoubleProperty("PFP_FRICTION_ANGLE_RES", ResidualFrictionAngle)
+		if Cohesion is not None:
+			self._setDoubleProperty("PFP_COHESION", Cohesion)
+		if ResidualCohesion is not None:
+			self._setDoubleProperty("PFP_RESIDUAL_COHESION", ResidualCohesion)
+		if UseShearResistanceCutoff is not None:
+			self._setBoolProperty("PFP_USE_SHEAR_RESISTANCE_CUTOFF", UseShearResistanceCutoff)
+		if ShearResistanceCutoff is not None:
+			self._setDoubleProperty("PFP_SHEAR_RESISTANCE_CUTOFF", ShearResistanceCutoff)
+		if Perimeter is not None:
+			self._setDoubleProperty("PFP_PERIMETER", Perimeter)
+		if UseBaseResistance is not None:
+			self._setBoolProperty("PFP_USE_BASE_RESISTANCE", UseBaseResistance)
+		if BaseNormalStiffness is not None:
+			self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", BaseNormalStiffness)
+		if BaseForceResistance is not None:
+			self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", BaseForceResistance)
+	def getProperties(self):
+		return {
+		"ShearStiffness" : self.getShearStiffness(), 
+		"NormalStiffness" : self.getNormalStiffness(), 
+		"FrictionAngle" : self.getFrictionAngle(), 
+		"ResidualFrictionAngle" : self.getResidualFrictionAngle(), 
+		"Cohesion" : self.getCohesion(), 
+		"ResidualCohesion" : self.getResidualCohesion(), 
+		"UseShearResistanceCutoff" : self.getUseShearResistanceCutoff(), 
+		"ShearResistanceCutoff" : self.getShearResistanceCutoff(), 
+		"Perimeter" : self.getPerimeter(), 
+		"UseBaseResistance" : self.getUseBaseResistance(), 
+		"BaseNormalStiffness" : self.getBaseNormalStiffness(), 
+		"BaseForceResistance" : self.getBaseForceResistance(), 
+		}

rs2/modeler/properties/pile/MultiLinear.py

@@ -0,0 +1,56 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class MultiLinear(PropertyProxy):
+	def getShearStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_SHEAR_STIFFNESS")
+	def setShearStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_SHEAR_STIFFNESS", value)
+	def getNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_NORMAL_STIFFNESS")
+	def setNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_NORMAL_STIFFNESS", value)
+	def getDefinitionMethod(self) -> PileDefinitionMethod:
+		return PileDefinitionMethod(self._getEnumEPFPApplicationProperty("PFP_TRACTION_APPLICATION_METHOD"))
+	def setDefinitionMethod(self, value: PileDefinitionMethod):
+		return self._setEnumEPFPApplicationProperty("PFP_TRACTION_APPLICATION_METHOD", value)
+	def getUseBaseResistance(self) -> bool:
+		return self._getBoolProperty("PFP_USE_BASE_RESISTANCE")
+	def setUseBaseResistance(self, value: bool):
+		return self._setBoolProperty("PFP_USE_BASE_RESISTANCE", value)
+	def getBaseNormalStiffness(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_NORMAL_STIFFNESS")
+	def setBaseNormalStiffness(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", value)
+	def getBaseForceResistance(self) -> float:
+		return self._getDoubleProperty("PFP_BASE_FORCE_RESISTANCE")
+	def setBaseForceResistance(self, value: float):
+		return self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", value)
+	def getCoordinates(self) -> tuple[list[float], list[float]]:
+		return self._callFunction("getCoordinates", [])
+	def setCoordinates(self, Location: list[float], Value: list[float]):
+		return self._callFunction("setCoordinates", [Location, Value])
+	def setProperties(self, ShearStiffness : float = None, NormalStiffness : float = None, DefinitionMethod : PileDefinitionMethod = None, UseBaseResistance : bool = None, BaseNormalStiffness : float = None, BaseForceResistance : float = None):
+		if ShearStiffness is not None:
+			self._setDoubleProperty("PFP_SHEAR_STIFFNESS", ShearStiffness)
+		if NormalStiffness is not None:
+			self._setDoubleProperty("PFP_NORMAL_STIFFNESS", NormalStiffness)
+		if DefinitionMethod is not None:
+			self._setEnumEPFPApplicationProperty("PFP_TRACTION_APPLICATION_METHOD", DefinitionMethod)
+		if UseBaseResistance is not None:
+			self._setBoolProperty("PFP_USE_BASE_RESISTANCE", UseBaseResistance)
+		if BaseNormalStiffness is not None:
+			self._setDoubleProperty("PFP_BASE_NORMAL_STIFFNESS", BaseNormalStiffness)
+		if BaseForceResistance is not None:
+			self._setDoubleProperty("PFP_BASE_FORCE_RESISTANCE", BaseForceResistance)
+	def getProperties(self):
+		return {
+		"ShearStiffness" : self.getShearStiffness(), 
+		"NormalStiffness" : self.getNormalStiffness(), 
+		"DefinitionMethod" : self.getDefinitionMethod(), 
+		"UseBaseResistance" : self.getUseBaseResistance(), 
+		"BaseNormalStiffness" : self.getBaseNormalStiffness(), 
+		"BaseForceResistance" : self.getBaseForceResistance(), 
+		}