RS3Scripting 4.42.0__py3-none-any.whl

rs3/results/JointResults.py

@@ -0,0 +1,160 @@
+from typing import Optional, Union
+import rs3.generatedFiles.JointResultsQueryService_pb2_grpc as JointResultsQueryService_pb2_grpc
+import rs3.generatedFiles.ResultsQueryCommonMessage_pb2 as ResultsQueryCommonMessage_pb2
+from rs3._proxyObject import _ProxyObject
+from rs3._client import Client
+from rs3.Geometry import Cube, Cylinder, Sphere
+from rs3.results.ResultEnums import *
+
+class JointNodalResults:
+    '''
+    Nodal result wrapper with per-material data access.
+
+    Notes:
+        - EntityNames/EntityIDs correspond to owning entities for this node.
+    '''
+    def __init__(self, grpcNodalResults):
+        self._grpcNodalResults = grpcNodalResults
+        
+    @property
+    def EntityName(self):
+        return self._grpcNodalResults.entityInformation.name
+
+    @property
+    def EntityID(self):
+        return self._grpcNodalResults.entityInformation.ID
+    
+    @property
+    def NodeID(self):
+        return self._grpcNodalResults.nodeInformation.nodeID
+
+    @property
+    def XCoordinate(self):
+        return self._grpcNodalResults.nodeInformation.location.x
+    
+    @property
+    def YCoordinate(self):
+        return self._grpcNodalResults.nodeInformation.location.y
+    
+    @property
+    def ZCoordinate(self):
+        return self._grpcNodalResults.nodeInformation.location.z 
+    
+class JointElementResults:
+    '''
+    Element-level results wrapper for a specific stage/SRF context.
+
+    Notes:
+        - AttachedNodes returns a copy of node IDs; modifying it does not affect internal state.
+    '''
+    def __init__(self, grpcElementResults):
+        self._grpcElementResults = grpcElementResults
+        self._jointResults = grpcElementResults.jointNodalResults
+    
+    @property
+    def ElementID(self):
+        return self._grpcElementResults.elementInformation.elementID
+    
+    @property
+    def AttachedNodeIDs(self):
+        return list(self._grpcElementResults.elementInformation.nodeIDs)
+
+    @property
+    def EntityName(self):
+        return self._grpcElementResults.entityInformation.name
+
+    @property
+    def EntityID(self):
+        return self._grpcElementResults.entityInformation.ID
+
+    @property
+    def FailureType(self):
+        return JointGaussPointFailureCombinations(self._grpcElementResults.failureType)
+    
+    def getResults(self, dataType: InterfaceResultTypes) -> list[float]:
+        if not self._jointResults:
+            raise ValueError("No joint results available")
+
+        result = self._jointResults[0]
+        return getattr(result, dataType.value)   
+
+class JointResults(_ProxyObject):
+    '''
+    Entry point to query joint nodal/element results for a given stage and SRF.
+
+    Parameters:
+        stageNumber (int): 1-based stage index.
+        srfResultIndex (int): 0-based SRF value index. 0 is to query SRF-None values.
+
+    Notes:
+        - entityName is trimmed; empty strings are ignored.
+        - region=None leaves the proto field unset (service returns all).
+        - Exceptions from the underlying service are propagated as-is by the client.
+
+    Examples:
+        See :ref:`joint_result_example`.
+    '''
+
+    def __init__(self, client: Client, projectId: str, stageNumber: list[int], srfResultIndex: int):
+        super().__init__(client, projectId)
+        self._queryService = JointResultsQueryService_pb2_grpc.JointResultsQueryServiceStub(self._client.channel)
+        self._stageNumber = stageNumber
+        self._srfResultIndex = srfResultIndex
+    
+    def getJointNodeResults(self, entityNames: Optional[list[str]] = None, region: Optional[Union[Cube, Cylinder, Sphere]] = None, includeIntersecting: bool = True) -> list[JointNodalResults]:
+        request = self._makeRequest(entityNames, region, includeIntersecting)     
+        stream = self._queryService.GetJointNodeResults(request)
+        
+        results = []
+        totalQueriedNodesCount = None
+        
+        for chunk in stream:
+            if chunk.HasField('header'):
+                header = chunk.header
+                totalQueriedNodesCount = header.totalQueriedNodesCount
+            elif chunk.HasField('data'):
+                results.extend(chunk.data.results)
+                
+        if totalQueriedNodesCount != len(results):
+            raise RuntimeError(f"Number of nodes received does not match the expected total queried nodes count. Expected {totalQueriedNodesCount}, but received {len(results)}")
+                    
+        return [JointNodalResults(r) for r in results]
+    
+    def getJointElementResults(self, entityName: Optional[str] = None, region: Optional[Union[Cube, Cylinder, Sphere]] = None, includeIntersecting: bool = True) -> list[JointElementResults]:
+        request = self._makeRequest(entityName, region, includeIntersecting)        
+        stream = self._queryService.GetJointElementResults(request)
+        
+        results = []
+        totalQueriedElementsCount = None
+        
+        for chunk in stream:
+            if chunk.HasField('header'):
+                header = chunk.header
+                totalQueriedElementsCount = header.totalQueriedElementsCount
+            elif chunk.HasField('data'):
+                results.extend(chunk.data.results)
+                
+        if totalQueriedElementsCount != len(results):
+            raise RuntimeError(f"Number of elements received does not match the expected total queried elements count. Expected {totalQueriedElementsCount}, but received {len(results)}")
+
+        return [JointElementResults(r) for r in results]
+
+    def _makeRequest(self, entityName: Optional[str], region: Optional[Union[Cube, Cylinder, Sphere]], includeIntersecting: bool = True) -> ResultsQueryCommonMessage_pb2.ResultsQueryRequest:       
+        request = ResultsQueryCommonMessage_pb2.ResultsQueryRequest(
+            _projectId=self._objectId,
+            stageNumber=self._stageNumber,
+            srfValueNumber=self._srfResultIndex)
+        
+        if entityName:
+        # Trim whitespace inside each string if needed
+            request.entityName = entityName.strip()
+        
+        if region is not None:
+            if isinstance(region, (Cube, Cylinder, Sphere)):
+                common_region = region.toCommonGeometryObject()
+                request.sampleRegion.region.CopyFrom(common_region)
+                request.sampleRegion.includeIntersecting = includeIntersecting
+            else:
+                raise TypeError(f"Unsupported region type: {type(region)}")
+
+        return request

