RS2Scripting 11.23.0__py3-none-any.whl

rs2/modeler/properties/material/strength/SoftSoilCreepStrength.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 SoftSoilCreepStrength(PropertyProxy):
+	def getFrictionAngle(self) -> float:
+		return self._getDoubleProperty("MP_SSC_FRIC_ANGLE")
+	def setFrictionAngle(self, value: float):
+		return self._setDoubleProperty("MP_SSC_FRIC_ANGLE", value)
+	def getCohesion(self) -> float:
+		return self._getDoubleProperty("MP_SSC_COHESION")
+	def setCohesion(self, value: float):
+		return self._setDoubleProperty("MP_SSC_COHESION", value)
+	def getTensileStrength(self) -> float:
+		return self._getDoubleProperty("MP_SSC_TENSILE")
+	def setTensileStrength(self, value: float):
+		return self._setDoubleProperty("MP_SSC_TENSILE", value)
+	def getDilationAngle(self) -> float:
+		return self._getDoubleProperty("MP_SSC_DILATION_ANGLE")
+	def setDilationAngle(self, value: float):
+		return self._setDoubleProperty("MP_SSC_DILATION_ANGLE", value)
+	def getLambda(self) -> float:
+		return self._getDoubleProperty("MP_SSC_LAMBDA")
+	def setLambda(self, value: float):
+		return self._setDoubleProperty("MP_SSC_LAMBDA", value)
+	def getKappa(self) -> float:
+		return self._getDoubleProperty("MP_SSC_KAPPA")
+	def setKappa(self, value: float):
+		return self._setDoubleProperty("MP_SSC_KAPPA", value)
+	def getK0NormalConsolidation(self) -> float:
+		return self._getDoubleProperty("MP_SSC_K0_NORM_CONSOL")
+	def setK0NormalConsolidation(self, value: float):
+		return self._setDoubleProperty("MP_SSC_K0_NORM_CONSOL", value)
+	def getInitialConsolidationCondition(self) -> InitialConsolidation:
+		return InitialConsolidation(self._getEnumEInitialConsolidationProperty("MP_SSC_INIT_CONSOL"))
+	def setInitialConsolidationCondition(self, value: InitialConsolidation):
+		return self._setEnumEInitialConsolidationProperty("MP_SSC_INIT_CONSOL", value)
+	def getOCRStress(self) -> float:
+		return self._getDoubleProperty("MP_SSC_OCR_STRESS")
+	def setOCRStress(self, value: float):
+		return self._setDoubleProperty("MP_SSC_OCR_STRESS", value)
+	def getInitialMeanStress(self) -> float:
+		return self._getDoubleProperty("MP_SSC_INIT_MEAN_STRESS")
+	def setInitialMeanStress(self, value: float):
+		return self._setDoubleProperty("MP_SSC_INIT_MEAN_STRESS", value)
+	def getMu(self) -> float:
+		return self._getDoubleProperty("MP_SSC_MU")
+	def setMu(self, value: float):
+		return self._setDoubleProperty("MP_SSC_MU", value)
+	def setProperties(self, FrictionAngle : float = None, Cohesion : float = None, TensileStrength : float = None, DilationAngle : float = None, Lambda : float = None, Kappa : float = None, K0NormalConsolidation : float = None, InitialConsolidationCondition : InitialConsolidation = None, OCRStress : float = None, InitialMeanStress : float = None, Mu : float = None):
+		if FrictionAngle is not None:
+			self._setDoubleProperty("MP_SSC_FRIC_ANGLE", FrictionAngle)
+		if Cohesion is not None:
+			self._setDoubleProperty("MP_SSC_COHESION", Cohesion)
+		if TensileStrength is not None:
+			self._setDoubleProperty("MP_SSC_TENSILE", TensileStrength)
+		if DilationAngle is not None:
+			self._setDoubleProperty("MP_SSC_DILATION_ANGLE", DilationAngle)
+		if Lambda is not None:
+			self._setDoubleProperty("MP_SSC_LAMBDA", Lambda)
+		if Kappa is not None:
+			self._setDoubleProperty("MP_SSC_KAPPA", Kappa)
+		if K0NormalConsolidation is not None:
+			self._setDoubleProperty("MP_SSC_K0_NORM_CONSOL", K0NormalConsolidation)
+		if InitialConsolidationCondition is not None:
+			self._setEnumEInitialConsolidationProperty("MP_SSC_INIT_CONSOL", InitialConsolidationCondition)
+		if OCRStress is not None:
+			self._setDoubleProperty("MP_SSC_OCR_STRESS", OCRStress)
+		if InitialMeanStress is not None:
+			self._setDoubleProperty("MP_SSC_INIT_MEAN_STRESS", InitialMeanStress)
+		if Mu is not None:
+			self._setDoubleProperty("MP_SSC_MU", Mu)
+	def getProperties(self):
+		return {
+		"FrictionAngle" : self.getFrictionAngle(), 
+		"Cohesion" : self.getCohesion(), 
+		"TensileStrength" : self.getTensileStrength(), 
+		"DilationAngle" : self.getDilationAngle(), 
+		"Lambda" : self.getLambda(), 
+		"Kappa" : self.getKappa(), 
+		"K0NormalConsolidation" : self.getK0NormalConsolidation(), 
+		"InitialConsolidationCondition" : self.getInitialConsolidationCondition(), 
+		"OCRStress" : self.getOCRStress(), 
+		"InitialMeanStress" : self.getInitialMeanStress(), 
+		"Mu" : self.getMu(), 
+		}

