RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/material/Material.py

@@ -0,0 +1,74 @@
+import rs3.generatedFiles.MaterialDataService_pb2_grpc as MaterialDataService_pb2_grpc
+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._PropertyAccessor import PropertyAccessor
+from rs3.properties.material.initialConditions.InitialConditions import InitialConditions
+from rs3.properties.material.constitutiveModel.ConstitutiveModel import ConstitutiveModel
+from rs3.properties.material.hydraulic.Hydraulic import Hydraulic
+from rs3.properties.material.datum.Datum import Datum
+from rs3.properties.material.stageFactors.StageFactors import StageFactors
+from rs3.ColorPicker import ColorPicker
+
+class MaterialProperty(_ProxyObject):
+    """
+    Define material properties.
+    
+    Attributes:
+        Standard (Standard): Reference object for modifying property.
+        Geosynthetic (Geosynthetic): Reference object for modifying property.
+        ReinforcedConcrete (ReinforcedConcrete): Reference object for modifying property.
+    
+    Examples:
+    - :ref:`material_initial_conditions_example`.
+    - :ref:`material_constitutive_models_example`.
+    - :ref:`material_hydraulic_example`.
+    - :ref:`material_datum_example`.
+    - :ref:`material_stage_factors_example`.
+    """
+    def __init__(self, client : Client, materialID : str):
+        super().__init__(client, materialID)
+        self._materialDataService = MaterialDataService_pb2_grpc.MaterialDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, materialID, self._materialDataService)
+        self.InitialConditions = InitialConditions(client, materialID)
+        self.ConstitutiveModel = ConstitutiveModel(client, materialID)
+        self.Hydraulic = Hydraulic(client, materialID)
+        self.Datum = Datum(client, materialID)
+        self.StageFactors = StageFactors(client, materialID)
+
+    def getMaterialName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setMaterialName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+    def setMaterialColor(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._materialDataService.SetColorProperty, request)
+    def getMaterialColor(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._materialDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha

rs3/properties/material/constitutiveModel/AnisotropicLinear.py

@@ -0,0 +1,149 @@
+# 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 AnisotropicLinearBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getUseTensileStrength(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseTensile")
+    def setUseTensileStrength(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseTensile", value)
+    def getCohesion1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Cohesion1")
+    def setCohesion1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Cohesion1", value)
+    def getCohesion2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Cohesion2")
+    def setCohesion2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Cohesion2", value)
+    def getFrictionAngle1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngle1")
+    def setFrictionAngle1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngle1", value)
+    def getFrictionAngle2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngle2")
+    def setFrictionAngle2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngle2", value)
+    def getResidualCohesion1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Cohesion1Residual")
+    def setResidualCohesion1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Cohesion1Residual", value)
+    def getResidualCohesion2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Cohesion2Residual")
+    def setResidualCohesion2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Cohesion2Residual", value)
+    def getResidualFrictionAngle1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngle1Residual")
+    def setResidualFrictionAngle1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngle1Residual", value)
+    def getResidualFrictionAngle2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngle2Residual")
+    def setResidualFrictionAngle2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngle2Residual", value)
+    def getDilationAngle1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("DilationAngle1")
+    def setDilationAngle1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("DilationAngle1", value)
+    def getDilationAngle2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("DilationAngle2")
+    def setDilationAngle2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("DilationAngle2", value)
+    def getResidualTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TensileStrengthResidual")
+    def setResidualTensileStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("TensileStrengthResidual", value)
+    def getA1Parameter(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("A1Parameter")
+    def setA1Parameter(self, value: float):
+        self._propertyAccessor.setDoubleProperty("A1Parameter", value)
+    def getB1Parameter(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("B1Parameter")
+    def setB1Parameter(self, value: float):
+        self._propertyAccessor.setDoubleProperty("B1Parameter", value)
+    def getTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PeakTensileStrength")
+    def setTensileStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PeakTensileStrength", value)
+    def getProperties(self):
+        return {
+            "UseTensileStrength": self.getUseTensileStrength(),
+            "Cohesion1": self.getCohesion1(),
+            "Cohesion2": self.getCohesion2(),
+            "FrictionAngle1": self.getFrictionAngle1(),
+            "FrictionAngle2": self.getFrictionAngle2(),
+            "ResidualCohesion1": self.getResidualCohesion1(),
+            "ResidualCohesion2": self.getResidualCohesion2(),
+            "ResidualFrictionAngle1": self.getResidualFrictionAngle1(),
+            "ResidualFrictionAngle2": self.getResidualFrictionAngle2(),
+            "DilationAngle1": self.getDilationAngle1(),
+            "DilationAngle2": self.getDilationAngle2(),
+            "ResidualTensileStrength": self.getResidualTensileStrength(),
+            "A1Parameter": self.getA1Parameter(),
+            "B1Parameter": self.getB1Parameter(),
+            "TensileStrength": self.getTensileStrength(),
+        }
+    def setProperties(self, UseTensileStrength: bool = None, Cohesion1: float = None, Cohesion2: float = None, FrictionAngle1: float = None, FrictionAngle2: float = None, ResidualCohesion1: float = None, ResidualCohesion2: float = None, ResidualFrictionAngle1: float = None, ResidualFrictionAngle2: float = None, DilationAngle1: float = None, DilationAngle2: float = None, ResidualTensileStrength: float = None, A1Parameter: float = None, B1Parameter: float = None, TensileStrength: float = None):
+        if UseTensileStrength is not None:
+            self.setUseTensileStrength(UseTensileStrength)
+        if Cohesion1 is not None:
+            self.setCohesion1(Cohesion1)
+        if Cohesion2 is not None:
+            self.setCohesion2(Cohesion2)
+        if FrictionAngle1 is not None:
+            self.setFrictionAngle1(FrictionAngle1)
+        if FrictionAngle2 is not None:
+            self.setFrictionAngle2(FrictionAngle2)
+        if ResidualCohesion1 is not None:
+            self.setResidualCohesion1(ResidualCohesion1)
+        if ResidualCohesion2 is not None:
+            self.setResidualCohesion2(ResidualCohesion2)
+        if ResidualFrictionAngle1 is not None:
+            self.setResidualFrictionAngle1(ResidualFrictionAngle1)
+        if ResidualFrictionAngle2 is not None:
+            self.setResidualFrictionAngle2(ResidualFrictionAngle2)
+        if DilationAngle1 is not None:
+            self.setDilationAngle1(DilationAngle1)
+        if DilationAngle2 is not None:
+            self.setDilationAngle2(DilationAngle2)
+        if ResidualTensileStrength is not None:
+            self.setResidualTensileStrength(ResidualTensileStrength)
+        if A1Parameter is not None:
+            self.setA1Parameter(A1Parameter)
+        if B1Parameter is not None:
+            self.setB1Parameter(B1Parameter)
+        if TensileStrength is not None:
+            self.setTensileStrength(TensileStrength)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.material.constitutiveModel.stiffness.LinearIsotropic import LinearIsotropic
+from rs3.properties.material.constitutiveModel.stiffness.TransverselyIsotropic import TransverselyIsotropic
+from rs3.properties.material.constitutiveModel.stiffness.Orthotropic import Orthotropic
+from rs3.properties.material.constitutiveModel.stiffness.DuncanChangHyperbolic import DuncanChangHyperbolic
+from rs3.properties.material.constitutiveModel.stiffness.NonlinearIsotropic import NonlinearIsotropic
+from rs3.properties.material.constitutiveModel.AnisotropicLinearPlanarBase import AnisotropicLinearPlanarBase
+from rs3.properties.material.constitutiveModel.BaseConstitutiveModel import BaseConstitutiveModel
+from rs3.properties.material.constitutiveModel.UnsaturatedZoneCalculations import UnsaturatedZoneCalculations
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.MaterialDataService_pb2_grpc as MaterialDataService_pb2_grpc
+from rs3.properties.PropertyEnums import *
+class AnisotropicLinear(AnisotropicLinearBase, AnisotropicLinearPlanarBase, BaseConstitutiveModel):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stiffnessPropertyAccessor = BasePropertyAccessor(client, id, MaterialDataService_pb2_grpc.MaterialDataServiceStub(self._client.channel))
+        self.LinearIsotropicStiffness = LinearIsotropic(client, id)
+        self.TransverselyIsotropicStiffness = TransverselyIsotropic(client, id)
+        self.OrthotropicStiffness = Orthotropic(client, id)
+        self.DuncanChangHyperbolicStiffness = DuncanChangHyperbolic(client, id)
+        self.NonlinearIsotropicStiffness = NonlinearIsotropic(client, id)
+        self.UnsaturatedZoneCalculations = UnsaturatedZoneCalculations(client, id)
+        
+    def getAnisotropyDefinition(self) -> AnisotropyDefinitionType:
+        return self._propertyAccessor.getEnumValue("AnisotropyDefinition", AnisotropyDefinitionType)
+    def setAnisotropyDefinition(self, AnisotropyDefinition: AnisotropyDefinitionType):
+        return self._propertyAccessor.setEnumValue("AnisotropyDefinition", AnisotropyDefinition.value)
+    
+    
+    

rs3/properties/material/constitutiveModel/AnisotropicLinearPlanarBase.py

@@ -0,0 +1,72 @@
+from rs3._proxyObject import _ProxyObject
+from rs3._client import Client
+from ._PropertyAccessor import MaterialStrengthAnisotropicLinearPlanarAccessor
+import rs3.generatedFiles.MaterialStrengthService_pb2_grpc as MaterialStrengthService_pb2_grpc
+import rs3.generatedFiles.MaterialStrengthService_pb2 as MaterialStrengthService_pb2
+from rs3.properties.PropertyEnums import *
+
+class AnisotropicLinearPlanarBase(_ProxyObject):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stub = MaterialStrengthService_pb2_grpc.MaterialStrengthServiceStub(client.channel)
+        self._anisotropicLinearPropertyAccessor = MaterialStrengthAnisotropicLinearPlanarAccessor(client, id)
+        
+    def getPlanarDirectionDefinedBy(self) -> PlanarDirectionType:
+        return self._anisotropicLinearPropertyAccessor.getEnumValue("DirectionType", PlanarDirectionType)
+    def setPlanarDirectionDefinedBy(self, planarDirectionType: PlanarDirectionType):
+        return self._anisotropicLinearPropertyAccessor.setEnumValue("DirectionType", planarDirectionType.value)
+    
+    def getNormalVector(self) -> tuple[float, float, float]:
+        """
+        Get the normal vector.
+
+        Returns
+        -------
+        tuple[float, float, float]
+            The normal direction defined as a 3D vector (nx, ny, nz),
+            representing the X, Y, and Z components in the global
+            coordinate system.
+        """
+        return self._anisotropicLinearPropertyAccessor.getVector3DValue("NormalDirection")
+    def setNormalVector(self, value : tuple[float, float, float]):
+        """
+        Set the normal vector.
+
+        Parameters
+        ----------
+        value : tuple[float, float, float]
+            A 3D vector (nx, ny, nz) representing the normal direction
+            in the global coordinate system.
+        """
+        self._anisotropicLinearPropertyAccessor.setVector3DValue("NormalDirection", value)
+        
+    def getDip(self) -> float:
+        return self._anisotropicLinearPropertyAccessor.getDoubleProperty("Dip")
+    def setDip(self, value: float):
+        self._anisotropicLinearPropertyAccessor.setDoubleProperty("Dip", value)
+        
+    def getDipDirection(self) -> float:
+        return self._anisotropicLinearPropertyAccessor.getDoubleProperty("DipDirection")
+    def setDipDirection(self, value: float):
+        self._anisotropicLinearPropertyAccessor.setDoubleProperty("DipDirection", value)
+    
+    def getSurface(self) -> str:
+        """
+        Get defined anisotropic surface for this material.
+        
+        Note:
+            At least one anisotropic surface needs to be defined to get anisotropy by surface. 
+        """
+        request = MaterialStrengthService_pb2.GetAnisotropicSurfacePropertyRequest(objectId=self._objectId)
+        response : MaterialStrengthService_pb2.GetAnisotropicSurfacePropertyResponse = self._client.callFunction(self._stub.GetAnisotropicSurfaceProperty, request)
+        return response.surfaceName
+    def setSurface(self, value: str):
+        """
+        Set anisotropic surface for this material.
+        
+        At least one anisotropic surface needs to be defined to define anisotropy by surface. 
+        See Materials > Add Anisotropic Surface or Add Anisotropic Surface by Location for setting 
+        anisotropic surfaces.
+        """
+        request = MaterialStrengthService_pb2.SetAnisotropicSurfacePropertyRequest(objectId=self._objectId, surfaceName=value)
+        self._client.callFunction(self._stub.SetAnisotropicSurfaceProperty, request)

rs3/properties/material/constitutiveModel/BarcelonaBasic.py

@@ -0,0 +1,158 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import StiffnessPropertyAccessor, StrengthPropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+class BarcelonaBasicBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stiffnessPropertyAccessor = StiffnessPropertyAccessor(client, id)
+        self._strengthPropertyAccessor = StrengthPropertyAccessor(client, id)
+    def getShearModulus(self) -> float:
+        return self._stiffnessPropertyAccessor.getDoubleProperty("ShearModulus")
+    def setShearModulus(self, value: float):
+        self._stiffnessPropertyAccessor.setDoubleProperty("ShearModulus", value)
+    def getPoissonsRatio(self) -> float:
+        return self._stiffnessPropertyAccessor.getDoubleProperty("PoissonsRatio")
+    def setPoissonsRatio(self, value: float):
+        self._stiffnessPropertyAccessor.setDoubleProperty("PoissonsRatio", value)
+    def getSlopeOfCriticalStateLines(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("SlopeCritStateLines")
+    def setSlopeOfCriticalStateLines(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("SlopeCritStateLines", value)
+    def getIncludeTheEffectOfLodesAngle(self) -> bool:
+        return self._strengthPropertyAccessor.getBoolValue("IncludeLodesAngle")
+    def setIncludeTheEffectOfLodesAngle(self, value: bool):
+        self._strengthPropertyAccessor.setBoolValue("IncludeLodesAngle", value)
+    def getLambda(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("Lambda")
+    def setLambda(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("Lambda", value)
+    def getKappa(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("Kappa")
+    def setKappa(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("Kappa", value)
+    def getSpecificVolumeAtUnitPressure(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("SpecificVolAtUnitPressure")
+    def setSpecificVolumeAtUnitPressure(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("SpecificVolAtUnitPressure", value)
+    def getOverConsolidationRatio(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("OverConsolidationratio")
+    def setOverConsolidationRatio(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("OverConsolidationratio", value)
+    def getPreconsolidationPressure(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("PreConsolidationPressure")
+    def setPreconsolidationPressure(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("PreConsolidationPressure", value)
+    def getAlfaFactor(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("AlfaFactor")
+    def setAlfaFactor(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("AlfaFactor", value)
+    def getMinimumBulkModulus(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("MinBulkModulus")
+    def setMinimumBulkModulus(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("MinBulkModulus", value)
+    def getKTensionSuction(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("KTensionSuction")
+    def setKTensionSuction(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("KTensionSuction", value)
+    def getKappaSuction(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("KappaSuction")
+    def setKappaSuction(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("KappaSuction", value)
+    def getRParameter(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("RParameter")
+    def setRParameter(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("RParameter", value)
+    def getBetaParameter(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("BetaParameter")
+    def setBetaParameter(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("BetaParameter", value)
+    def getReferenceMeanStress(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("RefMeanStress")
+    def setReferenceMeanStress(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("RefMeanStress", value)
+    def getAtmosphericPressure(self) -> float:
+        return self._strengthPropertyAccessor.getDoubleProperty("AtmosphericPressure")
+    def setAtmosphericPressure(self, value: float):
+        self._strengthPropertyAccessor.setDoubleProperty("AtmosphericPressure", value)
+    def getAutoCalculateAlphaFactor(self) -> bool:
+        return self._strengthPropertyAccessor.getBoolValue("AutoCalcAlfaFactor")
+    def setAutoCalculateAlphaFactor(self, value: bool):
+        self._strengthPropertyAccessor.setBoolValue("AutoCalcAlfaFactor", value)
+    def getProperties(self):
+        return {
+            "ShearModulus": self.getShearModulus(),
+            "PoissonsRatio": self.getPoissonsRatio(),
+            "SlopeOfCriticalStateLines": self.getSlopeOfCriticalStateLines(),
+            "IncludeTheEffectOfLodesAngle": self.getIncludeTheEffectOfLodesAngle(),
+            "Lambda": self.getLambda(),
+            "Kappa": self.getKappa(),
+            "SpecificVolumeAtUnitPressure": self.getSpecificVolumeAtUnitPressure(),
+            "OverConsolidationRatio": self.getOverConsolidationRatio(),
+            "PreconsolidationPressure": self.getPreconsolidationPressure(),
+            "AlfaFactor": self.getAlfaFactor(),
+            "MinimumBulkModulus": self.getMinimumBulkModulus(),
+            "KTensionSuction": self.getKTensionSuction(),
+            "KappaSuction": self.getKappaSuction(),
+            "RParameter": self.getRParameter(),
+            "BetaParameter": self.getBetaParameter(),
+            "ReferenceMeanStress": self.getReferenceMeanStress(),
+            "AtmosphericPressure": self.getAtmosphericPressure(),
+            "AutoCalculateAlphaFactor": self.getAutoCalculateAlphaFactor(),
+        }
+    def setProperties(self, ShearModulus: float = None, PoissonsRatio: float = None, SlopeOfCriticalStateLines: float = None, IncludeTheEffectOfLodesAngle: bool = None, Lambda: float = None, Kappa: float = None, SpecificVolumeAtUnitPressure: float = None, OverConsolidationRatio: float = None, PreconsolidationPressure: float = None, AlfaFactor: float = None, MinimumBulkModulus: float = None, KTensionSuction: float = None, KappaSuction: float = None, RParameter: float = None, BetaParameter: float = None, ReferenceMeanStress: float = None, AtmosphericPressure: float = None, AutoCalculateAlphaFactor: bool = None):
+        if ShearModulus is not None:
+            self.setShearModulus(ShearModulus)
+        if PoissonsRatio is not None:
+            self.setPoissonsRatio(PoissonsRatio)
+        if SlopeOfCriticalStateLines is not None:
+            self.setSlopeOfCriticalStateLines(SlopeOfCriticalStateLines)
+        if IncludeTheEffectOfLodesAngle is not None:
+            self.setIncludeTheEffectOfLodesAngle(IncludeTheEffectOfLodesAngle)
+        if Lambda is not None:
+            self.setLambda(Lambda)
+        if Kappa is not None:
+            self.setKappa(Kappa)
+        if SpecificVolumeAtUnitPressure is not None:
+            self.setSpecificVolumeAtUnitPressure(SpecificVolumeAtUnitPressure)
+        if OverConsolidationRatio is not None:
+            self.setOverConsolidationRatio(OverConsolidationRatio)
+        if PreconsolidationPressure is not None:
+            self.setPreconsolidationPressure(PreconsolidationPressure)
+        if AlfaFactor is not None:
+            self.setAlfaFactor(AlfaFactor)
+        if MinimumBulkModulus is not None:
+            self.setMinimumBulkModulus(MinimumBulkModulus)
+        if KTensionSuction is not None:
+            self.setKTensionSuction(KTensionSuction)
+        if KappaSuction is not None:
+            self.setKappaSuction(KappaSuction)
+        if RParameter is not None:
+            self.setRParameter(RParameter)
+        if BetaParameter is not None:
+            self.setBetaParameter(BetaParameter)
+        if ReferenceMeanStress is not None:
+            self.setReferenceMeanStress(ReferenceMeanStress)
+        if AtmosphericPressure is not None:
+            self.setAtmosphericPressure(AtmosphericPressure)
+        if AutoCalculateAlphaFactor is not None:
+            self.setAutoCalculateAlphaFactor(AutoCalculateAlphaFactor)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.material.constitutiveModel.UnsaturatedZoneCalculations import UnsaturatedZoneCalculations
+from rs3.properties.PropertyEnums import *
+class BarcelonaBasic(BarcelonaBasicBase):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self.UnsaturatedZoneCalculations = UnsaturatedZoneCalculations(client, id)
+        
+    def getElasticParameters(self) -> ElasticParametersType:
+        return self._stiffnessPropertyAccessor.getEnumValue("ElasticParameters", ElasticParametersType)
+    def setElasticParameters(self, ElasticParameters: ElasticParametersType):
+        self._stiffnessPropertyAccessor.setEnumValue("ElasticParameters", ElasticParameters.value)
+        
+    def getInitialStateOfConsolidation(self) -> InitialStateOfConsolidationType:
+        return self._strengthPropertyAccessor.getEnumValue("InitialStateOfConsolidation", InitialStateOfConsolidationType)
+    def setInitialStateOfConsolidation(self, InitialStateOfConsolidation: InitialStateOfConsolidationType):
+        return self._strengthPropertyAccessor.setEnumValue("InitialStateOfConsolidation", InitialStateOfConsolidation.value)

rs3/properties/material/constitutiveModel/BartonBandis.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 BartonBandisBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getPhiR(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PhiR")
+    def setPhiR(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PhiR", value)
+    def getJRC(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("JRC")
+    def setJRC(self, value: float):
+        self._propertyAccessor.setDoubleProperty("JRC", value)
+    def getJCS(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("JCS")
+    def setJCS(self, value: float):
+        self._propertyAccessor.setDoubleProperty("JCS", value)
+    def getDilationAngle(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("DilationAngle")
+    def setDilationAngle(self, value: float):
+        self._propertyAccessor.setDoubleProperty("DilationAngle", value)
+    def getResidualStrength(self) -> bool:
+        return self._propertyAccessor.getBoolValue("ResidualStrength")
+    def setResidualStrength(self, value: bool):
+        self._propertyAccessor.setBoolValue("ResidualStrength", value)
+    def getApplySSRShearStrengthReduction(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseSSR")
+    def setApplySSRShearStrengthReduction(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseSSR", value)
+    def getProperties(self):
+        return {
+            "PhiR": self.getPhiR(),
+            "JRC": self.getJRC(),
+            "JCS": self.getJCS(),
+            "DilationAngle": self.getDilationAngle(),
+            "ResidualStrength": self.getResidualStrength(),
+            "ApplySSRShearStrengthReduction": self.getApplySSRShearStrengthReduction(),
+        }
+    def setProperties(self, PhiR: float = None, JRC: float = None, JCS: float = None, DilationAngle: float = None, ResidualStrength: bool = None, ApplySSRShearStrengthReduction: bool = None):
+        if PhiR is not None:
+            self.setPhiR(PhiR)
+        if JRC is not None:
+            self.setJRC(JRC)
+        if JCS is not None:
+            self.setJCS(JCS)
+        if DilationAngle is not None:
+            self.setDilationAngle(DilationAngle)
+        if ResidualStrength is not None:
+            self.setResidualStrength(ResidualStrength)
+        if ApplySSRShearStrengthReduction is not None:
+            self.setApplySSRShearStrengthReduction(ApplySSRShearStrengthReduction)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.material.constitutiveModel.stiffness.LinearIsotropic import LinearIsotropic
+from rs3.properties.material.constitutiveModel.stiffness.TransverselyIsotropic import TransverselyIsotropic
+from rs3.properties.material.constitutiveModel.stiffness.Orthotropic import Orthotropic
+from rs3.properties.material.constitutiveModel.stiffness.DuncanChangHyperbolic import DuncanChangHyperbolic
+from rs3.properties.material.constitutiveModel.stiffness.NonlinearIsotropic import NonlinearIsotropic
+from rs3.properties.material.constitutiveModel.BaseConstitutiveModel import BaseConstitutiveModel
+from rs3.properties.material.constitutiveModel.UnsaturatedZoneCalculations import UnsaturatedZoneCalculations
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.MaterialDataService_pb2_grpc as MaterialDataService_pb2_grpc
+from rs3.properties.PropertyEnums import *
+class BartonBandis(BartonBandisBase, BaseConstitutiveModel):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stiffnessPropertyAccessor = BasePropertyAccessor(client, id, MaterialDataService_pb2_grpc.MaterialDataServiceStub(self._client.channel))
+        self.LinearIsotropicStiffness = LinearIsotropic(client, id)
+        self.TransverselyIsotropicStiffness = TransverselyIsotropic(client, id)
+        self.OrthotropicStiffness = Orthotropic(client, id)
+        self.DuncanChangHyperbolicStiffness = DuncanChangHyperbolic(client, id)
+        self.NonlinearIsotropicStiffness = NonlinearIsotropic(client, id)
+        self.UnsaturatedZoneCalculations = UnsaturatedZoneCalculations(client, id)

rs3/properties/material/constitutiveModel/BaseConstitutiveModel.py

@@ -0,0 +1,11 @@
+from rs3.properties.PropertyEnums import *
+class BaseConstitutiveModel():
+    def getElasticType(self) -> MaterialElasticityTypes:
+        return self._stiffnessPropertyAccessor.getEnumValue("StiffnessType", MaterialElasticityTypes)
+    def setElasticType(self, StiffnessType : MaterialElasticityTypes):
+        self._stiffnessPropertyAccessor.setEnumValue("StiffnessType", StiffnessType.value)
+        
+    def getMaterialType(self) -> MaterialType:
+        return MaterialType(self._propertyAccessor.getBoolValue("IsPlastic"))
+    def setMaterialType(self, materialType: MaterialType):
+        return self._propertyAccessor.setBoolValue("IsPlastic", materialType.value)

rs3/properties/material/constitutiveModel/BoundingSurfacePlasticity.py

@@ -0,0 +1,88 @@
+# 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 BoundingSurfacePlasticityBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getCriticalFrictionAngleZeroDilation(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("CriticalFrictionAngle")
+    def setCriticalFrictionAngleZeroDilation(self, value: float):
+        self._propertyAccessor.setDoubleProperty("CriticalFrictionAngle", value)
+    def getHardeningProperty(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("HardeningProperty")
+    def setHardeningProperty(self, value: float):
+        self._propertyAccessor.setDoubleProperty("HardeningProperty", value)
+    def getUnloadingToLoadingPlasticModulusRatio(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("UnloadLoadPlasticModRatio")
+    def setUnloadingToLoadingPlasticModulusRatio(self, value: float):
+        self._propertyAccessor.setDoubleProperty("UnloadLoadPlasticModRatio", value)
+    def getPowerTerm(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PowerTerm")
+    def setPowerTerm(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PowerTerm", value)
+    def getTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TensileStrength")
+    def setTensileStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("TensileStrength", value)
+    def getFrictionAngle(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngle")
+    def setFrictionAngle(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngle", value)
+    def getCohesion(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Cohesion")
+    def setCohesion(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Cohesion", value)
+    def getProperties(self):
+        return {
+            "CriticalFrictionAngleZeroDilation": self.getCriticalFrictionAngleZeroDilation(),
+            "HardeningProperty": self.getHardeningProperty(),
+            "UnloadingToLoadingPlasticModulusRatio": self.getUnloadingToLoadingPlasticModulusRatio(),
+            "PowerTerm": self.getPowerTerm(),
+            "TensileStrength": self.getTensileStrength(),
+            "FrictionAngle": self.getFrictionAngle(),
+            "Cohesion": self.getCohesion(),
+        }
+    def setProperties(self, CriticalFrictionAngleZeroDilation: float = None, HardeningProperty: float = None, UnloadingToLoadingPlasticModulusRatio: float = None, PowerTerm: float = None, TensileStrength: float = None, FrictionAngle: float = None, Cohesion: float = None):
+        if CriticalFrictionAngleZeroDilation is not None:
+            self.setCriticalFrictionAngleZeroDilation(CriticalFrictionAngleZeroDilation)
+        if HardeningProperty is not None:
+            self.setHardeningProperty(HardeningProperty)
+        if UnloadingToLoadingPlasticModulusRatio is not None:
+            self.setUnloadingToLoadingPlasticModulusRatio(UnloadingToLoadingPlasticModulusRatio)
+        if PowerTerm is not None:
+            self.setPowerTerm(PowerTerm)
+        if TensileStrength is not None:
+            self.setTensileStrength(TensileStrength)
+        if FrictionAngle is not None:
+            self.setFrictionAngle(FrictionAngle)
+        if Cohesion is not None:
+            self.setCohesion(Cohesion)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.material.constitutiveModel.stiffness.LinearIsotropic import LinearIsotropic
+from rs3.properties.material.constitutiveModel.stiffness.TransverselyIsotropic import TransverselyIsotropic
+from rs3.properties.material.constitutiveModel.stiffness.Orthotropic import Orthotropic
+from rs3.properties.material.constitutiveModel.stiffness.DuncanChangHyperbolic import DuncanChangHyperbolic
+from rs3.properties.material.constitutiveModel.stiffness.NonlinearIsotropic import NonlinearIsotropic
+from rs3.properties.material.constitutiveModel.UnsaturatedZoneCalculations import UnsaturatedZoneCalculations
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.MaterialDataService_pb2_grpc as MaterialDataService_pb2_grpc
+from rs3.properties.PropertyEnums import *
+class BoundingSurfacePlasticity(BoundingSurfacePlasticityBase):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._stiffnessPropertyAccessor = BasePropertyAccessor(client, id, MaterialDataService_pb2_grpc.MaterialDataServiceStub(self._client.channel))
+        self.LinearIsotropicStiffness = LinearIsotropic(client, id)
+        self.TransverselyIsotropicStiffness = TransverselyIsotropic(client, id)
+        self.OrthotropicStiffness = Orthotropic(client, id)
+        self.DuncanChangHyperbolicStiffness = DuncanChangHyperbolic(client, id)
+        self.NonlinearIsotropicStiffness = NonlinearIsotropic(client, id)
+        self.UnsaturatedZoneCalculations = UnsaturatedZoneCalculations(client, id)
+        
+    def getElasticType(self) -> MaterialElasticityTypes:
+        return self._stiffnessPropertyAccessor.getEnumValue("StiffnessType", MaterialElasticityTypes)
+    def setElasticType(self, StiffnessType : MaterialElasticityTypes):
+        self._stiffnessPropertyAccessor.setEnumValue("StiffnessType", StiffnessType.value)