rs3/results/PileForepoleResults.py

@@ -0,0 +1,219 @@
+from typing import List, Dict, Union, Optional, Tuple
+
+import rs3.generatedFiles.PileForepoleResultsQueryService_pb2_grpc as PileForepoleResultsQueryService_pb2_grpc
+
+from rs3._client import Client
+
+from rs3.results.ResultsCommon import _NodeValuePairCollection, _ResultsQueryBase
+from rs3.results.ResultEnums import BeamsDataType, PileInterfaceDataType, BeamForepolePileGaussPointFailureType
+from rs3.results.YieldedElement import YieldedElement
+from rs3.Geometry import Cube, Cylinder, Sphere
+
+
+class PileNodeResults:
+    def __init__(self, grpcNodeResults):
+        self._grpcNodeResults = grpcNodeResults
+    
+    @property
+    def NodeID(self):
+        return self._grpcNodeResults.nodeInformation.nodeID
+    
+    @property
+    def XCoordinate(self):
+        return self._grpcNodeResults.nodeInformation.location.x
+    
+    @property
+    def YCoordinate(self):
+        return self._grpcNodeResults.nodeInformation.location.y
+    
+    @property
+    def ZCoordinate(self):
+        return self._grpcNodeResults.nodeInformation.location.z
+    
+    @property
+    def EntityName(self):
+        return self._grpcNodeResults.entityInformation.name
+    
+    @property
+    def EntityID(self):
+        return self._grpcNodeResults.entityInformation.ID
+
+    @property
+    def PileID(self):
+        return self._grpcNodeResults.indexToPattern
+
+
+
+class PileForepoleElementResults:
+    def __init__(self, grpcElementResults):
+        self._grpcElementResults = grpcElementResults
+        self._nodeResultsByDataType = self._buildNodeResultsByDataType(grpcElementResults)
+        self._yieldedElement = YieldedElement(grpcElementResults.failurePoint, failureTypeEnum=BeamForepolePileGaussPointFailureType) if grpcElementResults.HasField('failurePoint') else None
+        self._interfaceYieldedElement = YieldedElement(grpcElementResults.interfaceFailurePoint, failureTypeEnum=BeamForepolePileGaussPointFailureType) if grpcElementResults.HasField('interfaceFailurePoint') else None
+    
+    @property
+    def EntityName(self):
+        return self._grpcElementResults.entityInformation.name
+
+    @property
+    def EntityID(self):
+        return self._grpcElementResults.entityInformation.ID
+
+    @property
+    def AttachedNodeIDs(self):
+        return self._grpcElementResults.nodeIDs
+
+    @property
+    def PileID(self):
+        return self._grpcElementResults.pileID
+
+    @property
+    def BeamID(self):
+        return self._grpcElementResults.beamElementID
+
+    @property
+    def InterfaceID(self):
+        return self._grpcElementResults.interfaceElementID
+
+    def getNodeResult(self, dataType: Union[BeamsDataType, PileInterfaceDataType]) -> List[float]:
+        key = (type(dataType), dataType)
+        if key not in self._nodeResultsByDataType:
+            raise ValueError(f"Data type {dataType} not found")
+        return self._nodeResultsByDataType[key].ResultValues
+
+
+    def getResultsInNodeDataTuple(self, dataType: Union[BeamsDataType, PileInterfaceDataType]) -> List[Tuple[int, float]]:
+        key = (type(dataType), dataType)
+        if key not in self._nodeResultsByDataType:
+            raise ValueError(f"Data type {dataType} not found")
+        return self._nodeResultsByDataType[key].NodeValuePairs
+
+
+    @property
+    def YieldedElement(self):
+        return self._yieldedElement
+
+    @property
+    def InterfaceYieldedElement(self):
+        return self._interfaceYieldedElement
+
+    
+    def _buildNodeResultsByDataType(self, grpcElementResults):
+        nodeIDElementValuePairs = [(nodeID, nodeValue) for nodeID, nodeValue in zip(grpcElementResults.nodeIDs, grpcElementResults.nodeValues.elementNodeValues)]
+        nodeIDInterfaceValuePairs = [(nodeID, nodeValue) for nodeID, nodeValue in zip(grpcElementResults.nodeIDs, grpcElementResults.nodeValues.interfaceNodeValues)]
+        beamNodePairsByType: Dict[BeamsDataType, List[tuple[int, float]]] = {dt: [] for dt in BeamsDataType}
+        for nodeID, nodeValue in nodeIDElementValuePairs:
+            beamNodePairsByType[BeamsDataType.AXIS_FORCE].append((nodeID, nodeValue.axisForce))
+            beamNodePairsByType[BeamsDataType.SHEAR_FORCE_MIN_AXIS].append((nodeID, nodeValue.shearForceMinAxis))
+            beamNodePairsByType[BeamsDataType.SHEAR_FORCE_MAX_AXIS].append((nodeID, nodeValue.shearForceMaxAxis))
+            beamNodePairsByType[BeamsDataType.MOMENT_MIN_AXIS].append((nodeID, nodeValue.momentMinAxis))
+            beamNodePairsByType[BeamsDataType.MOMENT_MAX_AXIS].append((nodeID, nodeValue.momentMaxAxis))
+            beamNodePairsByType[BeamsDataType.DISPLACEMENT_X].append((nodeID, nodeValue.displacementX))
+            beamNodePairsByType[BeamsDataType.DISPLACEMENT_Y].append((nodeID, nodeValue.displacementY))
+            beamNodePairsByType[BeamsDataType.DISPLACEMENT_Z].append((nodeID, nodeValue.displacementZ))
+            beamNodePairsByType[BeamsDataType.DISPLACEMENT_TOTAL].append((nodeID, nodeValue.totalDisplacement))
+        interfaceNodePairsByType: Dict[PileInterfaceDataType, List[tuple[int, float]]] = {dt: [] for dt in PileInterfaceDataType}
+        for nodeID, nodeValue in nodeIDInterfaceValuePairs:
+            interfaceNodePairsByType[PileInterfaceDataType.SHEAR_FORCE].append((nodeID, nodeValue.shearForce))
+            interfaceNodePairsByType[PileInterfaceDataType.NORMAL_FORCE_MIN_AXIS].append((nodeID, nodeValue.normalForceMinAxis))
+            interfaceNodePairsByType[PileInterfaceDataType.NORMAL_FORCE_MAX_AXIS].append((nodeID, nodeValue.normalForceMaxAxis))
+            interfaceNodePairsByType[PileInterfaceDataType.CONFINING_STRESS].append((nodeID, nodeValue.confiningStress))
+            interfaceNodePairsByType[PileInterfaceDataType.DISPLACEMENT_X].append((nodeID, nodeValue.rockDisplacementX))
+            interfaceNodePairsByType[PileInterfaceDataType.DISPLACEMENT_Y].append((nodeID, nodeValue.rockDisplacementY))
+            interfaceNodePairsByType[PileInterfaceDataType.DISPLACEMENT_Z].append((nodeID, nodeValue.rockDisplacementZ))
+            interfaceNodePairsByType[PileInterfaceDataType.DISPLACEMENT_TOTAL].append((nodeID, nodeValue.rockTotalDisplacement))
+
+        # Use (type(dt), dt) as key so BeamsDataType and PileInterfaceDataType entries with same
+        # enum value (e.g. DISPLACEMENT_TOTAL) are stored separately; str Enum equality would
+        # otherwise collapse them into one key.
+        nodeResultsByType: Dict[Tuple[type, Union[BeamsDataType, PileInterfaceDataType]], _NodeValuePairCollection] = {}
+        for dt, pairs in beamNodePairsByType.items():
+            nodeResultsByType[(BeamsDataType, dt)] = _NodeValuePairCollection(pairs)
+        for dt, pairs in interfaceNodePairsByType.items():
+            nodeResultsByType[(PileInterfaceDataType, dt)] = _NodeValuePairCollection(pairs)
+
+        return nodeResultsByType
+
+
+
+class PileForepoleResults(_ResultsQueryBase):
+    '''
+    Entry point to query pile forepole nodal/element results for a given stage and SRF.
+
+    Parameters:
+        stageNumber (int): 1-based stage index.
+        srfResultIndex (int): 0-based SRF value index. 0 is to query SRF-None values.
+
+    Notes:
+        - entityName is trimmed; empty strings are ignored.
+        - region=None leaves the proto field unset (service returns all).
+        - Exceptions from the underlying service are propagated as-is by the client.
+
+    Examples:
+        See :ref:`pile_result_example`.
+    '''
+    def __init__(self, client: Client, projectId: str, stageNumber: int, srfResultIndex: int):
+        super().__init__(client, projectId, stageNumber, srfResultIndex)
+        self._queryService = PileForepoleResultsQueryService_pb2_grpc.PileForepoleResultsQueryServiceStub(client.channel)
+
+    
+    def getPileForepoleNodeResults(self, entityName: Optional[str] = None, region: Optional[Union[Cube, Cylinder, Sphere]] = None, includeIntersecting: bool = True) -> list[PileNodeResults]:
+        '''
+        Query pile forepole node results at a specific stage and SRF value.
+        Parameters:
+            entityName: Optional[str]: If provided, only nodes belonging to the specified entity are queried.
+            region: Optional[Union[Cube, Cylinder, Sphere]]: Sample region filter. When None, the field is not set in the request (proto3 unset), and the service returns all nodes.
+            includeIntersecting: bool: If True, nodes that intersect the sample region are included. When False, only nodes fully contained are included. Ignored when region is None.
+        Raises:
+            Exception if:
+                - stageNumber is less than 1
+                - stageNumber is greater than the number of stages in the project
+                - _srfResultIndex is less than 0
+                - _srfResultIndex is greater than the number of SRF values in the project
+        Returns:
+            list[PileNodeResults]: A list of pile forepole node results wrappers for the requested stage and SRF value.
+        '''
+        request = self._makeRequest(entityName, region, includeIntersecting)
+        stream = self._queryService.QueryPileForepoleNodeResults(request)
+        allResults = []
+        totalQueriedNodesCount = None
+        for chunk in stream:
+            if chunk.HasField('header'):
+                header = chunk.header
+                totalQueriedNodesCount = header.totalQueriedNodesCount
+            elif chunk.HasField('data'):
+                allResults.extend(chunk.data.results)
+        if totalQueriedNodesCount is not None and totalQueriedNodesCount != len(allResults):
+            raise RuntimeError(f"Number of nodes received does not match the expected total queried nodes count. Expected {totalQueriedNodesCount}, but received {len(allResults)}.")
+        return [PileNodeResults(r) for r in allResults]
+    
+
+    def getPileForepoleElementResults(self, entityName: Optional[str] = None, region: Optional[Union[Cube, Cylinder, Sphere]] = None, includeIntersecting: bool = True) -> list[PileForepoleElementResults]:
+        '''
+        Query pile forepole element results at a specific stage and SRF value.
+        Parameters:
+            entityName: Optional[str]: If provided, only elements belonging to the specified entity are queried.
+            region: Optional[Union[Cube, Cylinder, Sphere]]: Sample region filter. When None, the field is not set in the request (proto3 unset), and the service returns all elements.
+            includeIntersecting: bool: If True, elements that intersect the sample region are included. When False, only elements fully contained are included. Ignored when region is None.
+        Raises:
+            Exception if:
+                - stageNumber is less than 1
+                - stageNumber is greater than the number of stages in the project
+                - _srfResultIndex is less than 0
+                - _srfResultIndex is greater than the number of SRF values in the project
+        Returns:
+            list[PileForepoleElementResults]: A list of pile forepole element results wrappers for the requested stage and SRF value.
+        '''
+        request = self._makeRequest(entityName, region, includeIntersecting)
+        stream = self._queryService.QueryPileForepoleElementResults(request)
+        allResults = []
+        totalQueriedElementsCount = None
+        for chunk in stream:
+            if chunk.HasField('header'):
+                header = chunk.header
+                totalQueriedElementsCount = header.totalQueriedElementsCount
+            elif chunk.HasField('data'):
+                allResults.extend(chunk.data.results)
+        if totalQueriedElementsCount is not None and totalQueriedElementsCount != len(allResults):
+            raise RuntimeError(f"Number of elements received does not match the expected total queried elements count. Expected {totalQueriedElementsCount}, but received {len(allResults)}.")
+        return [PileForepoleElementResults(r) for r in allResults]

