RS2Scripting 11.23.0__py3-none-any.whl

rs2/modeler/properties/RelativeStageFactorInterface.py

@@ -0,0 +1,50 @@
+from rs2._common.ProxyObject import ProxyObject
+from typing import Generic
+from typing import TypeVar
+from rs2.modeler.properties.PropertyEnums import *
+
+DefinedStageFactor = TypeVar('DefinedStageFactor', bound=ProxyObject)
+StageFactor = TypeVar('StageFactor', bound=ProxyObject)
+
+class RelativeStageFactorInterface(ProxyObject, Generic[DefinedStageFactor, StageFactor]):
+	def __init__(self, client, proxyId, propertyID, definedFactorClass, factorClass):
+		super().__init__(client, proxyId)
+		self._definedStageFactorType = definedFactorClass
+		self._stageFactorType = factorClass
+		self.propertyID = propertyID
+
+	def getDefinedStageFactors(self) -> dict[int, DefinedStageFactor]:
+		"""
+		Returns a map of stage factors. The key is the absolute or relative stage at which the stage factor is applied. The value is the stage factor object
+		"""
+		stageFactorReferenceIds = self._callFunction('getDefinedStageFactors', [], keepReturnValueReference=True)
+		stageFactors = {}
+		for stageKey in stageFactorReferenceIds :
+			stageFactors[stageKey] = self._definedStageFactorType(self._client, stageFactorReferenceIds[stageKey], self.propertyID)
+		return stageFactors
+	def getStageFactor(self, stage: int) -> StageFactor:
+		"""
+		Returns the stage factor for the given stage.
+		"""
+		factorReferenceID = self._callFunction('getStageFactor', [stage], keepReturnValueReference=True)
+		return self._stageFactorType(self._client, factorReferenceID,  self.propertyID)
+	def createStageFactor(self, stage: int) -> DefinedStageFactor:
+		"""
+		Creates a stage factor for the given stage.
+
+		NOTE: Invalidates any existing stage factor proxies. Get them again using getDefinedStageFactors or getStageFactor.
+		"""
+		factorReferenceID = self._callFunction('createStageFactor', [stage], keepReturnValueReference=True)
+		return self._definedStageFactorType(self._client, factorReferenceID,  self.propertyID)
+	def setDefinedStageFactors(self, method: StageFactorDefinitionMethod, stageFactors: dict[int, StageFactor]):
+		"""
+		Sets the defined stage factors to those given. The method indicates if the stages in the keys of the map are absolute or relative.
+
+		NOTE: Invalidates any existing stage factor proxies. Get them again using getDefinedStageFactors or getStageFactor.
+		"""
+		stageFactorIdMap = {}
+		for stage in stageFactors :
+			stageFactorIdMap[stage] = stageFactors[stage]._ID
+		return self._callFunction("setDefinedStageFactors", [method.value, stageFactorIdMap], proxyArgumentIndices = [1])
+	def getStageFactorMethod(self) -> StageFactorDefinitionMethod:
+		return StageFactorDefinitionMethod(self._callFunction("__getattribute__", ["relative_stage_factors"]))

rs2/modeler/properties/ShearNormalFunction.py

@@ -0,0 +1,45 @@
+from rs2._common.ProxyObject import ProxyObject
+from rs2.modeler.properties.PropertyEnums import *
+
+class ShearNormalFunction(ProxyObject):
+    def getName(self) -> str:
+        return self._callFunction("Get_Name")
+    def setMaterialType(self, materialType: MaterialType):
+        return self._callFunction("setMaterialTypeByName", [materialType.value])
+    def getMaterialType(self) -> str:
+        return MaterialType(self._callFunction("getMaterialTypeName"))
+    def setPeakTensileStrength(self, peakTensileStrength: float):
+        return self._callFunction("setPeakTensileStrength", [peakTensileStrength])
+    def getPeakTensileStrength(self) -> float:
+        return self._callFunction("getPeakTensileStrength")
+    def setResidualTensileStrength(self, residualTensileStrength: float):
+        return self._callFunction("setResidualTensileStrength", [residualTensileStrength])
+    def getResidualTensileStrength(self) -> float:
+        return self._callFunction("getResidualTensileStrength")
+    def setDilationRatio(self, dilationRatio: float):
+        return self._callFunction("setDilationRatio", [dilationRatio])
+    def getDilationRatio(self) -> float:
+        return self._callFunction("getDilationRatio")
+    def setUseCalculatedTensileStrength(self, useCalculatedTensileStrength: bool):
+        return self._callFunction("setUseCalculatedTensileStrength", [useCalculatedTensileStrength])
+    def getUseCalculatedTensileStrength(self) -> bool:
+        return self._callFunction("getUseCalculatedTensileStrength")
+    def setFunctionPoints(self, functionPoints: list[tuple[float,float,float]]):
+        """set the function points. Each point has  (normal, shear, residual shear). Residual shear is ignored if the material type is not plastic.
+        Function must not be concave. If a concave function is provided, it will transform the function into a convex function.
+
+        Args:
+            functionPoints: list of tuples of (normal, shear, residual shear)
+
+        Returns:
+            None
+        """
+        return self._callFunction("setFunctionPoints", [functionPoints])
+    def getFunctionPoints(self) -> list[tuple[float,float,float]]:
+        """returns the function points as a list of tuples of (normal, shear, residual shear). Residual shear is ignored if the material type is not plastic.
+
+        Returns:
+            list[tuple(float,float,float)]: list of tuples of (normal, shear, residual shear)
+        """
+        return self._callFunction("getFunctionPoints")
+    

