RS2Scripting 11.23.0__py3-none-any.whl

rs2/modeler/properties/liner/StandardBeam.py

@@ -0,0 +1,268 @@
+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.RelativeStageFactorInterface import RelativeStageFactorInterface
+class StandardBeamStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getUnitWeightFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_UNIT_WEIGHT", self.propertyID], proxyArgumentIndices=[1])
+	def getThicknessFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_THICKNESS", self.propertyID], proxyArgumentIndices=[1])
+	def getAreaFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_AREA", self.propertyID], proxyArgumentIndices=[1])
+	def getMomentOfInertiaFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_MOMENT_OF_INERTIA", self.propertyID], proxyArgumentIndices=[1])
+	def getYoungsModulusFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_YOUNGS_MODULUS", self.propertyID], proxyArgumentIndices=[1])
+	def getPoissonsRatioFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_POISSONS_RATIO", self.propertyID], proxyArgumentIndices=[1])
+	def getAxialStrainExpansionFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_AXIAL_STRAIN", self.propertyID], proxyArgumentIndices=[1])
+	def getCompressiveStrengthPeakFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_COMPRESSIVE_STRENGTH", self.propertyID], proxyArgumentIndices=[1])
+	def getCompressiveStrengthResidualFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_COMPRESSIVE_STRENGTH_RES", self.propertyID], proxyArgumentIndices=[1])
+	def getTensileStrengthPeakFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_TENSILE_STRENGTH", self.propertyID], proxyArgumentIndices=[1])
+	def getTensileStrengthResidualFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_TENSILE_STRENGTH_RES", self.propertyID], proxyArgumentIndices=[1])
+	def getConductivityFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_THERAMAL_CONDUCTIVITY", self.propertyID], proxyArgumentIndices=[1])
+	def getSpecificHeatCapacityFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_THERAMAL_SPECIFIC_HEAT_CAPACITY", self.propertyID], proxyArgumentIndices=[1])
+	def getExpansionCoefficientFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["LNP_THERAMAL_EXPANSION_ALPHA", self.propertyID], proxyArgumentIndices=[1])
+class StandardBeamDefinedStageFactor(StandardBeamStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setUnitWeightFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_UNIT_WEIGHT", value, self.propertyID], proxyArgumentIndices=[2])
+	def setThicknessFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_THICKNESS", value, self.propertyID], proxyArgumentIndices=[2])
+	def setAreaFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_AREA", value, self.propertyID], proxyArgumentIndices=[2])
+	def setMomentOfInertiaFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_MOMENT_OF_INERTIA", value, self.propertyID], proxyArgumentIndices=[2])
+	def setYoungsModulusFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_YOUNGS_MODULUS", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPoissonsRatioFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_POISSONS_RATIO", value, self.propertyID], proxyArgumentIndices=[2])
+	def setAxialStrainExpansionFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_AXIAL_STRAIN", value, self.propertyID], proxyArgumentIndices=[2])
+	def setCompressiveStrengthPeakFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_COMPRESSIVE_STRENGTH", value, self.propertyID], proxyArgumentIndices=[2])
+	def setCompressiveStrengthResidualFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_COMPRESSIVE_STRENGTH_RES", value, self.propertyID], proxyArgumentIndices=[2])
+	def setTensileStrengthPeakFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_TENSILE_STRENGTH", value, self.propertyID], proxyArgumentIndices=[2])
+	def setTensileStrengthResidualFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_TENSILE_STRENGTH_RES", value, self.propertyID], proxyArgumentIndices=[2])
+	def setConductivityFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_THERAMAL_CONDUCTIVITY", value, self.propertyID], proxyArgumentIndices=[2])
+	def setSpecificHeatCapacityFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_THERAMAL_SPECIFIC_HEAT_CAPACITY", value, self.propertyID], proxyArgumentIndices=[2])
+	def setExpansionCoefficientFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["LNP_THERAMAL_EXPANSION_ALPHA", value, self.propertyID], proxyArgumentIndices=[2])
+class StandardBeam(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID):
+		super().__init__(client, ID, documentProxyID)
+		stageFactorInterfaceID = self._callFunction("getStageFactorInterface", [], keepReturnValueReference=True)
+		self.stageFactorInterface = RelativeStageFactorInterface[StandardBeamDefinedStageFactor, StandardBeamStageFactor](self._client, stageFactorInterfaceID, ID, StandardBeamDefinedStageFactor, StandardBeamStageFactor)
+	def getUnitWeight(self) -> float:
+		return self._getDoubleProperty("LNP_UNIT_WEIGHT")
+	def setUnitWeight(self, value: float):
+		return self._setDoubleProperty("LNP_UNIT_WEIGHT", value)
+	def getIncludeWeightInStressAnalysis(self) -> bool:
+		return self._getBoolProperty("LNP_USE_WEIGHT")
+	def setIncludeWeightInStressAnalysis(self, value: bool):
+		return self._setBoolProperty("LNP_USE_WEIGHT", value)
+	def getInitialTemperature(self) -> float:
+		return self._getDoubleProperty("LNP_THERAMAL_INITIAL_TEMPERATURE")
+	def setInitialTemperature(self, value: float):
+		return self._setDoubleProperty("LNP_THERAMAL_INITIAL_TEMPERATURE", value)
+	def getMethod(self) -> GeometryChoice:
+		return GeometryChoice(self._getEnumEGeometryChoiceProperty("LNP_GEOMETRY_CHOICE"))
+	def setMethod(self, value: GeometryChoice):
+		return self._setEnumEGeometryChoiceProperty("LNP_GEOMETRY_CHOICE", value)
+	def getThickness(self) -> float:
+		return self._getDoubleProperty("LNP_THICKNESS")
+	def setThickness(self, value: float):
+		return self._setDoubleProperty("LNP_THICKNESS", value)
+	def getArea(self) -> float:
+		return self._getDoubleProperty("LNP_AREA")
+	def setArea(self, value: float):
+		return self._setDoubleProperty("LNP_AREA", value)
+	def getMomentOfInertia(self) -> float:
+		return self._getDoubleProperty("LNP_MOMENT_OF_INERTIA")
+	def setMomentOfInertia(self, value: float):
+		return self._setDoubleProperty("LNP_MOMENT_OF_INERTIA", value)
+	def getYoungsModulus(self) -> float:
+		return self._getDoubleProperty("LNP_YOUNGS_MODULUS")
+	def setYoungsModulus(self, value: float):
+		return self._setDoubleProperty("LNP_YOUNGS_MODULUS", value)
+	def getPoissonsRatio(self) -> float:
+		return self._getDoubleProperty("LNP_POISSONS_RATIO")
+	def setPoissonsRatio(self, value: float):
+		return self._setDoubleProperty("LNP_POISSONS_RATIO", value)
+	def getMaterialType(self) -> MaterialType:
+		return MaterialType(self._getEnumEMaterialAnalysisTypesProperty("LNP_MATERIAL_TYPE"))
+	def setMaterialType(self, value: MaterialType):
+		return self._setEnumEMaterialAnalysisTypesProperty("LNP_MATERIAL_TYPE", value)
+	def getCompressiveStrengthPeak(self) -> float:
+		return self._getDoubleProperty("LNP_COMPRESSIVE_STRENGTH")
+	def setCompressiveStrengthPeak(self, value: float):
+		return self._setDoubleProperty("LNP_COMPRESSIVE_STRENGTH", value)
+	def getCompressiveStrengthResidual(self) -> float:
+		return self._getDoubleProperty("LNP_COMPRESSIVE_STRENGTH_RES")
+	def setCompressiveStrengthResidual(self, value: float):
+		return self._setDoubleProperty("LNP_COMPRESSIVE_STRENGTH_RES", value)
+	def getTensileStrengthPeak(self) -> float:
+		return self._getDoubleProperty("LNP_TENSILE_STRENGTH")
+	def setTensileStrengthPeak(self, value: float):
+		return self._setDoubleProperty("LNP_TENSILE_STRENGTH", value)
+	def getTensileStrengthResidual(self) -> float:
+		return self._getDoubleProperty("LNP_TENSILE_STRENGTH_RES")
+	def setTensileStrengthResidual(self, value: float):
+		return self._setDoubleProperty("LNP_TENSILE_STRENGTH_RES", value)
+	def getSlidingGap(self) -> bool:
+		return self._getBoolProperty("LNP_USE_SLIDING_GAP")
+	def setSlidingGap(self, value: bool):
+		return self._setBoolProperty("LNP_USE_SLIDING_GAP", value)
+	def getStrainAtLocking(self) -> float:
+		return self._getDoubleProperty("LNP_STRAIN_AT_LOCKING")
+	def setStrainAtLocking(self, value: float):
+		return self._setDoubleProperty("LNP_STRAIN_AT_LOCKING", value)
+	def getBeamElementFormulation(self) -> LinerFormulation:
+		return LinerFormulation(self._getEnumELinerFormulationProperty("LNP_BEAM_ELEMENT_FORMULATION"))
+	def setBeamElementFormulation(self, value: LinerFormulation):
+		return self._setEnumELinerFormulationProperty("LNP_BEAM_ELEMENT_FORMULATION", value)
+	def getAxialStrainExpansion(self) -> float:
+		return self._getDoubleProperty("LNP_AXIAL_STRAIN")
+	def setAxialStrainExpansion(self, value: float):
+		return self._setDoubleProperty("LNP_AXIAL_STRAIN", value)
+	def getActivateThermal(self) -> bool:
+		return self._getBoolProperty("LNP_THERAMAL_ACTIVATE")
+	def setActivateThermal(self, value: bool):
+		return self._setBoolProperty("LNP_THERAMAL_ACTIVATE", value)
+	def getStaticTemperatureMode(self) -> StaticWaterModes:
+		return StaticWaterModes(self._getEnumEStaticWaterModesProperty("LNP_STATIC_TEMPERATURE_METHOD"))
+	def setStaticTemperatureMode(self, value: StaticWaterModes):
+		return self._setEnumEStaticWaterModesProperty("LNP_STATIC_TEMPERATURE_METHOD", value)
+	def getStaticTemperature(self) -> float:
+		return self._getDoubleProperty("LNP_STATIC_TEMPERATURE_CONST")
+	def setStaticTemperature(self, value: float):
+		return self._setDoubleProperty("LNP_STATIC_TEMPERATURE_CONST", value)
+	def getConductivity(self) -> float:
+		return self._getDoubleProperty("LNP_THERAMAL_CONDUCTIVITY")
+	def setConductivity(self, value: float):
+		return self._setDoubleProperty("LNP_THERAMAL_CONDUCTIVITY", value)
+	def getSpecificHeatCapacity(self) -> float:
+		return self._getDoubleProperty("LNP_THERAMAL_SPECIFIC_HEAT_CAPACITY")
+	def setSpecificHeatCapacity(self, value: float):
+		return self._setDoubleProperty("LNP_THERAMAL_SPECIFIC_HEAT_CAPACITY", value)
+	def getThermalExpansion(self) -> bool:
+		return self._getBoolProperty("LNP_THERAMAL_EXPANSION_IS_ON")
+	def setThermalExpansion(self, value: bool):
+		return self._setBoolProperty("LNP_THERAMAL_EXPANSION_IS_ON", value)
+	def getExpansionCoefficient(self) -> float:
+		return self._getDoubleProperty("LNP_THERAMAL_EXPANSION_ALPHA")
+	def setExpansionCoefficient(self, value: float):
+		return self._setDoubleProperty("LNP_THERAMAL_EXPANSION_ALPHA", value)
+	def getStageLinerProperties(self) -> bool:
+		return self._getBoolProperty("LNP_USE_STAGE_LINER")
+	def setStageLinerProperties(self, value: bool):
+		return self._setBoolProperty("LNP_USE_STAGE_LINER", value)
+	def getStaticTemperatureGridToUse(self) -> str:
+		return self._callFunction("getStaticTemperatureGridToUse", [])
+	def setStaticTemperatureGridToUse(self, gridName: str):
+		"""
+		Grids "None" and "Default Grid" available by default.
+		"""
+		return self._callFunction("setStaticTemperatureGridToUse", [gridName])
+	def setProperties(self, UnitWeight : float = None, IncludeWeightInStressAnalysis : bool = None, InitialTemperature : float = None, Method : GeometryChoice = None, Thickness : float = None, Area : float = None, MomentOfInertia : float = None, YoungsModulus : float = None, PoissonsRatio : float = None, MaterialType : MaterialType = None, CompressiveStrengthPeak : float = None, CompressiveStrengthResidual : float = None, TensileStrengthPeak : float = None, TensileStrengthResidual : float = None, SlidingGap : bool = None, StrainAtLocking : float = None, BeamElementFormulation : LinerFormulation = None, AxialStrainExpansion : float = None, ActivateThermal : bool = None, StaticTemperatureMode : StaticWaterModes = None, StaticTemperature : float = None, Conductivity : float = None, SpecificHeatCapacity : float = None, ThermalExpansion : bool = None, ExpansionCoefficient : float = None, StageLinerProperties : bool = None):
+		if UnitWeight is not None:
+			self._setDoubleProperty("LNP_UNIT_WEIGHT", UnitWeight)
+		if IncludeWeightInStressAnalysis is not None:
+			self._setBoolProperty("LNP_USE_WEIGHT", IncludeWeightInStressAnalysis)
+		if InitialTemperature is not None:
+			self._setDoubleProperty("LNP_THERAMAL_INITIAL_TEMPERATURE", InitialTemperature)
+		if Method is not None:
+			self._setEnumEGeometryChoiceProperty("LNP_GEOMETRY_CHOICE", Method)
+		if Thickness is not None:
+			self._setDoubleProperty("LNP_THICKNESS", Thickness)
+		if Area is not None:
+			self._setDoubleProperty("LNP_AREA", Area)
+		if MomentOfInertia is not None:
+			self._setDoubleProperty("LNP_MOMENT_OF_INERTIA", MomentOfInertia)
+		if YoungsModulus is not None:
+			self._setDoubleProperty("LNP_YOUNGS_MODULUS", YoungsModulus)
+		if PoissonsRatio is not None:
+			self._setDoubleProperty("LNP_POISSONS_RATIO", PoissonsRatio)
+		if MaterialType is not None:
+			self._setEnumEMaterialAnalysisTypesProperty("LNP_MATERIAL_TYPE", MaterialType)
+		if CompressiveStrengthPeak is not None:
+			self._setDoubleProperty("LNP_COMPRESSIVE_STRENGTH", CompressiveStrengthPeak)
+		if CompressiveStrengthResidual is not None:
+			self._setDoubleProperty("LNP_COMPRESSIVE_STRENGTH_RES", CompressiveStrengthResidual)
+		if TensileStrengthPeak is not None:
+			self._setDoubleProperty("LNP_TENSILE_STRENGTH", TensileStrengthPeak)
+		if TensileStrengthResidual is not None:
+			self._setDoubleProperty("LNP_TENSILE_STRENGTH_RES", TensileStrengthResidual)
+		if SlidingGap is not None:
+			self._setBoolProperty("LNP_USE_SLIDING_GAP", SlidingGap)
+		if StrainAtLocking is not None:
+			self._setDoubleProperty("LNP_STRAIN_AT_LOCKING", StrainAtLocking)
+		if BeamElementFormulation is not None:
+			self._setEnumELinerFormulationProperty("LNP_BEAM_ELEMENT_FORMULATION", BeamElementFormulation)
+		if AxialStrainExpansion is not None:
+			self._setDoubleProperty("LNP_AXIAL_STRAIN", AxialStrainExpansion)
+		if ActivateThermal is not None:
+			self._setBoolProperty("LNP_THERAMAL_ACTIVATE", ActivateThermal)
+		if StaticTemperatureMode is not None:
+			self._setEnumEStaticWaterModesProperty("LNP_STATIC_TEMPERATURE_METHOD", StaticTemperatureMode)
+		if StaticTemperature is not None:
+			self._setDoubleProperty("LNP_STATIC_TEMPERATURE_CONST", StaticTemperature)
+		if Conductivity is not None:
+			self._setDoubleProperty("LNP_THERAMAL_CONDUCTIVITY", Conductivity)
+		if SpecificHeatCapacity is not None:
+			self._setDoubleProperty("LNP_THERAMAL_SPECIFIC_HEAT_CAPACITY", SpecificHeatCapacity)
+		if ThermalExpansion is not None:
+			self._setBoolProperty("LNP_THERAMAL_EXPANSION_IS_ON", ThermalExpansion)
+		if ExpansionCoefficient is not None:
+			self._setDoubleProperty("LNP_THERAMAL_EXPANSION_ALPHA", ExpansionCoefficient)
+		if StageLinerProperties is not None:
+			self._setBoolProperty("LNP_USE_STAGE_LINER", StageLinerProperties)
+	def getProperties(self):
+		return {
+		"UnitWeight" : self.getUnitWeight(), 
+		"IncludeWeightInStressAnalysis" : self.getIncludeWeightInStressAnalysis(), 
+		"InitialTemperature" : self.getInitialTemperature(), 
+		"Method" : self.getMethod(), 
+		"Thickness" : self.getThickness(), 
+		"Area" : self.getArea(), 
+		"MomentOfInertia" : self.getMomentOfInertia(), 
+		"YoungsModulus" : self.getYoungsModulus(), 
+		"PoissonsRatio" : self.getPoissonsRatio(), 
+		"MaterialType" : self.getMaterialType(), 
+		"CompressiveStrengthPeak" : self.getCompressiveStrengthPeak(), 
+		"CompressiveStrengthResidual" : self.getCompressiveStrengthResidual(), 
+		"TensileStrengthPeak" : self.getTensileStrengthPeak(), 
+		"TensileStrengthResidual" : self.getTensileStrengthResidual(), 
+		"SlidingGap" : self.getSlidingGap(), 
+		"StrainAtLocking" : self.getStrainAtLocking(), 
+		"BeamElementFormulation" : self.getBeamElementFormulation(), 
+		"AxialStrainExpansion" : self.getAxialStrainExpansion(), 
+		"ActivateThermal" : self.getActivateThermal(), 
+		"StaticTemperatureMode" : self.getStaticTemperatureMode(), 
+		"StaticTemperature" : self.getStaticTemperature(), 
+		"Conductivity" : self.getConductivity(), 
+		"SpecificHeatCapacity" : self.getSpecificHeatCapacity(), 
+		"ThermalExpansion" : self.getThermalExpansion(), 
+		"ExpansionCoefficient" : self.getExpansionCoefficient(), 
+		"StageLinerProperties" : self.getStageLinerProperties(), 
+		}

