RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/pile/PileCommon.py

@@ -0,0 +1,99 @@
+# 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
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.PileStageFactorService_pb2_grpc as PileStageFactorService_pb2_grpc
+class PileCommonBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getShearStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ShearStiffness")
+    def setShearStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ShearStiffness", value)
+    def getNormalStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("NormalStiffness")
+    def setNormalStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("NormalStiffness", value)
+    def getUsingPileProperties(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsPile")
+    def setUsingPileProperties(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsPile", value)
+    def getBaseNormalStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("BaseNormalStiffness")
+    def setBaseNormalStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("BaseNormalStiffness", value)
+    def getBaseForceResistance(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("BaseForceResistance")
+    def setBaseForceResistance(self, value: float):
+        self._propertyAccessor.setDoubleProperty("BaseForceResistance", value)
+    def getProperties(self):
+        return {
+            "ShearStiffness": self.getShearStiffness(),
+            "NormalStiffness": self.getNormalStiffness(),
+            "UsingPileProperties": self.getUsingPileProperties(),
+            "BaseNormalStiffness": self.getBaseNormalStiffness(),
+            "BaseForceResistance": self.getBaseForceResistance(),
+        }
+    def setProperties(self, ShearStiffness: float = None, NormalStiffness: float = None, UsingPileProperties: bool = None, BaseNormalStiffness: float = None, BaseForceResistance: float = None):
+        if ShearStiffness is not None:
+            self.setShearStiffness(ShearStiffness)
+        if NormalStiffness is not None:
+            self.setNormalStiffness(NormalStiffness)
+        if UsingPileProperties is not None:
+            self.setUsingPileProperties(UsingPileProperties)
+        if BaseNormalStiffness is not None:
+            self.setBaseNormalStiffness(BaseNormalStiffness)
+        if BaseForceResistance is not None:
+            self.setBaseForceResistance(BaseForceResistance)
+class PileCommonStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, PileStageFactorService_pb2_grpc.PileStageFactorServiceStub(client.channel))
+    def getEndConditionFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_Force")
+    def getShearStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_ShearStiffness")
+    def getNormalStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_NormalStiffness")
+    def getBaseStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_BaseStiffness")
+    def getBaseResistanceFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_BaseResistance")
+class PileCommonDefinedStageFactorBase(PileCommonStageFactorBase):
+    def setEndConditionFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_Force", value)
+    def setShearStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_ShearStiffness", value)
+    def setNormalStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_NormalStiffness", value)
+    def setBaseStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_BaseStiffness", value)
+    def setBaseResistanceFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_BaseResistance", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.PropertyEnums import *
+class PileCommonStageFactor(PileCommonStageFactorBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+        
+class PileCommonDefinedStageFactor(PileCommonStageFactor, PileCommonDefinedStageFactorBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""
+    pass
+
+class PileCommon(PileCommonBase):
+    """
+	Examples:
+		See :ref:`pile_example`.
+	"""    
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)

rs3/properties/pile/_PropertyAccessor.py

@@ -0,0 +1,9 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor
+import rs3.generatedFiles.PileDataService_pb2_grpc as PileDataService_pb2_grpc
+from rs3._client import Client
+class PropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str, serviceStub = None):
+        if serviceStub is None:
+            serviceStub = PileDataService_pb2_grpc.PileDataServiceStub(client.channel)
+        super().__init__(client, objectId, serviceStub)
+

rs3/properties/stageFactors/IStageFactorBase.py

@@ -0,0 +1,10 @@
+from rs3._client import Client
+from rs3.properties.stageFactors._StageFactorPropertyAccessor import StageFactorPropertyAccessor
+from rs3._proxyObject import _ProxyObject
+
+class IStageFactorBase(_ProxyObject) :
+    def __init__(self, parentID : str, stageFactorID : str, client : Client, stub):
+        super().__init__(client, stageFactorID)
+        self.parentID = parentID
+        self._stub = stub
+        self._stageFactorPropertyAccessor = StageFactorPropertyAccessor(parentID, stageFactorID, client, stub)

rs3/properties/stageFactors/StageFactorBaseInterfaces.py

@@ -0,0 +1,24 @@
+from rs3.properties.stageFactors._StageFactorInterface import _AbsoluteStageFactorInterface
+from rs3.properties.PropertyEnums import *
+from rs3._client import Client
+from typing import TypeVar
+
+DefinedStageFactor = TypeVar('DefinedStageFactor')
+StageFactor = TypeVar('StageFactor')
+
+class AbsoluteStageFactorInterface(_AbsoluteStageFactorInterface[DefinedStageFactor, StageFactor]):
+    def __init__(self, propertyID : str, client : Client, definedStageFactorClass, stageFactorClass, useJointOptions : bool = False, materialId : str = None):
+        super().__init__(propertyID, client, definedStageFactorClass, stageFactorClass, useJointOptions, materialId)
+
+    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
+		"""
+        return self._getDefinedStageFactors()
+    
+    def getStageFactor(self, stage : int) -> StageFactor:
+        """
+		Returns the stage factor for the given stage.
+		"""
+        return self._getStageFactor(stage)
+    

rs3/properties/stageFactors/StageFactorInterfaces.py

@@ -0,0 +1,70 @@
+import rs3.generatedFiles.StageFactorService_pb2 as StageFactorService_pb2
+import rs3.generatedFiles.RelativeStageFactorService_pb2 as RelativeStageFactorService_pb2
+import rs3.generatedFiles.RelativeStageFactorService_pb2_grpc as RelativeStageFactorService_pb2_grpc
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface as StageFactorBaseInterfaces
+from rs3.properties.PropertyEnums import *
+from rs3._client import Client
+from typing import TypeVar
+
+DefinedStageFactor = TypeVar('DefinedStageFactor')
+StageFactor = TypeVar('StageFactor')
+
+class AbsoluteStageFactorInterface(StageFactorBaseInterfaces[DefinedStageFactor, StageFactor]):
+    def __init__(self, propertyID : str, client : Client, definedStageFactorClass, stageFactorClass, useJointOptions : bool = False, materialId : str = None):
+        super().__init__(propertyID, client, definedStageFactorClass, stageFactorClass, useJointOptions, materialId)
+        
+    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.
+        """
+        return self._createStageFactor(stage)
+
+    def setDefinedStageFactors(self, stageFactors : dict[int, StageFactor]):
+        """
+        Sets the defined stage factors to those given.
+
+        Note: 
+            Invalidates any existing stage factor proxies. Get them again using getDefinedStageFactors or getStageFactor.
+        """
+        convertedStageFactors = {}
+        for stageNum, stageFactor in stageFactors.items():
+            convertedStageFactors[stageNum] = StageFactorService_pb2.StageFactorProperty(stageFactorID = stageFactor._objectId)
+        self._setDefinedStageFactors(StageFactorMethodType.ABSOLUTE_STAGE_FACTOR, convertedStageFactors)
+
+    def getStageFactorMethod(self) -> StageFactorMethodType:
+        """
+        Returns the method used when defining stage factors.
+        """
+        return StageFactorMethodType.ABSOLUTE_STAGE_FACTOR
+    
+class RelativeStageFactorInterface(AbsoluteStageFactorInterface[DefinedStageFactor, StageFactor]):
+    def __init__(self, propertyID : str, client : Client, definedStageFactorClass, stageFactorClass):
+        super().__init__(propertyID, client, definedStageFactorClass, stageFactorClass)
+        self._relativeStageFactorServiceStub = RelativeStageFactorService_pb2_grpc.RelativeStageFactorServiceStub(self._client.channel)
+    def _getIsRelativeStaging(self) -> bool:
+        getIsRelativeStagingRequest = RelativeStageFactorService_pb2.GetIsRelativeStagingRequest(propertyID = self._propertyID)
+        getIsRelativeStagingResponse : RelativeStageFactorService_pb2.GetIsRelativeStagingResponse = self._client.callFunction(self._relativeStageFactorServiceStub.GetIsRelativeStaging, getIsRelativeStagingRequest)
+        return getIsRelativeStagingResponse.isRelativeStaging
+    
+
+    def setDefinedStageFactors(self, method : StageFactorMethodType, 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.
+            - If the 'stageFactors' dictionary is empty (stageFactors = {}), the stage factor at the installed stage (stage 0) will remain, and its factor values will be reset to their defaults.
+        """
+        convertedStageFactors = {}
+        for stageNum, stageFactor in stageFactors.items():
+            convertedStageFactors[stageNum] = StageFactorService_pb2.StageFactorProperty(stageFactorID = stageFactor._objectId)
+        self._setDefinedStageFactors(method, convertedStageFactors)
+
+    def getStageFactorMethod(self) -> StageFactorMethodType:
+        """
+        Returns the method used when defining stage factors.
+        """
+        return StageFactorMethodType.RELATIVE_STAGE_FACTOR if self._getIsRelativeStaging() else StageFactorMethodType.ABSOLUTE_STAGE_FACTOR

rs3/properties/stageFactors/_StageFactorInterface.py

@@ -0,0 +1,48 @@
+import rs3.generatedFiles.StageFactorService_pb2 as StageFactorService_pb2
+import rs3.generatedFiles.StageFactorService_pb2_grpc as StageFactorService_pb2_grpc
+from rs3.properties.PropertyEnums import *
+from rs3._client import Client
+from typing import TypeVar, Generic
+
+DefinedStageFactor = TypeVar('DefinedStageFactor')
+StageFactor = TypeVar('StageFactor')
+
+class _AbsoluteStageFactorInterface(Generic[DefinedStageFactor, StageFactor]):
+    def __init__(self, propertyID : str, client : Client, definedStageFactorClass, stageFactorClass, useJointOptions : bool = False, materialId : str = None):
+        self._propertyID = propertyID
+        self._client = client
+        self._definedStageFactorClass = definedStageFactorClass
+        self._stageFactorClass = stageFactorClass
+        self._stageFactorServiceStub = StageFactorService_pb2_grpc.StageFactorServiceStub(self._client.channel)
+        self._useJointOptions = useJointOptions
+        self._materialId = materialId
+
+    def _getDefinedStageFactors(self) -> dict[int, DefinedStageFactor]:
+        getDefinedStageFactorsRequest = StageFactorService_pb2.GetDefinedStageFactorsRequest(propertyID = self._propertyID)
+        getDefinedStageFactorsResponse : StageFactorService_pb2.GetDefinedStageFactorsResponse = self._client.callFunction(self._stageFactorServiceStub.GetDefinedStageFactors, getDefinedStageFactorsRequest)
+        definedStageFactors = {}
+        if(self._useJointOptions):
+            for stageFactorProp in getDefinedStageFactorsResponse.stageFactors:
+                definedStageFactors[stageFactorProp.stageAppliedTo] = self._definedStageFactorClass(self._propertyID, stageFactorProp.stageFactorID, self._client, self._materialId)
+        else:  
+            for stageFactorProp in getDefinedStageFactorsResponse.stageFactors:
+                definedStageFactors[stageFactorProp.stageAppliedTo] = self._definedStageFactorClass(self._propertyID, stageFactorProp.stageFactorID, self._client)
+        return definedStageFactors
+    def _getStageFactor(self, stage : int) -> StageFactor:
+        getStageFactorRequest = StageFactorService_pb2.GetStageFactorRequest(propertyID = self._propertyID, stage = stage)
+        if(self._useJointOptions):
+            getStageFactorResponse : StageFactorService_pb2.GetStageFactorResponse = self._client.callFunction(self._stageFactorServiceStub.GetStageFactor, getStageFactorRequest)
+            return self._stageFactorClass(self._propertyID, getStageFactorResponse.stageFactor.stageFactorID, self._client, self._materialId)
+        else:  
+            getStageFactorResponse : StageFactorService_pb2.GetStageFactorResponse = self._client.callFunction(self._stageFactorServiceStub.GetStageFactor, getStageFactorRequest)
+            return self._stageFactorClass(self._propertyID, getStageFactorResponse.stageFactor.stageFactorID, self._client)
+    def _createStageFactor(self, stage : int) -> DefinedStageFactor:
+        createStageFactorRequest = StageFactorService_pb2.CreateStageFactorRequest(propertyID = self._propertyID, stage = stage, useJointOptions=self._useJointOptions)
+        createStageFactorResponse : StageFactorService_pb2.CreateStageFactorResponse = self._client.callFunction(self._stageFactorServiceStub.CreateStageFactor, createStageFactorRequest)
+        if(self._useJointOptions):
+            return self._definedStageFactorClass(self._propertyID, createStageFactorResponse.stageFactor.stageFactorID, self._client, self._materialId)
+        else:
+            return self._definedStageFactorClass(self._propertyID, createStageFactorResponse.stageFactor.stageFactorID, self._client)
+    def _setDefinedStageFactors(self, method : StageFactorMethodType, stageFactors : dict[int, StageFactorService_pb2.StageFactorProperty]):
+        setDefinedStageFactorsRequest = StageFactorService_pb2.SetDefinedStageFactorsRequest(propertyID = self._propertyID, stageFactorDictionary = stageFactors, isRelativeStageFactors = method == StageFactorMethodType.RELATIVE_STAGE_FACTOR, useJointOptions=self._useJointOptions)
+        self._client.callFunction(self._stageFactorServiceStub.SetDefinedStageFactors, setDefinedStageFactorsRequest)

rs3/properties/stageFactors/_StageFactorPropertyAccessor.py

@@ -0,0 +1,18 @@
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+from rs3.properties._PropertyAccessor import PropertyAccessor
+
+class StageFactorPropertyAccessor(PropertyAccessor):
+    def __init__(self, parentObjectId: str, stageFactorId : str, client: Client, stub):
+        super().__init__(client, parentObjectId, stub)
+        self.stageFactorId = stageFactorId
+        
+    def _getProperty(self, propertyName: str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetStageFactorPropertyRequest(propertyId=self.objectId, stageFactorId=self.stageFactorId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetStageFactorPropertyResponse = self._client.callFunction(self._stub.GetStageFactorProperty, request)
+        return response.value
+
+    def _setProperty(self, propertyName: str, value: CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetStageFactorPropertyRequest(propertyId=self.objectId, stageFactorId=self.stageFactorId, propertyName=propertyName, value=value)
+        self._client.callFunction(self._stub.SetStageFactorProperty, request)
+    

rs3/results/BeamResults.py

@@ -0,0 +1,181 @@
+from typing import Optional, Union, List, Dict, Tuple
+
+import rs3.generatedFiles.BeamsResultsQueryService_pb2_grpc as BeamsResultsQueryService_pb2_grpc
+
+from rs3._client import Client
+
+from rs3.Geometry import Cube, Cylinder, Sphere
+from rs3.results.ResultsCommon import _NodeValuePairCollection, _ResultsQueryBase
+from rs3.results.YieldedElement import YieldedElement
+from rs3.results.ResultEnums import BeamsDataType, BeamForepolePileGaussPointFailureType
+
+
+class BeamNodeResults:
+    def __init__(self, grpcNodalResults):
+        self._grpcNodalResults = grpcNodalResults
+
+    @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
+    
+    @property
+    def EntityName(self):
+        return self._grpcNodalResults.entityInformation.name
+    
+    @property
+    def EntityID(self):
+        return self._grpcNodalResults.entityInformation.ID
+
+class BeamElementResults:
+    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
+
+    @property
+    def ElementID(self):
+        return self._grpcElementResults.elementInformation.elementID
+
+    @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.elementInformation.nodeIDs
+
+    
+    def getNodeResult(self, dataType: BeamsDataType) -> List[float]:
+        if dataType not in self._nodeResultsByDataType:
+            raise ValueError(f"Data type {dataType} not found")
+        return self._nodeResultsByDataType[dataType].ResultValues
+
+    
+    def getResultsInNodeDataTuple(self, dataType: BeamsDataType) -> List[Tuple[int, float]]:
+        if dataType not in self._nodeResultsByDataType:
+            raise ValueError(f"Data type {dataType} not found")
+        return self._nodeResultsByDataType[dataType].NodeValuePairs
+        
+    
+    @property
+    def YieldedElement(self):
+        return self._yieldedElement
+
+    
+    def _buildNodeResultsByDataType(self, grpcElementResults):
+        nodeIdResultPairs = [(nodeID, nodeValue) for nodeID, nodeValue in zip(grpcElementResults.elementInformation.nodeIDs, grpcElementResults.nodeValues)]
+        pairsByType: Dict[BeamsDataType, List[tuple[int, float]]] = {dt: [] for dt in BeamsDataType}
+        for nodeID, nodeValue in nodeIdResultPairs:
+            pairsByType[BeamsDataType.AXIS_FORCE].append((nodeID, nodeValue.axisForce))
+            pairsByType[BeamsDataType.SHEAR_FORCE_MIN_AXIS].append((nodeID, nodeValue.shearForceMinAxis))
+            pairsByType[BeamsDataType.SHEAR_FORCE_MAX_AXIS].append((nodeID, nodeValue.shearForceMaxAxis))
+            pairsByType[BeamsDataType.MOMENT_MIN_AXIS].append((nodeID, nodeValue.momentMinAxis))
+            pairsByType[BeamsDataType.MOMENT_MAX_AXIS].append((nodeID, nodeValue.momentMaxAxis))
+            pairsByType[BeamsDataType.DISPLACEMENT_X].append((nodeID, nodeValue.displacementX))
+            pairsByType[BeamsDataType.DISPLACEMENT_Y].append((nodeID, nodeValue.displacementY))
+            pairsByType[BeamsDataType.DISPLACEMENT_Z].append((nodeID, nodeValue.displacementZ))
+            pairsByType[BeamsDataType.DISPLACEMENT_TOTAL].append((nodeID, nodeValue.totalDisplacement))
+
+        return {dt: _NodeValuePairCollection(pairs) for dt, pairs in pairsByType.items()}
+
+
+
+class BeamResults(_ResultsQueryBase):
+    '''
+    Entry point to query beam nodal 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:`beam_result_example`.
+    '''
+
+    def __init__(self, client: Client, projectId: str, stageNumber: int, srfResultIndex: int):
+        super().__init__(client, projectId, stageNumber, srfResultIndex)
+        self._queryService = BeamsResultsQueryService_pb2_grpc.BeamResultsQueryServiceStub(client.channel)
+
+    
+    def getBeamNodeResults(self, entityName: Optional[str] = None, region: Optional[Union[Cube, Cylinder, Sphere]] = None, includeIntersecting: bool = True) -> list[BeamNodeResults]:
+        '''
+        Query beam nodal 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[BeamNodalResults]: A list of beam nodal results wrappers for the requested stage and SRF value.
+        '''
+        request = self._makeRequest(entityName, region, includeIntersecting)
+        stream = self._queryService.QueryBeamNodalResults(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 [BeamNodeResults(r) for r in allResults]
+
+
+
+    def getBeamElementResults(self, entityName: Optional[str] = None, region: Optional[Union[Cube, Cylinder, Sphere]] = None, includeIntersecting: bool = True) -> list[BeamElementResults]:
+        '''
+        Query beam 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[BeamElementResults]: A list of beam element results wrappers for the requested stage and SRF value.
+        '''
+        request = self._makeRequest(entityName, region, includeIntersecting)
+        stream = self._queryService.QueryBeamElementResults(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 != 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 [BeamElementResults(r) for r in allResults]