rs2/modeler/properties/SnowdenAnisotropicFunction.py

@@ -0,0 +1,56 @@
+from rs2._common.ProxyObject import ProxyObject
+from rs2.modeler.properties.PropertyEnums import *
+
+class SnowdenAnisotropicFunction(ProxyObject):
+    def setFunctionType(self, functionType : SnowdenAnisotropicFunctionType):
+        return self._callFunction("setFunctionType", [functionType.value])
+    def getFunctionType(self) -> SnowdenAnisotropicFunctionType:
+        return SnowdenAnisotropicFunctionType(self._callFunction("getFunctionType"))
+    
+    def setPeakTensileStrength(self, peakTensileStrength : float):
+        return self._callFunction("setPeakTensileStrength", [peakTensileStrength])
+    def getPeakTensileStrength(self) -> float:
+        return float(self._callFunction("getPeakTensileStrength"))
+    
+    def setResidualTensileStrength(self, residualTensileStrength : float):
+        return self._callFunction("setResidualTensileStrength", [residualTensileStrength])
+    def getResidualTensileStrength(self) -> float:
+        return float(self._callFunction("getResidualTensileStrength"))
+    
+    def setDilationRatio(self, dilationRatio : float):
+        return self._callFunction("setDilationRatio", [dilationRatio])
+    def getDilationRatio(self) -> float:
+        return float(self._callFunction("getDilationRatio"))
+
+    def setShearNormalFunction(self, normalStress : list[float], shearStress : list[float]):
+        return self._callFunction("setShearNormalFunction", [normalStress, shearStress])
+
+    def setShearNormalFunctionWithResidual(self, normalStress : list[float], shearStress : list[float], residualShearStress : list[float]):
+        return self._callFunction("setShearNormalFunctionWithResidual", [normalStress, shearStress, residualShearStress])
+    
+    def setCohesionFrictionFunction(self, normalStress : list[float], cohesion : list[float], frictionAngle : list[float]):
+        return self._callFunction("setCohesionFrictionFunction", [normalStress, cohesion, frictionAngle])
+    
+    def setCohesionFrictionFunctionWithResidual(self, normalStress : list[float], cohesion : list[float], frictionAngle : list[float], residualCohesion : list[float], residualFrictionAngle : list[float]):
+        return self._callFunction("setCohesionFrictionFunctionWithResidual", [normalStress, cohesion, frictionAngle, residualCohesion, residualFrictionAngle])
+    
+    def getNormalStress(self) -> list[float]:
+        return list(self._callFunction("getNormalStress"))
+    
+    def getShearStress(self) -> list[float]:
+        return list(self._callFunction("getShearStress"))
+    
+    def getResidualShearStress(self) -> list[float]:
+        return list(self._callFunction("getResidualShearStress"))
+    
+    def getCohesion(self) -> list[float]:
+        return list(self._callFunction("getCohesion"))
+    
+    def getFrictionAngle(self) -> list[float]:
+        return list(self._callFunction("getFrictionAngle"))
+    
+    def getResidualCohesion(self) -> list[float]:
+        return list(self._callFunction("getResidualCohesion"))
+    
+    def getResidualFrictionAngle(self) -> list[float]:
+        return list(self._callFunction("getResidualFrictionAngle"))

rs2/modeler/properties/StructuralInterface.py