rs3/results/ResultEnums.py

@@ -0,0 +1,146 @@
+from enum import Enum
+
+class SolidsDataType(str, Enum):
+    SIGMA_1_EFFECTIVE = "sigma1"
+    SIGMA_2_EFFECTIVE = "sigma2"
+    SIGMA_3_EFFECTIVE = "sigma3"
+    STRESS_MEAN = "stressMean"
+    STRESS_VON_MISES = "stressVonMises"
+    SIGMA_1_TOTAL = "sigma1Total"
+    SIGMA_2_TOTAL = "sigma2Total"
+    SIGMA_3_TOTAL = "sigma3Total"
+    STRESS_MEAN_TOTAL = "stressMeanTotal"
+    STRESS_VON_MISES_TOTAL = "stressVonMisesTotal"
+    DISPLACEMENT_X = "displacementX"
+    DISPLACEMENT_Y = "displacementY"
+    DISPLACEMENT_Z = "displacementZ"
+    TOTAL_DISPLACEMENT = "totalDisplacement"
+    EXCESS_PWP = "excessPWP"
+    TOTAL_PWP = "totalPWP"
+    VOLUMETRIC_STRAIN = "volumetricStrain"
+    MAX_SHEAR_STRAIN = "maxShearStrain"
+    SIGMA_XX_EFFECTIVE = "sigmaXX"
+    SIGMA_YY_EFFECTIVE = "sigmaYY"
+    SIGMA_ZZ_EFFECTIVE = "sigmaZZ"
+    SIGMA_XY_EFFECTIVE = "sigmaXY"
+    SIGMA_XZ_EFFECTIVE = "sigmaXZ"
+    SIGMA_YZ_EFFECTIVE = "sigmaYZ"
+    SIGMA_XX_TOTAL = "sigmaXXTotal"
+    SIGMA_YY_TOTAL = "sigmaYYTotal"
+    SIGMA_ZZ_TOTAL = "sigmaZZTotal"
+    SIGMA_XY_TOTAL = "sigmaXYTotal"
+    SIGMA_XZ_TOTAL = "sigmaXZTotal"
+    SIGMA_YZ_TOTAL = "sigmaYZTotal"
+    STRAIN_P_MAJOR = "strainPMajor"
+    STRAIN_P_MEAN = "strainPMean"
+    STRAIN_P_MINOR = "strainPMinor"
+    STRAIN_XX = "strainXX"
+    STRAIN_YY = "strainYY"
+    STRAIN_ZZ = "strainZZ"
+    STRAIN_XY = "strainXY"
+    STRAIN_XZ = "strainXZ"
+    STRAIN_YZ = "strainYZ"
+    PRESSURE_HEAD = "pressureHead"
+    TOTAL_HEAD = "totalHead"
+    DISCHARGE_VELOCITY_X = "dischargeVelocityX"
+    DISCHARGE_VELOCITY_Y = "dischargeVelocityY"
+    DISCHARGE_VELOCITY_Z = "dischargeVelocityZ"
+    TOTAL_DISCHARGE_VELOCITY = "totalDischargeVelocity"
+    HYDRAULIC_GRADIENT_X = "hydraulicGradientX"
+    HYDRAULIC_GRADIENT_Y = "hydraulicGradientY"
+    HYDRAULIC_GRADIENT_Z = "hydraulicGradientZ"
+    HYDRAULIC_GRADIENT_TOTAL = "hydraulicGradientTotal"
+    DEGREE_SATURATION = "degreeSaturation"
+    STRENGTH_FACTOR = "strengthFactor"
+
+
+class BeamsDataType(str, Enum):
+    AXIS_FORCE = "axisForce"
+    SHEAR_FORCE_MIN_AXIS = "shearForceMinAxis"
+    SHEAR_FORCE_MAX_AXIS = "shearForceMaxAxis"
+    MOMENT_MIN_AXIS = "momentMinAxis"
+    MOMENT_MAX_AXIS = "momentMaxAxis"
+    DISPLACEMENT_X = "displacementX"
+    DISPLACEMENT_Y = "displacementY"
+    DISPLACEMENT_Z = "displacementZ"
+    DISPLACEMENT_TOTAL = "displacementTotal"
+
+
+class PileInterfaceDataType(str, Enum):
+    SHEAR_FORCE = "shearForce"
+    NORMAL_FORCE_MIN_AXIS = "normalForceMinAxis"
+    NORMAL_FORCE_MAX_AXIS = "normalForceMaxAxis"
+    CONFINING_STRESS = "confiningStress"
+    DISPLACEMENT_X = "displacementX"
+    DISPLACEMENT_Y = "displacementY"
+    DISPLACEMENT_Z = "displacementZ"
+    DISPLACEMENT_TOTAL = "displacementTotal"
+
+
+class BeamForepolePileGaussPointFailureType(str, Enum):
+    NONE = "No failure"
+    SHEAR = "Shear failure"
+    TENSION = "Tension failure"
+    TENSION_SHEAR = "Shear + tension failure"
+    COMPRESSION = "Compression failure"
+
+class LinerResultTypes(Enum):
+    DISPLACEMENT_X = "DISPLACEMENT_X"
+    DISPLACEMENT_Y = "DISPLACEMENT_Y"
+    DISPLACEMENT_Z = "DISPLACEMENT_Z"
+    TOTAL_DISPLACEMENT = "TOTAL_DISPLACEMENT"
+    NORMAL_DISPLACEMENT = "NORMAL_DISPLACEMENT"
+    AXIAL_FORCE_XX = "AXIAL_FORCE_XX"
+    AXIAL_FORCE_YY = "AXIAL_FORCE_YY"
+    AXIAL_FORCE_ZZ = "AXIAL_FORCE_ZZ"
+    SHEAR_FORCE_YZ = "SHEAR_FORCE_YZ"
+    SHEAR_FORCE_XZ = "SHEAR_FORCE_XZ"
+    SHEAR_FORCE_XY = "SHEAR_FORCE_XY"
+    MOMENT_XX = "MOMENT_XX"
+    MOMENT_YY = "MOMENT_YY"
+    MOMENT_ZZ = "MOMENT_ZZ"
+    MOMENT_YZ = "MOMENT_YZ"
+    MOMENT_XZ = "MOMENT_XZ"
+    MOMENT_XY = "MOMENT_XY"
+    
+class InterfaceResultTypes(Enum):
+    DISPLACEMENT_X = "DISPLACEMENT_X"
+    DISPLACEMENT_Y = "DISPLACEMENT_Y"
+    DISPLACEMENT_Z = "DISPLACEMENT_Z"
+    NORMAL_STRESS = "NORMAL_STRESS"
+    SHEAR_STRESS = "SHEAR_STRESS"
+    PLASTIC_STRAIN = "PLASTIC_STRAIN"
+    DISPLACEMENT_NORMAL = "DISPLACEMENT_NORMAL"
+    DISPLACEMENT_SHEAR = "DISPLACEMENT_SHEAR"
+    
+class LinerGaussPointFailureCombinations(Enum):
+    NONE = "NONE"
+    TENSION = "TENSION"
+    COMPRESSION = "COMPRESSION"
+    
+class JointGaussPointFailureCombinations(Enum):
+    NONE = "NONE"
+    SHEAR = "SHEAR"
+    TENSION = "TENSION"
+    TENSION_SHEAR = "TENSION_SHEAR"
+    
+class BoltDataType(str, Enum):
+    AXIAL_FORCE = "axialForce"
+    AXIAL_STRESS = "axialStress"
+    DISPLACEMENT_X = "displacementX"
+    DISPLACEMENT_Y = "displacementY"
+    DISPLACEMENT_Z = "displacementZ"
+    DISPLACEMENT_TOTAL = "displacementTotal"
+    INTERFACE_SHEAR_FORCE = "interfaceShearForce"
+    INTERFACE_DISPLACEMENT_X = "interfaceDisplacementX"
+    INTERFACE_DISPLACEMENT_Y = "interfaceDisplacementY"
+    INTERFACE_DISPLACEMENT_Z = "interfaceDisplacementZ"
+    INTERFACE_DISPLACEMENT_TOTAL = "interfaceDisplacementTotal"
+
+
+class BoltGaussPointFailureType(str, Enum):
+    NONE = "No failure"
+    SHEAR = "Shear failure"
+    TENSION = "Tension failure"
+    TENSION_SHEAR = "Shear + tension failure"
+    COMPRESSION = "Compression failure"