RS2Scripting 11.23.0__py3-none-any.whl

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

@@ -0,0 +1,94 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class VerticalStressRatio(PropertyProxy):
+	def getMaterialType(self) -> MaterialType:
+		return MaterialType(self._getEnumEMaterialAnalysisTypesProperty("MP_MATERIAL_TYPE"))
+	def setMaterialType(self, value: MaterialType):
+		return self._setEnumEMaterialAnalysisTypesProperty("MP_MATERIAL_TYPE", value)
+	def getUseMaximumShearStrength(self) -> bool:
+		return self._getBoolProperty("MP_USE_MAX_SHEAR_STRENGTH")
+	def setUseMaximumShearStrength(self, value: bool):
+		return self._setBoolProperty("MP_USE_MAX_SHEAR_STRENGTH", value)
+	def getUseTensileStrength(self) -> bool:
+		return self._getBoolProperty("MP_USE_TENSILE_STRENGTH")
+	def setUseTensileStrength(self, value: bool):
+		return self._setBoolProperty("MP_USE_TENSILE_STRENGTH", value)
+	def getVerticalStressRatio(self) -> float:
+		return self._getDoubleProperty("MP_VERTICAL_STRESS_RATIO")
+	def setVerticalStressRatio(self, value: float):
+		return self._setDoubleProperty("MP_VERTICAL_STRESS_RATIO", value)
+	def getMinimumShearStrength(self) -> float:
+		return self._getDoubleProperty("MP_MIN_SHEAR_STRENGTH")
+	def setMinimumShearStrength(self, value: float):
+		return self._setDoubleProperty("MP_MIN_SHEAR_STRENGTH", value)
+	def getMaximumShearStrength(self) -> float:
+		return self._getDoubleProperty("MP_MAX_SHEAR_STRENGTH")
+	def setMaximumShearStrength(self, value: float):
+		return self._setDoubleProperty("MP_MAX_SHEAR_STRENGTH", value)
+	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 getResidualVerticalStressRatio(self) -> float:
+		return self._getDoubleProperty("MP_VERTICAL_STRESS_RATIO_RES")
+	def setResidualVerticalStressRatio(self, value: float):
+		return self._setDoubleProperty("MP_VERTICAL_STRESS_RATIO_RES", value)
+	def getResidualMinimumShearStrength(self) -> float:
+		return self._getDoubleProperty("MP_MIN_SHEAR_STRENGTH_RES")
+	def setResidualMinimumShearStrength(self, value: float):
+		return self._setDoubleProperty("MP_MIN_SHEAR_STRENGTH_RES", value)
+	def getResidualMaximumShearStrength(self) -> float:
+		return self._getDoubleProperty("MP_MAX_SHEAR_STRENGTH_RES")
+	def setResidualMaximumShearStrength(self, value: float):
+		return self._setDoubleProperty("MP_MAX_SHEAR_STRENGTH_RES", value)
+	def getResidualTensileStrength(self) -> float:
+		return self._getDoubleProperty("MP_TENSILE_STRENGTH_RES")
+	def setResidualTensileStrength(self, value: float):
+		return self._setDoubleProperty("MP_TENSILE_STRENGTH_RES", value)
+	def getApplySSRShearStrengthReduction(self) -> bool:
+		return self._getBoolProperty("MP_APPLY_SSR")
+	def setApplySSRShearStrengthReduction(self, value: bool):
+		return self._setBoolProperty("MP_APPLY_SSR", value)
+	def setProperties(self, MaterialType : MaterialType = None, UseMaximumShearStrength : bool = None, UseTensileStrength : bool = None, VerticalStressRatio : float = None, MinimumShearStrength : float = None, MaximumShearStrength : float = None, PeakTensileStrength : float = None, ResidualVerticalStressRatio : float = None, ResidualMinimumShearStrength : float = None, ResidualMaximumShearStrength : float = None, ResidualTensileStrength : float = None, ApplySSRShearStrengthReduction : bool = None):
+		if MaterialType is not None:
+			self._setEnumEMaterialAnalysisTypesProperty("MP_MATERIAL_TYPE", MaterialType)
+		if UseMaximumShearStrength is not None:
+			self._setBoolProperty("MP_USE_MAX_SHEAR_STRENGTH", UseMaximumShearStrength)
+		if UseTensileStrength is not None:
+			self._setBoolProperty("MP_USE_TENSILE_STRENGTH", UseTensileStrength)
+		if VerticalStressRatio is not None:
+			self._setDoubleProperty("MP_VERTICAL_STRESS_RATIO", VerticalStressRatio)
+		if MinimumShearStrength is not None:
+			self._setDoubleProperty("MP_MIN_SHEAR_STRENGTH", MinimumShearStrength)
+		if MaximumShearStrength is not None:
+			self._setDoubleProperty("MP_MAX_SHEAR_STRENGTH", MaximumShearStrength)
+		if PeakTensileStrength is not None:
+			self._setDoubleProperty("MP_PEAK_TENSILE_STRENGTH", PeakTensileStrength)
+		if ResidualVerticalStressRatio is not None:
+			self._setDoubleProperty("MP_VERTICAL_STRESS_RATIO_RES", ResidualVerticalStressRatio)
+		if ResidualMinimumShearStrength is not None:
+			self._setDoubleProperty("MP_MIN_SHEAR_STRENGTH_RES", ResidualMinimumShearStrength)
+		if ResidualMaximumShearStrength is not None:
+			self._setDoubleProperty("MP_MAX_SHEAR_STRENGTH_RES", ResidualMaximumShearStrength)
+		if ResidualTensileStrength is not None:
+			self._setDoubleProperty("MP_TENSILE_STRENGTH_RES", ResidualTensileStrength)
+		if ApplySSRShearStrengthReduction is not None:
+			self._setBoolProperty("MP_APPLY_SSR", ApplySSRShearStrengthReduction)
+	def getProperties(self):
+		return {
+		"MaterialType" : self.getMaterialType(), 
+		"UseMaximumShearStrength" : self.getUseMaximumShearStrength(), 
+		"UseTensileStrength" : self.getUseTensileStrength(), 
+		"VerticalStressRatio" : self.getVerticalStressRatio(), 
+		"MinimumShearStrength" : self.getMinimumShearStrength(), 
+		"MaximumShearStrength" : self.getMaximumShearStrength(), 
+		"PeakTensileStrength" : self.getPeakTensileStrength(), 
+		"ResidualVerticalStressRatio" : self.getResidualVerticalStressRatio(), 
+		"ResidualMinimumShearStrength" : self.getResidualMinimumShearStrength(), 
+		"ResidualMaximumShearStrength" : self.getResidualMaximumShearStrength(), 
+		"ResidualTensileStrength" : self.getResidualTensileStrength(), 
+		"ApplySSRShearStrengthReduction" : self.getApplySSRShearStrengthReduction(), 
+		}