rs2/modeler/properties/material/strength/SoftSoilStrength.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 SoftSoilStrength(PropertyProxy):
+	def getFrictionAngle(self) -> float:
+		return self._getDoubleProperty("MP_SS_FRICTION_ANGLE")
+	def setFrictionAngle(self, value: float):
+		return self._setDoubleProperty("MP_SS_FRICTION_ANGLE", value)
+	def getCohesion(self) -> float:
+		return self._getDoubleProperty("MP_SS_COHESION")
+	def setCohesion(self, value: float):
+		return self._setDoubleProperty("MP_SS_COHESION", value)
+	def getTensileStrength(self) -> float:
+		return self._getDoubleProperty("MP_SS_TENSILE")
+	def setTensileStrength(self, value: float):
+		return self._setDoubleProperty("MP_SS_TENSILE", value)
+	def getDilationAngle(self) -> float:
+		return self._getDoubleProperty("MP_SS_DILATION_ANGLE")
+	def setDilationAngle(self, value: float):
+		return self._setDoubleProperty("MP_SS_DILATION_ANGLE", value)
+	def getLambda(self) -> float:
+		return self._getDoubleProperty("MP_SS_LAMBDA")
+	def setLambda(self, value: float):
+		return self._setDoubleProperty("MP_SS_LAMBDA", value)
+	def getKappa(self) -> float:
+		return self._getDoubleProperty("MP_SS_KAPPA")
+	def setKappa(self, value: float):
+		return self._setDoubleProperty("MP_SS_KAPPA", value)
+	def getK0NormalConsolidation(self) -> float:
+		return self._getDoubleProperty("MP_SS_K0_NORM_CONSOL")
+	def setK0NormalConsolidation(self, value: float):
+		return self._setDoubleProperty("MP_SS_K0_NORM_CONSOL", value)
+	def getInitialConsolidationCondition(self) -> InitialConsolidation:
+		return InitialConsolidation(self._getEnumEInitialConsolidationProperty("MP_SS_INIT_CONSOL"))
+	def setInitialConsolidationCondition(self, value: InitialConsolidation):
+		return self._setEnumEInitialConsolidationProperty("MP_SS_INIT_CONSOL", value)
+	def getOCRStress(self) -> float:
+		return self._getDoubleProperty("MP_SS_OCR_STRESS")
+	def setOCRStress(self, value: float):
+		return self._setDoubleProperty("MP_SS_OCR_STRESS", value)
+	def getInitialMeanStress(self) -> float:
+		return self._getDoubleProperty("MP_SS_INIT_MEAN_STRESS")
+	def setInitialMeanStress(self, value: float):
+		return self._setDoubleProperty("MP_SS_INIT_MEAN_STRESS", value)
+	def setProperties(self, FrictionAngle : float = None, Cohesion : float = None, TensileStrength : float = None, DilationAngle : float = None, Lambda : float = None, Kappa : float = None, K0NormalConsolidation : float = None, InitialConsolidationCondition : InitialConsolidation = None, OCRStress : float = None, InitialMeanStress : float = None):
+		if FrictionAngle is not None:
+			self._setDoubleProperty("MP_SS_FRICTION_ANGLE", FrictionAngle)
+		if Cohesion is not None:
+			self._setDoubleProperty("MP_SS_COHESION", Cohesion)
+		if TensileStrength is not None:
+			self._setDoubleProperty("MP_SS_TENSILE", TensileStrength)
+		if DilationAngle is not None:
+			self._setDoubleProperty("MP_SS_DILATION_ANGLE", DilationAngle)
+		if Lambda is not None:
+			self._setDoubleProperty("MP_SS_LAMBDA", Lambda)
+		if Kappa is not None:
+			self._setDoubleProperty("MP_SS_KAPPA", Kappa)
+		if K0NormalConsolidation is not None:
+			self._setDoubleProperty("MP_SS_K0_NORM_CONSOL", K0NormalConsolidation)
+		if InitialConsolidationCondition is not None:
+			self._setEnumEInitialConsolidationProperty("MP_SS_INIT_CONSOL", InitialConsolidationCondition)
+		if OCRStress is not None:
+			self._setDoubleProperty("MP_SS_OCR_STRESS", OCRStress)
+		if InitialMeanStress is not None:
+			self._setDoubleProperty("MP_SS_INIT_MEAN_STRESS", InitialMeanStress)
+	def getProperties(self):
+		return {
+		"FrictionAngle" : self.getFrictionAngle(), 
+		"Cohesion" : self.getCohesion(), 
+		"TensileStrength" : self.getTensileStrength(), 
+		"DilationAngle" : self.getDilationAngle(), 
+		"Lambda" : self.getLambda(), 
+		"Kappa" : self.getKappa(), 
+		"K0NormalConsolidation" : self.getK0NormalConsolidation(), 
+		"InitialConsolidationCondition" : self.getInitialConsolidationCondition(), 
+		"OCRStress" : self.getOCRStress(), 
+		"InitialMeanStress" : self.getInitialMeanStress(), 
+		}

rs2/modeler/properties/material/strength/SofteningHardeningModel.py