@@ -0,0 +1,59 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class StructuralInterfaceProperty(PropertyProxy):
+	"""
+	:ref:`Structural Interface Example`
+	"""
+	def getStructuralInterfaceName(self) -> str:
+		"""
+		Returns the structural interface name
+		"""
+		return self._callFunction("getStructuralInterfaceName", [])
+	def setStructuralInterfaceName(self, name: str):
+		"""
+		Sets structural interface name
+		"""
+		return self._callFunction("setStructuralInterfaceName", [name])
+	def getColor(self) -> int:
+		"""
+		Returns the structural interface color
+		"""
+		return self._callFunction("getColor", [])
+	def setColor(self, color: int):
+		"""
+		Sets structural interface color
+		"""
+		return self._callFunction("setColor", [color])
+	def getPositiveJointPropertyName(self) -> str:
+		"""
+		Returns the positive side joint property name
+		"""
+		return self._callFunction("getPositiveJointPropertyName", [])
+	def setPositiveJointPropertyByName(self, jointName: str):
+		"""
+		Set positive side joint property by name
+		"""
+		return self._callFunction("setPositiveJointPropertyByName", [jointName])
+	def getNegativeJointPropertyName(self) -> str:
+		"""
+		Returns the negative side joint property name
+		"""
+		return self._callFunction("getNegativeJointPropertyName", [])
+	def setNegativeJointPropertyByName(self, jointName: str):
+		"""
+		Set negative side joint property by name
+		"""
+		return self._callFunction("setNegativeJointPropertyByName", [jointName])
+	def getLinerPropertyName(self) -> str:
+		"""
+		Returns the liner property name
+		"""
+		return self._callFunction("getLinerPropertyName", [])
+	def setLinerPropertyByName(self, linerName: str):
+		"""
+		Set liner property by name
+		"""
+		return self._callFunction("setLinerPropertyByName", [linerName])

rs2/modeler/properties/UserDefinedWaterMode.py

@@ -0,0 +1,21 @@
+from rs2._common.ProxyObject import ProxyObject
+from rs2.modeler.properties.PropertyEnums import WCInputType
+class UserDefinedWaterMode(ProxyObject):
+    def setWaterContentInputType(self, inputType : WCInputType):
+        return self._callFunction('setWaterContentInputType', [inputType.value])
+    def getWaterContentInputType(self) -> WCInputType:
+        return WCInputType(self._callFunction('getWaterContentInputType'))
+    def getWaterContentFunction(self) -> list[tuple[float, float]]:
+        return self._callFunction('getWCFunction')
+    def setWaterContentFunction(self, wcFunction : list[tuple[float, float]]):
+        return self._callFunction('setWCFunction', [wcFunction])
+    def getDegreeOfSaturationFunction(self) -> list[tuple[float, float]]:
+        return self._callFunction('getDOSFunction')
+    def setDegreeOfSaturationFunction(self, dosFunction : list[tuple[float, float]]):
+        return self._callFunction('setDOSFunction', [dosFunction])
+    def getPermeabilityFunction(self) -> list[tuple[float, float]]:
+        return self._callFunction('getStrengthFunction')
+    def setPermeabilityFunction(self, strengthFunction : list[tuple[float, float]]):
+        return self._callFunction('setStrengthFunction', [strengthFunction])
+    
+    

rs2/modeler/properties/bolt/Bolt.py

@@ -0,0 +1,33 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+from rs2.modeler.properties.bolt.EndAnchored import EndAnchored
+from rs2.modeler.properties.bolt.FullyBonded import FullyBonded
+from rs2.modeler.properties.bolt.PlainStrandCable import PlainStrandCable
+from rs2.modeler.properties.bolt.Swellex import Swellex
+from rs2.modeler.properties.bolt.Tieback import Tieback
+class BoltProperty(PropertyProxy):
+	"""
+	:ref:`Bolt Example`
+	"""
+	def __init__(self, client : Client, ID, documentProxyID):
+		self.EndAnchored = EndAnchored(client, ID, documentProxyID)
+		self.FullyBonded = FullyBonded(client, ID, documentProxyID)
+		self.PlainStrandCable = PlainStrandCable(client, ID, documentProxyID)
+		self.Swellex = Swellex(client, ID, documentProxyID)
+		self.Tieback = Tieback(client, ID, documentProxyID)
+		super().__init__(client, ID, documentProxyID)
+	def getBoltName(self) -> str:
+		return self._getCStringProperty("BP_NAME")
+	def setBoltName(self, value: str):
+		return self._setCStringProperty("BP_NAME", value)
+	def getBoltColor(self) -> int:
+		return self._getUnsignedLongProperty("BP_COLOR")
+	def setBoltColor(self, value: int):
+		return self._setUnsignedLongProperty("BP_COLOR", value)
+	def getBoltType(self) -> BoltTypes:
+		return BoltTypes(self._getEnumEBoltTypesProperty("BP_TYPE"))
+	def setBoltType(self, value: BoltTypes):
+		return self._setEnumEBoltTypesProperty("BP_TYPE", value)

rs2/modeler/properties/bolt/EndAnchored.py

