RS2Scripting 11.23.0__py3-none-any.whl

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

@@ -0,0 +1,180 @@
+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 OrthotropicStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getAngleCounterclockwiseFromHorizontalToE1Factor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_ELASTIC_ANGLE", self.propertyID], proxyArgumentIndices=[1])
+	def getPoissonsRatioV12Factor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_POISSONS_RATIO_V12", self.propertyID], proxyArgumentIndices=[1])
+	def getPoissonsRatioV2Factor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_POISSONS_RATIO_V2", self.propertyID], proxyArgumentIndices=[1])
+	def getPoissonsRatioV2zFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_POISSONS_RATIO_V2Z", self.propertyID], proxyArgumentIndices=[1])
+	def getShearModulusFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_SHEAR_MODULUS", self.propertyID], proxyArgumentIndices=[1])
+	def getYoungsModulusE1Factor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_YOUNGS_MODULUS_E1", self.propertyID], proxyArgumentIndices=[1])
+	def getYoungsModulusE2Factor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_YOUNGS_MODULUS_E2", self.propertyID], proxyArgumentIndices=[1])
+	def getYoungsModulusEZFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_YOUNGS_MODULUS_EZ", self.propertyID], proxyArgumentIndices=[1])
+class OrthotropicDefinedStageFactor(OrthotropicStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setAngleCounterclockwiseFromHorizontalToE1Factor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_ELASTIC_ANGLE", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPoissonsRatioV12Factor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_POISSONS_RATIO_V12", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPoissonsRatioV2Factor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_POISSONS_RATIO_V2", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPoissonsRatioV2zFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_POISSONS_RATIO_V2Z", value, self.propertyID], proxyArgumentIndices=[2])
+	def setShearModulusFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_SHEAR_MODULUS", value, self.propertyID], proxyArgumentIndices=[2])
+	def setYoungsModulusE1Factor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_YOUNGS_MODULUS_E1", value, self.propertyID], proxyArgumentIndices=[2])
+	def setYoungsModulusE2Factor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_YOUNGS_MODULUS_E2", value, self.propertyID], proxyArgumentIndices=[2])
+	def setYoungsModulusEZFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_YOUNGS_MODULUS_EZ", value, self.propertyID], proxyArgumentIndices=[2])
+class Orthotropic(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[OrthotropicDefinedStageFactor, OrthotropicStageFactor](self._client, stageFactorInterfaceID, ID, OrthotropicDefinedStageFactor, OrthotropicStageFactor)
+	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 getShearModulus(self) -> float:
+		return self._getDoubleProperty("MP_SHEAR_MODULUS")
+	def setShearModulus(self, value: float):
+		return self._setDoubleProperty("MP_SHEAR_MODULUS", value)
+	def getAngleCounterclockwiseFromHorizontalToE1(self) -> float:
+		return self._getDoubleProperty("MP_ELASTIC_ANGLE")
+	def setAngleCounterclockwiseFromHorizontalToE1(self, value: float):
+		return self._setDoubleProperty("MP_ELASTIC_ANGLE", value)
+	def getYoungsModulusE1(self) -> float:
+		return self._getDoubleProperty("MP_YOUNGS_MODULUS_E1")
+	def setYoungsModulusE1(self, value: float):
+		return self._setDoubleProperty("MP_YOUNGS_MODULUS_E1", value)
+	def getYoungsModulusE2(self) -> float:
+		return self._getDoubleProperty("MP_YOUNGS_MODULUS_E2")
+	def setYoungsModulusE2(self, value: float):
+		return self._setDoubleProperty("MP_YOUNGS_MODULUS_E2", value)
+	def getYoungsModulusEZ(self) -> float:
+		return self._getDoubleProperty("MP_YOUNGS_MODULUS_EZ")
+	def setYoungsModulusEZ(self, value: float):
+		return self._setDoubleProperty("MP_YOUNGS_MODULUS_EZ", value)
+	def getPoissonsRatioV12(self) -> float:
+		return self._getDoubleProperty("MP_POISSONS_RATIO_V12")
+	def setPoissonsRatioV12(self, value: float):
+		return self._setDoubleProperty("MP_POISSONS_RATIO_V12", value)
+	def getPoissonsRatioV2(self) -> float:
+		return self._getDoubleProperty("MP_POISSONS_RATIO_V2")
+	def setPoissonsRatioV2(self, value: float):
+		return self._setDoubleProperty("MP_POISSONS_RATIO_V2", value)
+	def getPoissonsRatioV2z(self) -> float:
+		return self._getDoubleProperty("MP_POISSONS_RATIO_V2Z")
+	def setPoissonsRatioV2z(self, value: float):
+		return self._setDoubleProperty("MP_POISSONS_RATIO_V2Z", value)
+	def getUnloadingShearModulus(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_SHEAR_MODULUS")
+	def setUnloadingShearModulus(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_SHEAR_MODULUS", value)
+	def getUnloadingAngleCounterclockwiseFromHorizontalToE1(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_ELASTIC_ANGLE")
+	def setUnloadingAngleCounterclockwiseFromHorizontalToE1(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_ELASTIC_ANGLE", value)
+	def getUnloadingYoungsModulusE1(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_E1")
+	def setUnloadingYoungsModulusE1(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_E1", value)
+	def getUnloadingYoungsModulusE2(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_E2")
+	def setUnloadingYoungsModulusE2(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_E2", value)
+	def getUnloadingYoungsModulusEZ(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_EZ")
+	def setUnloadingYoungsModulusEZ(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_EZ", value)
+	def getUnloadingPoissonsRatioV12(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V12")
+	def setUnloadingPoissonsRatioV12(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V12", value)
+	def getUnloadingPoissonsRatioV2(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V2")
+	def setUnloadingPoissonsRatioV2(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V2", value)
+	def getUnloadingPoissonsRatioV2z(self) -> float:
+		return self._getDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V2Z")
+	def setUnloadingPoissonsRatioV2z(self, value: float):
+		return self._setDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V2Z", value)
+	def setProperties(self, UseUnloadingCondition : bool = None, UnloadingCondition : UnloadingConditions = None, ShearModulus : float = None, AngleCounterclockwiseFromHorizontalToE1 : float = None, YoungsModulusE1 : float = None, YoungsModulusE2 : float = None, YoungsModulusEZ : float = None, PoissonsRatioV12 : float = None, PoissonsRatioV2 : float = None, PoissonsRatioV2z : float = None, UnloadingShearModulus : float = None, UnloadingAngleCounterclockwiseFromHorizontalToE1 : float = None, UnloadingYoungsModulusE1 : float = None, UnloadingYoungsModulusE2 : float = None, UnloadingYoungsModulusEZ : float = None, UnloadingPoissonsRatioV12 : float = None, UnloadingPoissonsRatioV2 : float = None, UnloadingPoissonsRatioV2z : 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 ShearModulus is not None:
+			self._setDoubleProperty("MP_SHEAR_MODULUS", ShearModulus)
+		if AngleCounterclockwiseFromHorizontalToE1 is not None:
+			self._setDoubleProperty("MP_ELASTIC_ANGLE", AngleCounterclockwiseFromHorizontalToE1)
+		if YoungsModulusE1 is not None:
+			self._setDoubleProperty("MP_YOUNGS_MODULUS_E1", YoungsModulusE1)
+		if YoungsModulusE2 is not None:
+			self._setDoubleProperty("MP_YOUNGS_MODULUS_E2", YoungsModulusE2)
+		if YoungsModulusEZ is not None:
+			self._setDoubleProperty("MP_YOUNGS_MODULUS_EZ", YoungsModulusEZ)
+		if PoissonsRatioV12 is not None:
+			self._setDoubleProperty("MP_POISSONS_RATIO_V12", PoissonsRatioV12)
+		if PoissonsRatioV2 is not None:
+			self._setDoubleProperty("MP_POISSONS_RATIO_V2", PoissonsRatioV2)
+		if PoissonsRatioV2z is not None:
+			self._setDoubleProperty("MP_POISSONS_RATIO_V2Z", PoissonsRatioV2z)
+		if UnloadingShearModulus is not None:
+			self._setDoubleProperty("MP_UNLOADING_SHEAR_MODULUS", UnloadingShearModulus)
+		if UnloadingAngleCounterclockwiseFromHorizontalToE1 is not None:
+			self._setDoubleProperty("MP_UNLOADING_ELASTIC_ANGLE", UnloadingAngleCounterclockwiseFromHorizontalToE1)
+		if UnloadingYoungsModulusE1 is not None:
+			self._setDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_E1", UnloadingYoungsModulusE1)
+		if UnloadingYoungsModulusE2 is not None:
+			self._setDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_E2", UnloadingYoungsModulusE2)
+		if UnloadingYoungsModulusEZ is not None:
+			self._setDoubleProperty("MP_UNLOADING_YOUNGS_MODULUS_EZ", UnloadingYoungsModulusEZ)
+		if UnloadingPoissonsRatioV12 is not None:
+			self._setDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V12", UnloadingPoissonsRatioV12)
+		if UnloadingPoissonsRatioV2 is not None:
+			self._setDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V2", UnloadingPoissonsRatioV2)
+		if UnloadingPoissonsRatioV2z is not None:
+			self._setDoubleProperty("MP_UNLOADING_POISSONS_RATIO_V2Z", UnloadingPoissonsRatioV2z)
+	def getProperties(self):
+		return {
+		"UseUnloadingCondition" : self.getUseUnloadingCondition(), 
+		"UnloadingCondition" : self.getUnloadingCondition(), 
+		"ShearModulus" : self.getShearModulus(), 
+		"AngleCounterclockwiseFromHorizontalToE1" : self.getAngleCounterclockwiseFromHorizontalToE1(), 
+		"YoungsModulusE1" : self.getYoungsModulusE1(), 
+		"YoungsModulusE2" : self.getYoungsModulusE2(), 
+		"YoungsModulusEZ" : self.getYoungsModulusEZ(), 
+		"PoissonsRatioV12" : self.getPoissonsRatioV12(), 
+		"PoissonsRatioV2" : self.getPoissonsRatioV2(), 
+		"PoissonsRatioV2z" : self.getPoissonsRatioV2z(), 
+		"UnloadingShearModulus" : self.getUnloadingShearModulus(), 
+		"UnloadingAngleCounterclockwiseFromHorizontalToE1" : self.getUnloadingAngleCounterclockwiseFromHorizontalToE1(), 
+		"UnloadingYoungsModulusE1" : self.getUnloadingYoungsModulusE1(), 
+		"UnloadingYoungsModulusE2" : self.getUnloadingYoungsModulusE2(), 
+		"UnloadingYoungsModulusEZ" : self.getUnloadingYoungsModulusEZ(), 
+		"UnloadingPoissonsRatioV12" : self.getUnloadingPoissonsRatioV12(), 
+		"UnloadingPoissonsRatioV2" : self.getUnloadingPoissonsRatioV2(), 
+		"UnloadingPoissonsRatioV2z" : self.getUnloadingPoissonsRatioV2z(), 
+		}

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

@@ -0,0 +1,80 @@
+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 Pm4Sand(PropertyProxy):
+	def getG0Parameter(self) -> float:
+		return self._getDoubleProperty("MP_MD_G0")
+	def setG0Parameter(self, value: float):
+		return self._setDoubleProperty("MP_MD_G0", value)
+	def getVParameter(self) -> float:
+		return self._getDoubleProperty("MP_MD_V")
+	def setVParameter(self, value: float):
+		return self._setDoubleProperty("MP_MD_V", value)
+	def getPatmParameter(self) -> float:
+		return self._getDoubleProperty("MP_MD_PATM")
+	def setPatmParameter(self, value: float):
+		return self._setDoubleProperty("MP_MD_PATM", value)
+	def getAutoCalculateCGDParameter(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_C_GD")
+	def setAutoCalculateCGDParameter(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_C_GD", value)
+	def getCGDParameter(self) -> float:
+		return self._getDoubleProperty("MP_PM4_C_GD")
+	def setCGDParameter(self, value: float):
+		return self._setDoubleProperty("MP_PM4_C_GD", value)
+	def getAutoCalculatePSedParameter(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_P_SED")
+	def setAutoCalculatePSedParameter(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_P_SED", value)
+	def getPSedParameter(self) -> float:
+		return self._getDoubleProperty("MP_PM4_SAND_P_SED")
+	def setPSedParameter(self, value: float):
+		return self._setDoubleProperty("MP_PM4_SAND_P_SED", value)
+	def getPostShake(self) -> bool:
+		return self._getBoolProperty("MP_PM4_POST_SHAKE")
+	def setPostShake(self, value: bool):
+		return self._setBoolProperty("MP_PM4_POST_SHAKE", value)
+	def getAutoCalculateFSedMin(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_F_SED_MIN")
+	def setAutoCalculateFSedMin(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_F_SED_MIN", value)
+	def getFSedMin(self) -> float:
+		return self._getDoubleProperty("MP_PM4_SAND_F_SED_MIN")
+	def setFSedMin(self, value: float):
+		return self._setDoubleProperty("MP_PM4_SAND_F_SED_MIN", value)
+	def setProperties(self, G0Parameter : float = None, VParameter : float = None, PatmParameter : float = None, AutoCalculateCGDParameter : bool = None, CGDParameter : float = None, AutoCalculatePSedParameter : bool = None, PSedParameter : float = None, PostShake : bool = None, AutoCalculateFSedMin : bool = None, FSedMin : float = None):
+		if G0Parameter is not None:
+			self._setDoubleProperty("MP_MD_G0", G0Parameter)
+		if VParameter is not None:
+			self._setDoubleProperty("MP_MD_V", VParameter)
+		if PatmParameter is not None:
+			self._setDoubleProperty("MP_MD_PATM", PatmParameter)
+		if AutoCalculateCGDParameter is not None:
+			self._setBoolProperty("MP_USE_AUTO_C_GD", AutoCalculateCGDParameter)
+		if CGDParameter is not None:
+			self._setDoubleProperty("MP_PM4_C_GD", CGDParameter)
+		if AutoCalculatePSedParameter is not None:
+			self._setBoolProperty("MP_USE_AUTO_P_SED", AutoCalculatePSedParameter)
+		if PSedParameter is not None:
+			self._setDoubleProperty("MP_PM4_SAND_P_SED", PSedParameter)
+		if PostShake is not None:
+			self._setBoolProperty("MP_PM4_POST_SHAKE", PostShake)
+		if AutoCalculateFSedMin is not None:
+			self._setBoolProperty("MP_USE_AUTO_F_SED_MIN", AutoCalculateFSedMin)
+		if FSedMin is not None:
+			self._setDoubleProperty("MP_PM4_SAND_F_SED_MIN", FSedMin)
+	def getProperties(self):
+		return {
+		"G0Parameter" : self.getG0Parameter(), 
+		"VParameter" : self.getVParameter(), 
+		"PatmParameter" : self.getPatmParameter(), 
+		"AutoCalculateCGDParameter" : self.getAutoCalculateCGDParameter(), 
+		"CGDParameter" : self.getCGDParameter(), 
+		"AutoCalculatePSedParameter" : self.getAutoCalculatePSedParameter(), 
+		"PSedParameter" : self.getPSedParameter(), 
+		"PostShake" : self.getPostShake(), 
+		"AutoCalculateFSedMin" : self.getAutoCalculateFSedMin(), 
+		"FSedMin" : self.getFSedMin(), 
+		}

rs2/modeler/properties/material/stiffness/Pm4Silt.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 Pm4Silt(PropertyProxy):
+	def getG0Parameter(self) -> float:
+		return self._getDoubleProperty("MP_MD_G0")
+	def setG0Parameter(self, value: float):
+		return self._setDoubleProperty("MP_MD_G0", value)
+	def getAutoCalculateNGParameter(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_NG")
+	def setAutoCalculateNGParameter(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_NG", value)
+	def getNGParameter(self) -> float:
+		return self._getDoubleProperty("MP_PM4_SILT_NG")
+	def setNGParameter(self, value: float):
+		return self._setDoubleProperty("MP_PM4_SILT_NG", value)
+	def getAutoCalculateVParameter(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_V")
+	def setAutoCalculateVParameter(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_V", value)
+	def getVParameter(self) -> float:
+		return self._getDoubleProperty("MP_MD_V")
+	def setVParameter(self, value: float):
+		return self._setDoubleProperty("MP_MD_V", value)
+	def getPatmParameter(self) -> float:
+		return self._getDoubleProperty("MP_MD_PATM")
+	def setPatmParameter(self, value: float):
+		return self._setDoubleProperty("MP_MD_PATM", value)
+	def getAutoCalculateCGDParameter(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_C_GD")
+	def setAutoCalculateCGDParameter(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_C_GD", value)
+	def getCGDParameter(self) -> float:
+		return self._getDoubleProperty("MP_PM4_C_GD")
+	def setCGDParameter(self, value: float):
+		return self._setDoubleProperty("MP_PM4_C_GD", value)
+	def getAutoCalculateCGCParameter(self) -> bool:
+		return self._getBoolProperty("MP_USE_AUTO_C_GC")
+	def setAutoCalculateCGCParameter(self, value: bool):
+		return self._setBoolProperty("MP_USE_AUTO_C_GC", value)
+	def getCGCParameter(self) -> float:
+		return self._getDoubleProperty("MP_PM4_SILT_C_GC")
+	def setCGCParameter(self, value: float):
+		return self._setDoubleProperty("MP_PM4_SILT_C_GC", value)
+	def getPostShake(self) -> bool:
+		return self._getBoolProperty("MP_PM4_POST_SHAKE")
+	def setPostShake(self, value: bool):
+		return self._setBoolProperty("MP_PM4_POST_SHAKE", value)
+	def setProperties(self, G0Parameter : float = None, AutoCalculateNGParameter : bool = None, NGParameter : float = None, AutoCalculateVParameter : bool = None, VParameter : float = None, PatmParameter : float = None, AutoCalculateCGDParameter : bool = None, CGDParameter : float = None, AutoCalculateCGCParameter : bool = None, CGCParameter : float = None, PostShake : bool = None):
+		if G0Parameter is not None:
+			self._setDoubleProperty("MP_MD_G0", G0Parameter)
+		if AutoCalculateNGParameter is not None:
+			self._setBoolProperty("MP_USE_AUTO_NG", AutoCalculateNGParameter)
+		if NGParameter is not None:
+			self._setDoubleProperty("MP_PM4_SILT_NG", NGParameter)
+		if AutoCalculateVParameter is not None:
+			self._setBoolProperty("MP_USE_AUTO_V", AutoCalculateVParameter)
+		if VParameter is not None:
+			self._setDoubleProperty("MP_MD_V", VParameter)
+		if PatmParameter is not None:
+			self._setDoubleProperty("MP_MD_PATM", PatmParameter)
+		if AutoCalculateCGDParameter is not None:
+			self._setBoolProperty("MP_USE_AUTO_C_GD", AutoCalculateCGDParameter)
+		if CGDParameter is not None:
+			self._setDoubleProperty("MP_PM4_C_GD", CGDParameter)
+		if AutoCalculateCGCParameter is not None:
+			self._setBoolProperty("MP_USE_AUTO_C_GC", AutoCalculateCGCParameter)
+		if CGCParameter is not None:
+			self._setDoubleProperty("MP_PM4_SILT_C_GC", CGCParameter)
+		if PostShake is not None:
+			self._setBoolProperty("MP_PM4_POST_SHAKE", PostShake)
+	def getProperties(self):
+		return {
+		"G0Parameter" : self.getG0Parameter(), 
+		"AutoCalculateNGParameter" : self.getAutoCalculateNGParameter(), 
+		"NGParameter" : self.getNGParameter(), 
+		"AutoCalculateVParameter" : self.getAutoCalculateVParameter(), 
+		"VParameter" : self.getVParameter(), 
+		"PatmParameter" : self.getPatmParameter(), 
+		"AutoCalculateCGDParameter" : self.getAutoCalculateCGDParameter(), 
+		"CGDParameter" : self.getCGDParameter(), 
+		"AutoCalculateCGCParameter" : self.getAutoCalculateCGCParameter(), 
+		"CGCParameter" : self.getCGCParameter(), 
+		"PostShake" : self.getPostShake(), 
+		}

rs2/modeler/properties/material/stiffness/SoftSoil.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 SoftSoil(PropertyProxy):
+	def getPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_SS_POISSON")
+	def setPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_SS_POISSON", value)
+	def getPlimit(self) -> float:
+		return self._getDoubleProperty("MP_SS_P_LIMIT")
+	def setPlimit(self, value: float):
+		return self._setDoubleProperty("MP_SS_P_LIMIT", value)
+	def setProperties(self, PoissonsRatio : float = None, Plimit : float = None):
+		if PoissonsRatio is not None:
+			self._setDoubleProperty("MP_SS_POISSON", PoissonsRatio)
+		if Plimit is not None:
+			self._setDoubleProperty("MP_SS_P_LIMIT", Plimit)
+	def getProperties(self):
+		return {
+		"PoissonsRatio" : self.getPoissonsRatio(), 
+		"Plimit" : self.getPlimit(), 
+		}

rs2/modeler/properties/material/stiffness/SoftSoilCreep.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 SoftSoilCreep(PropertyProxy):
+	def getPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("MP_SSC_POISSON")
+	def setPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("MP_SSC_POISSON", value)
+	def getPlimit(self) -> float:
+		return self._getDoubleProperty("MP_SSC_P_LIMIT")
+	def setPlimit(self, value: float):
+		return self._setDoubleProperty("MP_SSC_P_LIMIT", value)
+	def setProperties(self, PoissonsRatio : float = None, Plimit : float = None):
+		if PoissonsRatio is not None:
+			self._setDoubleProperty("MP_SSC_POISSON", PoissonsRatio)
+		if Plimit is not None:
+			self._setDoubleProperty("MP_SSC_P_LIMIT", Plimit)
+	def getProperties(self):
+		return {
+		"PoissonsRatio" : self.getPoissonsRatio(), 
+		"Plimit" : self.getPlimit(), 
+		}

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

@@ -0,0 +1,53 @@
+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.stiffness.Isotropic import Isotropic
+from rs2.modeler.properties.material.stiffness.TransverselyIsotropic import TransverselyIsotropic
+from rs2.modeler.properties.material.stiffness.Orthotropic import Orthotropic
+from rs2.modeler.properties.material.stiffness.NonLinearHyperbolic import NonLinearHyperbolic
+from rs2.modeler.properties.material.stiffness.NonLinearIsotropic import NonLinearIsotropic
+from rs2.modeler.properties.material.stiffness.ViscoElastic import ViscoElastic
+from rs2.modeler.properties.material.stiffness.Custom import Custom
+from rs2.modeler.properties.material.stiffness.ChSoil import ChSoil
+from rs2.modeler.properties.material.stiffness.CySoil import CySoil
+from rs2.modeler.properties.material.stiffness.DoubleYield import DoubleYield
+from rs2.modeler.properties.material.stiffness.HardeningSoil import HardeningSoil
+from rs2.modeler.properties.material.stiffness.HardeningSoilSmallStrainStiffness import HardeningSoilSmallStrainStiffness
+from rs2.modeler.properties.material.stiffness.SoftSoil import SoftSoil
+from rs2.modeler.properties.material.stiffness.SoftSoilCreep import SoftSoilCreep
+from rs2.modeler.properties.material.stiffness.SwellingRock import SwellingRock
+from rs2.modeler.properties.material.stiffness.ManzariAndDafalias import ManzariAndDafalias
+from rs2.modeler.properties.material.stiffness.Norsand import Norsand
+from rs2.modeler.properties.material.stiffness.Pm4Sand import Pm4Sand
+from rs2.modeler.properties.material.stiffness.Pm4Silt import Pm4Silt
+class Stiffness(PropertyProxy):
+	"""
+	:ref:`Material Property Stiffness Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.Isotropic = Isotropic(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.TransverselyIsotropic = TransverselyIsotropic(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.Orthotropic = Orthotropic(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.NonLinearHyperbolic = NonLinearHyperbolic(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.NonLinearIsotropic = NonLinearIsotropic(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.ViscoElastic = ViscoElastic(client, ID, documentProxyID)
+		self.Custom = Custom(client, ID, documentProxyID)
+		self.ChSoil = ChSoil(client, ID, documentProxyID)
+		self.CySoil = CySoil(client, ID, documentProxyID)
+		self.DoubleYield = DoubleYield(client, ID, documentProxyID)
+		self.HardeningSoil = HardeningSoil(client, ID, documentProxyID)
+		self.HardeningSoilSmallStrainStiffness = HardeningSoilSmallStrainStiffness(client, ID, documentProxyID)
+		self.SoftSoil = SoftSoil(client, ID, documentProxyID)
+		self.SoftSoilCreep = SoftSoilCreep(client, ID, documentProxyID)
+		self.SwellingRock = SwellingRock(client, ID, documentProxyID)
+		self.ManzariAndDafalias = ManzariAndDafalias(client, ID, documentProxyID)
+		self.Norsand = Norsand(client, ID, documentProxyID)
+		self.Pm4Sand = Pm4Sand(client, ID, documentProxyID)
+		self.Pm4Silt = Pm4Silt(client, ID, documentProxyID)
+	def getElasticType(self) -> MaterialElasticityTypes:
+		return MaterialElasticityTypes(self._getEnumEMaterialElasticityTypesProperty("MP_ELASTIC_TYPE"))
+	def setElasticType(self, value: MaterialElasticityTypes):
+		return self._setEnumEMaterialElasticityTypesProperty("MP_ELASTIC_TYPE", value)

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

@@ -0,0 +1,52 @@
+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 SwellingRock(PropertyProxy):
+	def getAngleToBeddingPlanes(self) -> float:
+		return self._getDoubleProperty("MP_SR_V")
+	def setAngleToBeddingPlanes(self, value: float):
+		return self._setDoubleProperty("MP_SR_V", value)
+	def getElasticModulusTangentialToBeddingPlane(self) -> float:
+		return self._getDoubleProperty("MP_SR_MODULUS_TANGENT")
+	def setElasticModulusTangentialToBeddingPlane(self, value: float):
+		return self._setDoubleProperty("MP_SR_MODULUS_TANGENT", value)
+	def getElasticModulusNormalToBeddingPlanes(self) -> float:
+		return self._getDoubleProperty("MP_SR_MODULUS_NORMAL")
+	def setElasticModulusNormalToBeddingPlanes(self, value: float):
+		return self._setDoubleProperty("MP_SR_MODULUS_NORMAL", value)
+	def getPoissonsRatioOutOfBeddingPlanes(self) -> float:
+		return self._getDoubleProperty("MP_SR_POISSON_OUT_OF")
+	def setPoissonsRatioOutOfBeddingPlanes(self, value: float):
+		return self._setDoubleProperty("MP_SR_POISSON_OUT_OF", value)
+	def getPoissonsRatioWithinBeddingPlanes(self) -> float:
+		return self._getDoubleProperty("MP_SR_POISSON_WITHIN")
+	def setPoissonsRatioWithinBeddingPlanes(self, value: float):
+		return self._setDoubleProperty("MP_SR_POISSON_WITHIN", value)
+	def getShearModulus(self) -> float:
+		return self._getDoubleProperty("MP_SR_SHEAR_MODULUS")
+	def setShearModulus(self, value: float):
+		return self._setDoubleProperty("MP_SR_SHEAR_MODULUS", value)
+	def setProperties(self, AngleToBeddingPlanes : float = None, ElasticModulusTangentialToBeddingPlane : float = None, ElasticModulusNormalToBeddingPlanes : float = None, PoissonsRatioOutOfBeddingPlanes : float = None, PoissonsRatioWithinBeddingPlanes : float = None, ShearModulus : float = None):
+		if AngleToBeddingPlanes is not None:
+			self._setDoubleProperty("MP_SR_V", AngleToBeddingPlanes)
+		if ElasticModulusTangentialToBeddingPlane is not None:
+			self._setDoubleProperty("MP_SR_MODULUS_TANGENT", ElasticModulusTangentialToBeddingPlane)
+		if ElasticModulusNormalToBeddingPlanes is not None:
+			self._setDoubleProperty("MP_SR_MODULUS_NORMAL", ElasticModulusNormalToBeddingPlanes)
+		if PoissonsRatioOutOfBeddingPlanes is not None:
+			self._setDoubleProperty("MP_SR_POISSON_OUT_OF", PoissonsRatioOutOfBeddingPlanes)
+		if PoissonsRatioWithinBeddingPlanes is not None:
+			self._setDoubleProperty("MP_SR_POISSON_WITHIN", PoissonsRatioWithinBeddingPlanes)
+		if ShearModulus is not None:
+			self._setDoubleProperty("MP_SR_SHEAR_MODULUS", ShearModulus)
+	def getProperties(self):
+		return {
+		"AngleToBeddingPlanes" : self.getAngleToBeddingPlanes(), 
+		"ElasticModulusTangentialToBeddingPlane" : self.getElasticModulusTangentialToBeddingPlane(), 
+		"ElasticModulusNormalToBeddingPlanes" : self.getElasticModulusNormalToBeddingPlanes(), 
+		"PoissonsRatioOutOfBeddingPlanes" : self.getPoissonsRatioOutOfBeddingPlanes(), 
+		"PoissonsRatioWithinBeddingPlanes" : self.getPoissonsRatioWithinBeddingPlanes(), 
+		"ShearModulus" : self.getShearModulus(), 
+		}