rs2/modeler/properties/material/thermal/Thermal.py

@@ -0,0 +1,74 @@
+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 ThermalStageFactor(ProxyObject):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID)
+		self.propertyID = propertyID
+	def getThermalGridFactor(self) -> str:
+		return self._callFunction("getThermalGridFactor", [self.propertyID], proxyArgumentIndices=[0])
+class ThermalDefinedStageFactor(ThermalStageFactor):
+	def __init__(self, client : Client, ID, propertyID):
+		super().__init__(client, ID, propertyID)
+	def setThermalGridFactor(self, thermalGridName: str):
+		return self._callFunction("setThermalGridFactor", [thermalGridName, self.propertyID], proxyArgumentIndices=[1])
+from rs2.modeler.properties.material.thermal.conductivity.Conductivity import Conductivity
+from rs2.modeler.properties.material.thermal.heatcapacity.HeatCapacity import HeatCapacity
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.SoilUnfrozenWaterContent import SoilUnfrozenWaterContent
+class Thermal(PropertyProxy):
+	"""
+	:ref:`Material Property Thermal Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID, stageFactorInterfaceID):
+		super().__init__(client, ID, documentProxyID)
+		self.stageFactorInterface = AbsoluteStageFactorGettersInterface[ThermalDefinedStageFactor, ThermalStageFactor](self._client, stageFactorInterfaceID, ID, ThermalDefinedStageFactor, ThermalStageFactor)
+		self.Conductivity = Conductivity(client, ID, documentProxyID)
+		self.HeatCapacity = HeatCapacity(client, ID, documentProxyID)
+		self.SoilUnfrozenWaterContent = SoilUnfrozenWaterContent(client, ID, documentProxyID)
+	def getStaticTemperatureMode(self) -> StaticWaterModes:
+		return StaticWaterModes(self._getEnumEStaticWaterModesProperty("MP_STATIC_TEMPERATURE_METHOD"))
+	def setStaticTemperatureMode(self, value: StaticWaterModes):
+		return self._setEnumEStaticWaterModesProperty("MP_STATIC_TEMPERATURE_METHOD", value)
+	def getStaticTemperature(self) -> float:
+		return self._getDoubleProperty("MP_STATIC_TEMPERATURE_CONST")
+	def setStaticTemperature(self, value: float):
+		return self._setDoubleProperty("MP_STATIC_TEMPERATURE_CONST", value)
+	def getWaterContent(self) -> ThermalWaterContentMethodType:
+		return ThermalWaterContentMethodType(self._getEnumEThermalWaterContentMethodTypeProperty("MP_THERMAL_WATER_CONTENT_METHOD"))
+	def setWaterContent(self, value: ThermalWaterContentMethodType):
+		return self._setEnumEThermalWaterContentMethodTypeProperty("MP_THERMAL_WATER_CONTENT_METHOD", value)
+	def getWaterContentValue(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_WATER_CONTENT_VALUE")
+	def setWaterContentValue(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_VALUE", value)
+	def getThermalExpansion(self) -> bool:
+		return self._getBoolProperty("MP_THERMAL_EXPANSION_IS_ON")
+	def setThermalExpansion(self, value: bool):
+		return self._setBoolProperty("MP_THERMAL_EXPANSION_IS_ON", value)
+	def getExpansionCoefficient(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_EXPANSION_ALPHA")
+	def setExpansionCoefficient(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_EXPANSION_ALPHA", value)
+	def getDispersivity(self) -> bool:
+		return self._getBoolProperty("MP_THERMAL_DISPERSIVITY_IS_ON")
+	def setDispersivity(self, value: bool):
+		return self._setBoolProperty("MP_THERMAL_DISPERSIVITY_IS_ON", value)
+	def getLongitudinalDispersivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_DISPERSIVITY_LONGITUDINAL")
+	def setLongitudinalDispersivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_DISPERSIVITY_LONGITUDINAL", value)
+	def getTransverseDispersivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_DISPERSIVITY_TRANSVERSE")
+	def setTransverseDispersivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_DISPERSIVITY_TRANSVERSE", value)
+	def setStaticTemperatureGridToUseByName(self, gridName: str):
+		"""
+		gridName is the name of the grid to be used. "None" and "Default Grid" are available by default.
+		"""
+		return self._callFunction("setStaticTemperatureGridToUseByName", [gridName])
+	def getStaticTemperatureGridToUse(self) -> str:
+		return self._callFunction("getStaticTemperatureGridToUse", [])

rs2/modeler/properties/material/thermal/conductivity/Conductivity.py

@@ -0,0 +1,27 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2.modeler.properties.material.thermal.conductivity.ConstantConductivity import ConstantConductivity
+from rs2.modeler.properties.material.thermal.conductivity.Johansen import Johansen
+from rs2.modeler.properties.material.thermal.conductivity.JohansenLu import JohansenLu
+from rs2.modeler.properties.material.thermal.conductivity.Derives import Derives
+from rs2.modeler.properties.material.thermal.conductivity.CoteAndKonrad import CoteAndKonrad
+from rs2.modeler.properties.material.thermal.conductivity.Tabular import Tabular
+class Conductivity(PropertyProxy):
+	"""
+	:ref:`Material Property Thermal Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID):
+		self.ConstantConductivity = ConstantConductivity(client, ID, documentProxyID)
+		self.Johansen = Johansen(client, ID, documentProxyID)
+		self.JohansenLu = JohansenLu(client, ID, documentProxyID)
+		self.Derives = Derives(client, ID, documentProxyID)
+		self.CoteAndKonrad = CoteAndKonrad(client, ID, documentProxyID)
+		self.Tabular = Tabular(client, ID, documentProxyID)
+		super().__init__(client, ID, documentProxyID)
+	def getMethod(self) -> ThermalType:
+		return ThermalType(self._getEnumEThermalTypeProperty("MP_THERMAL_TYPE"))
+	def setMethod(self, value: ThermalType):
+		return self._setEnumEThermalTypeProperty("MP_THERMAL_TYPE", value)

rs2/modeler/properties/material/thermal/conductivity/ConstantConductivity.py

@@ -0,0 +1,31 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class ConstantConductivity(PropertyProxy):
+	def getUnfrozenConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_UNFROZEN_CONDUCTIVITY")
+	def setUnfrozenConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_UNFROZEN_CONDUCTIVITY", value)
+	def getFrozenConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_FROZEN_CONDUCTIVITY")
+	def setFrozenConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_FROZEN_CONDUCTIVITY", value)
+	def getFrozenTemperature(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_FROZEN_TEMPERATURE")
+	def setFrozenTemperature(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_FROZEN_TEMPERATURE", value)
+	def setProperties(self, UnfrozenConductivity : float = None, FrozenConductivity : float = None, FrozenTemperature : float = None):
+		if UnfrozenConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_UNFROZEN_CONDUCTIVITY", UnfrozenConductivity)
+		if FrozenConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_FROZEN_CONDUCTIVITY", FrozenConductivity)
+		if FrozenTemperature is not None:
+			self._setDoubleProperty("MP_THERMAL_FROZEN_TEMPERATURE", FrozenTemperature)
+	def getProperties(self):
+		return {
+		"UnfrozenConductivity" : self.getUnfrozenConductivity(), 
+		"FrozenConductivity" : self.getFrozenConductivity(), 
+		"FrozenTemperature" : self.getFrozenTemperature(), 
+		}

rs2/modeler/properties/material/thermal/conductivity/CoteAndKonrad.py

@@ -0,0 +1,45 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class CoteAndKonrad(PropertyProxy):
+	def getParticleConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_PARTICLE_CONDUCTIVITY")
+	def setParticleConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_PARTICLE_CONDUCTIVITY", value)
+	def getUnfrozenKappa(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_UNFROZEN_KAPPA")
+	def setUnfrozenKappa(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_UNFROZEN_KAPPA", value)
+	def getFrozenKappa(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_FROZEN_KAPPA")
+	def setFrozenKappa(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_FROZEN_KAPPA", value)
+	def getChi(self) -> float:
+		return self._getDoubleProperty("MP_CHI")
+	def setChi(self, value: float):
+		return self._setDoubleProperty("MP_CHI", value)
+	def getEta(self) -> float:
+		return self._getDoubleProperty("MP_ETA")
+	def setEta(self, value: float):
+		return self._setDoubleProperty("MP_ETA", value)
+	def setProperties(self, ParticleConductivity : float = None, UnfrozenKappa : float = None, FrozenKappa : float = None, Chi : float = None, Eta : float = None):
+		if ParticleConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_PARTICLE_CONDUCTIVITY", ParticleConductivity)
+		if UnfrozenKappa is not None:
+			self._setDoubleProperty("MP_THERMAL_UNFROZEN_KAPPA", UnfrozenKappa)
+		if FrozenKappa is not None:
+			self._setDoubleProperty("MP_THERMAL_FROZEN_KAPPA", FrozenKappa)
+		if Chi is not None:
+			self._setDoubleProperty("MP_CHI", Chi)
+		if Eta is not None:
+			self._setDoubleProperty("MP_ETA", Eta)
+	def getProperties(self):
+		return {
+		"ParticleConductivity" : self.getParticleConductivity(), 
+		"UnfrozenKappa" : self.getUnfrozenKappa(), 
+		"FrozenKappa" : self.getFrozenKappa(), 
+		"Chi" : self.getChi(), 
+		"Eta" : self.getEta(), 
+		}

rs2/modeler/properties/material/thermal/conductivity/Derives.py

@@ -0,0 +1,17 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Derives(PropertyProxy):
+	def getParticleConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_PARTICLE_CONDUCTIVITY")
+	def setParticleConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_PARTICLE_CONDUCTIVITY", value)
+	def setProperties(self, ParticleConductivity : float = None):
+		if ParticleConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_PARTICLE_CONDUCTIVITY", ParticleConductivity)
+	def getProperties(self):
+		return {
+		"ParticleConductivity" : self.getParticleConductivity(), 
+		}

rs2/modeler/properties/material/thermal/conductivity/Johansen.py

@@ -0,0 +1,45 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Johansen(PropertyProxy):
+	def getSoilType(self) -> ThermalSoilType:
+		return ThermalSoilType(self._getEnumEThermalSoilTypeProperty("MP_THERMAL_SOIL_TYPE_JOHANSEN"))
+	def setSoilType(self, value: ThermalSoilType):
+		return self._setEnumEThermalSoilTypeProperty("MP_THERMAL_SOIL_TYPE_JOHANSEN", value)
+	def getQuartzContent(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_QUARTZ_CONTENT")
+	def setQuartzContent(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_QUARTZ_CONTENT", value)
+	def getDryConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_DRY_CONDUCTIVITY")
+	def setDryConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_DRY_CONDUCTIVITY", value)
+	def getSaturatedUnfrozenConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_SATURATED_CONDUCTIVITY")
+	def setSaturatedUnfrozenConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_SATURATED_CONDUCTIVITY", value)
+	def getSaturatedFrozenConductivity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_SATURATED_FROZEN_CONDUCTIVITY")
+	def setSaturatedFrozenConductivity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_SATURATED_FROZEN_CONDUCTIVITY", value)
+	def setProperties(self, SoilType : ThermalSoilType = None, QuartzContent : float = None, DryConductivity : float = None, SaturatedUnfrozenConductivity : float = None, SaturatedFrozenConductivity : float = None):
+		if SoilType is not None:
+			self._setEnumEThermalSoilTypeProperty("MP_THERMAL_SOIL_TYPE_JOHANSEN", SoilType)
+		if QuartzContent is not None:
+			self._setDoubleProperty("MP_THERMAL_QUARTZ_CONTENT", QuartzContent)
+		if DryConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_DRY_CONDUCTIVITY", DryConductivity)
+		if SaturatedUnfrozenConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_SATURATED_CONDUCTIVITY", SaturatedUnfrozenConductivity)
+		if SaturatedFrozenConductivity is not None:
+			self._setDoubleProperty("MP_THERMAL_SATURATED_FROZEN_CONDUCTIVITY", SaturatedFrozenConductivity)
+	def getProperties(self):
+		return {
+		"SoilType" : self.getSoilType(), 
+		"QuartzContent" : self.getQuartzContent(), 
+		"DryConductivity" : self.getDryConductivity(), 
+		"SaturatedUnfrozenConductivity" : self.getSaturatedUnfrozenConductivity(), 
+		"SaturatedFrozenConductivity" : self.getSaturatedFrozenConductivity(), 
+		}

rs2/modeler/properties/material/thermal/conductivity/JohansenLu.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 JohansenLu(PropertyProxy):
+	def getSoilType(self) -> ThermalSoilType:
+		return ThermalSoilType(self._getEnumEThermalSoilTypeProperty("MP_THERMAL_SOIL_TYPE_JOHANSEN_LU"))
+	def setSoilType(self, value: ThermalSoilType):
+		return self._setEnumEThermalSoilTypeProperty("MP_THERMAL_SOIL_TYPE_JOHANSEN_LU", value)
+	def getQuartzContent(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_QUARTZ_CONTENT")
+	def setQuartzContent(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_QUARTZ_CONTENT", value)
+	def setProperties(self, SoilType : ThermalSoilType = None, QuartzContent : float = None):
+		if SoilType is not None:
+			self._setEnumEThermalSoilTypeProperty("MP_THERMAL_SOIL_TYPE_JOHANSEN_LU", SoilType)
+		if QuartzContent is not None:
+			self._setDoubleProperty("MP_THERMAL_QUARTZ_CONTENT", QuartzContent)
+	def getProperties(self):
+		return {
+		"SoilType" : self.getSoilType(), 
+		"QuartzContent" : self.getQuartzContent(), 
+		}

rs2/modeler/properties/material/thermal/conductivity/Tabular.py

@@ -0,0 +1,31 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Tabular(PropertyProxy):
+	def getDependence(self) -> ThermalVolumetricDepencenceType:
+		return ThermalVolumetricDepencenceType(self._getEnumEThermalVolumetricDepencenceTypeProperty("MP_THERMAL_TABULAR_DEPENDENCE"))
+	def setDependence(self, value: ThermalVolumetricDepencenceType):
+		return self._setEnumEThermalVolumetricDepencenceTypeProperty("MP_THERMAL_TABULAR_DEPENDENCE", value)
+	def setThermalConductivityTemperatureFunction(self, temperature: list[float], conductivity: list[float]):
+		return self._callFunction("setThermalConductivityTemperatureFunction", [temperature, conductivity])
+	def getThermalConductivityTemperatureFunction(self) -> tuple[list[float],list[float]]:
+		"""
+		returns tuple (temperatureList, conductivityList).
+		"""
+		return self._callFunction("getThermalConductivityTemperatureFunction", [])
+	def setThermalConductivityWaterContentFunction(self, waterContent: list[float], conductivity: list[float]):
+		return self._callFunction("setThermalConductivityWaterContentFunction", [waterContent, conductivity])
+	def getThermalConductivityWaterContentFunction(self) -> tuple[list[float],list[float]]:
+		"""
+		returns tuple (waterContentList, conductivityList).
+		"""
+		return self._callFunction("getThermalConductivityWaterContentFunction", [])
+	def setProperties(self, Dependence : ThermalVolumetricDepencenceType = None):
+		if Dependence is not None:
+			self._setEnumEThermalVolumetricDepencenceTypeProperty("MP_THERMAL_TABULAR_DEPENDENCE", Dependence)
+	def getProperties(self):
+		return {
+		"Dependence" : self.getDependence(), 
+		}

rs2/modeler/properties/material/thermal/heatcapacity/ConstantHeatCapacity.py

@@ -0,0 +1,38 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class ConstantHeatCapacity(PropertyProxy):
+	def getIncludeLatentHeat(self) -> bool:
+		return self._getBoolProperty("MP_THERMAL_LATENT_HEAT")
+	def setIncludeLatentHeat(self, value: bool):
+		return self._setBoolProperty("MP_THERMAL_LATENT_HEAT", value)
+	def getUnfrozenVolumetricHeatCapacity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_VOLUMETRIC_HEAT_CAPACITY_UNFROZEN")
+	def setUnfrozenVolumetricHeatCapacity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_VOLUMETRIC_HEAT_CAPACITY_UNFROZEN", value)
+	def getFrozenVolumetricHeatCapacity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_VOLUMETRIC_HEAT_CAPACITY_FROZEN")
+	def setFrozenVolumetricHeatCapacity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_VOLUMETRIC_HEAT_CAPACITY_FROZEN", value)
+	def getFrozenTemperature(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_VOLUMETRIC_FROZEN_TEMPERATURE_UNITS")
+	def setFrozenTemperature(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_VOLUMETRIC_FROZEN_TEMPERATURE_UNITS", value)
+	def setProperties(self, IncludeLatentHeat : bool = None, UnfrozenVolumetricHeatCapacity : float = None, FrozenVolumetricHeatCapacity : float = None, FrozenTemperature : float = None):
+		if IncludeLatentHeat is not None:
+			self._setBoolProperty("MP_THERMAL_LATENT_HEAT", IncludeLatentHeat)
+		if UnfrozenVolumetricHeatCapacity is not None:
+			self._setDoubleProperty("MP_THERMAL_VOLUMETRIC_HEAT_CAPACITY_UNFROZEN", UnfrozenVolumetricHeatCapacity)
+		if FrozenVolumetricHeatCapacity is not None:
+			self._setDoubleProperty("MP_THERMAL_VOLUMETRIC_HEAT_CAPACITY_FROZEN", FrozenVolumetricHeatCapacity)
+		if FrozenTemperature is not None:
+			self._setDoubleProperty("MP_THERMAL_VOLUMETRIC_FROZEN_TEMPERATURE_UNITS", FrozenTemperature)
+	def getProperties(self):
+		return {
+		"IncludeLatentHeat" : self.getIncludeLatentHeat(), 
+		"UnfrozenVolumetricHeatCapacity" : self.getUnfrozenVolumetricHeatCapacity(), 
+		"FrozenVolumetricHeatCapacity" : self.getFrozenVolumetricHeatCapacity(), 
+		"FrozenTemperature" : self.getFrozenTemperature(), 
+		}

rs2/modeler/properties/material/thermal/heatcapacity/CustomHeatCapacity.py

@@ -0,0 +1,38 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class CustomHeatCapacity(PropertyProxy):
+	def getIncludeLatentHeat(self) -> bool:
+		return self._getBoolProperty("MP_THERMAL_LATENT_HEAT")
+	def setIncludeLatentHeat(self, value: bool):
+		return self._setBoolProperty("MP_THERMAL_LATENT_HEAT", value)
+	def getDependence(self) -> ThermalVolumetricDepencenceType:
+		return ThermalVolumetricDepencenceType(self._getEnumEThermalVolumetricDepencenceTypeProperty("MP_THERMAL_DEPENDENCE"))
+	def setDependence(self, value: ThermalVolumetricDepencenceType):
+		return self._setEnumEThermalVolumetricDepencenceTypeProperty("MP_THERMAL_DEPENDENCE", value)
+	def setVolumetricHeatCapacityVsTemperatureTable(self, volumetricHeatCapacity: list[float], temperature: list[float]):
+		return self._callFunction("setVolumetricHeatCapacityVsTemperatureTable", [volumetricHeatCapacity, temperature])
+	def getVolumetricHeatCapacityVsTemperatureTable(self) -> tuple[list[float],list[float]]:
+		"""
+		Returns a tuple of lists ([volumetricHeatCapacity],[temperature])
+		"""
+		return self._callFunction("getVolumetricHeatCapacityVsTemperatureTable", [])
+	def setVolumetricHeatCapacityVsWaterContentTable(self, volumetricHeatCapacity: list[float], waterContent: list[float]):
+		return self._callFunction("setVolumetricHeatCapacityVsWaterContentTable", [volumetricHeatCapacity, waterContent])
+	def getVolumetricHeatCapacityVsWaterContentTable(self) -> tuple[list[float],list[float]]:
+		"""
+		Returns a tuple of lists ([volumetricHeatCapacity],[waterContent])
+		"""
+		return self._callFunction("getVolumetricHeatCapacityVsWaterContentTable", [])
+	def setProperties(self, IncludeLatentHeat : bool = None, Dependence : ThermalVolumetricDepencenceType = None):
+		if IncludeLatentHeat is not None:
+			self._setBoolProperty("MP_THERMAL_LATENT_HEAT", IncludeLatentHeat)
+		if Dependence is not None:
+			self._setEnumEThermalVolumetricDepencenceTypeProperty("MP_THERMAL_DEPENDENCE", Dependence)
+	def getProperties(self):
+		return {
+		"IncludeLatentHeat" : self.getIncludeLatentHeat(), 
+		"Dependence" : self.getDependence(), 
+		}

rs2/modeler/properties/material/thermal/heatcapacity/HeatCapacity.py

@@ -0,0 +1,21 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2.modeler.properties.material.thermal.heatcapacity.ConstantHeatCapacity import ConstantHeatCapacity
+from rs2.modeler.properties.material.thermal.heatcapacity.JameNewman import JameNewman
+from rs2.modeler.properties.material.thermal.heatcapacity.CustomHeatCapacity import CustomHeatCapacity
+class HeatCapacity(PropertyProxy):
+	"""
+	:ref:`Material Property Thermal Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID):
+		self.ConstantHeatCapacity = ConstantHeatCapacity(client, ID, documentProxyID)
+		self.JameNewman = JameNewman(client, ID, documentProxyID)
+		self.CustomHeatCapacity = CustomHeatCapacity(client, ID, documentProxyID)
+		super().__init__(client, ID, documentProxyID)
+	def getType(self) -> ThermalHeatCapacityType:
+		return ThermalHeatCapacityType(self._getEnumEThermalHeatCapacityTypeProperty("MP_THERMAL_HEAT_CAPACITY_TYPE"))
+	def setType(self, value: ThermalHeatCapacityType):
+		return self._setEnumEThermalHeatCapacityTypeProperty("MP_THERMAL_HEAT_CAPACITY_TYPE", value)