@@ -0,0 +1,59 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class EndAnchored(PropertyProxy):
+	def getBoltDiameter(self) -> float:
+		return self._getDoubleProperty("BP_BOLT_DIAMETER")
+	def setBoltDiameter(self, value: float):
+		return self._setDoubleProperty("BP_BOLT_DIAMETER", value)
+	def getBoltModulusE(self) -> float:
+		return self._getDoubleProperty("BP_BOLT_MODULUS")
+	def setBoltModulusE(self, value: float):
+		return self._setDoubleProperty("BP_BOLT_MODULUS", value)
+	def getTensileCapacity(self) -> float:
+		return self._getDoubleProperty("BP_TENSILE_END")
+	def setTensileCapacity(self, value: float):
+		return self._setDoubleProperty("BP_TENSILE_END", value)
+	def getResidualTensileCapacity(self) -> float:
+		return self._getDoubleProperty("BP_RES_TENSILE_END")
+	def setResidualTensileCapacity(self, value: float):
+		return self._setDoubleProperty("BP_RES_TENSILE_END", value)
+	def getOutofPlaneSpacing(self) -> float:
+		return self._getDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT")
+	def setOutofPlaneSpacing(self, value: float):
+		return self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", value)
+	def getPreTensioningForce(self) -> float:
+		return self._getDoubleProperty("BP_PRETENSIONING")
+	def setPreTensioningForce(self, value: float):
+		return self._setDoubleProperty("BP_PRETENSIONING", value)
+	def getConstantPretensioningForceInInstallStage(self) -> bool:
+		return self._getBoolProperty("BP_USE_CONSTANT_FORCE")
+	def setConstantPretensioningForceInInstallStage(self, value: bool):
+		return self._setBoolProperty("BP_USE_CONSTANT_FORCE", value)
+	def setProperties(self, BoltDiameter : float = None, BoltModulusE : float = None, TensileCapacity : float = None, ResidualTensileCapacity : float = None, OutofPlaneSpacing : float = None, PreTensioningForce : float = None, ConstantPretensioningForceInInstallStage : bool = None):
+		if BoltDiameter is not None:
+			self._setDoubleProperty("BP_BOLT_DIAMETER", BoltDiameter)
+		if BoltModulusE is not None:
+			self._setDoubleProperty("BP_BOLT_MODULUS", BoltModulusE)
+		if TensileCapacity is not None:
+			self._setDoubleProperty("BP_TENSILE_END", TensileCapacity)
+		if ResidualTensileCapacity is not None:
+			self._setDoubleProperty("BP_RES_TENSILE_END", ResidualTensileCapacity)
+		if OutofPlaneSpacing is not None:
+			self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", OutofPlaneSpacing)
+		if PreTensioningForce is not None:
+			self._setDoubleProperty("BP_PRETENSIONING", PreTensioningForce)
+		if ConstantPretensioningForceInInstallStage is not None:
+			self._setBoolProperty("BP_USE_CONSTANT_FORCE", ConstantPretensioningForceInInstallStage)
+	def getProperties(self):
+		return {
+		"BoltDiameter" : self.getBoltDiameter(), 
+		"BoltModulusE" : self.getBoltModulusE(), 
+		"TensileCapacity" : self.getTensileCapacity(), 
+		"ResidualTensileCapacity" : self.getResidualTensileCapacity(), 
+		"OutofPlaneSpacing" : self.getOutofPlaneSpacing(), 
+		"PreTensioningForce" : self.getPreTensioningForce(), 
+		"ConstantPretensioningForceInInstallStage" : self.getConstantPretensioningForceInInstallStage(), 
+		}

rs2/modeler/properties/bolt/FullyBonded.py

