RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/CustomHydraulicModel.py

@@ -0,0 +1,129 @@
+from rs3._proxyObject import _ProxyObject
+from rs3._client import Client
+import rs3.generatedFiles.MaterialHydraulicModelService_pb2_grpc as MaterialHydraulicModelService_pb2_grpc
+import rs3.generatedFiles.MaterialHydraulicModelService_pb2 as MaterialHydraulicModelService_pb2
+from ._PropertyAccessor import CustomHydraulicModelPropertyAccessor
+from rs3.properties.PropertyEnums import *
+
+class _CustomHydraulicFunctionTypes(Enum):
+    PERMEABILITY_FUNCTION = "PermeabilityPoints"
+    DEGREE_OF_SATURATION_FUNCTION = "DegreeSaturationPoints"
+    WATER_CONTENT_FUNCTION = "WaterContentPoints"
+    
+class CustomHydraulicModel(_ProxyObject):
+    """
+	Examples:
+		See :ref:`material_hydraulic_example`.
+    """
+    def __init__(self, client: Client, objectId: str, projectId : str):
+        super().__init__(client, objectId)
+        self._projectId = projectId
+        self._stub = MaterialHydraulicModelService_pb2_grpc.MaterialHydraulicModelServiceStub(client.channel)
+        self._propertyAccessor = CustomHydraulicModelPropertyAccessor(self._client, self._objectId, self._projectId)
+        
+    def getName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setName(self, value: str):
+        self._propertyAccessor.setStringValue("Name", value)
+        
+    def setWaterContentInputType(self, waterContentInputType : WCInputType):
+        self._propertyAccessor.setEnumValue("WCInput", waterContentInputType.value)
+    def getWaterContentInputType(self) -> WCInputType:
+        return self._propertyAccessor.getEnumValue("WCInput", WCInputType)
+        
+    def setPermeabilityFunction(self, value : list[(float, float)]):
+        """
+        Set the user-defined permeability function with a list of (suction, permeability) data points for the current material.
+
+        Args:
+            value (list[tuple[float, float]]):
+                A list of tuples, where each tuple contains:
+                - suction (float): The suction value.
+                - permeability (float): The corresponding permeability value.
+        """
+        pointList = []
+        for suction, permeability in value:
+            point = MaterialHydraulicModelService_pb2.UserDefinedFunctionPoint(suction=suction, value=permeability)
+            pointList.append(point)
+        request = MaterialHydraulicModelService_pb2.SetUserDefinedFunctionRequest(objectId=self._objectId, projectId=self._projectId, propertyName=_CustomHydraulicFunctionTypes.PERMEABILITY_FUNCTION.value, point=pointList)
+        self._client.callFunction(self._stub.SetUserDefinedFunction, request)
+
+    def getPermeabilityFunction(self) -> list[(float, float)]:
+        """
+        Retrieve the permeability function with a list of (suction, permeability) data points for the current material.
+        
+        Returns:
+            list[tuple[float, float]]:
+                A list of tuples, where each tuple contains:
+                - suction (float): The suction value.
+                - permeability (float): The corresponding permeability value.
+
+        """
+        request = MaterialHydraulicModelService_pb2.GetUserDefinedFunctionRequest(objectId=self._objectId, projectId=self._projectId, propertyName = _CustomHydraulicFunctionTypes.PERMEABILITY_FUNCTION.value)
+        response : MaterialHydraulicModelService_pb2.GetUserDefinedFunctionResponse = self._client.callFunction(self._stub.GetUserDefinedFunction, request)
+        return list((p.suction, p.value) for p in response.point)
+    
+    def setDegreeOfSaturationFunction(self, value : list[(float, float)]):
+        """
+        Set the user-defined degree of saturation function with a list of (suction, degree of saturation) data points for the current material.
+
+        Args:
+            value (list[tuple[float, float]]):
+                A list of tuples, where each tuple contains:
+                - suction (float): The suction value.
+                - degree of saturation (float): The corresponding degree of saturation value.
+        """
+        pointList = []
+        for suction, degreeOfSaturation in value:
+            point = MaterialHydraulicModelService_pb2.UserDefinedFunctionPoint(suction=suction, value=degreeOfSaturation)
+            pointList.append(point)
+        request = MaterialHydraulicModelService_pb2.SetUserDefinedFunctionRequest(objectId=self._objectId, projectId=self._projectId, propertyName=_CustomHydraulicFunctionTypes.DEGREE_OF_SATURATION_FUNCTION.value, point=pointList)
+        self._client.callFunction(self._stub.SetUserDefinedFunction, request)
+
+    def getDegreeOfSaturationFunction(self) -> list[(float, float)]:
+        """
+        Retrieve the degree of saturation function with a list of (suction, degree of saturation) data points for the current material.
+        
+        Returns:
+            list[tuple[float, float]]:
+                A list of tuples, where each tuple contains:
+                - suction (float): The suction value.
+                - degree of saturation (float): The corresponding degree of saturation value.
+
+        """
+        request = MaterialHydraulicModelService_pb2.GetUserDefinedFunctionRequest(objectId=self._objectId, projectId=self._projectId, propertyName = _CustomHydraulicFunctionTypes.DEGREE_OF_SATURATION_FUNCTION.value)
+        response : MaterialHydraulicModelService_pb2.GetUserDefinedFunctionResponse = self._client.callFunction(self._stub.GetUserDefinedFunction, request)
+        return list((p.suction, p.value) for p in response.point)
+    
+    def setWaterContentFunction(self, value : list[(float, float)]):
+        """
+        Set the user-defined water content function with a list of (suction, water content) data points for the current material.
+
+        Args:
+            value (list[tuple[float, float]]):
+                A list of tuples, where each tuple contains:
+                - suction (float): The suction value.
+                - water content (float): The corresponding water content value.
+        """
+        pointList = []
+        for suction, waterContent in value:
+            point = MaterialHydraulicModelService_pb2.UserDefinedFunctionPoint(suction=suction, value=waterContent)
+            pointList.append(point)
+        request = MaterialHydraulicModelService_pb2.SetUserDefinedFunctionRequest(objectId=self._objectId, projectId=self._projectId, propertyName = _CustomHydraulicFunctionTypes.WATER_CONTENT_FUNCTION.value, point=pointList)
+        self._client.callFunction(self._stub.SetUserDefinedFunction, request)
+
+    def getWaterContentFunction(self) -> list[(float, float)]:
+        """
+        Retrieve the water content function with a list of (suction, water content) data points for the current material.
+        
+        Returns:
+            list[tuple[float, float]]:
+                A list of tuples, where each tuple contains:
+                - suction (float): The suction value.
+                - water content (float): The corresponding water content value.
+
+        """
+        request = MaterialHydraulicModelService_pb2.GetUserDefinedFunctionRequest(objectId=self._objectId, projectId=self._projectId, propertyName = _CustomHydraulicFunctionTypes.WATER_CONTENT_FUNCTION.value)
+        response : MaterialHydraulicModelService_pb2.GetUserDefinedFunctionResponse = self._client.callFunction(self._stub.GetUserDefinedFunction, request)
+        return list((p.suction, p.value) for p in response.point)
+        

