RS3Scripting 4.42.0__py3-none-any.whl

rs3/projectSettings/Dynamic.py

@@ -0,0 +1,110 @@
+# 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 DynamicBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getIsDynamicOn(self) -> bool:
+        return self._propertyAccessor.getBoolValue("is_dynamic_on")
+    def setIsDynamicOn(self, value: bool):
+        self._propertyAccessor.setBoolValue("is_dynamic_on", value)
+    def getIsRayleighDampingbyAlphaMOn(self) -> bool:
+        return self._propertyAccessor.getBoolValue("is_alpha_m_on")
+    def setIsRayleighDampingbyAlphaMOn(self, value: bool):
+        self._propertyAccessor.setBoolValue("is_alpha_m_on", value)
+    def getAlphaM(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("alpha_m")
+    def setAlphaM(self, value: float):
+        self._propertyAccessor.setDoubleProperty("alpha_m", value)
+    def getBetaK(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("betta_k")
+    def setBetaK(self, value: float):
+        self._propertyAccessor.setDoubleProperty("betta_k", value)
+    def getFrequency1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("frequency1")
+    def setFrequency1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("frequency1", value)
+    def getFrequency2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("frequency2")
+    def setFrequency2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("frequency2", value)
+    def getDampingRatio1(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("damping_ratio1")
+    def setDampingRatio1(self, value: float):
+        self._propertyAccessor.setDoubleProperty("damping_ratio1", value)
+    def getDampingRatio2(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("damping_ratio2")
+    def setDampingRatio2(self, value: float):
+        self._propertyAccessor.setDoubleProperty("damping_ratio2", value)
+    def getNumTimeSteps(self) -> int:
+        return self._propertyAccessor.getIntProperty("num_time_steps")
+    def setNumTimeSteps(self, value: int):
+        self._propertyAccessor.setIntProperty("num_time_steps", value)
+    def getBeta(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("betta")
+    def setBeta(self, value: float):
+        self._propertyAccessor.setDoubleProperty("betta", value)
+    def getGamma(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("gamma")
+    def setGamma(self, value: float):
+        self._propertyAccessor.setDoubleProperty("gamma", value)
+    def getProperties(self):
+        return {
+            "IsDynamicOn": self.getIsDynamicOn(),
+            "IsRayleighDampingbyAlphaMOn": self.getIsRayleighDampingbyAlphaMOn(),
+            "AlphaM": self.getAlphaM(),
+            "BetaK": self.getBetaK(),
+            "Frequency1": self.getFrequency1(),
+            "Frequency2": self.getFrequency2(),
+            "DampingRatio1": self.getDampingRatio1(),
+            "DampingRatio2": self.getDampingRatio2(),
+            "NumTimeSteps": self.getNumTimeSteps(),
+            "Beta": self.getBeta(),
+            "Gamma": self.getGamma(),
+        }
+    def setProperties(self, IsDynamicOn: bool = None, IsRayleighDampingbyAlphaMOn: bool = None, AlphaM: float = None, BetaK: float = None, Frequency1: float = None, Frequency2: float = None, DampingRatio1: float = None, DampingRatio2: float = None, NumTimeSteps: int = None, Beta: float = None, Gamma: float = None):
+        if IsDynamicOn is not None:
+            self.setIsDynamicOn(IsDynamicOn)
+        if IsRayleighDampingbyAlphaMOn is not None:
+            self.setIsRayleighDampingbyAlphaMOn(IsRayleighDampingbyAlphaMOn)
+        if AlphaM is not None:
+            self.setAlphaM(AlphaM)
+        if BetaK is not None:
+            self.setBetaK(BetaK)
+        if Frequency1 is not None:
+            self.setFrequency1(Frequency1)
+        if Frequency2 is not None:
+            self.setFrequency2(Frequency2)
+        if DampingRatio1 is not None:
+            self.setDampingRatio1(DampingRatio1)
+        if DampingRatio2 is not None:
+            self.setDampingRatio2(DampingRatio2)
+        if NumTimeSteps is not None:
+            self.setNumTimeSteps(NumTimeSteps)
+        if Beta is not None:
+            self.setBeta(Beta)
+        if Gamma is not None:
+            self.setGamma(Gamma)
+
+################ Code below this line will not be overridden ################
+from ._PropertyAccessor import DynamicPropertyAccessor
+from rs3.projectSettings.ProjectSettingEnums import *
+class Dynamic(DynamicBase):
+    """
+    Define dynamic analysis properties.
+    
+    Examples:
+		See :ref:`project_settings_example`.
+  
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = DynamicPropertyAccessor(client, id)
+        
+    def getTimeHistoryMethod(self) -> TimeHistoryType:
+        return self._propertyAccessor.getEnumValue("time_history_type", TimeHistoryType) 
+    def setTimeHistoryMethod(self, value : TimeHistoryType):
+        self._propertyAccessor.setEnumValue("time_history_type", value.value)

rs3/projectSettings/Groundwater.py

@@ -0,0 +1,118 @@
+# 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 GroundwaterBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getPoreFluidUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PoreFluidWeight")
+    def setPoreFluidUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PoreFluidWeight", value)
+    def getIsNegativePorePressureCutoff(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsNegativePorePressureCutoff")
+    def setIsNegativePorePressureCutoff(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsNegativePorePressureCutoff", value)
+    def getNegativePorePressureCutoff(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("NegativePorePressureCutoff")
+    def setNegativePorePressureCutoff(self, value: float):
+        self._propertyAccessor.setDoubleProperty("NegativePorePressureCutoff", value)
+    def getPWPMethodByStage(self) -> bool:
+        return self._propertyAccessor.getBoolValue("PWPMethodByStage")
+    def setPWPMethodByStage(self, value: bool):
+        self._propertyAccessor.setBoolValue("PWPMethodByStage", value)
+    def getMaxNumIterations(self) -> int:
+        return self._propertyAccessor.getIntProperty("max_num_iterations")
+    def setMaxNumIterations(self, value: int):
+        self._propertyAccessor.setIntProperty("max_num_iterations", value)
+    def getTolerance(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Tolerance")
+    def setTolerance(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Tolerance", value)
+    def getLoadSteps(self) -> int:
+        return self._propertyAccessor.getIntProperty("LoadSteps")
+    def setLoadSteps(self, value: int):
+        self._propertyAccessor.setIntProperty("LoadSteps", value)
+    def getTimeSteps(self) -> int:
+        return self._propertyAccessor.getIntProperty("TimeSteps")
+    def setTimeSteps(self, value: int):
+        self._propertyAccessor.setIntProperty("TimeSteps", value)
+    def getIsScaleTolerance(self) -> bool:
+        return self._propertyAccessor.getBoolValue("is_scale_tolerance")
+    def setIsScaleTolerance(self, value: bool):
+        self._propertyAccessor.setBoolValue("is_scale_tolerance", value)
+    def getIsAddFluidBodyForce(self) -> bool:
+        return self._propertyAccessor.getBoolValue("is_add_fluid_body_force")
+    def setIsAddFluidBodyForce(self, value: bool):
+        self._propertyAccessor.setBoolValue("is_add_fluid_body_force", value)
+    def getFluidBulkModulus(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("fluid_bulk_modulus")
+    def setFluidBulkModulus(self, value: float):
+        self._propertyAccessor.setDoubleProperty("fluid_bulk_modulus", value)
+    def getProperties(self):
+        return {
+            "PoreFluidUnitWeight": self.getPoreFluidUnitWeight(),
+            "IsNegativePorePressureCutoff": self.getIsNegativePorePressureCutoff(),
+            "NegativePorePressureCutoff": self.getNegativePorePressureCutoff(),
+            "PWPMethodByStage": self.getPWPMethodByStage(),
+            "MaxNumIterations": self.getMaxNumIterations(),
+            "Tolerance": self.getTolerance(),
+            "LoadSteps": self.getLoadSteps(),
+            "TimeSteps": self.getTimeSteps(),
+            "IsScaleTolerance": self.getIsScaleTolerance(),
+            "IsAddFluidBodyForce": self.getIsAddFluidBodyForce(),
+            "FluidBulkModulus": self.getFluidBulkModulus(),
+        }
+    def setProperties(self, PoreFluidUnitWeight: float = None, IsNegativePorePressureCutoff: bool = None, NegativePorePressureCutoff: float = None, PWPMethodByStage: bool = None, MaxNumIterations: int = None, Tolerance: float = None, LoadSteps: int = None, TimeSteps: int = None, IsScaleTolerance: bool = None, IsAddFluidBodyForce: bool = None, FluidBulkModulus: float = None):
+        if PoreFluidUnitWeight is not None:
+            self.setPoreFluidUnitWeight(PoreFluidUnitWeight)
+        if IsNegativePorePressureCutoff is not None:
+            self.setIsNegativePorePressureCutoff(IsNegativePorePressureCutoff)
+        if NegativePorePressureCutoff is not None:
+            self.setNegativePorePressureCutoff(NegativePorePressureCutoff)
+        if PWPMethodByStage is not None:
+            self.setPWPMethodByStage(PWPMethodByStage)
+        if MaxNumIterations is not None:
+            self.setMaxNumIterations(MaxNumIterations)
+        if Tolerance is not None:
+            self.setTolerance(Tolerance)
+        if LoadSteps is not None:
+            self.setLoadSteps(LoadSteps)
+        if TimeSteps is not None:
+            self.setTimeSteps(TimeSteps)
+        if IsScaleTolerance is not None:
+            self.setIsScaleTolerance(IsScaleTolerance)
+        if IsAddFluidBodyForce is not None:
+            self.setIsAddFluidBodyForce(IsAddFluidBodyForce)
+        if FluidBulkModulus is not None:
+            self.setFluidBulkModulus(FluidBulkModulus)
+
+################ Code below this line will not be overridden ################
+from ._PropertyAccessor import GroundwaterPropertyAccessor
+from rs3.projectSettings.ProjectSettingEnums import *
+class Groundwater(GroundwaterBase):
+    """
+    Define the method to establish groundwater pore pressure conditions in the model.
+    
+    Examples:
+		See :ref:`project_settings_example`.
+  
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = GroundwaterPropertyAccessor(client, id)
+        
+    def getGroundwaterMethod(self) -> GroundwaterMethodType:
+        return self._propertyAccessor.getEnumValue("Method", GroundwaterMethodType) 
+    def setGroundwaterMethod(self, value : GroundwaterMethodType):
+        self._propertyAccessor.setEnumValue("Method", value.value)
+    def setLoadStepType(self, value : GWLoadStepType):
+        self._propertyAccessor.setEnumValue("load_step_type", value.value)
+    def getLoadStepType(self) -> GWLoadStepType:
+        return self._propertyAccessor.getEnumValue("load_step_type", GWLoadStepType)
+    def setTimeStepType(self, value : TimeStepType):
+        self._propertyAccessor.setEnumValue("time_step_type", value.value)
+    def getTimeStepType(self) -> TimeStepType:
+        return self._propertyAccessor.getEnumValue("time_step_type", TimeStepType)

rs3/projectSettings/ProjectSettingEnums.py

@@ -0,0 +1,108 @@
+from enum import Enum
+
+# units
+class UnitSystemType(Enum):
+    METRIC_MPA = "RFC_METRIC_MPA"
+    METRIC_KPA = "RFC_METRIC_KPA"
+    METRIC_TONNES = "RFC_METRIC_TONNES"
+    IMPERIAL_TONS = "RFC_IMPERIAL_TONS"
+    IMPERIAL_KSF = "RFC_IMPERIAL_KSF"
+    IMPERIAL_PSF = "RFC_IMPERIAL_PSF"
+
+class TimeUnitsType(Enum):
+    SECONDS = "SECONDS"
+    MINUTES = "MINUTES"
+    HOURS = "HOURS"
+    DAYS = "DAYS"
+    MONTHS = "MONTHS"
+    YEARS = "YEARS"
+    
+class PermeabilityUnitsType(Enum):
+    FEET_SECONDS = "FEET_SECONDS"
+    FEET_MINUTES = "FEET_MINUTES"
+    FEET_HOURS = "FEET_HOURS"
+    FEET_DAYS = "FEET_DAYS"
+    FEET_MONTHS = "FEET_MONTHS"
+    FEET_YEARS = "FEET_YEARS"
+    INCHES_SECOND = "INCHES_SECOND"
+    INCHES_MINUTES = "INCHES_MINUTES"
+    INCHES_HOURS = "INCHES_HOURS"
+    INCHES_DAYS = "INCHES_DAYS"
+    INCHES_MONTHS = "INCHES_MONTHS"
+    INCHES_YEARS = "INCHES_YEARS"
+    METER_SECONDS = "METER_SECONDS"
+    METER_MINUTES = "METER_MINUTES"
+    METER_HOURS = "METER_HOURS"
+    METER_DAYS = "METER_DAYS"
+    METER_MONTHS = "METER_MONTHS"
+    METER_YEARS = "METER_YEARS"
+    CENTIMETER_SECONDS = "CENTIMETER_SECONDS"
+    CENTIMETER_MINUTES = "CENTIMETER_MINUTES"
+    CENTIMETER_HOURS = "CENTIMETER_HOURS"
+    CENTIMETER_DAYS = "CENTIMETER_DAYS"
+    CENTIMETER_MONTHS = "CENTIMETER_MONTHS"
+    CENTIMETER_YEARS = "CENTIMETER_YEARS"
+    MILLIMETER_SECONDS = "MILLIMETER_SECONDS"
+    MILLIMETER_MINUTES = "MILLIMETER_MINUTES"
+    MILLIMETER_HOURS = "MILLIMETER_HOURS"
+    MILLIMETER_DAYS = "MILLIMETER_DAYS"
+    MILLIMETER_MONTHS = "MILLIMETER_MONTHS"
+    MILLIMETER_YEARS = "MILLIMETER_YEARS"
+
+# Stages
+class PWPMethod(Enum):
+    GW_NONE = "GW_NONE"
+    GW_SURFACES = "GW_SURFACES"
+    GW_STEADYSTATE = "GW_STEADYSTATE"
+    GW_TRANSIENT = "GW_TRANSIENT"
+
+# Stress Analysis
+class LoadStepType(Enum):
+    LoadAuto = "LoadAuto"
+    LoadFixed = "LoadFixed"
+    LoadAdaptive = "LoadAdaptive"
+    
+class StressConvergenceCriteriaType(Enum):
+    ABSOLUTE_ENERGY = "ABSOLUTE_ENERGY"
+    ABSOLUTE_FORCE = "ABSOLUTE_FORCE"
+    ABSOLUTE_FORCE_ENERGY = "ABSOLUTE_FORCE_ENERGY"
+
+# Solver Options
+class AnalysisType(Enum):
+    UNCOUPLED = "UNCOUPLED"
+    COUPLED_BIOT = "COUPLED_BIOT"
+
+class SolverType(Enum):
+    DIRECT_CPU = "DIRECT"
+    ITERATIVE_CPU = "ITERATIVE"
+    FGMRES_AMG_PRECONDITIONER_CPU = "FGMRES_AMG_PRECONDITIONER"
+    FGMRESG_ILU_PRECONDITIONER_CPU = "FGMRESG_ILU_PRECONDITONER"
+    DIRECT_GPU = "DIRECT_GPU"
+    FGMRES_AMG_GPU = "FGMRES_AMG_GPU"
+    AUTO = "AUTO"
+    
+# Groundwater
+class GWLoadStepType(Enum):
+    AUTO = "Auto"
+    FIXED = "Fixed"
+    
+class TimeStepType(Enum):
+    AUTO = "Auto"
+    FIXED = "Fixed"
+    
+class GroundwaterMethodType(Enum):
+    GW_NONE = "GW_NONE"
+    GW_SURFACES = "GW_SURFACES"
+    GW_STEADYSTATE = "GW_STEADYSTATE"
+    GW_TRANSIENT = "GW_TRANSIENT"
+
+# SSR
+class SSRConvergenceType(Enum):
+    ABSOLUTE_ENERGY = "ABSOLUTE_ENERGY"
+    ABSOLUTE_FORCE = "ABSOLUTE_FORCE"
+    ABSOLUTE_FORCE_ENERGY = "ABSOLUTE_FORCE_ENERGY"
+
+# Dynamic
+class TimeHistoryType(Enum):
+    TIME_AUTO = "TimeAuto"
+    NUM_TIME_STEPS = "NumTimeSteps"

rs3/projectSettings/ProjectSettings.py

@@ -0,0 +1,43 @@
+import rs3.generatedFiles.ProjectSettingsDataService_pb2_grpc as ProjectSettingsDataService_pb2_grpc
+import rs3.generatedFiles.ProjectSettingsDataService_pb2 as ProjectSettingsDataService_pb2
+from rs3._client import Client
+from rs3.projectSettings.ProjectSettingEnums import *
+from rs3.projectSettings.Units import Units
+from rs3.projectSettings.Stages import Stages
+from rs3.projectSettings.StressAnalysis import StressAnalysis
+from rs3.projectSettings.SolverOptions import SolverOptions
+from rs3.projectSettings.Groundwater import Groundwater
+from rs3.projectSettings.ShearStrengthReduction import ShearStrengthReduction
+from rs3.projectSettings.Dynamic import Dynamic
+from rs3.properties._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+
+class ProjectSettings(_ProxyObject):
+    """
+    Set up the project parameters.
+    
+    Attributes:
+        Units (Units): Reference object for modifying property.
+        Stages (Stages): Reference object for modifying property.
+        StressAnalysis (StressAnalysis): Reference object for modifying property.
+        SolverOptions (SolverOptions): Reference object for modifying property.
+        Groundwater (Groundwater): Reference object for modifying property.
+        ShearStrengthReduction (ShearStrengthReduction): Reference object for modifying property.
+        Dynamic (Dynamic): Reference object for modifying property.
+    
+    Examples:
+		See :ref:`project_settings_example`.
+  
+    """
+    def __init__(self, client : Client, id : str):
+        super().__init__(client, id)
+        self._projectSettingsDataService = ProjectSettingsDataService_pb2_grpc.ProjectSettingsDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, id, self._projectSettingsDataService)
+        self.projectId = id
+        self.Units = Units(client, id)
+        self.Stages = Stages(client, id)
+        self.StressAnalysis = StressAnalysis(client, id)
+        self.SolverOptions = SolverOptions(client, id)
+        self.Groundwater = Groundwater(client, id)
+        self.ShearStrengthReduction = ShearStrengthReduction(client, id)
+        self.Dynamic = Dynamic(client, id)

rs3/projectSettings/ShearStrengthReduction.py

@@ -0,0 +1,130 @@
+# 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 ShearStrengthReductionBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getSRFIsOn(self) -> bool:
+        return self._propertyAccessor.getBoolValue("SRF_is_on")
+    def setSRFIsOn(self, value: bool):
+        self._propertyAccessor.setBoolValue("SRF_is_on", value)
+    def getInitialEstimateOfSRF(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SRF_min")
+    def setInitialEstimateOfSRF(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SRF_min", value)
+    def getSRFAuto(self) -> bool:
+        return self._propertyAccessor.getBoolValue("SRF_auto")
+    def setSRFAuto(self, value: bool):
+        self._propertyAccessor.setBoolValue("SRF_auto", value)
+    def getSRFTolerance(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SRF_delta_FOS")
+    def setSRFTolerance(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SRF_delta_FOS", value)
+    def getSRFStepSize(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SRF_step_size")
+    def setSRFStepSize(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SRF_step_size", value)
+    def getFinalSRF(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SRF_max")
+    def setFinalSRF(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SRF_max", value)
+    def getAccelerateSRF(self) -> bool:
+        return self._propertyAccessor.getBoolValue("SRF_accelerate")
+    def setAccelerateSRF(self, value: bool):
+        self._propertyAccessor.setBoolValue("SRF_accelerate", value)
+    def getSRFAccelerateAdvanced(self) -> bool:
+        """
+        In advanced SRF, get if accelerate analysis by reducing number of iterations after failure is on.
+        """
+        return self._propertyAccessor.getBoolValue("SRF_accelerate_advanced")
+    def setSRFAccelerateAdvanced(self, value: bool):
+        """
+        In advanced SRF, set if accelerate analysis by reducing number of iterations after failure is on.
+        """
+        self._propertyAccessor.setBoolValue("SRF_accelerate_advanced", value)
+    def getApplySSRToMohrCoulombTensileStrength(self) -> bool:
+        """
+        In advanced SRF, get if apply SSR to Mohr-Coulomb tensile strength is on.
+        """
+        return self._propertyAccessor.getBoolValue("SRF_tensilestrength")
+    def setApplySSRToMohrCoulombTensileStrength(self, value: bool):
+        """
+        In advanced SRF, set if apply SSR to Mohr-Coulomb tensile strength is on.
+        """
+        self._propertyAccessor.setBoolValue("SRF_tensilestrength", value)
+    def getSRFUserdefined(self) -> bool:
+        return self._propertyAccessor.getBoolValue("SRF_userdefined")
+    def setSRFUserdefined(self, value: bool):
+        self._propertyAccessor.setBoolValue("SRF_userdefined", value)
+    def getStressAnalysisTolerance(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SRF_tolerance")
+    def setStressAnalysisTolerance(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SRF_tolerance", value)
+    def getMaximumNumberOfIterations(self) -> int:
+        return self._propertyAccessor.getLongProperty("SRF_iterations")
+    def setMaximumNumberOfIterations(self, value: int):
+        self._propertyAccessor.setLongProperty("SRF_iterations", value)
+    def getProperties(self):
+        return {
+            "SRFIsOn": self.getSRFIsOn(),
+            "InitialEstimateOfSRF": self.getInitialEstimateOfSRF(),
+            "SRFAuto": self.getSRFAuto(),
+            "SRFTolerance": self.getSRFTolerance(),
+            "SRFStepSize": self.getSRFStepSize(),
+            "FinalSRF": self.getFinalSRF(),
+            "AccelerateSRF": self.getAccelerateSRF(),
+            "SRFAccelerateAdvanced": self.getSRFAccelerateAdvanced(),
+            "ApplySSRToMohrCoulombTensileStrength": self.getApplySSRToMohrCoulombTensileStrength(),
+            "SRFUserdefined": self.getSRFUserdefined(),
+            "StressAnalysisTolerance": self.getStressAnalysisTolerance(),
+            "MaximumNumberOfIterations": self.getMaximumNumberOfIterations(),
+        }
+    def setProperties(self, SRFIsOn: bool = None, InitialEstimateOfSRF: float = None, SRFAuto: bool = None, SRFTolerance: float = None, SRFStepSize: float = None, FinalSRF: float = None, AccelerateSRF: bool = None, SRFAccelerateAdvanced: bool = None, ApplySSRToMohrCoulombTensileStrength: bool = None, SRFUserdefined: bool = None, StressAnalysisTolerance: float = None, MaximumNumberOfIterations: int = None):
+        if SRFIsOn is not None:
+            self.setSRFIsOn(SRFIsOn)
+        if InitialEstimateOfSRF is not None:
+            self.setInitialEstimateOfSRF(InitialEstimateOfSRF)
+        if SRFAuto is not None:
+            self.setSRFAuto(SRFAuto)
+        if SRFTolerance is not None:
+            self.setSRFTolerance(SRFTolerance)
+        if SRFStepSize is not None:
+            self.setSRFStepSize(SRFStepSize)
+        if FinalSRF is not None:
+            self.setFinalSRF(FinalSRF)
+        if AccelerateSRF is not None:
+            self.setAccelerateSRF(AccelerateSRF)
+        if SRFAccelerateAdvanced is not None:
+            self.setSRFAccelerateAdvanced(SRFAccelerateAdvanced)
+        if ApplySSRToMohrCoulombTensileStrength is not None:
+            self.setApplySSRToMohrCoulombTensileStrength(ApplySSRToMohrCoulombTensileStrength)
+        if SRFUserdefined is not None:
+            self.setSRFUserdefined(SRFUserdefined)
+        if StressAnalysisTolerance is not None:
+            self.setStressAnalysisTolerance(StressAnalysisTolerance)
+        if MaximumNumberOfIterations is not None:
+            self.setMaximumNumberOfIterations(MaximumNumberOfIterations)
+
+################ Code below this line will not be overridden ################
+from ._PropertyAccessor import SSRPropertyAccessor
+from rs3.projectSettings.ProjectSettingEnums import *
+class ShearStrengthReduction(ShearStrengthReductionBase):
+    """
+    This module allows to automatically perform a finite element slope stability analysis using the 
+    Shear Strength Reduction (SSR) method.
+    
+    Examples:
+		See :ref:`project_settings_example`.
+  
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = SSRPropertyAccessor(client, id)
+    
+    def getSSRConvergenceType(self) -> SSRConvergenceType:
+        return self._propertyAccessor.getEnumValue("SRF_convergencetype", SSRConvergenceType) 
+    def setSSRConvergenceType(self, value : SSRConvergenceType):
+        self._propertyAccessor.setEnumValue("SRF_convergencetype", value.value)

rs3/projectSettings/SolverOptions.py

@@ -0,0 +1,88 @@
+from rs3.projectSettings.ProjectSettingEnums import *
+from rs3._client import Client
+from ._PropertyAccessor import StressAnalysisPropertyAccessor
+from rs3._proxyObject import _ProxyObject
+
+
+class SolverOptions(_ProxyObject):
+    """
+    Set the solid and fluid interaction type and solver type.
+    
+    Examples:
+        See :ref:`project_settings_example`.
+        
+    """
+    def __init__(self, client: Client, projectId: str):
+        super().__init__(client, projectId)
+        self._propertyAccessor = StressAnalysisPropertyAccessor(client, projectId)
+
+    def getAnalysisType(self) -> AnalysisType:
+        """
+        Get the interaction between fluid pore pressure and solid stresses and deformation.
+        """
+        return self._propertyAccessor.getEnumValue("Method", AnalysisType)
+
+    def setAnalysisType(self, value: AnalysisType):
+        """
+        Set the interaction between fluid pore pressure and solid stresses and deformation.
+        """
+        self._propertyAccessor.setEnumValue("Method", value.value)
+
+    def getSolverType(self) -> SolverType:
+        """
+        Get the currently configured solver type for solving the matrix representing the
+        system of equations defined by your model.
+
+        Returns:
+            SolverType: The solver type currently set for this model.
+
+        Notes:
+            - DIRECT_CPU: Direct solver running on CPU.
+            - ITERATIVE_CPU: Iterative CPU solver (PCG with ICT preconditioner).
+            - FGMRES_AMG_PRECONDITIONER_CPU: FGMRES solver on CPU with AMG preconditioner.
+            - FGMRESG_ILU_PRECONDITIONER_CPU: FGMRES(G) solver on CPU with ILU preconditioner.
+            - DIRECT_GPU: Direct solver running on GPU.
+            - FGMRES_AMG_GPU: FGMRES solver on GPU with AMG preconditioner.
+            - AUTO: Automatically select the solver based on the problem configuration.
+
+        """
+        return self._propertyAccessor.getEnumValue("Solver", SolverType)
+
+    def setSolverType(self, value: SolverType):
+        """
+        Set the currently configured solver type for solving the matrix representing the
+        system of equations defined by your model.
+
+        Args:
+            value (SolverType): The solver type to configure.
+
+        Notes:
+            - ITERATIVE_CPU corresponds to a CPU-based PCG solver with an ICT preconditioner.
+            - GPU-based solvers require compatible GPU hardware.
+            - AUTO allows the system to determine the most appropriate solver.
+
+        """
+        self._propertyAccessor.setEnumValue("Solver", value.value)
+
+    def getMemoryFillLevel(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("SolverFillLevel")
+
+    def setMemoryFillLevel(self, value: float):
+        self._propertyAccessor.setDoubleProperty("SolverFillLevel", value)
+
+    def getRelativeTolerance(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Tolerance")
+
+    def setRelativeTolerance(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Tolerance", value)
+
+    def getProperties(self):
+        return {
+            "AnalysisMethod": self.getAnalysisType(),
+            "Solver": self.getSolverType(),
+        }
+    def setProperties(self, AnalysisMethod: AnalysisType = None, Solver: SolverType = None):
+        if AnalysisMethod is not None:
+            self.setAnalysisType(AnalysisMethod)
+        if Solver is not None:
+            self.setSolverType(Solver)