@@ -0,0 +1,66 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class FullyBonded(PropertyProxy):
+	def getBoltDiameter(self) -> float:
+		return self._getDoubleProperty("BP_BOLT_DIAMETER")
+	def setBoltDiameter(self, value: float):
+		return self._setDoubleProperty("BP_BOLT_DIAMETER", value)
+	def getBoltModulusE(self) -> float:
+		return self._getDoubleProperty("BP_BOLT_MODULUS")
+	def setBoltModulusE(self, value: float):
+		return self._setDoubleProperty("BP_BOLT_MODULUS", value)
+	def getTensileCapacity(self) -> float:
+		return self._getDoubleProperty("BP_TENSILE_END")
+	def setTensileCapacity(self, value: float):
+		return self._setDoubleProperty("BP_TENSILE_END", value)
+	def getResidualTensileCapacity(self) -> float:
+		return self._getDoubleProperty("BP_RES_TENSILE_END")
+	def setResidualTensileCapacity(self, value: float):
+		return self._setDoubleProperty("BP_RES_TENSILE_END", value)
+	def getOutofPlaneSpacing(self) -> float:
+		return self._getDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT")
+	def setOutofPlaneSpacing(self, value: float):
+		return self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", value)
+	def getPreTensioningForce(self) -> float:
+		return self._getDoubleProperty("BP_PRETENSIONING")
+	def setPreTensioningForce(self, value: float):
+		return self._setDoubleProperty("BP_PRETENSIONING", value)
+	def getConstantPretensioningForceInInstallStage(self) -> bool:
+		return self._getBoolProperty("BP_USE_CONSTANT_FORCE")
+	def setConstantPretensioningForceInInstallStage(self, value: bool):
+		return self._setBoolProperty("BP_USE_CONSTANT_FORCE", value)
+	def getJointShear(self) -> bool:
+		return self._getBoolProperty("BP_USE_JOINT_SHEAR")
+	def setJointShear(self, value: bool):
+		return self._setBoolProperty("BP_USE_JOINT_SHEAR", value)
+	def setProperties(self, BoltDiameter : float = None, BoltModulusE : float = None, TensileCapacity : float = None, ResidualTensileCapacity : float = None, OutofPlaneSpacing : float = None, PreTensioningForce : float = None, ConstantPretensioningForceInInstallStage : bool = None, JointShear : bool = None):
+		if BoltDiameter is not None:
+			self._setDoubleProperty("BP_BOLT_DIAMETER", BoltDiameter)
+		if BoltModulusE is not None:
+			self._setDoubleProperty("BP_BOLT_MODULUS", BoltModulusE)
+		if TensileCapacity is not None:
+			self._setDoubleProperty("BP_TENSILE_END", TensileCapacity)
+		if ResidualTensileCapacity is not None:
+			self._setDoubleProperty("BP_RES_TENSILE_END", ResidualTensileCapacity)
+		if OutofPlaneSpacing is not None:
+			self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", OutofPlaneSpacing)
+		if PreTensioningForce is not None:
+			self._setDoubleProperty("BP_PRETENSIONING", PreTensioningForce)
+		if ConstantPretensioningForceInInstallStage is not None:
+			self._setBoolProperty("BP_USE_CONSTANT_FORCE", ConstantPretensioningForceInInstallStage)
+		if JointShear is not None:
+			self._setBoolProperty("BP_USE_JOINT_SHEAR", JointShear)
+	def getProperties(self):
+		return {
+		"BoltDiameter" : self.getBoltDiameter(), 
+		"BoltModulusE" : self.getBoltModulusE(), 
+		"TensileCapacity" : self.getTensileCapacity(), 
+		"ResidualTensileCapacity" : self.getResidualTensileCapacity(), 
+		"OutofPlaneSpacing" : self.getOutofPlaneSpacing(), 
+		"PreTensioningForce" : self.getPreTensioningForce(), 
+		"ConstantPretensioningForceInInstallStage" : self.getConstantPretensioningForceInInstallStage(), 
+		"JointShear" : self.getJointShear(), 
+		}

rs2/modeler/properties/bolt/PlainStrandCable.py