@@ -0,0 +1,150 @@
+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 SofteningHardeningModelStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getHardeningPropertyFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_HARDENING_PROPERTY", self.propertyID], proxyArgumentIndices=[1])
+	def getInitialMeanStressFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_INITIAL_MEAN_STRESS", self.propertyID], proxyArgumentIndices=[1])
+	def getLambdaKappaFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_LAMBDA_KAPPA", self.propertyID], proxyArgumentIndices=[1])
+	def getPeakCohesionFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_PEAK_COHESION", self.propertyID], proxyArgumentIndices=[1])
+	def getPeakFrictionAngleFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_PEAK_FRICTION_ANGLE", self.propertyID], proxyArgumentIndices=[1])
+	def getPeakTensileStrengthFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_PEAK_TENSILE_STRENGTH", self.propertyID], proxyArgumentIndices=[1])
+	def getDilationAngleFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_SOFT_HARD_DILATION_ANGLE", self.propertyID], proxyArgumentIndices=[1])
+class SofteningHardeningModelDefinedStageFactor(SofteningHardeningModelStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setHardeningPropertyFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_HARDENING_PROPERTY", value, self.propertyID], proxyArgumentIndices=[2])
+	def setInitialMeanStressFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_INITIAL_MEAN_STRESS", value, self.propertyID], proxyArgumentIndices=[2])
+	def setLambdaKappaFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_LAMBDA_KAPPA", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPeakCohesionFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_PEAK_COHESION", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPeakFrictionAngleFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_PEAK_FRICTION_ANGLE", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPeakTensileStrengthFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_PEAK_TENSILE_STRENGTH", value, self.propertyID], proxyArgumentIndices=[2])
+	def setDilationAngleFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_SOFT_HARD_DILATION_ANGLE", value, self.propertyID], proxyArgumentIndices=[2])
+class SofteningHardeningModel(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[SofteningHardeningModelDefinedStageFactor, SofteningHardeningModelStageFactor](self._client, stageFactorInterfaceID, ID, SofteningHardeningModelDefinedStageFactor, SofteningHardeningModelStageFactor)
+	def getPeakTensileStrength(self) -> float:
+		return self._getDoubleProperty("MP_PEAK_TENSILE_STRENGTH")
+	def setPeakTensileStrength(self, value: float):
+		return self._setDoubleProperty("MP_PEAK_TENSILE_STRENGTH", value)
+	def getPeakFrictionAngle(self) -> float:
+		return self._getDoubleProperty("MP_PEAK_FRICTION_ANGLE")
+	def setPeakFrictionAngle(self, value: float):
+		return self._setDoubleProperty("MP_PEAK_FRICTION_ANGLE", value)
+	def getPeakCohesion(self) -> float:
+		return self._getDoubleProperty("MP_PEAK_COHESION")
+	def setPeakCohesion(self, value: float):
+		return self._setDoubleProperty("MP_PEAK_COHESION", value)
+	def getConeHardeningType(self) -> ConeHardeningTypes:
+		return ConeHardeningTypes(self._getEnumEConeHardeningTypesProperty("MP_CONE_HARDENING_TYPE"))
+	def setConeHardeningType(self, value: ConeHardeningTypes):
+		return self._setEnumEConeHardeningTypesProperty("MP_CONE_HARDENING_TYPE", value)
+	def getHardeningProperty(self) -> float:
+		return self._getDoubleProperty("MP_HARDENING_PROPERTY")
+	def setHardeningProperty(self, value: float):
+		return self._setDoubleProperty("MP_HARDENING_PROPERTY", value)
+	def getDilationAngle(self) -> float:
+		return self._getDoubleProperty("MP_SOFT_HARD_DILATION_ANGLE")
+	def setDilationAngle(self, value: float):
+		return self._setDoubleProperty("MP_SOFT_HARD_DILATION_ANGLE", value)
+	def getConeDilationType(self) -> DilationTypes:
+		return DilationTypes(self._getEnumEDilationTypesProperty("MP_CONE_DILATION"))
+	def setConeDilationType(self, value: DilationTypes):
+		return self._setEnumEDilationTypesProperty("MP_CONE_DILATION", value)
+	def getCapType(self) -> CapTypes:
+		return CapTypes(self._getEnumECapTypesProperty("MP_SH_CAP_TYPE"))
+	def setCapType(self, value: CapTypes):
+		return self._setEnumECapTypesProperty("MP_SH_CAP_TYPE", value)
+	def getCapHardeningType(self) -> CapHardeningTypes:
+		return CapHardeningTypes(self._getEnumECapHardeningTypesProperty("MP_SH_CAP_HARDENING_TYPE"))
+	def setCapHardeningType(self, value: CapHardeningTypes):
+		return self._setEnumECapHardeningTypesProperty("MP_SH_CAP_HARDENING_TYPE", value)
+	def getInitialMeanStress(self) -> float:
+		return self._getDoubleProperty("MP_INITIAL_MEAN_STRESS")
+	def setInitialMeanStress(self, value: float):
+		return self._setDoubleProperty("MP_INITIAL_MEAN_STRESS", value)
+	def getLambdaKappa(self) -> float:
+		return self._getDoubleProperty("MP_LAMBDA_KAPPA")
+	def setLambdaKappa(self, value: float):
+		return self._setDoubleProperty("MP_LAMBDA_KAPPA", value)
+	def setSHConeHardening(self, plasticStrainVsFrictionAngle: list[tuple[float,float]], plasticStrainVsCohesion: list[tuple[float,float]]):
+		"""
+		plasticStrainVsFrictionAngle: list of tuples, (plainStrain, frictionAngle)
+		plasticStrainVsCohesion: list of tuples, (plasticStrain, Cohesion)
+		"""
+		return self._callFunction("setSHConeHardening", [plasticStrainVsFrictionAngle, plasticStrainVsCohesion])
+	def getSHConeHardening(self) -> tuple[list[tuple[float,float]],list[tuple[float,float]]]:
+		"""
+		returns a tuple of (plasticStrainVsFrictionAngle, plasticStrainVsCohesion), where
+		plasticStrainVsFrictionAngle: list of tuples, (plainStrain, frictionAngle)
+		plasticStrainVsCohesion: list of tuples, (plasticStrain, Cohesion)
+		"""
+		return self._callFunction("getSHConeHardening", [])
+	def setSHCapMeanStress(self, meanStress: list[tuple[float,float]]):
+		"""
+		meanStress is a list of (x,y) tuples.
+		"""
+		return self._callFunction("setSHCapMeanStress", [meanStress])
+	def getSHCapMeanStress(self) -> list[tuple[float,float]]:
+		"""
+		returns a list of (x,y) tuples.
+		"""
+		return self._callFunction("getSHCapMeanStress", [])
+	def setProperties(self, PeakTensileStrength : float = None, PeakFrictionAngle : float = None, PeakCohesion : float = None, ConeHardeningType : ConeHardeningTypes = None, HardeningProperty : float = None, DilationAngle : float = None, ConeDilationType : DilationTypes = None, CapType : CapTypes = None, CapHardeningType : CapHardeningTypes = None, InitialMeanStress : float = None, LambdaKappa : float = None):
+		if PeakTensileStrength is not None:
+			self._setDoubleProperty("MP_PEAK_TENSILE_STRENGTH", PeakTensileStrength)
+		if PeakFrictionAngle is not None:
+			self._setDoubleProperty("MP_PEAK_FRICTION_ANGLE", PeakFrictionAngle)
+		if PeakCohesion is not None:
+			self._setDoubleProperty("MP_PEAK_COHESION", PeakCohesion)
+		if ConeHardeningType is not None:
+			self._setEnumEConeHardeningTypesProperty("MP_CONE_HARDENING_TYPE", ConeHardeningType)
+		if HardeningProperty is not None:
+			self._setDoubleProperty("MP_HARDENING_PROPERTY", HardeningProperty)
+		if DilationAngle is not None:
+			self._setDoubleProperty("MP_SOFT_HARD_DILATION_ANGLE", DilationAngle)
+		if ConeDilationType is not None:
+			self._setEnumEDilationTypesProperty("MP_CONE_DILATION", ConeDilationType)
+		if CapType is not None:
+			self._setEnumECapTypesProperty("MP_SH_CAP_TYPE", CapType)
+		if CapHardeningType is not None:
+			self._setEnumECapHardeningTypesProperty("MP_SH_CAP_HARDENING_TYPE", CapHardeningType)
+		if InitialMeanStress is not None:
+			self._setDoubleProperty("MP_INITIAL_MEAN_STRESS", InitialMeanStress)
+		if LambdaKappa is not None:
+			self._setDoubleProperty("MP_LAMBDA_KAPPA", LambdaKappa)
+	def getProperties(self):
+		return {
+		"PeakTensileStrength" : self.getPeakTensileStrength(), 
+		"PeakFrictionAngle" : self.getPeakFrictionAngle(), 
+		"PeakCohesion" : self.getPeakCohesion(), 
+		"ConeHardeningType" : self.getConeHardeningType(), 
+		"HardeningProperty" : self.getHardeningProperty(), 
+		"DilationAngle" : self.getDilationAngle(), 
+		"ConeDilationType" : self.getConeDilationType(), 
+		"CapType" : self.getCapType(), 
+		"CapHardeningType" : self.getCapHardeningType(), 
+		"InitialMeanStress" : self.getInitialMeanStress(), 
+		"LambdaKappa" : self.getLambdaKappa(), 
+		}

rs2/modeler/properties/material/strength/Strength.py

@@ -0,0 +1,185 @@
+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.strength.MohrCoulombStrength import MohrCoulombStrength
+from rs2.modeler.properties.material.strength.HoekBrown import HoekBrown
+from rs2.modeler.properties.material.strength.DruckerPrager import DruckerPrager
+from rs2.modeler.properties.material.strength.GeneralizedHoekBrown import GeneralizedHoekBrown
+from rs2.modeler.properties.material.strength.DiscreteFunction import DiscreteFunction
+from rs2.modeler.properties.material.strength.CamClay import CamClay
+from rs2.modeler.properties.material.strength.ModifiedCamClay import ModifiedCamClay
+from rs2.modeler.properties.material.strength.MohrCoulombWithCap import MohrCoulombWithCap
+from rs2.modeler.properties.material.strength.SofteningHardeningModel import SofteningHardeningModel
+from rs2.modeler.properties.material.strength.BarcelonaBasic import BarcelonaBasic
+from rs2.modeler.properties.material.strength.NorSandStrength import NorSandStrength
+from rs2.modeler.properties.material.strength.BoundingSurfacePlasticity import BoundingSurfacePlasticity
+from rs2.modeler.properties.material.strength.ManzariAndDafaliasStrength import ManzariAndDafaliasStrength
+from rs2.modeler.properties.material.strength.PM4SandStrength import PM4SandStrength
+from rs2.modeler.properties.material.strength.PM4SiltStrength import PM4SiltStrength
+from rs2.modeler.properties.material.strength.Finn import Finn
+from rs2.modeler.properties.material.strength.BartonBandisStrength import BartonBandisStrength
+from rs2.modeler.properties.material.strength.Hyperbolic import Hyperbolic
+from rs2.modeler.properties.material.strength.PowerCurve import PowerCurve
+from rs2.modeler.properties.material.strength.ShearNormalFunction import ShearNormalFunction
+from rs2.modeler.properties.material.strength.Shansep import Shansep
+from rs2.modeler.properties.material.strength.VerticalStressRatio import VerticalStressRatio
+from rs2.modeler.properties.material.strength.SnowdenModAnisotropicLinear import SnowdenModAnisotropicLinear
+from rs2.modeler.properties.material.strength.AnisotropicLinear import AnisotropicLinear
+from rs2.modeler.properties.material.strength.GeneralizedAnisotropic import GeneralizedAnisotropic
+from rs2.modeler.properties.material.strength.JointedMohrCoulomb import JointedMohrCoulomb
+from rs2.modeler.properties.material.strength.JointedGeneralizedHoekBrown import JointedGeneralizedHoekBrown
+from rs2.modeler.properties.material.strength.ChSoilStrength import ChSoilStrength
+from rs2.modeler.properties.material.strength.CySoilStrength import CySoilStrength
+from rs2.modeler.properties.material.strength.DoubleYieldStrength import DoubleYieldStrength
+from rs2.modeler.properties.material.strength.HardeningSoilStrength import HardeningSoilStrength
+from rs2.modeler.properties.material.strength.HardeningSoilWithSmallStrainStiffness import HardeningSoilWithSmallStrainStiffness
+from rs2.modeler.properties.material.strength.SoftSoilStrength import SoftSoilStrength
+from rs2.modeler.properties.material.strength.SoftSoilCreepStrength import SoftSoilCreepStrength
+from rs2.modeler.properties.material.strength.SwellingRockStrength import SwellingRockStrength
+from rs2._common.ProxyObject import ProxyObject
+from rs2.modeler.properties.AbsoluteStageFactorGettersInterface import AbsoluteStageFactorGettersInterface
+class StrengthStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getAirEntryValueFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_UNSATURATED_AIR_ENTRY_VALUE", self.propertyID], proxyArgumentIndices=[1])
+	def getUnsaturatedShearStrengthAngleFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_UNSATURATED_SHEAR_STRENGTH_ANGLE", self.propertyID], proxyArgumentIndices=[1])
+	def getResetYield(self) -> bool:
+		return self._callFunction("getResetYield", [])
+class StrengthDefinedStageFactor(StrengthStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setAirEntryValueFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_UNSATURATED_AIR_ENTRY_VALUE", value, self.propertyID], proxyArgumentIndices=[2])
+	def setUnsaturatedShearStrengthAngleFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_UNSATURATED_SHEAR_STRENGTH_ANGLE", value, self.propertyID], proxyArgumentIndices=[2])
+	def setResetYield(self, resetYield: bool):
+		return self._callFunction("setResetYield", [resetYield])
+class Strength(PropertyProxy):
+	"""
+	:ref:`Material Property Strength Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[StrengthDefinedStageFactor, StrengthStageFactor](self._client, stageFactorInterfaceID, ID, StrengthDefinedStageFactor, StrengthStageFactor)
+		self.MohrCoulombStrength = MohrCoulombStrength(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.HoekBrown = HoekBrown(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.DruckerPrager = DruckerPrager(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.GeneralizedHoekBrown = GeneralizedHoekBrown(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.DiscreteFunction = DiscreteFunction(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.CamClay = CamClay(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.ModifiedCamClay = ModifiedCamClay(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.MohrCoulombWithCap = MohrCoulombWithCap(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.SofteningHardeningModel = SofteningHardeningModel(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.BarcelonaBasic = BarcelonaBasic(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.NorSandStrength = NorSandStrength(client, ID, documentProxyID)
+		self.BoundingSurfacePlasticity = BoundingSurfacePlasticity(client, ID, documentProxyID)
+		self.ManzariAndDafaliasStrength = ManzariAndDafaliasStrength(client, ID, documentProxyID)
+		self.PM4SandStrength = PM4SandStrength(client, ID, documentProxyID)
+		self.PM4SiltStrength = PM4SiltStrength(client, ID, documentProxyID)
+		self.Finn = Finn(client, ID, documentProxyID)
+		self.BartonBandisStrength = BartonBandisStrength(client, ID, documentProxyID)
+		self.Hyperbolic = Hyperbolic(client, ID, documentProxyID)
+		self.PowerCurve = PowerCurve(client, ID, documentProxyID)
+		self.ShearNormalFunction = ShearNormalFunction(client, ID, documentProxyID)
+		self.Shansep = Shansep(client, ID, documentProxyID)
+		self.VerticalStressRatio = VerticalStressRatio(client, ID, documentProxyID)
+		self.SnowdenModAnisotropicLinear = SnowdenModAnisotropicLinear(client, ID, documentProxyID)
+		self.AnisotropicLinear = AnisotropicLinear(client, ID, documentProxyID)
+		self.GeneralizedAnisotropic = GeneralizedAnisotropic(client, ID, documentProxyID)
+		self.JointedMohrCoulomb = JointedMohrCoulomb(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.JointedGeneralizedHoekBrown = JointedGeneralizedHoekBrown(client, ID, documentProxyID, stageFactorInterfaceID)
+		self.ChSoilStrength = ChSoilStrength(client, ID, documentProxyID)
+		self.CySoilStrength = CySoilStrength(client, ID, documentProxyID)
+		self.DoubleYieldStrength = DoubleYieldStrength(client, ID, documentProxyID)
+		self.HardeningSoilStrength = HardeningSoilStrength(client, ID, documentProxyID)
+		self.HardeningSoilWithSmallStrainStiffness = HardeningSoilWithSmallStrainStiffness(client, ID, documentProxyID)
+		self.SoftSoilStrength = SoftSoilStrength(client, ID, documentProxyID)
+		self.SoftSoilCreepStrength = SoftSoilCreepStrength(client, ID, documentProxyID)
+		self.SwellingRockStrength = SwellingRockStrength(client, ID, documentProxyID)
+	def getFailureCriterion(self) -> StrengthCriteriaTypes:
+		return StrengthCriteriaTypes(self._getEnumEStrengthCriteriaTypesProperty("MP_FAILURE_CRITERION"))
+	def setFailureCriterion(self, value: StrengthCriteriaTypes):
+		return self._setEnumEStrengthCriteriaTypesProperty("MP_FAILURE_CRITERION", value)
+	def getUnsaturatedBehavior(self) -> UnsaturatedParameterType:
+		return UnsaturatedParameterType(self._getEnumEUnsaturatedParameterTypeProperty("MP_UNSATURATED_PARAMETER_TYPE"))
+	def setUnsaturatedBehavior(self, value: UnsaturatedParameterType):
+		return self._setEnumEUnsaturatedParameterTypeProperty("MP_UNSATURATED_PARAMETER_TYPE", value)
+	def getUnsaturatedShearStrengthType(self) -> UnsaturatedShearStrengthType:
+		return UnsaturatedShearStrengthType(self._getEnumEUnsaturatedShearStrengthTypeProperty("MP_UNSATURATED_SHEAR_STRENGTH_TYPE"))
+	def setUnsaturatedShearStrengthType(self, value: UnsaturatedShearStrengthType):
+		return self._setEnumEUnsaturatedShearStrengthTypeProperty("MP_UNSATURATED_SHEAR_STRENGTH_TYPE", value)
+	def getUnsaturatedShearStrengthAngle(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_SHEAR_STRENGTH_ANGLE")
+	def setUnsaturatedShearStrengthAngle(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_SHEAR_STRENGTH_ANGLE", value)
+	def getAirEntryValue(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_AIR_ENTRY_VALUE")
+	def setAirEntryValue(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_AIR_ENTRY_VALUE", value)
+	def getSingleEffectiveStressMethod(self) -> UnsaturatedSingleEffectiveStressMethod:
+		return UnsaturatedSingleEffectiveStressMethod(self._getEnumEUnsaturatedSingleEffectiveStressMethodProperty("MP_UNSATURATED_SINGLE_EFFECTIVE_STRESS_METHOD"))
+	def setSingleEffectiveStressMethod(self, value: UnsaturatedSingleEffectiveStressMethod):
+		return self._setEnumEUnsaturatedSingleEffectiveStressMethodProperty("MP_UNSATURATED_SINGLE_EFFECTIVE_STRESS_METHOD", value)
+	def getAlpha(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_ALPHA")
+	def setAlpha(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_ALPHA", value)
+	def getAirEntrySuction(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_AIR_ENTRY_SUCTION")
+	def setAirEntrySuction(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_AIR_ENTRY_SUCTION", value)
+	def getCriticalSuction(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_CRITICAL_SUCTION")
+	def setCriticalSuction(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_CRITICAL_SUCTION", value)
+	def getMaterialParameter(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_MATERIAL_PARAMETER")
+	def setMaterialParameter(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_MATERIAL_PARAMETER", value)
+	def getUseCutoff(self) -> bool:
+		return self._getBoolProperty("MP_UNSATURATED_USE_CUTOFF")
+	def setUseCutoff(self, value: bool):
+		return self._setBoolProperty("MP_UNSATURATED_USE_CUTOFF", value)
+	def getCutoffValue(self) -> float:
+		return self._getDoubleProperty("MP_UNSATURATED_CUTOFF_VALUE")
+	def setCutoffValue(self, value: float):
+		return self._setDoubleProperty("MP_UNSATURATED_CUTOFF_VALUE", value)
+	def getTabularValues(self) -> UnsaturatedTabularValueMethod:
+		return UnsaturatedTabularValueMethod(self._getEnumEUnsaturatedTabularValueMethodProperty("MP_UNSATURATED_TABULAR_VALUE_METHOD"))
+	def setTabularValues(self, value: UnsaturatedTabularValueMethod):
+		return self._setEnumEUnsaturatedTabularValueMethodProperty("MP_UNSATURATED_TABULAR_VALUE_METHOD", value)
+	def setUnsaturatedZoneTableWithRespectToSuction(self, coefficients: list[float], values: list[float]):
+		"""
+		Specify the coefficient and values with respect to suction.
+		"""
+		return self._callFunction("setUnsaturatedZoneTableWithRespectToSuction", [coefficients, values])
+	def getUnsaturatedZoneTableWithRespectToSuction(self) -> tuple[list[float],list[float]]:
+		"""
+		Returns a tuple of lists where the first element is coefficients and the second is values with respect to suction.
+		"""
+		return self._callFunction("getUnsaturatedZoneTableWithRespectToSuction", [])
+	def setUnsaturatedZoneTableWithRespectToDegreeOfSaturation(self, coefficients: list[float], values: list[float]):
+		"""
+		Specify the coefficient and values with respect to degree of saturation.
+		"""
+		return self._callFunction("setUnsaturatedZoneTableWithRespectToDegreeOfSaturation", [coefficients, values])
+	def getUnsaturatedZoneTableWithRespectToDegreeOfSaturation(self) -> list[tuple[float,float]]:
+		"""
+		Returns a tuple of lists where the first element is coefficients and the second is values with respect to degree of saturation.
+		"""
+		return self._callFunction("getUnsaturatedZoneTableWithRespectToDegreeOfSaturation", [])
+	def setUnsaturatedZoneTableWithRespectToEffectiveDegreeOfSaturation(self, coefficients: list[float], values: list[float]):
+		"""
+		Specify the coefficient and values with respect to effective degree of saturation.
+		"""
+		return self._callFunction("setUnsaturatedZoneTableWithRespectToEffectiveDegreeOfSaturation", [coefficients, values])
+	def getUnsaturatedZoneTableWithRespectToEffectiveDegreeOfSaturation(self) -> list[tuple[float,float]]:
+		"""
+		Returns a tuple of lists where the first element is coefficients and the second is values with respect to effective degree of saturation.
+		"""
+		return self._callFunction("getUnsaturatedZoneTableWithRespectToEffectiveDegreeOfSaturation", [])

rs2/modeler/properties/material/strength/SwellingRockStrength.py

@@ -0,0 +1,122 @@
+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 SwellingRockStrength(PropertyProxy):
+	def getFrictionAngle(self) -> float:
+		return self._getDoubleProperty("MP_SR_FRIC_ANGLE")
+	def setFrictionAngle(self, value: float):
+		return self._setDoubleProperty("MP_SR_FRIC_ANGLE", value)
+	def getCohesion(self) -> float:
+		return self._getDoubleProperty("MP_SR_COHESION")
+	def setCohesion(self, value: float):
+		return self._setDoubleProperty("MP_SR_COHESION", value)
+	def getTensileStrength(self) -> float:
+		return self._getDoubleProperty("MP_SR_TENSILE")
+	def setTensileStrength(self, value: float):
+		return self._setDoubleProperty("MP_SR_TENSILE", value)
+	def getDilationAngle(self) -> float:
+		return self._getDoubleProperty("MP_SR_DILATION_ANGLE")
+	def setDilationAngle(self, value: float):
+		return self._setDoubleProperty("MP_SR_DILATION_ANGLE", value)
+	def getA0(self) -> float:
+		return self._getDoubleProperty("MP_SR_A0")
+	def setA0(self, value: float):
+		return self._setDoubleProperty("MP_SR_A0", value)
+	def getAElastic(self) -> float:
+		return self._getDoubleProperty("MP_SR_A_ELASTIC")
+	def setAElastic(self, value: float):
+		return self._setDoubleProperty("MP_SR_A_ELASTIC", value)
+	def getAPlastic(self) -> float:
+		return self._getDoubleProperty("MP_SR_A_PLASTIC")
+	def setAPlastic(self, value: float):
+		return self._setDoubleProperty("MP_SR_A_PLASTIC", value)
+	def getMaximumPlasticVolumetricStrainForAPlastic(self) -> float:
+		return self._getDoubleProperty("MP_SR_MAX_PLASTIC_V_STRAIN")
+	def setMaximumPlasticVolumetricStrainForAPlastic(self, value: float):
+		return self._setDoubleProperty("MP_SR_MAX_PLASTIC_V_STRAIN", value)
+	def getKSwellNormal(self) -> float:
+		return self._getDoubleProperty("MP_SR_K_SWELL_NORMAL")
+	def setKSwellNormal(self, value: float):
+		return self._setDoubleProperty("MP_SR_K_SWELL_NORMAL", value)
+	def getKSwellTangential(self) -> float:
+		return self._getDoubleProperty("MP_SR_K_SWELL_TANGENT")
+	def setKSwellTangential(self, value: float):
+		return self._setDoubleProperty("MP_SR_K_SWELL_TANGENT", value)
+	def getMaximumSwellingStressNormal(self) -> float:
+		return self._getDoubleProperty("MP_SR_MAX_STRESS_NORMAL")
+	def setMaximumSwellingStressNormal(self, value: float):
+		return self._setDoubleProperty("MP_SR_MAX_STRESS_NORMAL", value)
+	def getMaximumSwellingStressTangential(self) -> float:
+		return self._getDoubleProperty("MP_SR_MAX_STRESS_TANGENT")
+	def setMaximumSwellingStressTangential(self, value: float):
+		return self._setDoubleProperty("MP_SR_MAX_STRESS_TANGENT", value)
+	def getMinimumSwellingStress(self) -> float:
+		return self._getDoubleProperty("MP_SR_MIN_STRESS")
+	def setMinimumSwellingStress(self, value: float):
+		return self._setDoubleProperty("MP_SR_MIN_STRESS", value)
+	def getSwellingFormulation(self) -> SwellingForm:
+		return SwellingForm(self._getEnumESwellingFormProperty("MP_SR_SWELLING_FORM"))
+	def setSwellingFormulation(self, value: SwellingForm):
+		return self._setEnumESwellingFormProperty("MP_SR_SWELLING_FORM", value)
+	def getWaterCondition(self) -> WaterCondition:
+		return WaterCondition(self._getEnumEWaterConditionProperty("MP_SR_WATER_CONDITION"))
+	def setWaterCondition(self, value: WaterCondition):
+		return self._setEnumEWaterConditionProperty("MP_SR_WATER_CONDITION", value)
+	def getSigmaCoupling(self) -> float:
+		return self._getDoubleProperty("MP_SR_SIGMA_COUPLING")
+	def setSigmaCoupling(self, value: float):
+		return self._setDoubleProperty("MP_SR_SIGMA_COUPLING", value)
+	def setProperties(self, FrictionAngle : float = None, Cohesion : float = None, TensileStrength : float = None, DilationAngle : float = None, A0 : float = None, AElastic : float = None, APlastic : float = None, MaximumPlasticVolumetricStrainForAPlastic : float = None, KSwellNormal : float = None, KSwellTangential : float = None, MaximumSwellingStressNormal : float = None, MaximumSwellingStressTangential : float = None, MinimumSwellingStress : float = None, SwellingFormulation : SwellingForm = None, WaterCondition : WaterCondition = None, SigmaCoupling : float = None):
+		if FrictionAngle is not None:
+			self._setDoubleProperty("MP_SR_FRIC_ANGLE", FrictionAngle)
+		if Cohesion is not None:
+			self._setDoubleProperty("MP_SR_COHESION", Cohesion)
+		if TensileStrength is not None:
+			self._setDoubleProperty("MP_SR_TENSILE", TensileStrength)
+		if DilationAngle is not None:
+			self._setDoubleProperty("MP_SR_DILATION_ANGLE", DilationAngle)
+		if A0 is not None:
+			self._setDoubleProperty("MP_SR_A0", A0)
+		if AElastic is not None:
+			self._setDoubleProperty("MP_SR_A_ELASTIC", AElastic)
+		if APlastic is not None:
+			self._setDoubleProperty("MP_SR_A_PLASTIC", APlastic)
+		if MaximumPlasticVolumetricStrainForAPlastic is not None:
+			self._setDoubleProperty("MP_SR_MAX_PLASTIC_V_STRAIN", MaximumPlasticVolumetricStrainForAPlastic)
+		if KSwellNormal is not None:
+			self._setDoubleProperty("MP_SR_K_SWELL_NORMAL", KSwellNormal)
+		if KSwellTangential is not None:
+			self._setDoubleProperty("MP_SR_K_SWELL_TANGENT", KSwellTangential)
+		if MaximumSwellingStressNormal is not None:
+			self._setDoubleProperty("MP_SR_MAX_STRESS_NORMAL", MaximumSwellingStressNormal)
+		if MaximumSwellingStressTangential is not None:
+			self._setDoubleProperty("MP_SR_MAX_STRESS_TANGENT", MaximumSwellingStressTangential)
+		if MinimumSwellingStress is not None:
+			self._setDoubleProperty("MP_SR_MIN_STRESS", MinimumSwellingStress)
+		if SwellingFormulation is not None:
+			self._setEnumESwellingFormProperty("MP_SR_SWELLING_FORM", SwellingFormulation)
+		if WaterCondition is not None:
+			self._setEnumEWaterConditionProperty("MP_SR_WATER_CONDITION", WaterCondition)
+		if SigmaCoupling is not None:
+			self._setDoubleProperty("MP_SR_SIGMA_COUPLING", SigmaCoupling)
+	def getProperties(self):
+		return {
+		"FrictionAngle" : self.getFrictionAngle(), 
+		"Cohesion" : self.getCohesion(), 
+		"TensileStrength" : self.getTensileStrength(), 
+		"DilationAngle" : self.getDilationAngle(), 
+		"A0" : self.getA0(), 
+		"AElastic" : self.getAElastic(), 
+		"APlastic" : self.getAPlastic(), 
+		"MaximumPlasticVolumetricStrainForAPlastic" : self.getMaximumPlasticVolumetricStrainForAPlastic(), 
+		"KSwellNormal" : self.getKSwellNormal(), 
+		"KSwellTangential" : self.getKSwellTangential(), 
+		"MaximumSwellingStressNormal" : self.getMaximumSwellingStressNormal(), 
+		"MaximumSwellingStressTangential" : self.getMaximumSwellingStressTangential(), 
+		"MinimumSwellingStress" : self.getMinimumSwellingStress(), 
+		"SwellingFormulation" : self.getSwellingFormulation(), 
+		"WaterCondition" : self.getWaterCondition(), 
+		"SigmaCoupling" : self.getSigmaCoupling(), 
+		}