RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/material/hydraulic/FEAGroundwater/Simple.py

@@ -0,0 +1,37 @@
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.PropertyEnums import *
+from rs3.properties.material.hydraulic.FEAGroundwater.HydraulicParametersCommon import HydraulicParametersCommon, HydraulicParametersCommonStageFactor, HydraulicParametersCommonDefinedStageFactor
+
+class SimpleStageFactor(HydraulicParametersCommonStageFactor):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+        
+class SimpleStageFactor(SimpleStageFactor, HydraulicParametersCommonDefinedStageFactor):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    pass
+
+class Simple(HydraulicParametersCommon):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[SimpleStageFactor, SimpleStageFactor](id, client, SimpleStageFactor, SimpleStageFactor)
+    
+    def setSoilType(self, simpleSoilType : EnhancedSimpleSoilTypes):
+        self._propertyAccessor.setEnumValue("SoilType", simpleSoilType.value)
+    def getSoilType(self) -> EnhancedSimpleSoilTypes:
+        return self._propertyAccessor.getEnumValue("SoilType", EnhancedSimpleSoilTypes)

rs3/properties/material/hydraulic/FEAGroundwater/VanGenuchten.py

@@ -0,0 +1,94 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.HydraulicStageFactorService_pb2_grpc as HydraulicStageFactorService_pb2_grpc
+class VanGenuchtenBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getAlpha(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("VanGnuAlpha")
+    def setAlpha(self, value: float):
+        self._propertyAccessor.setDoubleProperty("VanGnuAlpha", value)
+    def getN(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("VanGnuN")
+    def setN(self, value: float):
+        self._propertyAccessor.setDoubleProperty("VanGnuN", value)
+    def getUseCustomM(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseCustomM")
+    def setUseCustomM(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseCustomM", value)
+    def getM(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("VanGnuM")
+    def setM(self, value: float):
+        self._propertyAccessor.setDoubleProperty("VanGnuM", value)
+    def getProperties(self):
+        return {
+            "Alpha": self.getAlpha(),
+            "N": self.getN(),
+            "UseCustomM": self.getUseCustomM(),
+            "M": self.getM(),
+        }
+    def setProperties(self, Alpha: float = None, N: float = None, UseCustomM: bool = None, M: float = None):
+        if Alpha is not None:
+            self.setAlpha(Alpha)
+        if N is not None:
+            self.setN(N)
+        if UseCustomM is not None:
+            self.setUseCustomM(UseCustomM)
+        if M is not None:
+            self.setM(M)
+class VanGenuchtenStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, HydraulicStageFactorService_pb2_grpc.HydraulicStageFactorServiceStub(client.channel))
+    def getAlphaFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("GW_VanGnuAlpha")
+    def getMFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("GW_VanGnuM")
+    def getUseCustomMFactor(self) -> bool:
+        return self._stageFactorPropertyAccessor.getBoolValue("GW_UseCustomM")
+    def getNFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("GW_VanGnuN")
+class VanGenuchtenDefinedStageFactorBase(VanGenuchtenStageFactorBase):
+    def setAlphaFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("GW_VanGnuAlpha", value)
+    def setMFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("GW_VanGnuM", value)
+    def setUseCustomMFactor(self, value: bool):
+        self._stageFactorPropertyAccessor.setBoolValue("GW_UseCustomM", value)
+    def setNFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("GW_VanGnuN", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.material.hydraulic.FEAGroundwater.HydraulicParametersCommon import HydraulicParametersCommon, HydraulicParametersCommonStageFactor, HydraulicParametersCommonDefinedStageFactor
+
+class VanGenuchtenStageFactor(VanGenuchtenStageFactorBase, HydraulicParametersCommonStageFactor):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+        
+class VanGenuchtenDefinedStageFactor(VanGenuchtenDefinedStageFactorBase, VanGenuchtenStageFactor, HydraulicParametersCommonDefinedStageFactor):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    pass
+
+class VanGenuchten(VanGenuchtenBase, HydraulicParametersCommon):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[VanGenuchtenDefinedStageFactor, VanGenuchtenStageFactor](id, client, VanGenuchtenDefinedStageFactor, VanGenuchtenStageFactor)
+        
+        

rs3/properties/material/hydraulic/FEAGroundwater/_PropertyAccessor.py

@@ -0,0 +1,16 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor as CommonPropertyAccessor
+import rs3.generatedFiles.MaterialHydraulicModelService_pb2_grpc as MaterialHydraulicModelService_pb2_grpc
+import rs3.generatedFiles.MaterialHydraulicModelService_pb2 as MaterialHydraulicModelService_pb2
+import rs3.generatedFiles.MaterialHydraulicDataService_pb2_grpc as MaterialHydraulicDataService_pb2_grpc
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2    
+from rs3._client import Client
+class BasePropertyAccessor(CommonPropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        self._stub = MaterialHydraulicDataService_pb2_grpc.MaterialHydraulicDataServiceStub(client.channel)
+        super().__init__(client, objectId, self._stub)
+        
+class PropertyAccessor(CommonPropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        self._stub = MaterialHydraulicModelService_pb2_grpc.MaterialHydraulicModelServiceStub(client.channel)
+        super().__init__(client, objectId, self._stub)
+

rs3/properties/material/hydraulic/Hydraulic.py

@@ -0,0 +1,111 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+class HydraulicBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getPorosityValue(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Porosity")
+    def setPorosityValue(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Porosity", value)
+    def getVoidRatio(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("VoidRatio")
+    def setVoidRatio(self, value: float):
+        self._propertyAccessor.setDoubleProperty("VoidRatio", value)
+    def getDefineMaximumNegativePoreWaterPressure(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseMaxNegativePWP")
+    def setDefineMaximumNegativePoreWaterPressure(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseMaxNegativePWP", value)
+    def getMaximumNegativePoreWaterPressure(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("MaxNegativePWP")
+    def setMaximumNegativePoreWaterPressure(self, value: float):
+        self._propertyAccessor.setDoubleProperty("MaxNegativePWP", value)
+    def getUseBiotsCoefficientForCalculatingEffectiveStress(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseBiotCoefficient")
+    def setUseBiotsCoefficientForCalculatingEffectiveStress(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseBiotCoefficient", value)
+    def getUseCustomBiotsCoefficient(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseCustomBiotCoefficient")
+    def setUseCustomBiotsCoefficient(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseCustomBiotCoefficient", value)
+    def getBiotsCoefficient(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("BiotCoefficient")
+    def setBiotsCoefficient(self, value: float):
+        self._propertyAccessor.setDoubleProperty("BiotCoefficient", value)
+    def getProperties(self):
+        return {
+            "PorosityValue": self.getPorosityValue(),
+            "VoidRatio": self.getVoidRatio(),
+            "DefineMaximumNegativePoreWaterPressure": self.getDefineMaximumNegativePoreWaterPressure(),
+            "MaximumNegativePoreWaterPressure": self.getMaximumNegativePoreWaterPressure(),
+            "UseBiotsCoefficientForCalculatingEffectiveStress": self.getUseBiotsCoefficientForCalculatingEffectiveStress(),
+            "UseCustomBiotsCoefficient": self.getUseCustomBiotsCoefficient(),
+            "BiotsCoefficient": self.getBiotsCoefficient(),
+        }
+    def setProperties(self, PorosityValue: float = None, VoidRatio: float = None, DefineMaximumNegativePoreWaterPressure: bool = None, MaximumNegativePoreWaterPressure: float = None, UseBiotsCoefficientForCalculatingEffectiveStress: bool = None, UseCustomBiotsCoefficient: bool = None, BiotsCoefficient: float = None):
+        if PorosityValue is not None:
+            self.setPorosityValue(PorosityValue)
+        if VoidRatio is not None:
+            self.setVoidRatio(VoidRatio)
+        if DefineMaximumNegativePoreWaterPressure is not None:
+            self.setDefineMaximumNegativePoreWaterPressure(DefineMaximumNegativePoreWaterPressure)
+        if MaximumNegativePoreWaterPressure is not None:
+            self.setMaximumNegativePoreWaterPressure(MaximumNegativePoreWaterPressure)
+        if UseBiotsCoefficientForCalculatingEffectiveStress is not None:
+            self.setUseBiotsCoefficientForCalculatingEffectiveStress(UseBiotsCoefficientForCalculatingEffectiveStress)
+        if UseCustomBiotsCoefficient is not None:
+            self.setUseCustomBiotsCoefficient(UseCustomBiotsCoefficient)
+        if BiotsCoefficient is not None:
+            self.setBiotsCoefficient(BiotsCoefficient)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+from rs3.properties.material.hydraulic.FEAGroundwater.FEAGroundwater import FEAGroundwater
+from rs3.properties.material.hydraulic.StaticGroundwater import StaticGroundwater
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.HydraulicStageFactorService_pb2_grpc as HydraulicStageFactorService_pb2_grpc
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface
+class HydraulicStageFactor(IStageFactorBase):
+    """
+	Examples:
+		See :ref:`material_stage_factors_example`.
+    """
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, HydraulicStageFactorService_pb2_grpc.HydraulicStageFactorServiceStub(client.channel))
+    def getMaterialBehaviorType(self) -> MaterialBehaviours:
+        return self._stageFactorPropertyAccessor.getEnumValue("MaterialBehaviorType", MaterialBehaviours)
+
+class HydraulicDefinedStageFactor(HydraulicStageFactor):
+    """
+	Examples:
+		See :ref:`material_stage_factors_example`.
+    """
+    def setMaterialBehaviorType(self, materialBehaviorType : MaterialBehaviours):
+        self._stageFactorPropertyAccessor.setEnumValue("MaterialBehaviorType", materialBehaviorType.value)
+        
+class Hydraulic(HydraulicBase):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self.FEAGroundwater = FEAGroundwater(client, id)
+        self.StaticGroundwater = StaticGroundwater(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[HydraulicDefinedStageFactor, HydraulicStageFactor](id, client, HydraulicDefinedStageFactor, HydraulicStageFactor)
+        
+    def setMaterialBehavior(self, materialBehaviorType : MaterialBehaviours):
+        self._propertyAccessor.setEnumValue("MaterialBehaviorType", materialBehaviorType.value)
+    def getMaterialBehavior(self) -> MaterialBehaviours:
+        return self._propertyAccessor.getEnumValue("MaterialBehaviorType", MaterialBehaviours)
+    
+    def setPorosityType(self, porosityType : PorosityType):
+        self._propertyAccessor.setEnumValue("IsPorosity", porosityType.value)
+    def getPorosityType(self) -> PorosityType:
+        return self._propertyAccessor.getEnumValue("IsPorosity", PorosityType)
+    
+    
+        

rs3/properties/material/hydraulic/PhreaticConditions.py

@@ -0,0 +1,37 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+class PhreaticConditionsBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setName(self, value: str):
+        self._propertyAccessor.setStringValue("Name", value)
+    def getUserDefinedValue(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("UserDefinedValue")
+    def setUserDefinedValue(self, value: float):
+        self._propertyAccessor.setDoubleProperty("UserDefinedValue", value)
+    def getProperties(self):
+        return {
+            "Name": self.getName(),
+            "UserDefinedValue": self.getUserDefinedValue(),
+        }
+    def setProperties(self, Name: str = None, UserDefinedValue: float = None):
+        if Name is not None:
+            self.setName(Name)
+        if UserDefinedValue is not None:
+            self.setUserDefinedValue(UserDefinedValue)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+from ._PropertyAccessor import PhreaticConditionsPropertyAccessor
+class PhreaticConditions(PhreaticConditionsBase):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PhreaticConditionsPropertyAccessor(client, id)
+        
+    

rs3/properties/material/hydraulic/StaticGroundwater.py

@@ -0,0 +1,100 @@
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3.properties.PropertyEnums import *
+from rs3.properties.material.hydraulic.PhreaticConditions import PhreaticConditions
+from rs3.properties.material.hydraulic.WaterConditions import WaterConditions
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.MaterialHydraulicDataService_pb2_grpc as MaterialHydraulicDataService_pb2_grpc
+import rs3.generatedFiles.HydraulicStageFactorService_pb2_grpc as HydraulicStageFactorService_pb2_grpc
+import rs3.generatedFiles.HydraulicStageFactorService_pb2 as HydraulicStageFactorService_pb2
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface
+class StaticGroundwaterStageFactor(IStageFactorBase):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        self._stub = HydraulicStageFactorService_pb2_grpc.HydraulicStageFactorServiceStub(client.channel)
+        super().__init__(id, stageFactorID, client, self._stub)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getWaterCondition(self) -> str:
+        """
+        Retrieve the name of the current default water condition in phreatic surface method and initial water condition in the steady state or trainsient state methods of the current material for each stage.
+
+        Returns:
+            str: The name of the initial water condition or "Dry" if the waterType is `DRY`.
+        """
+        request = HydraulicStageFactorService_pb2.GetInitialWaterConditionRequest(propertyId=self.parentID, stageFactorId=self._objectId)
+        response : HydraulicStageFactorService_pb2.GetInitialWaterConditionResponse = self._client.callFunction(self._stub.GetInitialWaterCondition, request)
+        return response.waterTableName
+
+class StaticGroundwaterDefinedStageFactor(StaticGroundwaterStageFactor):
+    """
+    Examples:
+        :ref:`material_hydraulic_example`
+    """
+    def setWaterCondition(self, waterType : StaticWaterModes, name : str = ""):
+        """
+        Set the default water condition in phreatic surface method and initial water condition in the steady state or trainsient state methods of the current material for each stage.
+
+        This defines the starting water condition used in hydraulic calculations.
+
+        - If `waterType` is `DRY`, no `name` is required.  
+        - If `waterType` refers to a water surface, PWP interpolation surface, or PWP point set, the `name` must match an existing water table.  
+        - If `waterType` is `USER_DEFINED_VALUE`, the `name` must match an existing user-defined pore water pressure (PWP) or Ru entry.
+
+        Args:
+            waterType (WaterConditionWaterType):
+                The type of water condition to set.
+            name (str, optional):
+                The name of the water table, PWP dataset, or user-defined PWP to use. Required for all types except `DRY`. Defaults to an empty string.
+
+        Raises:
+            ValueError: If `name` is required for the given `waterType` but is not provided.
+        """
+        request = HydraulicStageFactorService_pb2.SetInitialWaterConditionRequest(propertyId=self.parentID, stageFactorId=self._objectId, waterType=waterType.value, waterTableName=name)
+        self._client.callFunction(self._stub.SetInitialWaterCondition, request)
+        
+class StaticGroundwater(WaterConditions):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stub = MaterialHydraulicDataService_pb2_grpc.MaterialHydraulicDataServiceStub(client.channel)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[StaticGroundwaterDefinedStageFactor, StaticGroundwaterStageFactor](id, client, StaticGroundwaterDefinedStageFactor, StaticGroundwaterStageFactor)
+    
+    def getStaticWaterModeByName(self, waterConditionName: str) -> PhreaticConditions:
+        return super().getWaterConditionPropertyByName(waterConditionName=waterConditionName)
+    def getAllStaticWaterModes(self) -> list[PhreaticConditions]:
+        return super().getWaterConditionProperties()
+    
+    def setStaticWaterMode(self, waterType : StaticWaterModes, name : str = ""):
+        """
+        Set the default water condition in phreatic surface method of the current material.
+
+        This defines the starting water condition used in hydraulic calculations.
+
+        - If `waterType` is `DRY`, no `name` is required.  
+        - If `waterType` refers to a water surface, PWP interpolation surface, or PWP point set, the `name` must match an existing water table.  
+        - If `waterType` is `USER_DEFINED_VALUE`, the `name` must match an existing user-defined pore water pressure (PWP) or Ru entry.
+
+        Args:
+            waterType (WaterConditionWaterType):
+                The type of water condition to set.
+            name (str, optional):
+                The name of the water table, PWP dataset, or user-defined PWP to use. Required for all types except `DRY`. Defaults to an empty string.
+
+        Raises:
+            ValueError: If `name` is required for the given `waterType` but is not provided.
+        """
+        super().setWaterConditions(waterType=waterType, name=name)
+    def getStaticWaterMode(self) -> str:
+        """
+        Retrieve the name of the current default water condition in phreatic surface method of the current material.
+
+        Returns:
+            str: The name of the initial water condition or "Dry" if the waterType is `DRY`.
+        """
+        return super().getWaterConditions()

rs3/properties/material/hydraulic/WaterConditions.py

@@ -0,0 +1,110 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import BasePropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+class WaterConditionsBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._basePropertyAccessor = BasePropertyAccessor(client, id)
+    def getStaticHuValue(self) -> float:
+        return self._basePropertyAccessor.getDoubleProperty("HuValue")
+    def setStaticHuValue(self, value: float):
+        self._basePropertyAccessor.setDoubleProperty("HuValue", value)
+    def getProperties(self):
+        return {
+            "StaticHuValue": self.getStaticHuValue(),
+        }
+    def setProperties(self, StaticHuValue: float = None):
+        if StaticHuValue is not None:
+            self.setStaticHuValue(StaticHuValue)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+import rs3.generatedFiles.MaterialHydraulicDataService_pb2_grpc as MaterialHydraulicDataService_pb2_grpc
+import rs3.generatedFiles.MaterialHydraulicDataService_pb2 as MaterialHydraulicDataService_pb2
+from rs3.properties.material.hydraulic.PhreaticConditions import PhreaticConditions
+class WaterConditions(WaterConditionsBase):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stub = MaterialHydraulicDataService_pb2_grpc.MaterialHydraulicDataServiceStub(client.channel)
+               
+    def setStaticHuType(self, value : HuTypes):
+        self._basePropertyAccessor.setEnumValue("HuFactorType", value.value)
+    def getStaticHuType(self) -> HuTypes:
+        return self._basePropertyAccessor.getEnumValue("HuFactorType", HuTypes)
+    
+    def createNewWaterCondition(self, waterConditionName: str, userDefinedType : HydraulicParameterType, value : float) -> None:
+        """
+        Create a new water condition entry with the specified name, parameter type, and value for the current material.
+
+        Args:
+            waterConditionName (str):
+                The name of the new water condition (e.g., "Pore Water Pressure 1").
+            userDefinedType (HydraulicParameterType):
+                The type of hydraulic parameter (e.g. PWP or Ru) to associate with this water condition
+            value (float):
+                The numerical value associated with the water condition.
+        """
+        request = MaterialHydraulicDataService_pb2.CreateNewWaterConditionRequest(objectId=self._objectId, waterConditionName=waterConditionName, userDefinedType=userDefinedType.value, value=value)
+        self._client.callFunction(self._stub.CreateNewWaterCondition, request)
+    
+    def deleteWaterCondition(self, waterConditionName: str) -> None:
+        """
+        Delete an existing water condition for the current material.
+
+        After deletion, the material's water condition will default to **DRY**.
+
+        Args:
+            waterConditionName (str):
+                The name of the water condition to delete (e.g., "Pore Water Pressure 1").
+        """
+        request = MaterialHydraulicDataService_pb2.DeleteWaterConditionRequest(objectId=self._objectId, waterConditionName=waterConditionName)
+        self._client.callFunction(self._stub.DeleteWaterCondition, request)
+    
+    def getWaterConditionPropertyByName(self, waterConditionName: str) -> PhreaticConditions:
+        request = MaterialHydraulicDataService_pb2.GetWaterConditionPropertyByNameRequest(objectId=self._objectId, waterConditionName=waterConditionName)
+        response : MaterialHydraulicDataService_pb2.GetWaterConditionPropertyByNameResponse  = self._client.callFunction(self._stub.GetWaterConditionPropertyByName, request)
+        return PhreaticConditions(self._client, response.result)
+    
+    def getWaterConditionProperties(self) -> list[PhreaticConditions]:
+        request = MaterialHydraulicDataService_pb2.GetWaterConditionPropertiesRequest(objectId=self._objectId)
+        response : MaterialHydraulicDataService_pb2.GetWaterConditionPropertiesResponse = self._client.callFunction(self._stub.GetWaterConditionProperties, request)
+        return [PhreaticConditions(self._client, obj) for obj in response.result]
+    
+    def setWaterConditions(self, waterType : StaticWaterModes, name : str = ""):
+        """
+        Set the default water condition in phreatic surface method and initial water condition in the steady state or trainsient state methods of the current material.
+
+        This defines the starting water condition used in hydraulic calculations.
+
+        - If `waterType` is `DRY`, no `name` is required.  
+        - If `waterType` refers to a water surface, PWP interpolation surface, or PWP point set, the `name` must match an existing water table.  
+        - If `waterType` is `USER_DEFINED_VALUE`, the `name` must match an existing user-defined pore water pressure (PWP) or Ru entry.
+
+        Args:
+            waterType (WaterConditionWaterType):
+                The type of water condition to set.
+            name (str, optional):
+                The name of the water table, PWP dataset, or user-defined PWP to use. Required for all types except `DRY`. Defaults to an empty string.
+
+        Raises:
+            ValueError: If `name` is required for the given `waterType` but is not provided.
+        """
+        request = MaterialHydraulicDataService_pb2.SetInitialWaterConditionRequest(objectId=self._objectId, waterType=waterType.value, waterTableName=name)
+        self._client.callFunction(self._stub.SetInitialWaterCondition, request)
+
+    def getWaterConditions(self) -> str:
+        """
+        Retrieve the name of the current default water condition in phreatic surface method and initial water condition in the steady state or trainsient state methods of the current material.
+
+        Returns:
+            str: The name of the initial water condition or "Dry" if the waterType is `DRY`.
+        """
+        request = MaterialHydraulicDataService_pb2.GetInitialWaterConditionRequest(objectId=self._objectId)
+        response : MaterialHydraulicDataService_pb2.GetInitialWaterConditionResponse = self._client.callFunction(self._stub.GetInitialWaterCondition, request)
+        return response.waterTableName

rs3/properties/material/hydraulic/_PropertyAccessor.py

@@ -0,0 +1,31 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor
+import rs3.generatedFiles.MaterialHydraulicDataService_pb2_grpc as MaterialHydraulicDataService_pb2_grpc
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+class _HydraulicPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, MaterialHydraulicDataService_pb2_grpc.MaterialHydraulicDataServiceStub(client.channel))
+
+class BasePropertyAccessor(_HydraulicPropertyAccessor):
+    pass
+
+class PropertyAccessor(_HydraulicPropertyAccessor):
+    pass
+
+class PhreaticConditionsPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        self._client = client
+        self._stub = MaterialHydraulicDataService_pb2_grpc.MaterialHydraulicDataServiceStub(client.channel)
+        self._object = objectId
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self._object, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._stub.GetWaterConditionValue, request)
+        return response.value
+    
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetPropertyRequest(objectId=self._object, 
+                                                        propertyName=propertyName,
+                                                        value=value)
+        self._client.callFunction(self._stub.SetWaterConditionValue, request)
+

rs3/properties/material/initialConditions/InitialConditions.py

@@ -0,0 +1,108 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+class InitialConditionsBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("UnitWeight")
+    def setUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("UnitWeight", value)
+    def getAccountForMoistureContentInUnitWeight(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseMoistureUnitWeight")
+    def setAccountForMoistureContentInUnitWeight(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseMoistureUnitWeight", value)
+    def getDryUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("DryUnitWeight")
+    def setDryUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("DryUnitWeight", value)
+    def getMoistureUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("MoistureUnitWeight")
+    def setMoistureUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("MoistureUnitWeight", value)
+    def getSaturatedUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SaturatedUnitWeight")
+    def setSaturatedUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SaturatedUnitWeight", value)
+    def getProperties(self):
+        return {
+            "UnitWeight": self.getUnitWeight(),
+            "AccountForMoistureContentInUnitWeight": self.getAccountForMoistureContentInUnitWeight(),
+            "DryUnitWeight": self.getDryUnitWeight(),
+            "MoistureUnitWeight": self.getMoistureUnitWeight(),
+            "SaturatedUnitWeight": self.getSaturatedUnitWeight(),
+        }
+    def setProperties(self, UnitWeight: float = None, AccountForMoistureContentInUnitWeight: bool = None, DryUnitWeight: float = None, MoistureUnitWeight: float = None, SaturatedUnitWeight: float = None):
+        if UnitWeight is not None:
+            self.setUnitWeight(UnitWeight)
+        if AccountForMoistureContentInUnitWeight is not None:
+            self.setAccountForMoistureContentInUnitWeight(AccountForMoistureContentInUnitWeight)
+        if DryUnitWeight is not None:
+            self.setDryUnitWeight(DryUnitWeight)
+        if MoistureUnitWeight is not None:
+            self.setMoistureUnitWeight(MoistureUnitWeight)
+        if SaturatedUnitWeight is not None:
+            self.setSaturatedUnitWeight(SaturatedUnitWeight)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+from rs3.properties.material.hydraulic.PhreaticConditions import PhreaticConditions
+from rs3.properties.material.hydraulic.WaterConditions import WaterConditions
+from ._PropertyAccessor import HydraulicPropertyAccessor
+class InitialConditions(InitialConditionsBase, WaterConditions):
+    """
+	Examples:
+		See :ref:`material_initial_conditions_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._basePropertyAccessor = HydraulicPropertyAccessor(client, id)
+    def getInitialElementLoading(self) -> InitialElementLoadingType:
+        return self._propertyAccessor.getEnumValue("InitialElementLoading", InitialElementLoadingType)
+    def setInitialElementLoading(self, initialElementLoading : InitialElementLoadingType):
+        self._propertyAccessor.setEnumValue("InitialElementLoading", initialElementLoading.value)
+        
+    def getDryUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("DryUnitWeight")
+    
+    def getApplyInitialWaterConditions(self) -> bool:
+        return self._basePropertyAccessor.getBoolValue("apply_initial_water")
+    def setApplyInitialWaterConditions(self, value: bool):
+        self._basePropertyAccessor.setBoolValue("apply_initial_water", value)
+    
+    def getInitialWaterConditionPropertyByName(self, waterConditionName: str) -> PhreaticConditions:
+        return super().getWaterConditionPropertyByName(waterConditionName=waterConditionName)
+    def getAllInitialWaterConditionProperties(self) -> list[PhreaticConditions]:
+        return super().getWaterConditionProperties()
+    
+    def setInitialWaterCondition(self, waterType : StaticWaterModes, name : str = ""):
+        """
+        Set the initial water condition in the steady state or trainsient state methods of the current material.
+
+        This defines the starting water condition used in hydraulic calculations.
+
+        - If `waterType` is `DRY`, no `name` is required.  
+        - If `waterType` refers to a water surface, PWP interpolation surface, or PWP point set, the `name` must match an existing water table.  
+        - If `waterType` is `USER_DEFINED_VALUE`, the `name` must match an existing user-defined pore water pressure (PWP) or Ru entry.
+
+        Args:
+            waterType (WaterConditionWaterType):
+                The type of water condition to set.
+            name (str, optional):
+                The name of the water table, PWP dataset, or user-defined PWP to use. Required for all types except `DRY`. Defaults to an empty string.
+
+        Raises:
+            ValueError: If `name` is required for the given `waterType` but is not provided.
+        """
+        super().setWaterConditions(waterType=waterType, name=name)
+    def getInitialWaterCondition(self) -> str:
+        """
+        Retrieve the name of the current initial water condition in the steady state or trainsient state methods of the current material.
+
+        Returns:
+            str: The name of the initial water condition or "Dry" if the waterType is `DRY`.
+        """
+        return super().getWaterConditions()