@@ -0,0 +1,112 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class PlainStrandCable(PropertyProxy):
+	def getBoreholeDiameter(self) -> float:
+		return self._getDoubleProperty("BP_BOREHOLE_DIAMETER_CABLE")
+	def setBoreholeDiameter(self, value: float):
+		return self._setDoubleProperty("BP_BOREHOLE_DIAMETER_CABLE", value)
+	def getCableDiameter(self) -> float:
+		return self._getDoubleProperty("BP_CABLE_DIAMETER")
+	def setCableDiameter(self, value: float):
+		return self._setDoubleProperty("BP_CABLE_DIAMETER", value)
+	def getCableModulusE(self) -> float:
+		return self._getDoubleProperty("BP_CABLE_MODULUS")
+	def setCableModulusE(self, value: float):
+		return self._setDoubleProperty("BP_CABLE_MODULUS", value)
+	def getCablePeak(self) -> float:
+		return self._getDoubleProperty("BP_CABLE_PEAK")
+	def setCablePeak(self, value: float):
+		return self._setDoubleProperty("BP_CABLE_PEAK", value)
+	def getOutofPlaneSpacing(self) -> float:
+		return self._getDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT")
+	def setOutofPlaneSpacing(self, value: float):
+		return self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", value)
+	def getWaterCementRatio(self) -> float:
+		return self._getDoubleProperty("BP_WATER_CEMENT_RATIO")
+	def setWaterCementRatio(self, value: float):
+		return self._setDoubleProperty("BP_WATER_CEMENT_RATIO", value)
+	def getJointShear(self) -> bool:
+		return self._getBoolProperty("BP_USE_JOINT_SHEAR")
+	def setJointShear(self, value: bool):
+		return self._setBoolProperty("BP_USE_JOINT_SHEAR", value)
+	def getFacePlates(self) -> bool:
+		return self._getBoolProperty("BP_FACE_PLATES")
+	def setFacePlates(self, value: bool):
+		return self._setBoolProperty("BP_FACE_PLATES", value)
+	def getAddPullOutForce(self) -> bool:
+		return self._getBoolProperty("BP_ADD_PULL_OUT_FORCE")
+	def setAddPullOutForce(self, value: bool):
+		return self._setBoolProperty("BP_ADD_PULL_OUT_FORCE", value)
+	def getPullOutForce(self) -> float:
+		return self._getDoubleProperty("BP_PULL_OUT_FORCE")
+	def setPullOutForce(self, value: float):
+		return self._setDoubleProperty("BP_PULL_OUT_FORCE", value)
+	def getConstantShearStiffness(self) -> bool:
+		return self._getBoolProperty("BP_ADD_CONSTANT_SHEAR_STIFFNESS")
+	def setConstantShearStiffness(self, value: bool):
+		return self._setBoolProperty("BP_ADD_CONSTANT_SHEAR_STIFFNESS", value)
+	def getStiffness(self) -> float:
+		return self._getDoubleProperty("BP_CONSTANT_SHEAR_STIFFNESS")
+	def setStiffness(self, value: float):
+		return self._setDoubleProperty("BP_CONSTANT_SHEAR_STIFFNESS", value)
+	def getAddBulges(self) -> bool:
+		return self._getBoolProperty("BP_ADD_BULGES")
+	def setAddBulges(self, value: bool):
+		return self._setBoolProperty("BP_ADD_BULGES", value)
+	def getBulgeType(self) -> BulgeTypes:
+		return BulgeTypes(self._getEnumEBulgeTypesProperty("BP_BULGE_TYPE"))
+	def setBulgeType(self, value: BulgeTypes):
+		return self._setEnumEBulgeTypesProperty("BP_BULGE_TYPE", value)
+	def getBulgeLocations(self) -> List[float]:
+		return self._callFunction("get_bulge_locations_ref", [])
+	def setBulgeLocations(self, locations: List[float]):
+		return self._callFunction("set_bulge_locations", [locations])
+	def setProperties(self, BoreholeDiameter : float = None, CableDiameter : float = None, CableModulusE : float = None, CablePeak : float = None, OutofPlaneSpacing : float = None, WaterCementRatio : float = None, JointShear : bool = None, FacePlates : bool = None, AddPullOutForce : bool = None, PullOutForce : float = None, ConstantShearStiffness : bool = None, Stiffness : float = None, AddBulges : bool = None, BulgeType : BulgeTypes = None):
+		if BoreholeDiameter is not None:
+			self._setDoubleProperty("BP_BOREHOLE_DIAMETER_CABLE", BoreholeDiameter)
+		if CableDiameter is not None:
+			self._setDoubleProperty("BP_CABLE_DIAMETER", CableDiameter)
+		if CableModulusE is not None:
+			self._setDoubleProperty("BP_CABLE_MODULUS", CableModulusE)
+		if CablePeak is not None:
+			self._setDoubleProperty("BP_CABLE_PEAK", CablePeak)
+		if OutofPlaneSpacing is not None:
+			self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", OutofPlaneSpacing)
+		if WaterCementRatio is not None:
+			self._setDoubleProperty("BP_WATER_CEMENT_RATIO", WaterCementRatio)
+		if JointShear is not None:
+			self._setBoolProperty("BP_USE_JOINT_SHEAR", JointShear)
+		if FacePlates is not None:
+			self._setBoolProperty("BP_FACE_PLATES", FacePlates)
+		if AddPullOutForce is not None:
+			self._setBoolProperty("BP_ADD_PULL_OUT_FORCE", AddPullOutForce)
+		if PullOutForce is not None:
+			self._setDoubleProperty("BP_PULL_OUT_FORCE", PullOutForce)
+		if ConstantShearStiffness is not None:
+			self._setBoolProperty("BP_ADD_CONSTANT_SHEAR_STIFFNESS", ConstantShearStiffness)
+		if Stiffness is not None:
+			self._setDoubleProperty("BP_CONSTANT_SHEAR_STIFFNESS", Stiffness)
+		if AddBulges is not None:
+			self._setBoolProperty("BP_ADD_BULGES", AddBulges)
+		if BulgeType is not None:
+			self._setEnumEBulgeTypesProperty("BP_BULGE_TYPE", BulgeType)
+	def getProperties(self):
+		return {
+		"BoreholeDiameter" : self.getBoreholeDiameter(), 
+		"CableDiameter" : self.getCableDiameter(), 
+		"CableModulusE" : self.getCableModulusE(), 
+		"CablePeak" : self.getCablePeak(), 
+		"OutofPlaneSpacing" : self.getOutofPlaneSpacing(), 
+		"WaterCementRatio" : self.getWaterCementRatio(), 
+		"JointShear" : self.getJointShear(), 
+		"FacePlates" : self.getFacePlates(), 
+		"AddPullOutForce" : self.getAddPullOutForce(), 
+		"PullOutForce" : self.getPullOutForce(), 
+		"ConstantShearStiffness" : self.getConstantShearStiffness(), 
+		"Stiffness" : self.getStiffness(), 
+		"AddBulges" : self.getAddBulges(), 
+		"BulgeType" : self.getBulgeType(), 
+		}