rs2/modeler/properties/material/thermal/heatcapacity/JameNewman.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 JameNewman(PropertyProxy):
+	def getIncludeLatentHeat(self) -> bool:
+		return self._getBoolProperty("MP_THERMAL_LATENT_HEAT")
+	def setIncludeLatentHeat(self, value: bool):
+		return self._setBoolProperty("MP_THERMAL_LATENT_HEAT", value)
+	def getSoilSpecificHeatCapacity(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_SOIL_HEATING_CAPACITY")
+	def setSoilSpecificHeatCapacity(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_SOIL_HEATING_CAPACITY", value)
+	def setProperties(self, IncludeLatentHeat : bool = None, SoilSpecificHeatCapacity : float = None):
+		if IncludeLatentHeat is not None:
+			self._setBoolProperty("MP_THERMAL_LATENT_HEAT", IncludeLatentHeat)
+		if SoilSpecificHeatCapacity is not None:
+			self._setDoubleProperty("MP_THERMAL_SOIL_HEATING_CAPACITY", SoilSpecificHeatCapacity)
+	def getProperties(self):
+		return {
+		"IncludeLatentHeat" : self.getIncludeLatentHeat(), 
+		"SoilSpecificHeatCapacity" : self.getSoilSpecificHeatCapacity(), 
+		}

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/CustomWaterContent.py

@@ -0,0 +1,13 @@
+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 CustomWaterContent(PropertyProxy):
+	def setTemperatureVsUnfrozenWaterContentValues(self, temperature: list[float], unfrozenWaterContent: list[float]):
+		return self._callFunction("setTemperatureVsUnfrozenWaterContentValues", [temperature, unfrozenWaterContent])
+	def getTemperatureVsUnfrozenWaterContentValues(self) -> tuple[list[float],list[float]]:
+		"""
+		Returns a tuple of lists [[temperature],[unfrozenWaterContent]]
+		"""
+		return self._callFunction("getTemperatureVsUnfrozenWaterContentValues", [])

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/Konrad.py

@@ -0,0 +1,31 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Konrad(PropertyProxy):
+	def getResidualWaterContent(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_WATER_CONTENT_RESIDUAL_WATER_CONTENT")
+	def setResidualWaterContent(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_RESIDUAL_WATER_CONTENT", value)
+	def getFrozenTemperature(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE")
+	def setFrozenTemperature(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE", value)
+	def getSolidusTemperature(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_WATER_CONTENT_SOLIDUS_TEMPERATURE")
+	def setSolidusTemperature(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_SOLIDUS_TEMPERATURE", value)
+	def setProperties(self, ResidualWaterContent : float = None, FrozenTemperature : float = None, SolidusTemperature : float = None):
+		if ResidualWaterContent is not None:
+			self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_RESIDUAL_WATER_CONTENT", ResidualWaterContent)
+		if FrozenTemperature is not None:
+			self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE", FrozenTemperature)
+		if SolidusTemperature is not None:
+			self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_SOLIDUS_TEMPERATURE", SolidusTemperature)
+	def getProperties(self):
+		return {
+		"ResidualWaterContent" : self.getResidualWaterContent(), 
+		"FrozenTemperature" : self.getFrozenTemperature(), 
+		"SolidusTemperature" : self.getSolidusTemperature(), 
+		}

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/SoilUnfrozenWaterContent.py

@@ -0,0 +1,23 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.Konrad import Konrad
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.TiceAnderson import TiceAnderson
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.CustomWaterContent import CustomWaterContent
+from rs2.modeler.properties.material.thermal.soilunfrozenwatercontent.hydraulic.HydraulicModel import HydraulicModel
+class SoilUnfrozenWaterContent(PropertyProxy):
+	"""
+	:ref:`Material Property Thermal Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID):
+		self.Konrad = Konrad(client, ID, documentProxyID)
+		self.TiceAnderson = TiceAnderson(client, ID, documentProxyID)
+		self.CustomWaterContent = CustomWaterContent(client, ID, documentProxyID)
+		self.HydraulicModel = HydraulicModel(client, ID, documentProxyID)
+		super().__init__(client, ID, documentProxyID)
+	def getType(self) -> ThermalWaterContentType:
+		return ThermalWaterContentType(self._getEnumEThermalWaterContentTypeProperty("MP_THERMAL_WATER_CONTENT_TYPE"))
+	def setType(self, value: ThermalWaterContentType):
+		return self._setEnumEThermalWaterContentTypeProperty("MP_THERMAL_WATER_CONTENT_TYPE", value)

rs2/modeler/properties/material/thermal/soilunfrozenwatercontent/TiceAnderson.py

@@ -0,0 +1,31 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class TiceAnderson(PropertyProxy):
+	def getInputAlpha(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_INPUT_A")
+	def setInputAlpha(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_INPUT_A", value)
+	def getInputBeta(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_INPUT_B")
+	def setInputBeta(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_INPUT_B", value)
+	def getFrozenTemperature(self) -> float:
+		return self._getDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE")
+	def setFrozenTemperature(self, value: float):
+		return self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE", value)
+	def setProperties(self, InputAlpha : float = None, InputBeta : float = None, FrozenTemperature : float = None):
+		if InputAlpha is not None:
+			self._setDoubleProperty("MP_THERMAL_INPUT_A", InputAlpha)
+		if InputBeta is not None:
+			self._setDoubleProperty("MP_THERMAL_INPUT_B", InputBeta)
+		if FrozenTemperature is not None:
+			self._setDoubleProperty("MP_THERMAL_WATER_CONTENT_FROZEN_TEMPERATURE", FrozenTemperature)
+	def getProperties(self):
+		return {
+		"InputAlpha" : self.getInputAlpha(), 
+		"InputBeta" : self.getInputBeta(), 
+		"FrozenTemperature" : self.getFrozenTemperature(), 
+		}