rs3/properties/DiscreteFunction.py

@@ -0,0 +1,147 @@
+import rs3.generatedFiles.MaterialDataService_pb2_grpc as MaterialDataService_pb2_grpc
+import rs3.generatedFiles.ModelFunctionService_pb2_grpc as ModelFunctionService_pb2_grpc
+import rs3.generatedFiles.ModelFunctionService_pb2 as ModelFunctionService_pb2
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+from rs3.properties.PropertyEnums import *
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.material.constitutiveModel._PropertyAccessor import MaterialStrengthFunctionDataPropertyAccessor
+from rs3.ColorPicker import ColorPicker
+
+class DiscreteFunction(_ProxyObject):
+    def __init__(self, client : Client, discreteFunctionID : str):
+        super().__init__(client, discreteFunctionID)
+        self._discreteFunctionDataService = ModelFunctionService_pb2_grpc.ModelFunctionServiceStub(self._client.channel)
+        self._propertyAccessor = MaterialStrengthFunctionDataPropertyAccessor(client, discreteFunctionID, ConstitutiveModelTypes.DISCRETE_FUNCTION)
+        
+    def getName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+
+    def setPointX(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="X", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointX(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="X")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+    
+    def setPointY(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Y", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointY(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Y")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+    
+    def setPointZ(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Z", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointZ(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Z")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+    
+    def setPointC(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="C", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointC(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="C")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+    
+    def setPointCu(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Cu", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointCu(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Cu")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+    
+    def setPointPhi(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Phi", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointPhi(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Phi")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+    
+    def setPointModulus(self, value: list[float]):
+        request = ModelFunctionService_pb2.SetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Modulus", value=value)
+        self._client.callFunction(self._discreteFunctionDataService.SetDiscreteFunctionDataPointsProperty, request)
+    def getPointModulus(self) -> list[float]:
+        request = ModelFunctionService_pb2.GetDiscreteFunctionDataPointsRequest(objectId=self._objectId, propertyName="Modulus")
+        response : ModelFunctionService_pb2.GetDiscreteFunctionDataPointsResponse = self._client.callFunction(self._discreteFunctionDataService.GetDiscreteFunctionDataPointsProperty, request)
+        return list(response.value)
+
+    def getDrainageCondition(self) -> DiscreteDrainedMode:
+        return self._propertyAccessor.getEnumValue("DiscreteFunctionType", DiscreteDrainedMode)
+    def setDrainageCondition(self, IsDrained: DiscreteDrainedMode):
+         self._propertyAccessor.setEnumValue("DiscreteFunctionType", IsDrained.value)
+
+    def getIs3D(self) -> bool:
+        return self._propertyAccessor.getBoolValue("Is3D")
+    def setIs3D(self, Is3D: bool):
+        self._propertyAccessor.setBoolValue("Is3D", Is3D)
+
+    def getPlane2DType(self) -> Plane2DType:
+        return self._propertyAccessor.getEnumValue("Plane2D_type", Plane2DType)
+    def setPlane2DType(self, plane2D_type: Plane2DType):
+        self._propertyAccessor.setEnumValue("Plane2D_type", plane2D_type.value)
+
+    def getHasModulus(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasModulus")
+    def setHasModulus(self, hasModulus: bool):
+        self._propertyAccessor.setBoolValue("HasModulus", hasModulus)
+
+    def getResidualStrengthFactor(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualStrengthFactor")
+    def setResidualStrengthFactor(self, residualStrengthFactor: float):
+        self._propertyAccessor.setDoubleProperty("ResidualStrengthFactor", residualStrengthFactor)
+
+    def getTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TensileStrength")
+    def setTensileStrength(self, tensileStrength: float):
+        self._propertyAccessor.setDoubleProperty("TensileStrength", tensileStrength)
+
+    def getResidualTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TensileStrengthResidual")
+    def setResidualTensileStrength(self, tensileStrengthResidual: float):
+        self._propertyAccessor.setDoubleProperty("TensileStrengthResidual", tensileStrengthResidual)
+
+    def getInterpolationMethod(self) -> DiscreteFunctionInterpolationMethodType:
+        return self._propertyAccessor.getEnumValue("InterpolationMethod", DiscreteFunctionInterpolationMethodType)
+    def setInterpolationMethod(self, interpolationMethod: DiscreteFunctionInterpolationMethodType):
+        self._propertyAccessor.setEnumValue("InterpolationMethod", interpolationMethod.value)
+
+    def setColor(self, *args):
+        """
+        Sets the RGBA color for the object.
+        
+        Notes:
+            Accepted formats:
+                - setColor(red, green, blue)
+                - setColor(red, green, blue, alpha)
+                - setColor("#RRGGBB")
+                - setColor("#RRGGBBAA")
+                - setColor(ColorType.Rose)
+                - setColor(0xE1E4FF)  # Integer COLORREF
+
+        Raises:
+            ValueError: If inputs are invalid or out of range.
+        """
+        color_bytes = ColorPicker._setColorValidation(*args)
+        request = ModelFunctionService_pb2.SetFunctionColorRequest(objectId=self._objectId, value=color_bytes)
+        self._client.callFunction(self._discreteFunctionDataService.SetColorProperty, request)
+    def getColor(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 = ModelFunctionService_pb2.GetFunctionColorRequest(objectId=self._objectId)
+        response : ModelFunctionService_pb2.GetFunctionColorResponse = self._client.callFunction(self._discreteFunctionDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha

rs3/properties/GeneralizedAnisotropicFunction.py

@@ -0,0 +1,98 @@
+from rs3._client import Client
+from rs3.properties.PropertyEnums import *
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.material.constitutiveModel._PropertyAccessor import MaterialStrengthFunctionDataPropertyAccessor
+import rs3.generatedFiles.ModelFunctionService_pb2_grpc as ModelFunctionService_pb2_grpc
+import rs3.generatedFiles.ModelFunctionService_pb2 as ModelFunctionService_pb2
+
+class GeneralizedAnisotropicFunction(_ProxyObject):
+    """
+    Examples:
+        See :ref:`generalized_anisotropic_function_example`.
+    """
+    def __init__(self, client : Client, generalizedAnisotropicFunctionID : str, projectID : str):
+        super().__init__(client, generalizedAnisotropicFunctionID)
+        self._stub = ModelFunctionService_pb2_grpc.ModelFunctionServiceStub(self._client.channel)
+        self._propertyAccessor = MaterialStrengthFunctionDataPropertyAccessor(client, generalizedAnisotropicFunctionID, ConstitutiveModelTypes.GENERALIZED_ANISOTROPIC)
+        self.projectId = projectID
+
+    def getName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+
+    def getDipDipDirectionFunctionPoints(self) -> list[tuple[float, float, float, float, str]]:
+        """
+        Get a list of dip-dip direction function points.
+
+        Returns:
+            list[tuple[float, float, float, float, str]]: A list of (dip, dip_direction, A, B, material_name) data points.
+        """
+        request = ModelFunctionService_pb2.GetGeneralizedAnisotropicFunctionDipDataPointsRequest(objectId=self._objectId, projectId=self.projectId)
+        response : ModelFunctionService_pb2.GetGeneralizedAnisotropicFunctionDipDataPointsResponse = self._client.callFunction(self._stub.GetGeneralizedAnisotropicFunctionDipDataPointsProperty, request)
+        return list((p.dip, p.dipDirection, p.A, p.B, p.materialName) for p in response.value)
+
+    def setDipDipDirectionFunctionPoints(self, value: list[tuple[float, float, float, float, str]]):
+        """
+        Set a list of dip-dip direction function points.
+
+        Parameters:
+            value : list[tuple[float, float, float, float, str]]: A list of (dip, dip_direction, A, B, material_name) data points.
+
+        Example:
+            >>> generalizedAnisotropicFunction = self.model.getGeneralizedAnisotropicFunctions()[0]
+            >>> dipDipDirectionPoints = [(15.5, 2.1, 0.4, 0.5, "Material 3"), (13.2, 24.1, 1.4, 1.5, "Material 5")]
+            >>> generalizedAnisotropicFunction.setDipDipDirectionFunctionPoints(dipDipDirectionPoints)
+        
+        """
+        pointlist = []
+        for dip, dipDirection, A, B, materialName in value:
+            point = ModelFunctionService_pb2.DipDipDirectionPoints(dip=dip, dipDirection=dipDirection, A=A, B=B, materialName=materialName)
+            pointlist.append(point)
+        request = ModelFunctionService_pb2.SetGeneralizedAnisotropicFunctionDipDataPointsRequest(objectId=self._objectId, projectId=self.projectId, value=pointlist)
+        self._client.callFunction(self._stub.SetGeneralizedAnisotropicFunctionDipDataPointsProperty, request)
+
+    def getSurfaceFunctionPoints(self) -> list[tuple[str, float, float, str]]:
+        """
+        Get a list of surface function points.
+
+        Returns:
+            list[tuple[str, float, float, str]]: A list of (surface_name, A, B, material_name) data points.
+        """
+        request = ModelFunctionService_pb2.GetGeneralizedAnisotropicFunctionSurfaceDataPointsRequest(objectId=self._objectId, projectId=self.projectId)
+        response : ModelFunctionService_pb2.GetGeneralizedAnisotropicFunctionSurfaceDataPointsResponse = self._client.callFunction(self._stub.GetGeneralizedAnisotropicFunctionSurfaceDataPointsProperty, request)
+        return list((p.surfaceName, p.A, p.B, p.materialName) for p in response.value)
+
+    def setSurfaceFunctionPoints(self, value: list[tuple[str, float, float, str]]):
+        """
+        Set a list of surface function points.
+
+        Parameters:
+            value : list[tuple[str, float, float, str]]: A list of (surface_name, A, B, material_name) data points.
+
+        Example:
+            >>> generalizedAnisotropicFunction = self.model.getGeneralizedAnisotropicFunctions()[0]
+            >>> surfacePoints = [("Anisotropic Surface 2", 0.4, 0.5, "Material 4"), ("Anisotropic Surface 1", 1.4, 1.5, "Material 2")]
+            >>> generalizedAnisotropicFunction.setSurfaceFunctionPoints(surfacePoints)
+        
+        """
+        pointlist = []
+        for surfaceName, A, B, materialName in value:
+            point = ModelFunctionService_pb2.SurfacePoints(surfaceName=surfaceName, A=A, B=B, materialName=materialName)
+            pointlist.append(point)
+        request = ModelFunctionService_pb2.SetGeneralizedAnisotropicFunctionSurfaceDataPointsRequest(objectId=self._objectId, projectId=self.projectId, value=pointlist)
+        self._client.callFunction(self._stub.SetGeneralizedAnisotropicFunctionSurfaceDataPointsProperty, request)
+
+    def getBaseMaterial(self) -> str:
+        request = ModelFunctionService_pb2.GetGeneralizedAnisotropicBaseMaterialRequest(objectId=self._objectId)
+        response : ModelFunctionService_pb2.GetGeneralizedAnisotropicBaseMaterialResponse = self._client.callFunction(self._stub.GetGeneralizedAnisotropicBaseMaterialProperty, request)
+        return response.baseMaterial
+
+    def setBaseMaterial(self, value: str):
+        request = ModelFunctionService_pb2.SetGeneralizedAnisotropicBaseMaterialRequest(objectId=self._objectId, projectId=self.projectId, baseMaterial=value)
+        self._client.callFunction(self._stub.SetGeneralizedAnisotropicBaseMaterialProperty, request)
+
+    def getAnisotropyDefinition(self) -> GeneralizedAnisotropyDefinitionType:
+        return self._propertyAccessor.getEnumValue("anisotropyDefinition", GeneralizedAnisotropyDefinitionType)
+    def setAnisotropyDefinition(self, anisotropyDefinition: GeneralizedAnisotropyDefinitionType):
+        return self._propertyAccessor.setEnumValue("anisotropyDefinition", anisotropyDefinition.value)

rs3/properties/IPropertyGroupAccessors.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+class IPropertyGroupAccessors(ABC):
+    @abstractmethod
+    def getProperties(self):
+        """Retrieve properties as a dictionary."""
+        pass
+
+    @abstractmethod
+    def setProperties(self, **kwargs):
+        """Set properties using keyword arguments."""
+        pass