RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/material/initialConditions/_PropertyAccessor.py

@@ -0,0 +1,11 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.MaterialInitialConditionsService_pb2_grpc as MaterialInitialConditionsService_pb2_grpc
+import rs3.generatedFiles.MaterialHydraulicDataService_pb2_grpc as MaterialHydraulicDataService_pb2_grpc
+from rs3._client import Client
+class PropertyAccessor(BasePropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, MaterialInitialConditionsService_pb2_grpc.MaterialInitialConditionsServiceStub(client.channel))
+
+class HydraulicPropertyAccessor(BasePropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, MaterialHydraulicDataService_pb2_grpc.MaterialHydraulicDataServiceStub(client.channel))

rs3/properties/material/stageFactors/StageFactors.py

@@ -0,0 +1,77 @@
+# 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 StageFactorsBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getApplyConstitutiveModelStageFactors(self) -> bool:
+        return self._propertyAccessor.getBoolValue("ApplyStageFactors")
+    def setApplyConstitutiveModelStageFactors(self, value: bool):
+        self._propertyAccessor.setBoolValue("ApplyStageFactors", value)
+    def getApplyHydraulicStageFactors(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseGWStageFactors")
+    def setApplyHydraulicStageFactors(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseGWStageFactors", value)
+    def getResetElementStressOnMaterialChange(self) -> bool:
+        return self._propertyAccessor.getBoolValue("ResetElementStressOnMaterialChange")
+    def setResetElementStressOnMaterialChange(self, value: bool):
+        self._propertyAccessor.setBoolValue("ResetElementStressOnMaterialChange", value)
+    def getProperties(self):
+        return {
+            "ApplyConstitutiveModelStageFactors": self.getApplyConstitutiveModelStageFactors(),
+            "ApplyHydraulicStageFactors": self.getApplyHydraulicStageFactors(),
+            "ResetElementStressOnMaterialChange": self.getResetElementStressOnMaterialChange(),
+        }
+    def setProperties(self, ApplyConstitutiveModelStageFactors: bool = None, ApplyHydraulicStageFactors: bool = None, ResetElementStressOnMaterialChange: bool = None):
+        if ApplyConstitutiveModelStageFactors is not None:
+            self.setApplyConstitutiveModelStageFactors(ApplyConstitutiveModelStageFactors)
+        if ApplyHydraulicStageFactors is not None:
+            self.setApplyHydraulicStageFactors(ApplyHydraulicStageFactors)
+        if ResetElementStressOnMaterialChange is not None:
+            self.setResetElementStressOnMaterialChange(ResetElementStressOnMaterialChange)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+import rs3.generatedFiles.StageFactorService_pb2 as StageFactorService_pb2
+import rs3.generatedFiles.MaterialDataService_pb2_grpc as MaterialDataService_pb2_grpc
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface as StageFactorBaseInterfaces
+
+class DefinedStageFactor(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, MaterialDataService_pb2_grpc.MaterialDataServiceStub(client.channel))
+class StageFactor(DefinedStageFactor):
+    pass
+
+class StageFactors(StageFactorsBase, StageFactorBaseInterfaces[DefinedStageFactor, StageFactor]):
+    """
+	Examples:
+		See :ref:`material_stage_factors_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._definedStageFactorClass = DefinedStageFactor
+        self._stageFactorClass = StageFactor
+        StageFactorBaseInterfaces.__init__(self, id, client, DefinedStageFactor, StageFactor)
+    
+    def createStageFactor(self, stage : int) -> DefinedStageFactor:
+        """
+        Creates a stage factor for the given stage.
+
+        NOTE: Invalidates any existing stage factor proxies. Get them again using getDefinedStageFactors or getStageFactor.
+        """
+        return self._createStageFactor(stage)
+
+    def setDefinedStageFactors(self, stageFactors : dict[int, StageFactor]):
+        """
+        Sets the defined stage factors to those given.
+
+        NOTE: Invalidates any existing stage factor proxies. Get them again using getDefinedStageFactors or getStageFactor.
+        """
+        convertedStageFactors = {}
+        for stageNum, stageFactor in stageFactors.items():
+            convertedStageFactors[stageNum] = StageFactorService_pb2.StageFactorProperty(stageFactorID = stageFactor._objectId)
+        self._setDefinedStageFactors(StageFactorMethodType.ABSOLUTE_STAGE_FACTOR, convertedStageFactors)

rs3/properties/material/stageFactors/_PropertyAccessor.py

@@ -0,0 +1,7 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor
+import rs3.generatedFiles.MaterialStageFactorsService_pb2_grpc as MaterialStageFactorsService_pb2_grpc
+from rs3._client import Client
+class PropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, MaterialStageFactorsService_pb2_grpc.MaterialStageFactorsServiceStub(client.channel))
+

rs3/properties/pile/EndCondition.py

@@ -0,0 +1,109 @@
+# 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.PileStageFactorService_pb2_grpc as PileStageFactorService_pb2_grpc
+class EndConditionBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getMagnitude(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ForceDisplacementValue")
+    def setMagnitude(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ForceDisplacementValue", value)
+    def getX(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ForceDisplacementVectorX")
+    def setX(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ForceDisplacementVectorX", value)
+    def getY(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ForceDisplacementVectorY")
+    def setY(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ForceDisplacementVectorY", value)
+    def getZ(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ForceDisplacementVectorZ")
+    def setZ(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ForceDisplacementVectorZ", value)
+    def getProperties(self):
+        return {
+            "Magnitude": self.getMagnitude(),
+            "X": self.getX(),
+            "Y": self.getY(),
+            "Z": self.getZ(),
+        }
+    def setProperties(self, Magnitude: float = None, X: float = None, Y: float = None, Z: float = None):
+        if Magnitude is not None:
+            self.setMagnitude(Magnitude)
+        if X is not None:
+            self.setX(X)
+        if Y is not None:
+            self.setY(Y)
+        if Z is not None:
+            self.setZ(Z)
+class EndConditionStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, PileStageFactorService_pb2_grpc.PileStageFactorServiceStub(client.channel))
+    def getEndConditionFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_Force")
+class EndConditionDefinedStageFactorBase(EndConditionStageFactorBase):
+    def setEndConditionFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_Force", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+import rs3.generatedFiles.PileDataService_pb2_grpc as PileDataService_pb2_grpc
+from rs3.properties.PropertyEnums import *
+
+class EndConditionStageFactor(EndConditionStageFactorBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+    
+class EndConditionDefinedStageFactor(EndConditionStageFactor, EndConditionDefinedStageFactorBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    pass
+
+class EndCondition(EndConditionBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._pileDataService = PileDataService_pb2_grpc.PileDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, id, self._pileDataService)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[EndConditionDefinedStageFactor, EndConditionStageFactor](id, client, EndConditionDefinedStageFactor, EndConditionStageFactor)
+    def getEndConditionType(self) -> EndConditionType:
+        """
+        When force/displacement function is not enabled, this function returns EndConditionType.NONE.
+        Otherwise, this function returns the defined force/displacement type.
+        """
+        hasEndCondition = self._propertyAccessor.getBoolValue("HasForceDisplacement")
+        if not hasEndCondition:
+            return EndConditionType.NONE
+        else:        
+            return self._propertyAccessor.getEnumValue("ForceDisplacementType", EndConditionType)
+    def setEndConditionType(self, endConditionType : EndConditionType):
+        """
+        When EndConditionType is not set to be NONE, force displacement function is automatically on 
+        when force type is set. If the EndConditionType is set to be NONE, force displacement function 
+        is automatically off.
+        """
+        if endConditionType == EndConditionType.NONE:
+            self._propertyAccessor.setBoolValue("HasForceDisplacement", False)
+        elif endConditionType == EndConditionType.FORCE or endConditionType == EndConditionType.DISPLACEMENT:
+            self._propertyAccessor.setBoolValue("HasForceDisplacement", True)
+            self._propertyAccessor.setEnumValue("ForceDisplacementType", endConditionType.value)
+        else:
+            raise Excpetion(f"Invalid force type {endConditionType}")
+    def getApplicationPoint(self) -> EndConditionPlacementPoint:
+        return self._propertyAccessor.getEnumValue("ForceDisplacementPlacement", EndConditionPlacementPoint)
+    def setApplicationPoint(self, applicationPoint : EndConditionPlacementPoint):
+        self._propertyAccessor.setEnumValue("ForceDisplacementPlacement", applicationPoint.value)

rs3/properties/pile/Linear.py

@@ -0,0 +1,69 @@
+# 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.PileStageFactorService_pb2_grpc as PileStageFactorService_pb2_grpc
+class LinearBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getMaxTractionAtTop(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("MaxTractionTop")
+    def setMaxTractionAtTop(self, value: float):
+        self._propertyAccessor.setDoubleProperty("MaxTractionTop", value)
+    def getMaxTractionAtBottom(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("MaxTractionBottom")
+    def setMaxTractionAtBottom(self, value: float):
+        self._propertyAccessor.setDoubleProperty("MaxTractionBottom", value)
+    def getProperties(self):
+        return {
+            "MaxTractionAtTop": self.getMaxTractionAtTop(),
+            "MaxTractionAtBottom": self.getMaxTractionAtBottom(),
+        }
+    def setProperties(self, MaxTractionAtTop: float = None, MaxTractionAtBottom: float = None):
+        if MaxTractionAtTop is not None:
+            self.setMaxTractionAtTop(MaxTractionAtTop)
+        if MaxTractionAtBottom is not None:
+            self.setMaxTractionAtBottom(MaxTractionAtBottom)
+class LinearStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, PileStageFactorService_pb2_grpc.PileStageFactorServiceStub(client.channel))
+    def getMaxTractionAtTopFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Linear_MaxTractionTop")
+    def getMaxTractionAtBottomFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Linear_MaxTractionBottom")
+class LinearDefinedStageFactorBase(LinearStageFactorBase):
+    def setMaxTractionAtTopFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Linear_MaxTractionTop", value)
+    def setMaxTractionAtBottomFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Linear_MaxTractionBottom", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.pile.PileCommon import PileCommon, PileCommonStageFactor, PileCommonDefinedStageFactor
+
+class LinearStageFactor(PileCommonStageFactor, LinearStageFactorBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        IStageFactorBase.__init__(self, id, stageFactorID, client, PileStageFactorService_pb2_grpc.PileStageFactorServiceStub(client.channel))
+    
+class LinearDefinedStageFactor(PileCommonDefinedStageFactor, LinearDefinedStageFactorBase, LinearStageFactor):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    pass
+
+class Linear(LinearBase, PileCommon):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[LinearDefinedStageFactor, LinearStageFactor](id, client, LinearDefinedStageFactor, LinearStageFactor)

rs3/properties/pile/MohrCoulomb.py

@@ -0,0 +1,123 @@
+# 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.PileStageFactorService_pb2_grpc as PileStageFactorService_pb2_grpc
+class MohrCoulombBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getPerimeter(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Perimeter")
+    def setPerimeter(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Perimeter", value)
+    def getCohesion(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Cohesion")
+    def setCohesion(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Cohesion", value)
+    def getResidualCohesion(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualCohesion")
+    def setResidualCohesion(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ResidualCohesion", value)
+    def getFrictionAngle(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngle")
+    def setFrictionAngle(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngle", value)
+    def getResidualFrictionAngle(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualFrictionAngle")
+    def setResidualFrictionAngle(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ResidualFrictionAngle", value)
+    def getUseShearResistanceCutoff(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasShearResistanceCutoff")
+    def setUseShearResistanceCutoff(self, value: bool):
+        self._propertyAccessor.setBoolValue("HasShearResistanceCutoff", value)
+    def getShearResistanceCutoff(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ShearResistanceCutoff")
+    def setShearResistanceCutoff(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ShearResistanceCutoff", value)
+    def getProperties(self):
+        return {
+            "Perimeter": self.getPerimeter(),
+            "Cohesion": self.getCohesion(),
+            "ResidualCohesion": self.getResidualCohesion(),
+            "FrictionAngle": self.getFrictionAngle(),
+            "ResidualFrictionAngle": self.getResidualFrictionAngle(),
+            "UseShearResistanceCutoff": self.getUseShearResistanceCutoff(),
+            "ShearResistanceCutoff": self.getShearResistanceCutoff(),
+        }
+    def setProperties(self, Perimeter: float = None, Cohesion: float = None, ResidualCohesion: float = None, FrictionAngle: float = None, ResidualFrictionAngle: float = None, UseShearResistanceCutoff: bool = None, ShearResistanceCutoff: float = None):
+        if Perimeter is not None:
+            self.setPerimeter(Perimeter)
+        if Cohesion is not None:
+            self.setCohesion(Cohesion)
+        if ResidualCohesion is not None:
+            self.setResidualCohesion(ResidualCohesion)
+        if FrictionAngle is not None:
+            self.setFrictionAngle(FrictionAngle)
+        if ResidualFrictionAngle is not None:
+            self.setResidualFrictionAngle(ResidualFrictionAngle)
+        if UseShearResistanceCutoff is not None:
+            self.setUseShearResistanceCutoff(UseShearResistanceCutoff)
+        if ShearResistanceCutoff is not None:
+            self.setShearResistanceCutoff(ShearResistanceCutoff)
+class MohrCoulombStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, PileStageFactorService_pb2_grpc.PileStageFactorServiceStub(client.channel))
+    def getExposedPerimeterFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("CAndPhi_ExposedPerimeter")
+    def getCohesionFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("CAndPhi_Cohesion")
+    def getResidualCohesionFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("CAndPhi_CohesionResidual")
+    def getFrictionAngleFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("CAndPhi_FrictionAngle")
+    def getResidualFrictionAngleFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("CAndPhi_FrictionAngleResidual")
+    def getShearResistanceCutoffFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("CAndPhi_ShearResistanceCutoff")
+class MohrCoulombDefinedStageFactorBase(MohrCoulombStageFactorBase):
+    def setExposedPerimeterFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("CAndPhi_ExposedPerimeter", value)
+    def setCohesionFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("CAndPhi_Cohesion", value)
+    def setResidualCohesionFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("CAndPhi_CohesionResidual", value)
+    def setFrictionAngleFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("CAndPhi_FrictionAngle", value)
+    def setResidualFrictionAngleFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("CAndPhi_FrictionAngleResidual", value)
+    def setShearResistanceCutoffFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("CAndPhi_ShearResistanceCutoff", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.pile.PileCommon import PileCommon, PileCommonStageFactor, PileCommonDefinedStageFactor
+
+class MohrCoulombStageFactor(PileCommonStageFactor, MohrCoulombStageFactorBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        IStageFactorBase.__init__(self, id, stageFactorID, client, PileStageFactorService_pb2_grpc.PileStageFactorServiceStub(client.channel))
+    
+class MohrCoulombDefinedStageFactor(PileCommonDefinedStageFactor, MohrCoulombDefinedStageFactorBase, MohrCoulombStageFactor):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    pass
+
+class MohrCoulomb(PileCommon, MohrCoulombBase):
+    """
+    UI Label:
+        C and phi
+        
+    Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[MohrCoulombDefinedStageFactor, MohrCoulombStageFactor](id, client, MohrCoulombDefinedStageFactor, MohrCoulombStageFactor)

rs3/properties/pile/MultiLinear.py

@@ -0,0 +1,70 @@
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+import rs3.generatedFiles.PileDataService_pb2 as PileDataService_pb2
+import rs3.generatedFiles.PileDataService_pb2_grpc as PileDataService_pb2_grpc
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.pile.PileCommon import PileCommon, PileCommonStageFactor, PileCommonDefinedStageFactor
+class MultiLinearStageFactor(PileCommonStageFactor):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client)
+    def getMultiLinearFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("MultiLinear_MultiLinear")
+class MultiLinearDefinedStageFactor(PileCommonDefinedStageFactor, MultiLinearStageFactor):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def setMultiLinearFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("MultiLinear_MultiLinear", value)        
+class MultiLinear(PileCommon):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._pileDataService = PileDataService_pb2_grpc.PileDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[MultiLinearDefinedStageFactor, MultiLinearStageFactor](id, client, MultiLinearDefinedStageFactor, MultiLinearStageFactor)
+    def getMultiLinearGrid(self) -> list[tuple[float, float]]:
+        """
+        Get a list of multi-linear skin resistance (distance to top, max traction) data points.
+        
+        Returns:
+            list[tuple[float, float]]
+            A list of (distance_to_top, max_traction) data points.
+
+            - distance_to_top : float
+                Distance measured from the top of the pile.
+            - max_traction : float
+                Maximum skin resistance (traction) at the corresponding distance.
+
+        """
+        request = PileDataService_pb2.GetMultiLinearGridRequest(pileId=self._objectId)
+        response : PileDataService_pb2.GetMultiLinearGridResponse = self._client.callFunction(self._pileDataService.GetMultiLinearGrid, request)
+        return [(dtv.distances, dtv.tractions) for dtv in response.distanceTractionValues]
+    def setMultiLinearGrid(self, value: list[tuple[float, float]]):
+        """
+        Set a list of multi-linear skin resistance (distance to top, max traction) data points.
+
+        Parameters:
+            value : list[tuple[float, float]]
+                A list of (distance_to_top, max_traction) data points.
+
+                - distance_to_top : float
+                    Distance measured from the top of the pile.
+                - max_traction : float
+                    Maximum skin resistance (traction) at that distance.
+
+        Example:
+            >>> list = [(1.1, 2.2), (3.3, 4.4), (5.5, 6.6)]
+            >>> MultiLinearPile.setMultiLinearGrid(list)
+            
+        """
+        request = PileDataService_pb2.SetMultiLinearGridRequest(pileId=self._objectId, 
+                                                                       distanceTractionValues=[PileDataService_pb2.DistanceTractionValues(distances=d, tractions=t)for d, t in value])
+        self._client.callFunction(self._pileDataService.SetMultiLinearGrid, request)

rs3/properties/pile/Pile.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 PileBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getApplyStageFactors(self) -> bool:
+        return self._propertyAccessor.getBoolValue("StageProperties")
+    def setApplyStageFactors(self, value: bool):
+        self._propertyAccessor.setBoolValue("StageProperties", value)
+    def getProperties(self):
+        return {
+            "ApplyStageFactors": self.getApplyStageFactors(),
+        }
+    def setProperties(self, ApplyStageFactors: bool = None):
+        if ApplyStageFactors is not None:
+            self.setApplyStageFactors(ApplyStageFactors)
+
+################ Code below this line will not be overridden ################
+import rs3.generatedFiles.PileDataService_pb2_grpc as PileDataService_pb2_grpc
+import rs3.generatedFiles.PileDataService_pb2 as PileDataService_pb2
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3.properties.PropertyEnums import *
+from rs3.properties.pile.Linear import Linear
+from rs3.properties.pile.MohrCoulomb import MohrCoulomb
+from rs3.properties.pile.MultiLinear import MultiLinear
+from rs3.properties.pile.EndCondition import EndCondition
+from rs3.ColorPicker import ColorPicker
+
+class PileProperty(PileBase):
+    """
+    Define pile properties.
+
+    Attributes:
+        Linear (Linear): Reference object for modifying property.
+        MohrCoulomb (MohrCoulomb): Reference object for modifying property.
+        MultiLinear (MultiLinear): Reference object for modifying property.
+
+    Examples:
+        See :ref:`pile_example`.
+    """
+    def __init__(self, client : Client, pileID : str):
+        super().__init__(client, pileID)
+        self._pileDataService = PileDataService_pb2_grpc.PileDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, pileID, self._pileDataService)
+        self.Linear = Linear(client, pileID)
+        self.MohrCoulomb = MohrCoulomb(client, pileID)
+        self.MultiLinear = MultiLinear(client, pileID)
+        self.EndCondition = EndCondition(client, pileID)
+
+    def getPileName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setPileName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+    def setPileColor(self, *args):
+        """
+        Sets the RGBA color for the object.
+
+        Raises:
+            ValueError: If inputs are invalid or out of range.
+            
+        Notes:
+            Accepted formats:
+                - setColor(red, green, blue)
+                - setColor(red, green, blue, alpha)
+                - setColor("#RRGGBB")
+                - setColor("#RRGGBBAA")
+                - setColor(ColorType.Rose)
+                - setColor(0xE1E4FF)  # Integer COLORREF
+
+        """
+        color_bytes = ColorPicker._setColorValidation(*args)
+        request = CommonMessages_pb2.SetColorRequest(objectId=self._objectId, value=color_bytes)
+        self._client.callFunction(self._pileDataService.SetColorProperty, request)
+    def getPileColor(self) -> tuple[int, int, int, int]:
+        """
+        Retrieves the RGBA color of the object.
+
+        Returns:
+            tuple[int, int, int, int]: A tuple of four integers representing the red, green, blue, and alpha components of the object's color, each in the range [0, 255].
+        """
+        request = CommonMessages_pb2.GetColorRequest(objectId=self._objectId)
+        response : CommonMessages_pb2.GetColorResponse = self._client.callFunction(self._pileDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha
+
+    def getSkinResistance(self) -> PileSkinResistanceType:
+        return self._propertyAccessor.getEnumValue("SkinResistance", PileSkinResistanceType)
+    def setSkinResistance(self, skinResistanceType : PileSkinResistanceType):
+        self._propertyAccessor.setEnumValue("SkinResistance", skinResistanceType.value)
+    def getConnectionType(self) -> ConnectionType:
+        return self._propertyAccessor.getEnumValue("Connection", ConnectionType)
+    def setConnectionType(self, connectionType : ConnectionType):
+        self._propertyAccessor.setEnumValue("Connection", connectionType.value)
+    def getLiningConnectionType(self) -> LiningConnectionType:
+        return self._propertyAccessor.getEnumValue("LiningConnection", LiningConnectionType)
+    def setLiningConnectionType(self, liningConnectionType : LiningConnectionType):
+        self._propertyAccessor.setEnumValue("LiningConnection", liningConnectionType.value)
+    def getBeamMaterial(self) -> str:
+        request = PileDataService_pb2.GetBeamPropertyRequest(pileId=self._objectId)
+        response : PileDataService_pb2.GetBeamPropertyResponse = self._client.callFunction(self._pileDataService.GetBeamProperty, request)
+        return response.beamName
+    def setBeamMaterial(self, value: str):
+        request = PileDataService_pb2.SetBeamPropertyRequest(pileId=self._objectId, beamName=value)
+        self._client.callFunction(self._pileDataService.SetBeamProperty, request)