RS2Scripting 11.23.0__py3-none-any.whl

rs2/modeler/properties/material/hydraulic/FEAGroundwater/Genuchten.py

@@ -0,0 +1,124 @@
+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.AbsoluteStageFactorGettersInterface import AbsoluteStageFactorGettersInterface
+class GenuchtenStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getMFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_VAN_CUSTOM_M", self.propertyID], proxyArgumentIndices=[1])
+	def getNFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_VAN_GENUCHTEM_N", self.propertyID], proxyArgumentIndices=[1])
+	def getAlphaFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_VAN_GENUCHTEN_ALPHA", self.propertyID], proxyArgumentIndices=[1])
+	def getKsFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_KS", self.propertyID], proxyArgumentIndices=[1])
+	def getWCSatFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_WC_SAT", self.propertyID], proxyArgumentIndices=[1])
+	def getWCResFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_WC_RES", self.propertyID], proxyArgumentIndices=[1])
+	def getDoSSatFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_DOS_SAT", self.propertyID], proxyArgumentIndices=[1])
+	def getDoSResFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_DOS_RES", self.propertyID], proxyArgumentIndices=[1])
+class GenuchtenDefinedStageFactor(GenuchtenStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setMFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_VAN_CUSTOM_M", value, self.propertyID], proxyArgumentIndices=[2])
+	def setNFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_VAN_GENUCHTEM_N", value, self.propertyID], proxyArgumentIndices=[2])
+	def setAlphaFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_VAN_GENUCHTEN_ALPHA", value, self.propertyID], proxyArgumentIndices=[2])
+	def setKsFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_KS", value, self.propertyID], proxyArgumentIndices=[2])
+	def setWCSatFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_WC_SAT", value, self.propertyID], proxyArgumentIndices=[2])
+	def setWCResFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_WC_RES", value, self.propertyID], proxyArgumentIndices=[2])
+	def setDoSSatFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_DOS_SAT", value, self.propertyID], proxyArgumentIndices=[2])
+	def setDoSResFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_DOS_RES", value, self.propertyID], proxyArgumentIndices=[2])
+class Genuchten(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[GenuchtenDefinedStageFactor, GenuchtenStageFactor](self._client, stageFactorInterfaceID, ID, GenuchtenDefinedStageFactor, GenuchtenStageFactor)
+	def getAlpha(self) -> float:
+		return self._getDoubleProperty("MP_VAN_GENUCHTEN_ALPHA")
+	def setAlpha(self, value: float):
+		return self._setDoubleProperty("MP_VAN_GENUCHTEN_ALPHA", value)
+	def getN(self) -> float:
+		return self._getDoubleProperty("MP_VAN_GENUCHTEM_N")
+	def setN(self, value: float):
+		return self._setDoubleProperty("MP_VAN_GENUCHTEM_N", value)
+	def getCustomM(self) -> bool:
+		return self._getBoolProperty("MP_VAN_USE_CUSTOM_M")
+	def setCustomM(self, value: bool):
+		return self._setBoolProperty("MP_VAN_USE_CUSTOM_M", value)
+	def getM(self) -> float:
+		return self._getDoubleProperty("MP_VAN_CUSTOM_M")
+	def setM(self, value: float):
+		return self._setDoubleProperty("MP_VAN_CUSTOM_M", value)
+	def getKs(self) -> float:
+		return self._getDoubleProperty("MP_KS")
+	def setKs(self, value: float):
+		return self._setDoubleProperty("MP_KS", value)
+	def getWCInputType(self) -> WCInputType:
+		return WCInputType(self._getEnumEWCInputTypeProperty("MP_WC_INPUT_TYPE"))
+	def setWCInputType(self, value: WCInputType):
+		return self._setEnumEWCInputTypeProperty("MP_WC_INPUT_TYPE", value)
+	def getWCSat(self) -> float:
+		return self._getDoubleProperty("MP_WC_SAT")
+	def setWCSat(self, value: float):
+		return self._setDoubleProperty("MP_WC_SAT", value)
+	def getWCRes(self) -> float:
+		return self._getDoubleProperty("MP_WC_RES")
+	def setWCRes(self, value: float):
+		return self._setDoubleProperty("MP_WC_RES", value)
+	def getDoSSat(self) -> float:
+		return self._getDoubleProperty("MP_DOS_SAT")
+	def setDoSSat(self, value: float):
+		return self._setDoubleProperty("MP_DOS_SAT", value)
+	def getDoSRes(self) -> float:
+		return self._getDoubleProperty("MP_DOS_RES")
+	def setDoSRes(self, value: float):
+		return self._setDoubleProperty("MP_DOS_RES", value)
+	def setProperties(self, Alpha : float = None, N : float = None, CustomM : bool = None, M : float = None, Ks : float = None, WCInputType : WCInputType = None, WCSat : float = None, WCRes : float = None, DoSSat : float = None, DoSRes : float = None):
+		if Alpha is not None:
+			self._setDoubleProperty("MP_VAN_GENUCHTEN_ALPHA", Alpha)
+		if N is not None:
+			self._setDoubleProperty("MP_VAN_GENUCHTEM_N", N)
+		if CustomM is not None:
+			self._setBoolProperty("MP_VAN_USE_CUSTOM_M", CustomM)
+		if M is not None:
+			self._setDoubleProperty("MP_VAN_CUSTOM_M", M)
+		if Ks is not None:
+			self._setDoubleProperty("MP_KS", Ks)
+		if WCInputType is not None:
+			self._setEnumEWCInputTypeProperty("MP_WC_INPUT_TYPE", WCInputType)
+		if WCSat is not None:
+			self._setDoubleProperty("MP_WC_SAT", WCSat)
+		if WCRes is not None:
+			self._setDoubleProperty("MP_WC_RES", WCRes)
+		if DoSSat is not None:
+			self._setDoubleProperty("MP_DOS_SAT", DoSSat)
+		if DoSRes is not None:
+			self._setDoubleProperty("MP_DOS_RES", DoSRes)
+	def getProperties(self):
+		return {
+		"Alpha" : self.getAlpha(), 
+		"N" : self.getN(), 
+		"CustomM" : self.getCustomM(), 
+		"M" : self.getM(), 
+		"Ks" : self.getKs(), 
+		"WCInputType" : self.getWCInputType(), 
+		"WCSat" : self.getWCSat(), 
+		"WCRes" : self.getWCRes(), 
+		"DoSSat" : self.getDoSSat(), 
+		"DoSRes" : self.getDoSRes(), 
+		}

rs2/modeler/properties/material/hydraulic/FEAGroundwater/Simple.py

@@ -0,0 +1,91 @@
+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.AbsoluteStageFactorGettersInterface import AbsoluteStageFactorGettersInterface
+class SimpleStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getKsFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_KS", self.propertyID], proxyArgumentIndices=[1])
+	def getWCSatFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_WC_SAT", self.propertyID], proxyArgumentIndices=[1])
+	def getWCResFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_WC_RES", self.propertyID], proxyArgumentIndices=[1])
+	def getDoSSatFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_DOS_SAT", self.propertyID], proxyArgumentIndices=[1])
+	def getDoSResFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_DOS_RES", self.propertyID], proxyArgumentIndices=[1])
+class SimpleDefinedStageFactor(SimpleStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setKsFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_KS", value, self.propertyID], proxyArgumentIndices=[2])
+	def setWCSatFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_WC_SAT", value, self.propertyID], proxyArgumentIndices=[2])
+	def setWCResFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_WC_RES", value, self.propertyID], proxyArgumentIndices=[2])
+	def setDoSSatFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_DOS_SAT", value, self.propertyID], proxyArgumentIndices=[2])
+	def setDoSResFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_DOS_RES", value, self.propertyID], proxyArgumentIndices=[2])
+class Simple(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[SimpleDefinedStageFactor, SimpleStageFactor](self._client, stageFactorInterfaceID, ID, SimpleDefinedStageFactor, SimpleStageFactor)
+	def getSoilType(self) -> EnhancedSimpleSoilTypes:
+		return EnhancedSimpleSoilTypes(self._getEnumEEnhancedSimpleSoilTypesProperty("MP_SOIL_TYPE"))
+	def setSoilType(self, value: EnhancedSimpleSoilTypes):
+		return self._setEnumEEnhancedSimpleSoilTypesProperty("MP_SOIL_TYPE", value)
+	def getKs(self) -> float:
+		return self._getDoubleProperty("MP_KS")
+	def setKs(self, value: float):
+		return self._setDoubleProperty("MP_KS", value)
+	def getWCInputType(self) -> WCInputType:
+		return WCInputType(self._getEnumEWCInputTypeProperty("MP_WC_INPUT_TYPE"))
+	def setWCInputType(self, value: WCInputType):
+		return self._setEnumEWCInputTypeProperty("MP_WC_INPUT_TYPE", value)
+	def getWCSat(self) -> float:
+		return self._getDoubleProperty("MP_WC_SAT")
+	def setWCSat(self, value: float):
+		return self._setDoubleProperty("MP_WC_SAT", value)
+	def getWCRes(self) -> float:
+		return self._getDoubleProperty("MP_WC_RES")
+	def setWCRes(self, value: float):
+		return self._setDoubleProperty("MP_WC_RES", value)
+	def getDoSSat(self) -> float:
+		return self._getDoubleProperty("MP_DOS_SAT")
+	def setDoSSat(self, value: float):
+		return self._setDoubleProperty("MP_DOS_SAT", value)
+	def getDoSRes(self) -> float:
+		return self._getDoubleProperty("MP_DOS_RES")
+	def setDoSRes(self, value: float):
+		return self._setDoubleProperty("MP_DOS_RES", value)
+	def setProperties(self, SoilType : EnhancedSimpleSoilTypes = None, Ks : float = None, WCInputType : WCInputType = None, WCSat : float = None, WCRes : float = None, DoSSat : float = None, DoSRes : float = None):
+		if SoilType is not None:
+			self._setEnumEEnhancedSimpleSoilTypesProperty("MP_SOIL_TYPE", SoilType)
+		if Ks is not None:
+			self._setDoubleProperty("MP_KS", Ks)
+		if WCInputType is not None:
+			self._setEnumEWCInputTypeProperty("MP_WC_INPUT_TYPE", WCInputType)
+		if WCSat is not None:
+			self._setDoubleProperty("MP_WC_SAT", WCSat)
+		if WCRes is not None:
+			self._setDoubleProperty("MP_WC_RES", WCRes)
+		if DoSSat is not None:
+			self._setDoubleProperty("MP_DOS_SAT", DoSSat)
+		if DoSRes is not None:
+			self._setDoubleProperty("MP_DOS_RES", DoSRes)
+	def getProperties(self):
+		return {
+		"SoilType" : self.getSoilType(), 
+		"Ks" : self.getKs(), 
+		"WCInputType" : self.getWCInputType(), 
+		"WCSat" : self.getWCSat(), 
+		"WCRes" : self.getWCRes(), 
+		"DoSSat" : self.getDoSSat(), 
+		"DoSRes" : self.getDoSRes(), 
+		}

rs2/modeler/properties/material/hydraulic/FEAGroundwater/UserDefined.py

@@ -0,0 +1,10 @@
+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 UserDefined(PropertyProxy):
+	def setUserDefinedPermeabilityAndWaterContentFunction(self, functionName: str):
+		return self._callFunction("setUserDefinedPermeabilityAndWaterContentFunction", [functionName])
+	def getUserDefinedPermeabilityAndWaterContentFunction(self) -> str:
+		return self._callFunction("getUserDefinedPermeabilityAndWaterContentFunction", [])

rs2/modeler/properties/material/hydraulic/Hydraulic.py

@@ -0,0 +1,41 @@
+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.hydraulic.FEAGroundwater.FEAGroundwater import FEAGroundwater
+from rs2.modeler.properties.material.hydraulic.StaticGroundwater import StaticGroundwater
+from rs2._common.ProxyObject import ProxyObject
+from rs2.modeler.properties.AbsoluteStageFactorGettersInterface import AbsoluteStageFactorGettersInterface
+class HydraulicStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getMaterialBehaviourFactor(self) -> str:
+		return MaterialBehaviours(self._callFunction("getMaterialBehaviourFactor", []))
+class HydraulicDefinedStageFactor(HydraulicStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setMaterialBehaviourFactor(self, materialBehavior: MaterialBehaviours):
+		return self._callFunction("setMaterialBehaviourFactor", [materialBehavior.value])
+class Hydraulic(PropertyProxy):
+	"""
+	:ref:`Hydraulic Property Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[HydraulicDefinedStageFactor, HydraulicStageFactor](self._client, stageFactorInterfaceID, ID, HydraulicDefinedStageFactor, HydraulicStageFactor)
+		self.StaticGroundwater = StaticGroundwater(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.FEAGroundwater = FEAGroundwater(client, ID, documentProxyID, stageFactorInterfaceID)
+	def getMaterialBehaviour(self) -> MaterialBehaviours:
+		return MaterialBehaviours(self._getEnumEMaterialBehavioursProperty("MP_MATERIAL_BEHAVIOUR"))
+	def setMaterialBehaviour(self, value: MaterialBehaviours):
+		return self._setEnumEMaterialBehavioursProperty("MP_MATERIAL_BEHAVIOUR", value)
+	def getFluidBulkModulus(self) -> float:
+		return self._getDoubleProperty("MP_FLUID_BULK_MODULUS")
+	def setFluidBulkModulus(self, value: float):
+		return self._setDoubleProperty("MP_FLUID_BULK_MODULUS", value)
+	def getUseBiotsCoefficientForCalculatingEffectiveStress(self) -> bool:
+		return self._getBoolProperty("MP_USE_ALPHA_BIOT")
+	def setUseBiotsCoefficientForCalculatingEffectiveStress(self, value: bool):
+		return self._setBoolProperty("MP_USE_ALPHA_BIOT", value)

rs2/modeler/properties/material/hydraulic/StaticGroundwater.py

@@ -0,0 +1,85 @@
+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.AbsoluteStageFactorGettersInterface import AbsoluteStageFactorGettersInterface
+class StaticGroundwaterStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getPiezoToUse(self) -> str:
+		return self._callFunction("getPiezoToUse", [self.propertyID], proxyArgumentIndices=[0])
+	def getGridToUse(self) -> str:
+		return self._callFunction("getGridToUse", [self.propertyID], proxyArgumentIndices=[0])
+class StaticGroundwaterDefinedStageFactor(StaticGroundwaterStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setPiezoToUse(self, piezoName: str):
+		return self._callFunction("setPiezoToUse", [piezoName, self.propertyID], proxyArgumentIndices=[1])
+	def setGridToUse(self, gridName: str):
+		return self._callFunction("setGridToUse", [gridName, self.propertyID], proxyArgumentIndices=[1])
+class StaticGroundwater(PropertyProxy):
+	"""
+	:ref:`Hydraulic Property Static Groundwater Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[StaticGroundwaterDefinedStageFactor, StaticGroundwaterStageFactor](self._client, stageFactorInterfaceID, ID, StaticGroundwaterDefinedStageFactor, StaticGroundwaterStageFactor)
+	def getStaticWaterMode(self) -> StaticWaterModes:
+		return StaticWaterModes(self._getEnumEStaticWaterModesProperty("MP_STATIC_WATER_MODE"))
+	def setStaticWaterMode(self, value: StaticWaterModes):
+		return self._setEnumEStaticWaterModesProperty("MP_STATIC_WATER_MODE", value)
+	def getStaticPoreWaterPressure(self) -> float:
+		return self._getDoubleProperty("MP_CONSTANT_PWP")
+	def setStaticPoreWaterPressure(self, value: float):
+		return self._setDoubleProperty("MP_CONSTANT_PWP", value)
+	def getRuValue(self) -> float:
+		return self._getDoubleProperty("MP_RU_VALUE")
+	def setRuValue(self, value: float):
+		return self._setDoubleProperty("MP_RU_VALUE", value)
+	def getHuType(self) -> HuTypes:
+		return HuTypes(self._getEnumEHuTypesProperty("MP_HU_TYPE"))
+	def setHuType(self, value: HuTypes):
+		return self._setEnumEHuTypesProperty("MP_HU_TYPE", value)
+	def getHuValue(self) -> float:
+		return self._getDoubleProperty("MP_HU_VALUE")
+	def setHuValue(self, value: float):
+		return self._setDoubleProperty("MP_HU_VALUE", value)
+	def setPiezoToUse(self, piezoName: str):
+		"""
+		piezoName is the id of the piezo line to be used or "None".
+		"""
+		return self._callFunction("setPiezoToUse", [piezoName])
+	def getPiezoToUse(self) -> str:
+		"""
+		Returns the id of the piezo line to be used or "None".
+		"""
+		return self._callFunction("getPiezoToUse", [])
+	def setGridToUse(self, gridName: str):
+		"""
+		gridName is the name of the grid to be used. "None" and "Default Grid" are available by default.
+		"""
+		return self._callFunction("setGridToUse", [gridName])
+	def getGridToUse(self) -> str:
+		return self._callFunction("getGridToUse", [])
+	def setProperties(self, StaticWaterMode : StaticWaterModes = None, StaticPoreWaterPressure : float = None, RuValue : float = None, HuType : HuTypes = None, HuValue : float = None):
+		if StaticWaterMode is not None:
+			self._setEnumEStaticWaterModesProperty("MP_STATIC_WATER_MODE", StaticWaterMode)
+		if StaticPoreWaterPressure is not None:
+			self._setDoubleProperty("MP_CONSTANT_PWP", StaticPoreWaterPressure)
+		if RuValue is not None:
+			self._setDoubleProperty("MP_RU_VALUE", RuValue)
+		if HuType is not None:
+			self._setEnumEHuTypesProperty("MP_HU_TYPE", HuType)
+		if HuValue is not None:
+			self._setDoubleProperty("MP_HU_VALUE", HuValue)
+	def getProperties(self):
+		return {
+		"StaticWaterMode" : self.getStaticWaterMode(), 
+		"StaticPoreWaterPressure" : self.getStaticPoreWaterPressure(), 
+		"RuValue" : self.getRuValue(), 
+		"HuType" : self.getHuType(), 
+		"HuValue" : self.getHuValue(), 
+		}

rs2/modeler/properties/material/stiffness/ChSoil.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 ChSoil(PropertyProxy):
+	def getGRef(self) -> float:
+		return self._getDoubleProperty("MP_CHS_G_REF")
+	def setGRef(self, value: float):
+		return self._setDoubleProperty("MP_CHS_G_REF", value)
+	def getNG(self) -> float:
+		return self._getDoubleProperty("MP_CHS_N_G")
+	def setNG(self, value: float):
+		return self._setDoubleProperty("MP_CHS_N_G", value)
+	def getKRef(self) -> float:
+		return self._getDoubleProperty("MP_CHS_K_REF")
+	def setKRef(self, value: float):
+		return self._setDoubleProperty("MP_CHS_K_REF", value)
+	def getMK(self) -> float:
+		return self._getDoubleProperty("MP_CHS_M_K")
+	def setMK(self, value: float):
+		return self._setDoubleProperty("MP_CHS_M_K", value)
+	def getReferencePressure(self) -> float:
+		return self._getDoubleProperty("MP_CHS_REF_PRESSURE")
+	def setReferencePressure(self, value: float):
+		return self._setDoubleProperty("MP_CHS_REF_PRESSURE", value)
+	def setProperties(self, GRef : float = None, NG : float = None, KRef : float = None, MK : float = None, ReferencePressure : float = None):
+		if GRef is not None:
+			self._setDoubleProperty("MP_CHS_G_REF", GRef)
+		if NG is not None:
+			self._setDoubleProperty("MP_CHS_N_G", NG)
+		if KRef is not None:
+			self._setDoubleProperty("MP_CHS_K_REF", KRef)
+		if MK is not None:
+			self._setDoubleProperty("MP_CHS_M_K", MK)
+		if ReferencePressure is not None:
+			self._setDoubleProperty("MP_CHS_REF_PRESSURE", ReferencePressure)
+	def getProperties(self):
+		return {
+		"GRef" : self.getGRef(), 
+		"NG" : self.getNG(), 
+		"KRef" : self.getKRef(), 
+		"MK" : self.getMK(), 
+		"ReferencePressure" : self.getReferencePressure(), 
+		}

rs2/modeler/properties/material/stiffness/Custom.py

@@ -0,0 +1,83 @@
+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 Custom(PropertyProxy):
+	def getUseUnloadingCondition(self) -> bool:
+		return self._getBoolProperty("MP_USE_UNLOADING_CONDITION")
+	def setUseUnloadingCondition(self, value: bool):
+		return self._setBoolProperty("MP_USE_UNLOADING_CONDITION", value)
+	def getUnloadingCondition(self) -> UnloadingConditions:
+		return UnloadingConditions(self._getEnumEUnloadingConditionsProperty("MP_UNLOADING_CONDITION"))
+	def setUnloadingCondition(self, value: UnloadingConditions):
+		return self._setEnumEUnloadingConditionsProperty("MP_UNLOADING_CONDITION", value)
+	def getCustomMode(self) -> CustomMode:
+		return CustomMode(self._getEnumECustomModeProperty("MP_CUSTOM_MODE"))
+	def setCustomMode(self, value: CustomMode):
+		return self._setEnumECustomModeProperty("MP_CUSTOM_MODE", value)
+	def getUseConstantPoissonsRatio(self) -> bool:
+		return self._getBoolProperty("MP_USE_CONSTANT_POISSONS_RATIO")
+	def setUseConstantPoissonsRatio(self, value: bool):
+		return self._setBoolProperty("MP_USE_CONSTANT_POISSONS_RATIO", value)
+	def getConstantPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_CONSTANT_POISSONS_RATIO")
+	def setConstantPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_CONSTANT_POISSONS_RATIO", value)
+	def getUnloadingUseConstantPoissonsRatio(self) -> bool:
+		return self._getBoolProperty("MP_UNLOADING_USE_CONSTANT_POISSONS_RATIO")
+	def setUnloadingUseConstantPoissonsRatio(self, value: bool):
+		return self._setBoolProperty("MP_UNLOADING_USE_CONSTANT_POISSONS_RATIO", value)
+	def getUnloadingConstantPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_CONSTANT_POISSONS_RATIO")
+	def setUnloadingConstantPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_CONSTANT_POISSONS_RATIO", value)
+	def setCustomStiffnessLoadingTable(self, mode: CustomMode, table: list[tuple[float,float,float]]):
+		"""
+		Tuple element order: (Custom Mode Parameter (p,q,S3...), Young's modulus, Poisson's Ratio).
+		Poisson's ratio set to zero if useContantPoissonsRatio is set to True.
+		"""
+		return self._callFunction("setCustomStiffnessLoadingTable", [mode.value, table])
+	def getCustomStiffnessLoadingTable(self) -> list[tuple[float,float,float]]:
+		"""
+		Tuple element order: (Custom Mode Parameter (p,q,S3...), Young's modulus, Poisson's Ratio).
+		Poisson's ratio set to zero if useContantPoissonsRatio is set to True.
+		"""
+		return self._callFunction("getCustomStiffnessLoadingTable", [])
+	def setCustomStiffnessUnloadingTable(self, mode: CustomMode, table: list[tuple[float,float,float]]):
+		"""
+		Tuple element order: (Custom Mode Parameter (p,q,S3...), Young's modulus, Poisson's Ratio).
+		Poisson's ratio set to zero and ignored if useContantPoissonsRatio is set to True.
+		"""
+		return self._callFunction("setCustomStiffnessUnloadingTable", [mode.value, table])
+	def getCustomStiffnessUnloadingTable(self) -> list[tuple[float,float,float]]:
+		"""
+		Tuple element order: (Custom Mode Parameter (p,q,S3...), Young's modulus, Poisson's Ratio).
+		Poisson's ratio set to zero and ignored if useContantPoissonsRatio is set to True.
+		"""
+		return self._callFunction("getCustomStiffnessUnloadingTable", [])
+	def setProperties(self, UseUnloadingCondition : bool = None, UnloadingCondition : UnloadingConditions = None, CustomMode : CustomMode = None, UseConstantPoissonsRatio : bool = None, ConstantPoissonsRatio : float = None, UnloadingUseConstantPoissonsRatio : bool = None, UnloadingConstantPoissonsRatio : float = None):
+		if UseUnloadingCondition is not None:
+			self._setBoolProperty("MP_USE_UNLOADING_CONDITION", UseUnloadingCondition)
+		if UnloadingCondition is not None:
+			self._setEnumEUnloadingConditionsProperty("MP_UNLOADING_CONDITION", UnloadingCondition)
+		if CustomMode is not None:
+			self._setEnumECustomModeProperty("MP_CUSTOM_MODE", CustomMode)
+		if UseConstantPoissonsRatio is not None:
+			self._setBoolProperty("MP_USE_CONSTANT_POISSONS_RATIO", UseConstantPoissonsRatio)
+		if ConstantPoissonsRatio is not None:
+			self._setDoubleProperty("MP_CONSTANT_POISSONS_RATIO", ConstantPoissonsRatio)
+		if UnloadingUseConstantPoissonsRatio is not None:
+			self._setBoolProperty("MP_UNLOADING_USE_CONSTANT_POISSONS_RATIO", UnloadingUseConstantPoissonsRatio)
+		if UnloadingConstantPoissonsRatio is not None:
+			self._setDoubleProperty("MP_UNLOADING_CONSTANT_POISSONS_RATIO", UnloadingConstantPoissonsRatio)
+	def getProperties(self):
+		return {
+		"UseUnloadingCondition" : self.getUseUnloadingCondition(), 
+		"UnloadingCondition" : self.getUnloadingCondition(), 
+		"CustomMode" : self.getCustomMode(), 
+		"UseConstantPoissonsRatio" : self.getUseConstantPoissonsRatio(), 
+		"ConstantPoissonsRatio" : self.getConstantPoissonsRatio(), 
+		"UnloadingUseConstantPoissonsRatio" : self.getUnloadingUseConstantPoissonsRatio(), 
+		"UnloadingConstantPoissonsRatio" : self.getUnloadingConstantPoissonsRatio(), 
+		}

rs2/modeler/properties/material/stiffness/CySoil.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 CySoil(PropertyProxy):
+	def getKRefiso(self) -> float:
+		return self._getDoubleProperty("MP_CYS_K_REF_ISO")
+	def setKRefiso(self, value: float):
+		return self._setDoubleProperty("MP_CYS_K_REF_ISO", value)
+	def getMK(self) -> float:
+		return self._getDoubleProperty("MP_CYS_M_K")
+	def setMK(self, value: float):
+		return self._setDoubleProperty("MP_CYS_M_K", value)
+	def getRK(self) -> float:
+		return self._getDoubleProperty("MP_CYS_R_K")
+	def setRK(self, value: float):
+		return self._setDoubleProperty("MP_CYS_R_K", value)
+	def getReferencePressure(self) -> float:
+		return self._getDoubleProperty("MP_CYS_REF_PRESSURE")
+	def setReferencePressure(self, value: float):
+		return self._setDoubleProperty("MP_CYS_REF_PRESSURE", value)
+	def getPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_CYS_POISSON")
+	def setPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_CYS_POISSON", value)
+	def setProperties(self, KRefiso : float = None, MK : float = None, RK : float = None, ReferencePressure : float = None, PoissonsRatio : float = None):
+		if KRefiso is not None:
+			self._setDoubleProperty("MP_CYS_K_REF_ISO", KRefiso)
+		if MK is not None:
+			self._setDoubleProperty("MP_CYS_M_K", MK)
+		if RK is not None:
+			self._setDoubleProperty("MP_CYS_R_K", RK)
+		if ReferencePressure is not None:
+			self._setDoubleProperty("MP_CYS_REF_PRESSURE", ReferencePressure)
+		if PoissonsRatio is not None:
+			self._setDoubleProperty("MP_CYS_POISSON", PoissonsRatio)
+	def getProperties(self):
+		return {
+		"KRefiso" : self.getKRefiso(), 
+		"MK" : self.getMK(), 
+		"RK" : self.getRK(), 
+		"ReferencePressure" : self.getReferencePressure(), 
+		"PoissonsRatio" : self.getPoissonsRatio(), 
+		}

rs2/modeler/properties/material/stiffness/DoubleYield.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 DoubleYield(PropertyProxy):
+	def getKRefiso(self) -> float:
+		return self._getDoubleProperty("MP_CYS_K_REF_ISO")
+	def setKRefiso(self, value: float):
+		return self._setDoubleProperty("MP_CYS_K_REF_ISO", value)
+	def getMK(self) -> float:
+		return self._getDoubleProperty("MP_CYS_M_K")
+	def setMK(self, value: float):
+		return self._setDoubleProperty("MP_CYS_M_K", value)
+	def getRK(self) -> float:
+		return self._getDoubleProperty("MP_CYS_R_K")
+	def setRK(self, value: float):
+		return self._setDoubleProperty("MP_CYS_R_K", value)
+	def getReferencePressure(self) -> float:
+		return self._getDoubleProperty("MP_CYS_REF_PRESSURE")
+	def setReferencePressure(self, value: float):
+		return self._setDoubleProperty("MP_CYS_REF_PRESSURE", value)
+	def getPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_CYS_POISSON")
+	def setPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_CYS_POISSON", value)
+	def setProperties(self, KRefiso : float = None, MK : float = None, RK : float = None, ReferencePressure : float = None, PoissonsRatio : float = None):
+		if KRefiso is not None:
+			self._setDoubleProperty("MP_CYS_K_REF_ISO", KRefiso)
+		if MK is not None:
+			self._setDoubleProperty("MP_CYS_M_K", MK)
+		if RK is not None:
+			self._setDoubleProperty("MP_CYS_R_K", RK)
+		if ReferencePressure is not None:
+			self._setDoubleProperty("MP_CYS_REF_PRESSURE", ReferencePressure)
+		if PoissonsRatio is not None:
+			self._setDoubleProperty("MP_CYS_POISSON", PoissonsRatio)
+	def getProperties(self):
+		return {
+		"KRefiso" : self.getKRefiso(), 
+		"MK" : self.getMK(), 
+		"RK" : self.getRK(), 
+		"ReferencePressure" : self.getReferencePressure(), 
+		"PoissonsRatio" : self.getPoissonsRatio(), 
+		}

rs2/modeler/properties/material/stiffness/HardeningSoil.py

@@ -0,0 +1,73 @@
+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 HardeningSoil(PropertyProxy):
+	def getERef50(self) -> float:
+		return self._getDoubleProperty("MP_HS_E_REF_50")
+	def setERef50(self, value: float):
+		return self._setDoubleProperty("MP_HS_E_REF_50", value)
+	def getERefoed(self) -> float:
+		return self._getDoubleProperty("MP_HS_E_REF_OED")
+	def setERefoed(self, value: float):
+		return self._setDoubleProperty("MP_HS_E_REF_OED", value)
+	def getERefur(self) -> float:
+		return self._getDoubleProperty("MP_HS_E_REF_UR")
+	def setERefur(self, value: float):
+		return self._setDoubleProperty("MP_HS_E_REF_UR", value)
+	def getM(self) -> float:
+		return self._getDoubleProperty("MP_HS_M")
+	def setM(self, value: float):
+		return self._setDoubleProperty("MP_HS_M", value)
+	def getReferencePressure(self) -> float:
+		return self._getDoubleProperty("MP_HS_REF_PRESSURE")
+	def setReferencePressure(self, value: float):
+		return self._setDoubleProperty("MP_HS_REF_PRESSURE", value)
+	def getPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_HS_POISSON")
+	def setPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_HS_POISSON", value)
+	def getPlimit(self) -> float:
+		return self._getDoubleProperty("MP_HS_P_LIMIT")
+	def setPlimit(self, value: float):
+		return self._setDoubleProperty("MP_HS_P_LIMIT", value)
+	def getG0ref(self) -> float:
+		return self._getDoubleProperty("MP_HS_G0_REF")
+	def setG0ref(self, value: float):
+		return self._setDoubleProperty("MP_HS_G0_REF", value)
+	def getGama07(self) -> float:
+		return self._getDoubleProperty("MP_HS_GAMA_07")
+	def setGama07(self, value: float):
+		return self._setDoubleProperty("MP_HS_GAMA_07", value)
+	def setProperties(self, ERef50 : float = None, ERefoed : float = None, ERefur : float = None, M : float = None, ReferencePressure : float = None, PoissonsRatio : float = None, Plimit : float = None, G0ref : float = None, Gama07 : float = None):
+		if ERef50 is not None:
+			self._setDoubleProperty("MP_HS_E_REF_50", ERef50)
+		if ERefoed is not None:
+			self._setDoubleProperty("MP_HS_E_REF_OED", ERefoed)
+		if ERefur is not None:
+			self._setDoubleProperty("MP_HS_E_REF_UR", ERefur)
+		if M is not None:
+			self._setDoubleProperty("MP_HS_M", M)
+		if ReferencePressure is not None:
+			self._setDoubleProperty("MP_HS_REF_PRESSURE", ReferencePressure)
+		if PoissonsRatio is not None:
+			self._setDoubleProperty("MP_HS_POISSON", PoissonsRatio)
+		if Plimit is not None:
+			self._setDoubleProperty("MP_HS_P_LIMIT", Plimit)
+		if G0ref is not None:
+			self._setDoubleProperty("MP_HS_G0_REF", G0ref)
+		if Gama07 is not None:
+			self._setDoubleProperty("MP_HS_GAMA_07", Gama07)
+	def getProperties(self):
+		return {
+		"ERef50" : self.getERef50(), 
+		"ERefoed" : self.getERefoed(), 
+		"ERefur" : self.getERefur(), 
+		"M" : self.getM(), 
+		"ReferencePressure" : self.getReferencePressure(), 
+		"PoissonsRatio" : self.getPoissonsRatio(), 
+		"Plimit" : self.getPlimit(), 
+		"G0ref" : self.getG0ref(), 
+		"Gama07" : self.getGama07(), 
+		}