RS3Scripting 4.42.0__py3-none-any.whl

rs3/loadings/fieldStress/Constant.py

@@ -0,0 +1,119 @@
+# 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 ConstantBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getSigma1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Sigma1")
+    def setSigma1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Sigma1", value)
+    def getSigma2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Sigma2")
+    def setSigma2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Sigma2", value)
+    def getSigma3(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Sigma3")
+    def setSigma3(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Sigma3", value)
+    def getProperties(self):
+        return {
+            "Sigma1": self.getSigma1(),
+            "Sigma2": self.getSigma2(),
+            "Sigma3": self.getSigma3(),
+        }
+    def setProperties(self, Sigma1: float = None, Sigma2: float = None, Sigma3: float = None):
+        if Sigma1 is not None:
+            self.setSigma1(Sigma1)
+        if Sigma2 is not None:
+            self.setSigma2(Sigma2)
+        if Sigma3 is not None:
+            self.setSigma3(Sigma3)
+
+################ Code below this line will not be overridden ################
+from rs3.loadings.LoadingEnums import *
+from rs3.CommonEnums import *
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+import rs3.generatedFiles.FieldStressSourceService_pb2 as FieldStressSourceService_pb2
+import rs3.generatedFiles.FieldStressSourceService_pb2_grpc as FieldStressSourceService_pb2_grpc
+class Constant(ConstantBase):
+    """
+	Examples:
+		See :ref:`field_stress_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._fieldStressSourceService = FieldStressSourceService_pb2_grpc.FieldStressSourceServiceStub(self._client.channel)
+        
+    def getOrientationType(self) -> LinearDirectionType:
+        request = FieldStressSourceService_pb2.GetDirectionTypeRequest(objectId=self._objectId)
+        response : FieldStressSourceService_pb2.GetDirectionTypeResponse = self._client.callFunction(self._fieldStressSourceService.GetDirectionType, request)
+        return LinearDirectionType(response.value)
+    
+    def setOrientationType(self, directionType : LinearDirectionType):
+        request = FieldStressSourceService_pb2.SetDirectionTypeRequest(objectId=self._objectId, value=directionType.value)
+        self._client.callFunction(self._fieldStressSourceService.SetDirectionType, request)
+        
+    def getTrendPlungeOrientation(self) -> tuple[float, float, float, float]:
+        """
+        Retrieves the trend and plunge orientations of the sigma1 and sigma3 stress axes.
+
+        Returns:
+            tuple[float, float, float, float]: A tuple containing:
+                - sigma1 trend (degrees)
+                - sigma1 plunge (degrees)
+                - sigma3 trend (degrees)
+                - sigma3 plunge (degrees)
+        """
+        request = FieldStressSourceService_pb2.GetTrendPlungePropertyRequest(objectId=self._objectId)
+        response : FieldStressSourceService_pb2.GetTrendPlungePropertyResponse = self._client.callFunction(self._fieldStressSourceService.GetTrendPlungeProperty, request)
+        return response.sigma1.trend, response.sigma1.plunge, response.sigma3.trend, response.sigma3.plunge
+    
+    def setTrendPlungeOrientation(self, signma1Trend : float = 0, sigma1Plunge : float = 90, signma3Trend : float = 90, sigma3Plunge : float = 0):
+        """
+        Sets the trend and plunge orientations for the sigma1 and sigma3 stress axes.
+
+        Args:
+            signma1Trend (float): Trend angle of sigma1 in degrees. Default is 0.
+            sigma1Plunge (float): Plunge angle of sigma1 in degrees. Default is 90.
+            signma3Trend (float): Trend angle of sigma3 in degrees. Default is 90.
+            sigma3Plunge (float): Plunge angle of sigma3 in degrees. Default is 0.
+        """
+        sigma1Orientation = CommonMessages_pb2.LinearDirection(trend=signma1Trend, plunge=sigma1Plunge)
+        sigma3Orientation = CommonMessages_pb2.LinearDirection(trend=signma3Trend, plunge=sigma3Plunge)
+        request = FieldStressSourceService_pb2.SetTrendPlungePropertyRequest(objectId=self._objectId, sigma1=sigma1Orientation, sigma3=sigma3Orientation)
+        self._client.callFunction(self._fieldStressSourceService.SetTrendPlungeProperty, request)
+        
+    def getVectorOrientation(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+        """
+        Retrieves the vectors representing the orientations of sigma1 and sigma3.
+
+        Returns:
+            tuple[tuple[float, float, float], tuple[float, float, float]]:
+                A tuple containing two 3D vectors:
+                - sigma1 vector (x, y, z)
+                - sigma3 vector (x, y, z)
+        """
+        request = FieldStressSourceService_pb2.GetVectorPropertyRequest(objectId=self._objectId)
+        response : FieldStressSourceService_pb2.GetVectorPropertyResponse = self._client.callFunction(self._fieldStressSourceService.GetVectorProperty, request)
+        return [(response.sigma1.x, response.sigma1.y, response.sigma1.z), (response.sigma3.x, response.sigma3.y, response.sigma3.z)]
+    
+    def setVectorOrientation(self, sigma1 = tuple[float, float, float], sigma3 = tuple[float, float, float]):
+        """
+        Sets the orientation vectors for sigma1 and sigma3.
+
+        Args:
+            sigma1 (tuple[float, float, float]): 3D vector representing sigma1 orientation (x, y, z).
+            sigma3 (tuple[float, float, float]): 3D vector representing sigma3 orientation (x, y, z).
+            
+        Note:
+            The sigma1 and sigma3 vectors must be orthogonal (i.e., their dot product should be zero)
+        """
+        sigma1Orientation = CommonMessages_pb2.Point3D(x=sigma1[0], y=sigma1[1], z=sigma1[2])
+        sigma3Orientation = CommonMessages_pb2.Point3D(x=sigma3[0], y=sigma3[1], z=sigma3[2])
+        request = FieldStressSourceService_pb2.SetVectorPropertyRequest(objectId=self._objectId, sigma1=sigma1Orientation, sigma3=sigma3Orientation)
+        self._client.callFunction(self._fieldStressSourceService.SetVectorProperty, request)
+        

rs3/loadings/fieldStress/FieldStress.py

@@ -0,0 +1,38 @@
+import rs3.generatedFiles.FieldStressService_pb2_grpc as FieldStressService_pb2_grpc
+from rs3.properties._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3._client import Client
+from rs3.loadings.LoadingEnums import *
+from rs3.loadings.fieldStress.Constant import Constant
+from rs3.loadings.fieldStress.Gravity import Gravity
+from rs3.loadings.fieldStress.AdvancedConstant import AdvancedConstant
+from rs3.loadings.fieldStress.AdvancedGravity import AdvancedGravity
+
+class FieldStress(_ProxyObject):
+    """
+    Modify field stress parameters.
+
+    Attributes:
+        Constant (Constant): Reference object for modifying property.
+        Gravity (Gravity): Reference object for modifying property.
+        AdvancedConstant (AdvancedConstant): Reference object for modifying property.
+        AdvancedGravity (AdvancedGravity): Reference object for modifying property.
+
+    Examples:
+        See :ref:`field_stress_example`.
+
+    """
+    def __init__(self, client : Client, projectID : str):
+        super().__init__(client, projectID)
+        self._fieldStressService = FieldStressService_pb2_grpc.FieldStressServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, projectID, self._fieldStressService)
+        self.Constant = Constant(client, projectID)
+        self.Gravity = Gravity(client, projectID)
+        self.AdvancedConstant = AdvancedConstant(client, projectID)
+        self.AdvancedGravity = AdvancedGravity(client, projectID)
+
+    def getType(self) -> FieldStressType:
+        return self._propertyAccessor.getEnumValue("StressType", FieldStressType)
+
+    def setType(self, fieldStressType : FieldStressType):
+        self._propertyAccessor.setEnumValue("StressType", fieldStressType.value)

rs3/loadings/fieldStress/Gravity.py

@@ -0,0 +1,206 @@
+# 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 GravityBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getUseActualGroundSurface(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseActualGroundSurface")
+    def setUseActualGroundSurface(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseActualGroundSurface", value)
+    def getGroundSurfaceElevation(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("GroundSurfaceElevation")
+    def setGroundSurfaceElevation(self, value: float):
+        self._propertyAccessor.setDoubleProperty("GroundSurfaceElevation", value)
+    def getOverburdenUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("OverburdenUnitWeight")
+    def setOverburdenUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("OverburdenUnitWeight", value)
+    def getUseEffectiveStressRatio(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseEffectiveStressRatio")
+    def setUseEffectiveStressRatio(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseEffectiveStressRatio", value)
+    def getUseNonlinearVariableStressRatio(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseNonlinearVariableStressRatio")
+    def setUseNonlinearVariableStressRatio(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseNonlinearVariableStressRatio", value)
+    def getK0Condition(self) -> bool:
+        return self._propertyAccessor.getBoolValue("K0Condition")
+    def setK0Condition(self, value: bool):
+        self._propertyAccessor.setBoolValue("K0Condition", value)
+    def getSigmaH1K1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH1K1")
+    def setSigmaH1K1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH1K1", value)
+    def getSigmaH1K1a(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH1K1a")
+    def setSigmaH1K1a(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH1K1a", value)
+    def getSigmaH1K1b(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH1K1b")
+    def setSigmaH1K1b(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH1K1b", value)
+    def getSigmaH1K1c(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH1K1c")
+    def setSigmaH1K1c(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH1K1c", value)
+    def getSigmaH1LockedIn(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH1LockedIn")
+    def setSigmaH1LockedIn(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH1LockedIn", value)
+    def getSigmaH2K2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH2K2")
+    def setSigmaH2K2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH2K2", value)
+    def getSigmaH2K2a(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH2K2a")
+    def setSigmaH2K2a(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH2K2a", value)
+    def getSigmaH2K2b(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH2K2b")
+    def setSigmaH2K2b(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH2K2b", value)
+    def getSigmaH2K2c(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH2K2c")
+    def setSigmaH2K2c(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH2K2c", value)
+    def getSigmaH2LockedIn(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SigmaH2LockedIn")
+    def setSigmaH2LockedIn(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SigmaH2LockedIn", value)
+    def getProperties(self):
+        return {
+            "UseActualGroundSurface": self.getUseActualGroundSurface(),
+            "GroundSurfaceElevation": self.getGroundSurfaceElevation(),
+            "OverburdenUnitWeight": self.getOverburdenUnitWeight(),
+            "UseEffectiveStressRatio": self.getUseEffectiveStressRatio(),
+            "UseNonlinearVariableStressRatio": self.getUseNonlinearVariableStressRatio(),
+            "K0Condition": self.getK0Condition(),
+            "SigmaH1K1": self.getSigmaH1K1(),
+            "SigmaH1K1a": self.getSigmaH1K1a(),
+            "SigmaH1K1b": self.getSigmaH1K1b(),
+            "SigmaH1K1c": self.getSigmaH1K1c(),
+            "SigmaH1LockedIn": self.getSigmaH1LockedIn(),
+            "SigmaH2K2": self.getSigmaH2K2(),
+            "SigmaH2K2a": self.getSigmaH2K2a(),
+            "SigmaH2K2b": self.getSigmaH2K2b(),
+            "SigmaH2K2c": self.getSigmaH2K2c(),
+            "SigmaH2LockedIn": self.getSigmaH2LockedIn(),
+        }
+    def setProperties(self, UseActualGroundSurface: bool = None, GroundSurfaceElevation: float = None, OverburdenUnitWeight: float = None, UseEffectiveStressRatio: bool = None, UseNonlinearVariableStressRatio: bool = None, K0Condition: bool = None, SigmaH1K1: float = None, SigmaH1K1a: float = None, SigmaH1K1b: float = None, SigmaH1K1c: float = None, SigmaH1LockedIn: float = None, SigmaH2K2: float = None, SigmaH2K2a: float = None, SigmaH2K2b: float = None, SigmaH2K2c: float = None, SigmaH2LockedIn: float = None):
+        if UseActualGroundSurface is not None:
+            self.setUseActualGroundSurface(UseActualGroundSurface)
+        if GroundSurfaceElevation is not None:
+            self.setGroundSurfaceElevation(GroundSurfaceElevation)
+        if OverburdenUnitWeight is not None:
+            self.setOverburdenUnitWeight(OverburdenUnitWeight)
+        if UseEffectiveStressRatio is not None:
+            self.setUseEffectiveStressRatio(UseEffectiveStressRatio)
+        if UseNonlinearVariableStressRatio is not None:
+            self.setUseNonlinearVariableStressRatio(UseNonlinearVariableStressRatio)
+        if K0Condition is not None:
+            self.setK0Condition(K0Condition)
+        if SigmaH1K1 is not None:
+            self.setSigmaH1K1(SigmaH1K1)
+        if SigmaH1K1a is not None:
+            self.setSigmaH1K1a(SigmaH1K1a)
+        if SigmaH1K1b is not None:
+            self.setSigmaH1K1b(SigmaH1K1b)
+        if SigmaH1K1c is not None:
+            self.setSigmaH1K1c(SigmaH1K1c)
+        if SigmaH1LockedIn is not None:
+            self.setSigmaH1LockedIn(SigmaH1LockedIn)
+        if SigmaH2K2 is not None:
+            self.setSigmaH2K2(SigmaH2K2)
+        if SigmaH2K2a is not None:
+            self.setSigmaH2K2a(SigmaH2K2a)
+        if SigmaH2K2b is not None:
+            self.setSigmaH2K2b(SigmaH2K2b)
+        if SigmaH2K2c is not None:
+            self.setSigmaH2K2c(SigmaH2K2c)
+        if SigmaH2LockedIn is not None:
+            self.setSigmaH2LockedIn(SigmaH2LockedIn)
+
+################ Code below this line will not be overridden ################
+from rs3.loadings.LoadingEnums import *
+from rs3.CommonEnums import *
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+import rs3.generatedFiles.FieldStressSourceService_pb2 as FieldStressSourceService_pb2
+import rs3.generatedFiles.FieldStressSourceService_pb2_grpc as FieldStressSourceService_pb2_grpc
+class Gravity(GravityBase):
+    """
+	Examples:
+		See :ref:`field_stress_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._fieldStressSourceService = FieldStressSourceService_pb2_grpc.FieldStressSourceServiceStub(self._client.channel)
+        
+    def getOrientationType(self) -> LinearDirectionType:
+        request = FieldStressSourceService_pb2.GetDirectionTypeRequest(objectId=self._objectId)
+        response : FieldStressSourceService_pb2.GetDirectionTypeResponse = self._client.callFunction(self._fieldStressSourceService.GetDirectionType, request)
+        return LinearDirectionType(response.value)
+    
+    def setOrientationType(self, directionType : LinearDirectionType):
+        request = FieldStressSourceService_pb2.SetDirectionTypeRequest(objectId=self._objectId, value=directionType.value)
+        self._client.callFunction(self._fieldStressSourceService.SetDirectionType, request)
+    
+    def getTrendPlungeOrientation(self) -> tuple[float, float, float]:
+        """
+        Retrieves the trend and plunge orientations of the vertical and horizontal stress axes.
+
+        Returns:
+            tuple[float, float, float]: A tuple containing:
+                - vertical stress trend angle in degrees
+                - vertical stress plunge angle in degrees
+                - horizontal stress trend angle in degrees
+        """
+        request = FieldStressSourceService_pb2.GetTrendPlungePropertyRequest(objectId=self._objectId)
+        response : FieldStressSourceService_pb2.GetTrendPlungePropertyResponse = self._client.callFunction(self._fieldStressSourceService.GetTrendPlungeProperty, request)
+        return response.sigma1.trend, response.sigma1.plunge, response.sigma3.trend
+    
+    def setTrendPlungeOrientation(self, verticalStressTrend : float = 0, verticalStressPlunge : float = 90, horizontalStressTrend : float = 90):
+        """
+        Sets the trend and plunge orientations of the vertical and horizontal stress axes.
+
+        Args:
+            verticalStressTrend (float): Trend angle of the vertical stress in degrees. Default is 0.
+            verticalStressPlunge (float): Plunge angle of the vertical stress in degrees. Default is 90. The valid data range is (0, 90].
+            horizontalStressTrend (float): Trend angle of the horizontal stress in degrees. Default is 90.
+        """
+        verticalStressOrientation = CommonMessages_pb2.LinearDirection(trend=verticalStressTrend, plunge=verticalStressPlunge)
+        horizontalStressOrientation = CommonMessages_pb2.LinearDirection(trend=horizontalStressTrend, plunge=0)
+        request = FieldStressSourceService_pb2.SetTrendPlungePropertyRequest(objectId=self._objectId, sigma1=verticalStressOrientation, sigma3=horizontalStressOrientation)
+        self._client.callFunction(self._fieldStressSourceService.SetTrendPlungeProperty, request)
+        
+    def getVectorOrientation(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+        """
+        Retrieves the vectors representing the directions of the horizontal and vertical stress axes.
+
+        Returns:
+            tuple[tuple[float, float, float], tuple[float, float, float]]:
+                - First tuple: horizontal stress 1 vector (x, y, z)
+                - Second tuple: vertical stress vector (x, y, z)
+        """
+        request = FieldStressSourceService_pb2.GetVectorPropertyRequest(objectId=self._objectId)
+        response : FieldStressSourceService_pb2.GetVectorPropertyResponse = self._client.callFunction(self._fieldStressSourceService.GetVectorProperty, request)
+        return [(response.sigma3.x, response.sigma3.y, response.sigma3.z), (response.sigma1.x, response.sigma1.y, response.sigma1.z)]
+    
+    def setVectorOrientation(self, horizontalStress1 = tuple[float, float, float], verticalStress = tuple[float, float, float]):
+        """
+        Sets the orientation vectors for the horizontal and vertical stress axes.
+
+        Args:
+            horizontalStress1 (tuple[float, float, float]): 3D vector representing horizontal stress 1.
+            verticalStress (tuple[float, float, float]): 3D vector representing vertical stress.
+
+        Note:
+            The horizontal and vertical stress vectors must be orthogonal.
+        """
+        verticalStressOrientation = CommonMessages_pb2.Point3D(x=verticalStress[0], y=verticalStress[1], z=verticalStress[2])
+        horizontalStressOrientation = CommonMessages_pb2.Point3D(x=horizontalStress1[0], y=horizontalStress1[1], z=horizontalStress1[2])
+        request = FieldStressSourceService_pb2.SetVectorPropertyRequest(objectId=self._objectId, sigma1=verticalStressOrientation, sigma3=horizontalStressOrientation)
+        self._client.callFunction(self._fieldStressSourceService.SetVectorProperty, request)

rs3/loadings/fieldStress/_PropertyAccessor.py

@@ -0,0 +1,41 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.FieldStressSourceService_pb2_grpc as FieldStressSourceService_pb2_grpc
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+import rs3.generatedFiles.FieldStressSourceService_pb2 as FieldStressSourceService_pb2
+from rs3._client import Client
+class PropertyAccessor(BasePropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, FieldStressSourceService_pb2_grpc.FieldStressSourceServiceStub(client.channel))
+        
+class AdvancedPropertyAccessor(BasePropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, FieldStressSourceService_pb2_grpc.FieldStressSourceServiceStub(client.channel))
+        self._fieldStressSourceService = FieldStressSourceService_pb2_grpc.FieldStressSourceServiceStub(client.channel)
+        self.projectId = objectId
+        
+    def _setProperty(self, materialName : str, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = FieldStressSourceService_pb2.SetMaterialPropertyRequest(objectId=self.projectId, 
+                                                                          materialName=materialName,
+                                                                          propertyName=propertyName,
+                                                                          value=value)
+        self._client.callFunction(self._fieldStressSourceService.SetMaterialProperty, request)
+        
+    def _getProperty(self, materialName : str, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = FieldStressSourceService_pb2.GetMaterialPropertyRequest(objectId=self.projectId, 
+                                                                          materialName=materialName, 
+                                                                          propertyName=propertyName)
+        response : FieldStressSourceService_pb2.GetMaterialPropertyResponse = self._client.callFunction(self._fieldStressSourceService.GetMaterialProperty, request)
+        return response.value
+    
+    def getDoubleProperty(self, materialName : str, propertyName : str) -> float:
+        return self._getProperty(materialName, propertyName).doubleValue
+
+    def setDoubleProperty(self, materialName : str, propertyName : str, value : float):
+        self._setProperty(materialName, propertyName, CommonMessages_pb2.PropertyValue(doubleValue=value))
+    
+    def getBoolValue(self, materialName : str, propertyName : str) -> bool:
+        return self._getProperty(materialName, propertyName).boolValue
+
+    def setBoolValue(self, materialName : str, propertyName : str, value: bool):
+        self._setProperty(materialName, propertyName, CommonMessages_pb2.PropertyValue(boolValue=value))
+

rs3/mesh/Graded.py

@@ -0,0 +1,59 @@
+# 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 GradedBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getMinGradedElementSize(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("MinGradedElementSize")
+    def setMinGradedElementSize(self, value: float):
+        self._propertyAccessor.setDoubleProperty("MinGradedElementSize", value)
+    def getMaxGradedElementSize(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("MaxGradedElementSize")
+    def setMaxGradedElementSize(self, value: float):
+        self._propertyAccessor.setDoubleProperty("MaxGradedElementSize", value)
+    def getOneDGradation(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("OneDGradation")
+    def setOneDGradation(self, value: float):
+        self._propertyAccessor.setDoubleProperty("OneDGradation", value)
+    def getTwoDGradation(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TwoDGradation")
+    def setTwoDGradation(self, value: float):
+        self._propertyAccessor.setDoubleProperty("TwoDGradation", value)
+    def getThreeDGradation(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ThreeDGradation")
+    def setThreeDGradation(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ThreeDGradation", value)
+    def getProperties(self):
+        return {
+            "MinGradedElementSize": self.getMinGradedElementSize(),
+            "MaxGradedElementSize": self.getMaxGradedElementSize(),
+            "OneDGradation": self.getOneDGradation(),
+            "TwoDGradation": self.getTwoDGradation(),
+            "ThreeDGradation": self.getThreeDGradation(),
+        }
+    def setProperties(self, MinGradedElementSize: float = None, MaxGradedElementSize: float = None, OneDGradation: float = None, TwoDGradation: float = None, ThreeDGradation: float = None):
+        if MinGradedElementSize is not None:
+            self.setMinGradedElementSize(MinGradedElementSize)
+        if MaxGradedElementSize is not None:
+            self.setMaxGradedElementSize(MaxGradedElementSize)
+        if OneDGradation is not None:
+            self.setOneDGradation(OneDGradation)
+        if TwoDGradation is not None:
+            self.setTwoDGradation(TwoDGradation)
+        if ThreeDGradation is not None:
+            self.setThreeDGradation(ThreeDGradation)
+
+################ Code below this line will not be overridden ################
+class Graded(GradedBase):
+    """
+	Examples:
+		See :ref:`mesh_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        
+    

rs3/mesh/Mesh.py

@@ -0,0 +1,50 @@
+import rs3.generatedFiles.MeshSettingsService_pb2_grpc as MeshSettingsService_pb2_grpc
+import rs3.generatedFiles.MeshSettingsService_pb2 as MeshSettingsService_pb2
+from rs3.properties._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3._client import Client
+from rs3.mesh.MeshEnums import *
+from rs3.mesh.Graded import Graded
+from rs3.mesh.Uniform import Uniform
+
+class Mesh(_ProxyObject):
+    """
+    Edit the mesh settings and generate the mesh.
+
+    Attributes:
+        Graded (Graded): Reference object for modifying property.
+        Uniform (Uniform): Reference object for modifying property.
+
+    Examples:
+        See :ref:`mesh_example`.
+
+    """
+    def __init__(self, client : Client, projectID : str):
+        super().__init__(client, projectID)
+        self._meshSettingsService = MeshSettingsService_pb2_grpc.MeshSettingsServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, projectID, self._meshSettingsService)
+        self.Graded = Graded(client, projectID)
+        self.Uniform = Uniform(client, projectID)
+
+    def getElementType(self) -> MeshElementType:
+        """
+        Get mesh element type set in the model.
+        """
+        return self._propertyAccessor.getEnumValue("ElementType", MeshElementType)
+    def setElementType(self, elementType : MeshElementType):
+        """
+        Set 4-noded, 10-noded or hybrid tetrahedral elements.
+        """
+        self._propertyAccessor.setEnumValue("ElementType", elementType.value)
+
+    def getMeshGradation(self) -> MeshGradation:
+        return self._propertyAccessor.getEnumValue("MeshGradation", MeshGradation)
+    def setMeshGradation(self, meshGradation : MeshGradation):
+        self._propertyAccessor.setEnumValue("MeshGradation", meshGradation.value)
+
+    def mesh(self):
+        """
+        Generate finite element mesh for this model. 
+        """
+        request = MeshSettingsService_pb2.MeshRequest(projectId=self._objectId)
+        self._client.callFunction(self._meshSettingsService.Mesh, request)

rs3/mesh/MeshEnums.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class MeshElementType(Enum):
+    MESH_4_NODED_TETRAHEDRA = "TET4"
+    MESH_10_NODED_TETRAHEDRA = "TET10"
+    MESH_MIXED_4_NODED_AND_10_NODED_TETRAHEDRA = "TET4AND10"
+    
+class MeshGradation(Enum):
+    GRADED = "GRADED"
+    UNIFORM = "UNIFORM"
+    
+class MeshDensity(Enum):
+    LOW = "LOW"
+    MEDIUM = "MEDIUM"
+    HIGH = "HIGH"
+    USER_DEFINED = "USERDEFINED"

rs3/mesh/Uniform.py

@@ -0,0 +1,35 @@
+# 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 UniformBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getUniformMeshElementSize(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("UniformMeshElementSize")
+    def setUniformMeshElementSize(self, value: float):
+        self._propertyAccessor.setDoubleProperty("UniformMeshElementSize", value)
+    def getProperties(self):
+        return {
+            "UniformMeshElementSize": self.getUniformMeshElementSize(),
+        }
+    def setProperties(self, UniformMeshElementSize: float = None):
+        if UniformMeshElementSize is not None:
+            self.setUniformMeshElementSize(UniformMeshElementSize)
+
+################ Code below this line will not be overridden ################
+from rs3.mesh.MeshEnums import *
+class Uniform(UniformBase):
+    """
+	Examples:
+		See :ref:`mesh_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        
+    def getMeshDensity(self) -> MeshDensity:
+        return self._propertyAccessor.getEnumValue("MeshDensity", MeshDensity)
+    def setMeshDensity(self, meshDensity : MeshDensity):
+        self._propertyAccessor.setEnumValue("MeshDensity", meshDensity.value)

rs3/mesh/_PropertyAccessor.py

@@ -0,0 +1,10 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.MeshSettingsService_pb2_grpc as MeshSettingsService_pb2_grpc
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+import rs3.generatedFiles.MeshSettingsService_pb2 as MeshSettingsService_pb2
+from rs3._client import Client
+class PropertyAccessor(BasePropertyAccessor):
+    def __init__(self, client : Client, objectId : str):
+        super().__init__(client, objectId, MeshSettingsService_pb2_grpc.MeshSettingsServiceStub(client.channel))
+        
+