rs2/modeler/properties/bolt/Swellex.py

@@ -0,0 +1,136 @@
+from rs2.modeler.properties.propertyProxy import PropertyProxy
+from rs2._common.Client import Client
+from enum import Enum, auto
+from typing import List
+from rs2.modeler.properties.PropertyEnums import *
+class Swellex(PropertyProxy):
+	def getTensileCapacity(self) -> float:
+		return self._getDoubleProperty("BP_TENSILE_END")
+	def setTensileCapacity(self, value: float):
+		return self._setDoubleProperty("BP_TENSILE_END", value)
+	def getResidualTensileCapacity(self) -> float:
+		return self._getDoubleProperty("BP_RES_TENSILE_END")
+	def setResidualTensileCapacity(self, value: float):
+		return self._setDoubleProperty("BP_RES_TENSILE_END", value)
+	def getTributaryArea(self) -> float:
+		return self._getDoubleProperty("BP_TRIBUTARY_AREA")
+	def setTributaryArea(self, value: float):
+		return self._setDoubleProperty("BP_TRIBUTARY_AREA", value)
+	def getBoltModulusE(self) -> float:
+		return self._getDoubleProperty("BP_BOLT_MODULUS")
+	def setBoltModulusE(self, value: float):
+		return self._setDoubleProperty("BP_BOLT_MODULUS", value)
+	def getOutofPlaneSpacing(self) -> float:
+		return self._getDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT")
+	def setOutofPlaneSpacing(self, value: float):
+		return self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", value)
+	def getMaterialDependent(self) -> bool:
+		return self._getBoolProperty("BP_MATERIAL_DEPENDENT")
+	def setMaterialDependent(self, value: bool):
+		return self._setBoolProperty("BP_MATERIAL_DEPENDENT", value)
+	def getBondStrengthCoefficient(self) -> float:
+		return self._getDoubleProperty("BP_BOND_STRENGTH_COEFFICIENT")
+	def setBondStrengthCoefficient(self, value: float):
+		return self._setDoubleProperty("BP_BOND_STRENGTH_COEFFICIENT", value)
+	def getBondShearStiffnessCoefficient(self) -> float:
+		return self._getDoubleProperty("BP_BOND_SHEAR_STIFF_COEFFICIENT")
+	def setBondShearStiffnessCoefficient(self, value: float):
+		return self._setDoubleProperty("BP_BOND_SHEAR_STIFF_COEFFICIENT", value)
+	def getBondShearStiffness(self) -> float:
+		return self._getDoubleProperty("BP_BOND_SHEAR_STIFFNESS")
+	def setBondShearStiffness(self, value: float):
+		return self._setDoubleProperty("BP_BOND_SHEAR_STIFFNESS", value)
+	def getBondStrength(self) -> float:
+		return self._getDoubleProperty("BP_BOND_STRENGTH")
+	def setBondStrength(self, value: float):
+		return self._setDoubleProperty("BP_BOND_STRENGTH", value)
+	def getResidualBondStrength(self) -> float:
+		return self._getDoubleProperty("BP_RES_BOND_STRENGTH")
+	def setResidualBondStrength(self, value: float):
+		return self._setDoubleProperty("BP_RES_BOND_STRENGTH", value)
+	def getBoltModel(self) -> BoltModels:
+		return BoltModels(self._getEnumEBoltModelsProperty("BP_BOLT_MODEL"))
+	def setBoltModel(self, value: BoltModels):
+		return self._setEnumEBoltModelsProperty("BP_BOLT_MODEL", value)
+	def getJointShear(self) -> bool:
+		return self._getBoolProperty("BP_USE_JOINT_SHEAR")
+	def setJointShear(self, value: bool):
+		return self._setBoolProperty("BP_USE_JOINT_SHEAR", value)
+	def getPreTensioningForce(self) -> float:
+		return self._getDoubleProperty("BP_PRETENSIONING")
+	def setPreTensioningForce(self, value: float):
+		return self._setDoubleProperty("BP_PRETENSIONING", value)
+	def getConstantPretensioningForceInInstallStage(self) -> bool:
+		return self._getBoolProperty("BP_USE_CONSTANT_FORCE")
+	def setConstantPretensioningForceInInstallStage(self, value: bool):
+		return self._setBoolProperty("BP_USE_CONSTANT_FORCE", value)
+	def getFacePlates(self) -> bool:
+		return self._getBoolProperty("BP_FACE_PLATES")
+	def setFacePlates(self, value: bool):
+		return self._setBoolProperty("BP_FACE_PLATES", value)
+	def getAddPullOutForce(self) -> bool:
+		return self._getBoolProperty("BP_ADD_PULL_OUT_FORCE")
+	def setAddPullOutForce(self, value: bool):
+		return self._setBoolProperty("BP_ADD_PULL_OUT_FORCE", value)
+	def getPullOutForce(self) -> float:
+		return self._getDoubleProperty("BP_PULL_OUT_FORCE")
+	def setPullOutForce(self, value: float):
+		return self._setDoubleProperty("BP_PULL_OUT_FORCE", value)
+	def setProperties(self, TensileCapacity : float = None, ResidualTensileCapacity : float = None, TributaryArea : float = None, BoltModulusE : float = None, OutofPlaneSpacing : float = None, MaterialDependent : bool = None, BondStrengthCoefficient : float = None, BondShearStiffnessCoefficient : float = None, BondShearStiffness : float = None, BondStrength : float = None, ResidualBondStrength : float = None, BoltModel : BoltModels = None, JointShear : bool = None, PreTensioningForce : float = None, ConstantPretensioningForceInInstallStage : bool = None, FacePlates : bool = None, AddPullOutForce : bool = None, PullOutForce : float = None):
+		if TensileCapacity is not None:
+			self._setDoubleProperty("BP_TENSILE_END", TensileCapacity)
+		if ResidualTensileCapacity is not None:
+			self._setDoubleProperty("BP_RES_TENSILE_END", ResidualTensileCapacity)
+		if TributaryArea is not None:
+			self._setDoubleProperty("BP_TRIBUTARY_AREA", TributaryArea)
+		if BoltModulusE is not None:
+			self._setDoubleProperty("BP_BOLT_MODULUS", BoltModulusE)
+		if OutofPlaneSpacing is not None:
+			self._setDoubleProperty("BP_OUT_OF_PLANE_SPACING_BOLT", OutofPlaneSpacing)
+		if MaterialDependent is not None:
+			self._setBoolProperty("BP_MATERIAL_DEPENDENT", MaterialDependent)
+		if BondStrengthCoefficient is not None:
+			self._setDoubleProperty("BP_BOND_STRENGTH_COEFFICIENT", BondStrengthCoefficient)
+		if BondShearStiffnessCoefficient is not None:
+			self._setDoubleProperty("BP_BOND_SHEAR_STIFF_COEFFICIENT", BondShearStiffnessCoefficient)
+		if BondShearStiffness is not None:
+			self._setDoubleProperty("BP_BOND_SHEAR_STIFFNESS", BondShearStiffness)
+		if BondStrength is not None:
+			self._setDoubleProperty("BP_BOND_STRENGTH", BondStrength)
+		if ResidualBondStrength is not None:
+			self._setDoubleProperty("BP_RES_BOND_STRENGTH", ResidualBondStrength)
+		if BoltModel is not None:
+			self._setEnumEBoltModelsProperty("BP_BOLT_MODEL", BoltModel)
+		if JointShear is not None:
+			self._setBoolProperty("BP_USE_JOINT_SHEAR", JointShear)
+		if PreTensioningForce is not None:
+			self._setDoubleProperty("BP_PRETENSIONING", PreTensioningForce)
+		if ConstantPretensioningForceInInstallStage is not None:
+			self._setBoolProperty("BP_USE_CONSTANT_FORCE", ConstantPretensioningForceInInstallStage)
+		if FacePlates is not None:
+			self._setBoolProperty("BP_FACE_PLATES", FacePlates)
+		if AddPullOutForce is not None:
+			self._setBoolProperty("BP_ADD_PULL_OUT_FORCE", AddPullOutForce)
+		if PullOutForce is not None:
+			self._setDoubleProperty("BP_PULL_OUT_FORCE", PullOutForce)
+	def getProperties(self):
+		return {
+		"TensileCapacity" : self.getTensileCapacity(), 
+		"ResidualTensileCapacity" : self.getResidualTensileCapacity(), 
+		"TributaryArea" : self.getTributaryArea(), 
+		"BoltModulusE" : self.getBoltModulusE(), 
+		"OutofPlaneSpacing" : self.getOutofPlaneSpacing(), 
+		"MaterialDependent" : self.getMaterialDependent(), 
+		"BondStrengthCoefficient" : self.getBondStrengthCoefficient(), 
+		"BondShearStiffnessCoefficient" : self.getBondShearStiffnessCoefficient(), 
+		"BondShearStiffness" : self.getBondShearStiffness(), 
+		"BondStrength" : self.getBondStrength(), 
+		"ResidualBondStrength" : self.getResidualBondStrength(), 
+		"BoltModel" : self.getBoltModel(), 
+		"JointShear" : self.getJointShear(), 
+		"PreTensioningForce" : self.getPreTensioningForce(), 
+		"ConstantPretensioningForceInInstallStage" : self.getConstantPretensioningForceInInstallStage(), 
+		"FacePlates" : self.getFacePlates(), 
+		"AddPullOutForce" : self.getAddPullOutForce(), 
+		"PullOutForce" : self.getPullOutForce(), 
+		}