rs2/modeler/properties/material/InitialConditions.py

@@ -0,0 +1,152 @@
+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 InitialConditionsStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getUnitWeightFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_UNIT_WEIGHT", self.propertyID], proxyArgumentIndices=[1])
+	def getPorosityValueFactor(self) -> float:
+		return self._callFunction("getDoubleFactor", ["MP_POROSITY_VALUE", self.propertyID], proxyArgumentIndices=[1])
+class InitialConditionsDefinedStageFactor(InitialConditionsStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setUnitWeightFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_UNIT_WEIGHT", value, self.propertyID], proxyArgumentIndices=[2])
+	def setPorosityValueFactor(self, value: float):
+		return self._callFunction("setDoubleFactor", ["MP_POROSITY_VALUE", value, self.propertyID], proxyArgumentIndices=[2])
+class InitialConditions(PropertyProxy):
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[InitialConditionsDefinedStageFactor, InitialConditionsStageFactor](self._client, stageFactorInterfaceID, ID, InitialConditionsDefinedStageFactor, InitialConditionsStageFactor)
+	def getInitialElementLoading(self) -> InitialElementLoadingType:
+		return InitialElementLoadingType(self._getEnumEInitialElementLoadingTypeProperty("MP_INITIAL_ELEMENT_LOADING"))
+	def setInitialElementLoading(self, value: InitialElementLoadingType):
+		return self._setEnumEInitialElementLoadingTypeProperty("MP_INITIAL_ELEMENT_LOADING", value)
+	def getAccountForMoistureContentInUnitWeight(self) -> bool:
+		return self._getBoolProperty("MP_ACCOUNT_MOISTURE_UNIT_WEIGHT")
+	def setAccountForMoistureContentInUnitWeight(self, value: bool):
+		return self._setBoolProperty("MP_ACCOUNT_MOISTURE_UNIT_WEIGHT", value)
+	def getDryUnitWeight(self) -> float:
+		return self._getDoubleProperty("MP_DRY_UNIT_WEIGHT")
+	def setDryUnitWeight(self, value: float):
+		return self._setDoubleProperty("MP_DRY_UNIT_WEIGHT", value)
+	def getMoistUnitWeight(self) -> float:
+		return self._getDoubleProperty("MP_MOIST_UNIT_WEIGHT")
+	def setMoistUnitWeight(self, value: float):
+		return self._setDoubleProperty("MP_MOIST_UNIT_WEIGHT", value)
+	def getSaturatedUnitWeight(self) -> float:
+		return self._getDoubleProperty("MP_SATURATED_UNIT_WEIGHT")
+	def setSaturatedUnitWeight(self, value: float):
+		return self._setDoubleProperty("MP_SATURATED_UNIT_WEIGHT", value)
+	def getUnitWeight(self) -> float:
+		return self._getDoubleProperty("MP_UNIT_WEIGHT")
+	def setUnitWeight(self, value: float):
+		return self._setDoubleProperty("MP_UNIT_WEIGHT", value)
+	def getPorosityValue(self) -> float:
+		return self._getDoubleProperty("MP_POROSITY_VALUE")
+	def setPorosityValue(self, value: float):
+		return self._setDoubleProperty("MP_POROSITY_VALUE", value)
+	def getInitialWaterCondition(self) -> StaticWaterModes:
+		return StaticWaterModes(self._getEnumEStaticWaterModesProperty("MP_INITIAL_WATER_CONDITIONS"))
+	def setInitialWaterCondition(self, value: StaticWaterModes):
+		return self._setEnumEStaticWaterModesProperty("MP_INITIAL_WATER_CONDITIONS", value)
+	def getInitialPoreWaterPressure(self) -> float:
+		return self._getDoubleProperty("MP_INITIAL_PWP")
+	def setInitialPoreWaterPressure(self, value: float):
+		return self._setDoubleProperty("MP_INITIAL_PWP", value)
+	def getInitialRu(self) -> float:
+		return self._getDoubleProperty("MP_INITIAL_RU")
+	def setInitialRu(self, value: float):
+		return self._setDoubleProperty("MP_INITIAL_RU", value)
+	def getInitialHuType(self) -> HuTypes:
+		return HuTypes(self._getEnumEHuTypesProperty("MP_INITIAL_HU_TYPE"))
+	def setInitialHuType(self, value: HuTypes):
+		return self._setEnumEHuTypesProperty("MP_INITIAL_HU_TYPE", value)
+	def getInitialHu(self) -> float:
+		return self._getDoubleProperty("MP_INITIAL_HU")
+	def setInitialHu(self, value: float):
+		return self._setDoubleProperty("MP_INITIAL_HU", value)
+	def getInitialTemperatureCondition(self) -> StaticWaterModes:
+		return StaticWaterModes(self._getEnumEStaticWaterModesProperty("MP_INITIAL_TEMPERATURE_METHOD"))
+	def setInitialTemperatureCondition(self, value: StaticWaterModes):
+		return self._setEnumEStaticWaterModesProperty("MP_INITIAL_TEMPERATURE_METHOD", value)
+	def getInitialTemperature(self) -> float:
+		return self._getDoubleProperty("MP_INITIAL_TEMPERATURE_CONST")
+	def setInitialTemperature(self, value: float):
+		return self._setDoubleProperty("MP_INITIAL_TEMPERATURE_CONST", value)
+	def setInitialPiezoByName(self, piezoName: str):
+		"""
+		piezoName is the id of the piezo line to be used or "None".
+		"""
+		return self._callFunction("setInitialPiezoByName", [piezoName])
+	def getInitialPiezoName(self) -> str:
+		"""
+		Returns the id of the selected initial piezoLine or "None".
+		"""
+		return self._callFunction("getInitialPiezoName", [])
+	def setInitialGridByName(self, gridName: str):
+		"""
+		gridName is the name of the grid to be used. "None" and "Default Grid" are available by default.
+		"""
+		return self._callFunction("setInitialGridByName", [gridName])
+	def getInitialGridName(self) -> str:
+		return self._callFunction("getInitialGridName", [])
+	def setInitialTemperatureGridByName(self, gridName: str):
+		"""
+		gridName is the name of the grid to be used. "None" and "Default Grid" are available by default.
+		"""
+		return self._callFunction("setInitialTemperatureGridByName", [gridName])
+	def getInitialTemperatureGridName(self) -> str:
+		return self._callFunction("getInitialTemperatureGridName", [])
+	def setProperties(self, InitialElementLoading : InitialElementLoadingType = None, AccountForMoistureContentInUnitWeight : bool = None, DryUnitWeight : float = None, MoistUnitWeight : float = None, SaturatedUnitWeight : float = None, UnitWeight : float = None, PorosityValue : float = None, InitialWaterCondition : StaticWaterModes = None, InitialPoreWaterPressure : float = None, InitialRu : float = None, InitialHuType : HuTypes = None, InitialHu : float = None, InitialTemperatureCondition : StaticWaterModes = None, InitialTemperature : float = None):
+		if InitialElementLoading is not None:
+			self._setEnumEInitialElementLoadingTypeProperty("MP_INITIAL_ELEMENT_LOADING", InitialElementLoading)
+		if AccountForMoistureContentInUnitWeight is not None:
+			self._setBoolProperty("MP_ACCOUNT_MOISTURE_UNIT_WEIGHT", AccountForMoistureContentInUnitWeight)
+		if DryUnitWeight is not None:
+			self._setDoubleProperty("MP_DRY_UNIT_WEIGHT", DryUnitWeight)
+		if MoistUnitWeight is not None:
+			self._setDoubleProperty("MP_MOIST_UNIT_WEIGHT", MoistUnitWeight)
+		if SaturatedUnitWeight is not None:
+			self._setDoubleProperty("MP_SATURATED_UNIT_WEIGHT", SaturatedUnitWeight)
+		if UnitWeight is not None:
+			self._setDoubleProperty("MP_UNIT_WEIGHT", UnitWeight)
+		if PorosityValue is not None:
+			self._setDoubleProperty("MP_POROSITY_VALUE", PorosityValue)
+		if InitialWaterCondition is not None:
+			self._setEnumEStaticWaterModesProperty("MP_INITIAL_WATER_CONDITIONS", InitialWaterCondition)
+		if InitialPoreWaterPressure is not None:
+			self._setDoubleProperty("MP_INITIAL_PWP", InitialPoreWaterPressure)
+		if InitialRu is not None:
+			self._setDoubleProperty("MP_INITIAL_RU", InitialRu)
+		if InitialHuType is not None:
+			self._setEnumEHuTypesProperty("MP_INITIAL_HU_TYPE", InitialHuType)
+		if InitialHu is not None:
+			self._setDoubleProperty("MP_INITIAL_HU", InitialHu)
+		if InitialTemperatureCondition is not None:
+			self._setEnumEStaticWaterModesProperty("MP_INITIAL_TEMPERATURE_METHOD", InitialTemperatureCondition)
+		if InitialTemperature is not None:
+			self._setDoubleProperty("MP_INITIAL_TEMPERATURE_CONST", InitialTemperature)
+	def getProperties(self):
+		return {
+		"InitialElementLoading" : self.getInitialElementLoading(), 
+		"AccountForMoistureContentInUnitWeight" : self.getAccountForMoistureContentInUnitWeight(), 
+		"DryUnitWeight" : self.getDryUnitWeight(), 
+		"MoistUnitWeight" : self.getMoistUnitWeight(), 
+		"SaturatedUnitWeight" : self.getSaturatedUnitWeight(), 
+		"UnitWeight" : self.getUnitWeight(), 
+		"PorosityValue" : self.getPorosityValue(), 
+		"InitialWaterCondition" : self.getInitialWaterCondition(), 
+		"InitialPoreWaterPressure" : self.getInitialPoreWaterPressure(), 
+		"InitialRu" : self.getInitialRu(), 
+		"InitialHuType" : self.getInitialHuType(), 
+		"InitialHu" : self.getInitialHu(), 
+		"InitialTemperatureCondition" : self.getInitialTemperatureCondition(), 
+		"InitialTemperature" : self.getInitialTemperature(), 
+		}

rs2/modeler/properties/material/MaterialProperty.py

@@ -0,0 +1,49 @@
+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.InitialConditions import InitialConditions
+from rs2.modeler.properties.material.stiffness.Stiffness import Stiffness
+from rs2.modeler.properties.material.strength.Strength import Strength
+from rs2.modeler.properties.material.hydraulic.Hydraulic import Hydraulic
+from rs2.modeler.properties.material.thermal.Thermal import Thermal
+from rs2.modeler.properties.material.datum.Datum import Datum
+from rs2.modeler.properties.material.StageFactors import StageFactors
+class MaterialProperty(PropertyProxy):
+	"""
+	:ref:`Material Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID):
+		super().__init__(client, ID, documentProxyID)
+		strengthStiffnessStageFactorInterface = self._callFunction("getStrengthStiffnessStageFactorInterface", [], keepReturnValueReference=True)
+		datumStageFactorInterface = self._callFunction("getDatumStageFactorInterface", [], keepReturnValueReference=True)
+		hydroStageFactorInterface = self._callFunction("getHydroStageFactorInterface", [], keepReturnValueReference=True)
+		thermalStageFactorInterface = self._callFunction("getThermalStageFactorInterface", [], keepReturnValueReference=True)
+		self.StageFactors = StageFactors(client, self._callFunction("getStageFactorManager", [], keepReturnValueReference = True))
+		self.InitialConditions = InitialConditions(client, ID, documentProxyID, strengthStiffnessStageFactorInterface)
+		self.Stiffness = Stiffness(client, ID, documentProxyID, strengthStiffnessStageFactorInterface)
+		self.Strength = Strength(client, ID, documentProxyID, strengthStiffnessStageFactorInterface)
+		self.Hydraulic = Hydraulic(client, ID, documentProxyID, hydroStageFactorInterface)
+		self.Thermal = Thermal(client, ID, documentProxyID, thermalStageFactorInterface)
+		self.Datum = Datum(client, ID, documentProxyID, datumStageFactorInterface)
+	def getMaterialName(self) -> str:
+		return self._getCStringProperty("MP_NAME")
+	def setMaterialName(self, value: str):
+		return self._setCStringProperty("MP_NAME", value)
+	def getMaterialColor(self) -> int:
+		return self._getUnsignedLongProperty("MP_COLOUR")
+	def setMaterialColor(self, value: int):
+		return self._setUnsignedLongProperty("MP_COLOUR", value)
+	def getHatch(self) -> bool:
+		return self._getBoolProperty("MP_USE_HATCH")
+	def setHatch(self, value: bool):
+		return self._setBoolProperty("MP_USE_HATCH", value)
+	def getHatchStyle(self) -> HatchStyle:
+		return HatchStyle(self._getEnumGdiplusHatchStyleProperty("MP_HATCH_STYLE"))
+	def setHatchStyle(self, value: HatchStyle):
+		return self._setEnumGdiplusHatchStyleProperty("MP_HATCH_STYLE", value)
+	def getHatchColour(self) -> int:
+		return self._getUnsignedLongProperty("MP_HATCH_COLOR")
+	def setHatchColour(self, value: int):
+		return self._setUnsignedLongProperty("MP_HATCH_COLOR", value)

rs2/modeler/properties/material/StageFactors.py

@@ -0,0 +1,100 @@
+from rs2._common.ProxyObject import ProxyObject
+from rs2._common.Client import Client
+from rs2.modeler.properties.PropertyEnums import *
+class StageFactors(ProxyObject):
+	"""This interface is specifically for managing the table of stage factors (create, enable/disable, etc...)
+	If you would like to modify specific stage factor values, you must get the stage factors through the stage factor interface present in the
+	property's module.
+	Ex:
+	stageFactor = strength.HoekBrown.stageFactorInterface.getDefinedStageFactors()[1]
+	stageFactor.setCompressiveStrengthFactor(2)
+	"""
+	def __init__(self, client : Client, ID):
+		super().__init__(client, ID)
+	def setStageStrengthStiffnessStageFactors(self, value: bool):
+		return self._callFunction("setApplyStrengthStiffnessStageFactors", [value])
+	def getStageStrengthStiffnessStageFactors(self) -> bool:
+		return self._callFunction("getApplyStrengthStiffnessStageFactors")
+	def setStageThermalStageFactors(self, value: bool):
+		return self._callFunction("setApplyThermalStageFactors", [value])
+	def getStageThermalStageFactors(self) -> bool:
+		return self._callFunction("getApplyThermalStageFactors")
+	def setStageHydraulicStageFactor(self, value: bool):
+		return self._callFunction("setApplyHydraulicStageFactor", [value])
+	def getStageHydraulicStageFactor(self) -> bool:
+		return self._callFunction("getApplyHydraulicStageFactor")
+	def setStageDatumStageFactor(self, value: bool):
+		return self._callFunction("setApplyDatumStageFactor", [value])
+	def getStageDatumStageFactor(self) -> bool:
+		return self._callFunction("getApplyDatumStageFactor")
+	def setResetStress(self, value: bool):
+		return self._callFunction("setResetStress", [value])
+	def getResetStress(self) -> bool:
+		return self._callFunction("getResetStress")
+	def getDefinedStageFactors(self) -> dict[int, tuple[ProxyObject, ProxyObject, ProxyObject]]:
+		"""returns a dictionary of the defined stage factors. 
+		The key is the stage number and the value is a tuple of stage factors defined for that stage (strengthStiffnessAndDatum, hydraulic, thermal)
+		If a stage factor is not enabled, the values for that type will be None.
+		Datum and Strength/Stiffness factors are combined and must be managed together.
+
+		Returns:
+			dict[int, (ObjectReferenceId, ObjectReferenceId, ObjectReferenceId): dictionary of defined stage factors (strengthStiffnessAndDatum, hydraulic, thermal)
+		"""
+		definedFactorIds = self._callFunction("getDefinedStageFactors", keepReturnValueReference=True)
+		return self._getObjectDictionaryFromReferenceDictionary(definedFactorIds)
+	
+	def getStageFactor(self, stage: int) -> tuple[ProxyObject, ProxyObject, ProxyObject]:
+		"""returns the stage factors for the given stage. 
+		If a stage factor is not enabled, the values for that type will be None.
+		Datum and Strength/Stiffness factors are combined and must be managed together.
+
+		Args:
+			stage (int): stage number
+
+		Returns:
+			(ObjectReferenceId, ObjectReferenceId, ObjectReferenceId): tuple of stage factors (strengthStiffnessAndDatum, hydraulic, thermal)
+		"""
+		stageFactorIds = self._callFunction("getStageFactor", [stage], keepReturnValueReference=True)
+		return self._getObjectTupleFromReferenceTuple(stageFactorIds)
+
+	def setDefinedStageFactors(self, stageFactors: dict[int, tuple[ProxyObject, ProxyObject, ProxyObject]]):
+		"""sets the stage factor table for the material. 
+		The key is the stage number and the value is a tuple of stage factors defined for that stage (strengthStiffnessAndDatum, hydraulic, thermal)
+		If a type of stage factor is not enabled, the values for that type should be None.
+		If a tuple of stage factors is provided, a value for all enabled types must be provided.
+		Datum and Strength/Stiffness factors are combined and must be managed together.
+
+		Args:
+			stageFactors (dict[int, (ObjectReferenceId, ObjectReferenceId, ObjectReferenceId)]): dictionary of defined stage factors (strengthStiffnessAndDatum, hydraulic, thermal)
+		"""
+		stageFactorReferences = self._getReferenceDictionaryFromObjectDictionary(stageFactors)
+		self._callFunction("setDefinedStageFactors", [stageFactorReferences], proxyArgumentIndices=[0])
+	
+	def createStageFactor(self, stage: int):
+		"""creates a stage factor for the material. A factor must be provided for all enabled types.
+		"""
+		stageFactorReferences = self._callFunction("createStageFactor", [stage], keepReturnValueReference=True)
+		return self._getObjectTupleFromReferenceTuple(stageFactorReferences)
+	
+	def _getProxyFromReferenceOrNone(self, ID : int) -> ProxyObject:
+		return ProxyObject(self._client, ID) if ID is not None else None
+	def _getReferenceFromProxyOrNone(self, proxy : ProxyObject) -> int:
+		return proxy._ID if proxy is not None else None
+	
+	def _getObjectTupleFromReferenceTuple(self, stageFactors : tuple[int, int, int]) -> tuple[ProxyObject, ProxyObject, ProxyObject]:
+		matFactorProxy = self._getProxyFromReferenceOrNone(stageFactors[0])
+		hydroFactorProxy = self._getProxyFromReferenceOrNone(stageFactors[1])
+		thermalFactorProxy = self._getProxyFromReferenceOrNone(stageFactors[2])
+		return (matFactorProxy, hydroFactorProxy, thermalFactorProxy)
+	
+	def _getReferenceTupleFromObjectTuple(self, stageFactors : tuple[ProxyObject, ProxyObject, ProxyObject]) -> tuple[int, int, int]:
+		matFactorId = self._getReferenceFromProxyOrNone(stageFactors[0])
+		hydroFactorId = self._getReferenceFromProxyOrNone(stageFactors[1])
+		thermalFactorId = self._getReferenceFromProxyOrNone(stageFactors[2])
+		return (matFactorId, hydroFactorId, thermalFactorId)
+	
+	def _getObjectDictionaryFromReferenceDictionary(self, stageFactors : dict[int, tuple[int, int, int]]) -> dict[int, tuple[ProxyObject, ProxyObject, ProxyObject]]:
+		return {key : self._getObjectTupleFromReferenceTuple(value) for key, value in stageFactors.items()}
+	
+	def _getReferenceDictionaryFromObjectDictionary(self, stageFactors : dict[int, tuple[ProxyObject, ProxyObject, ProxyObject]]) -> dict[int, tuple[int, int, int]]:
+		return {key : self._getReferenceTupleFromObjectTuple(value) for key, value in stageFactors.items()}

rs2/modeler/properties/material/datum/BaseDatum.py

@@ -0,0 +1,23 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2.modeler.properties.PropertyEnums import *
+class BaseDatum(PropertyProxy):
+    def setUsing(self, use : bool):
+        self._callFunction("setUsing", [use])
+    def getUsing(self) -> bool:
+        return bool(self._callFunction("getUsing"))
+    def setType(self, type : DatumType):
+        self._callFunction("setType", [type.value])
+    def getType(self) -> DatumType:
+        return DatumType(self._callFunction("getType"))
+    def setDatum(self, depth : float):
+        self._callFunction("setDatum", [depth])
+    def getDatum(self) -> float:
+        return self._callFunction("getDatum")
+    def setCenter(self, x: float , y : float):
+        self._callFunction("setCenter", [x,y])
+    def getCenter(self)-> (float, float): 
+        """
+        Returns the Datum's center as a tuple (x,y)
+        """
+        return self._callFunction("getCenter")
+