RS2Scripting 11.23.0__py3-none-any.whl

rs2/interpreter/InterpreterGraphEnums.py

@@ -0,0 +1,54 @@
+from enum import Enum, auto
+class HistoryQueryGraphEnums():
+    class VerticalAxisTypes(Enum):
+        HORIZONTAL_DISPLACEMENT = 4070
+        VERTICAL_DISPLACEMENT = 4071
+        HORIZONTAL_VELOCITY = 4072
+        VERTICAL_VELOCITY = 4073
+        HORIZONTAL_ACCELERATION = 4074
+        VERTICAL_ACCELERATION = 4075
+        EFFECTIVE_STRESS_XX = 4076
+        EFFECTIVE_STRESS_YY = 4077
+        EFFECTIVE_STRESS_XY = 4078
+        EFFECTIVE_STRESS_Z = 4079
+        STRAIN_XX = 4080
+        STRAIN_YY = 4081
+        STRAIN_XY = 4082
+        EXCESS_PORE_PRESSURE = 4083
+        # Water
+        PORE_PRESSURE = 4084
+        HORIZONTAL_HYDRAULIC_VELOCITY = 4085
+        VERTICAL_HYDRAULIC_VELOCITY = 4086
+        HORIZONTAL_HYDRAULIC_GRADIENT = 4087
+        VERTICAL_HYDRAULIC_GRADIENT = 4088
+        # Temperature
+        TEMPERATURE = 4089
+        HORIZONTAL_THERMAL_FLUX = 4090
+        VERTICAL_THERMAL_FLUX = 4091
+        HORIZONTAL_THERMAL_GRADIENT = 4092
+        VERTICAL_THERMAL_GRADIENT = 4093
+        
+    class HorizontalAxisTypes(Enum):
+        TIME = 9094
+        STAGE_LOAD_PERCENTAGE = 9096
+
+class TimeQueryGraphEnums():
+    class VerticalAxisTypes(Enum):
+        X_VELOCITY = 4041
+        X_DISPLACEMENT = 4042
+        X_ACCELERATION = 4043
+        Y_VELOCITY = 4044
+        Y_DISPLACEMENT = 4045
+        Y_ACCELERATION = 4046
+        PORE_PRESSURE = 4050
+        STRAIN_XX = 4055
+        STRAIN_YY = 4056
+        STRAIN_XY = 4057
+        TOTAL_STRESS_XX = 4058
+        TOTAL_STRESS_YY = 4059
+        TOTAL_STRESS_XY = 4060
+        TOTAL_STRESS_ZZ = 4061
+        EFFECTIVE_STRESS_XX = 4062
+        EFFECTIVE_STRESS_YY = 4063
+        EFFECTIVE_STRESS_XY = 4064
+        EFFECTIVE_STRESS_ZZ = 4065

rs2/interpreter/InterpreterModel.py

@@ -0,0 +1,328 @@
+from rs2.interpreter.InterpreterEnums import *
+from rs2.interpreter.queryResults.MeshResults import MeshResults
+from rs2.interpreter.queryResults.HistoryQueryResults import *
+from rs2.interpreter.queryResults.TimeQueryResults import *
+from rs2.interpreter.InterpreterGraphEnums import *
+from rs2.interpreter.supportResults.JointResult import *
+from rs2.interpreter.supportResults.LinerResult import *
+from rs2.interpreter.supportResults.BoltResult import*
+from rs2.interpreter.supportResults.CompositeResult import*
+from rs2.interpreter.queryResults.MaterialQueryResults import *
+from rs2.BaseModel import BaseModel
+
+class Model(BaseModel):
+	"""
+	:ref:`Model Example`
+	"""
+	def saveCopyAs(self, fileName : str):
+		'''
+		Saves the model using the given file name.
+
+		Example:
+
+		.. code-block:: python
+			
+			model.saveCopyAs('C:/simple_3_stage.fez')
+		'''
+		formattedFileName = fileName.replace('/', '\\')
+		self._enforceFeaFezEnding(formattedFileName)
+		return self._callFunction('saveAs', [formattedFileName])
+
+
+	
+	def SetActiveStage(self, stageNumber: int):
+		'''
+		:ref:`Material Query Example`
+
+		|  Change model's active stage by its stage number
+		'''
+		return self._callFunction('SetActiveStage', [stageNumber])
+	
+	def SetResultType(self, resultType: ExportResultType) -> list[dict]:
+		"""
+		:ref:`Get Mesh Results Example`
+
+		|  Sets the export result type for your model.
+		
+		Raises:
+			ValueError: resultType must be an enum of type ExportResultType. Any other value will raise an error
+		
+		"""
+		return self._callFunction('SetResultType', [resultType.value])
+	
+	def SetUserDefinedResultType(self, resultName: str) -> list[dict]:
+		"""
+		|  Sets the export result type to the user defined result type name.
+		
+		"""
+		return self._callFunction('SetUserDefinedResultType', [resultName])
+	
+	def GetMeshResults(self) -> MeshResults:
+		"""
+		:ref:`Get Mesh Results Example`
+
+		|  Returns the mesh results at all nodes for your model.
+		
+		"""
+		results = self._callFunction('GetMeshResults', [])
+		return MeshResults(results)
+
+	def GetHistoryQueryResults(self, hq_name: str, horizontal_axis: HistoryQueryGraphEnums.HorizontalAxisTypes, vertical_axis: HistoryQueryGraphEnums.VerticalAxisTypes, 
+							stages: list[int]) -> dict[int, list[HistoryQueryResult]]:
+		"""
+		:ref:`History Query Example`
+
+		|   Returns a map of HistoryQueryResult for all input stages and history queries in your model.
+		
+		Raises:
+			ValueError: horizontal_axis and vertical_axis must be an enum of type HistoryQueryGraphEnums.
+						Any other value will raise an error.
+
+		"""
+		map_data = self._callFunction('GetHistoryQueryResults', [hq_name, horizontal_axis.value, vertical_axis.value, stages])
+		structured_data = {}
+		for stage_idx, stage_data in map_data.items():
+			list_stage_data_as_classObj = []
+			for result in stage_data:
+				list_stage_data_as_classObj.append(HistoryQueryResult(result[0], result[1], result[2], result[3]))
+			
+			structured_data[stage_idx] = list_stage_data_as_classObj
+		
+		return structured_data
+	
+	def GetAllTimeQueryPointResults(self, stages: list[int], 
+							  vertical_axis: TimeQueryGraphEnums.VerticalAxisTypes
+							  ) -> dict[int, list[TimeQueryPointResults]]:
+		"""
+		:ref:`Time Query Example`
+
+		|  Returns a map of TimeQueryPointResults for all input stages and time query points in your model.
+
+		|  Please note points that are over an excavation at specific stages will not have data returned at those locations.
+		
+		Raises:
+			ValueError: vertical_axis must be an enum of type TimeQueryGraphEnums. Any other value will raise an error.
+
+		"""
+		map_data = self._callFunction('GetAllTimeQueryPointsResults', 
+							 [stages, vertical_axis.value])
+		structured_data = {}
+		for stageNumber, stageData in map_data.items():
+			list_stage_data_as_classObj = []
+			for query_point_data in stageData:
+				entity_id, list_node_result = query_point_data
+				unpack_list_data = [entity_id, list_node_result]
+				list_stage_data_as_classObj.append(TimeQueryPointResults(*unpack_list_data))
+			
+			structured_data[stageNumber] = list_stage_data_as_classObj
+		
+		return structured_data
+
+	def GetAllTimeQueryLinesResults(self, stages: list[int], 
+							  vertical_axis: TimeQueryGraphEnums.VerticalAxisTypes,
+							  apply_post_process_scaling: bool
+							  ) -> dict[int, list[TimeQueryLineResults]]:
+		"""
+		:ref:`Time Query Example`
+
+		|  Returns a map of TimeQueryLineResults for all input stages and time query lines in your model.
+
+		|  Please note points that are over an excavation at specific stages will not have data returned at those locations.
+		
+		Raises:
+			ValueError: vertical_axis must be an enum of type TimeQueryGraphEnums. Any other value will raise an error.
+
+		"""
+		map_data =  self._callFunction('GetAllTimeQueryLinesResults', 
+							 [stages, vertical_axis.value, apply_post_process_scaling])
+		structured_data = {}
+		for stageNumber, stageData in map_data.items():
+			list_stage_data_as_classObj = []
+			for line_data in stageData:
+				entity_id, list_line_node_data = line_data
+				unpack_list_data = [entity_id, list_line_node_data]
+				list_stage_data_as_classObj.append(TimeQueryLineResults(*unpack_list_data))
+			
+			structured_data[stageNumber] = list_stage_data_as_classObj
+		
+		return structured_data	
+	
+	def AddMaterialQuery(self, points: list[list[float]]) -> str:
+		"""
+		:ref:`Material Query Example`
+
+		|  Adds a material query point/line to your model using the specified coordinates in order.
+
+		|  Returns a unique identifier for the newly added material query point/line.
+		
+		"""
+		return self._callFunction('AddMaterialQuery', [points])
+	
+	def RemoveMaterialQuery(self, IDs_toRemove: list[str]) -> str:
+		"""
+		:ref:`Material Query Example`
+
+		|  Removes material query points or lines for provided list of IDs.
+
+		"""
+		return self._callFunction('RemoveMaterialQuery', [IDs_toRemove])
+	
+	def GetMaterialQueryResults(self) -> list[MaterialQueryResults]:
+		"""
+		:ref:`Material Query Example`
+		
+		|  Returns the results for all the material queries defined in your model for active model stage and result type.
+		|  To get results for a different stage, please call SetActiveStage(int stageNumber) before calling this function.
+		|  To get results for a different result type, please call either before calling this function:
+
+		* SetResultType(InterpreterGraphEnums resultType)
+		* SetUserDefinedResultType("Your defined resultType name")
+
+		"""
+		all_material_query_data = self._callFunction('GetMaterialQueryResults', [])
+		all_mat_query_data_as_classObj = []
+		for mat_query_data in all_material_query_data:
+			# This list corresponds to the data at each vertex of material query in iteration
+			entity_id, material_id, list_query_data = mat_query_data
+			unpack_list_data = [entity_id, material_id, list_query_data]
+			all_mat_query_data_as_classObj.append(MaterialQueryResults(*unpack_list_data))
+		return all_mat_query_data_as_classObj
+
+	def GetBoltResults (self, stages: list[int]) -> dict[int, list[BoltResult]]:
+		"""
+		:ref:`Support Bolt Results Example`
+		
+		|  Returns a map of BoltResult for all input stages and support bolt defined in your model.
+
+		"""
+		map_data = self._callFunction('GetBoltResults', [stages])
+		structured_data = {}
+		for stage_idx, stage_data in map_data.items():
+			structured_data[stage_idx] = []
+			for entity_name, entity_data in stage_data.items():
+				yielding_results = []
+				displacement_force_results = []
+				# location # [start = [x,y],end = [x,y]]
+				# yeilding
+				# displacement force
+				if len(entity_data) < 3 or len(entity_data[0]) <1 or len(entity_data[0][0]) < 4:
+					continue
+				if len(entity_data[1]) < 1 or len(entity_data[2]) < 1:
+					continue
+				for yeilding_vector in entity_data[1]:
+					yielding = BoltYieldingResult(*yeilding_vector)
+					yielding_results.append(yielding)
+
+				for displacement_force_vector in entity_data[2]:
+					displacement_force = BoltForceDisplacementResult(*displacement_force_vector)
+					displacement_force_results.append(displacement_force)
+				bolt_result = BoltResult(entity_name,entity_data,yielding_results, displacement_force_results)
+				structured_data[stage_idx].append(bolt_result)
+		return structured_data
+		
+	def _process_joint_data(self, entity_data, entity_name):
+
+		joint_element_results = []
+		for joint_vector in entity_data[1]:
+			#joint_vector[yeilded_indx] = bool(joint_vector[yeilded_indx])
+			joint_element = JointElementResult(*joint_vector)
+			joint_element_results.append(joint_element)
+		joint_result = JointResult(entity_name, joint_element_results)
+		return joint_result
+
+	def _process_liner_data(self, entity_data, entity_name):
+		liner_element_results = []
+
+		for liner_vector in entity_data[0]:
+			liner_element = LinerElementResult(*liner_vector)
+			liner_element_results.append(liner_element)
+		liner_result = LinerResult(entity_name,liner_element_results)
+		return liner_result
+
+	def GetJointResults(self, stages: list[int]) -> dict[int, list[JointResult]]:
+		"""
+		:ref:`Support Joint Results Example`
+		
+		|  Returns a map of JointResult for all input stages and support joint defined in your model.
+
+		"""
+		map_data = self._callFunction('GetJointResults', [stages])
+		structured_data = {}
+		for stage_idx, stage_data in map_data.items():
+
+			structured_data[stage_idx] = []
+			for entity_name, entity_data in stage_data.items():
+				joint_result = self._process_joint_data(entity_data, entity_name)
+				structured_data[stage_idx].append(joint_result)
+		
+		return structured_data
+	
+	def GetLinerResults(self, stages: list[int]) -> dict[int, list[LinerResult]]:
+		"""
+		:ref:`Support Liner Results Example`
+		
+		|  Returns a map of LinerResult for all input stages and support liner defined in your model.
+
+		"""
+		map_data = self._callFunction('GetLinerResults', [stages])
+		structured_data = {}
+		for stage_idx, stage_data in map_data.items():
+
+			structured_data[stage_idx] = []
+			for entity_name, entity_data in stage_data.items():
+				liner_result = self._process_liner_data(entity_data, entity_name)
+				structured_data[stage_idx].append(liner_result)
+		
+		return structured_data
+
+	def GetPileResults(self, stages: list[int]) -> dict[int, list[PileResult]]:
+		"""
+		:ref:`Support Pile Results Example`
+		
+		|  Returns a map of PileResult for all input stages and support pile defined in your model.
+
+		"""
+		return self._get_composition_result('GetPileResults',PileResult, stages)
+
+	def GetCompositeResults(self, stages: list[int]) -> dict[int, list[CompositeResult]]:
+		"""
+		:ref:`Support Composite Results Example`
+		
+		|  Returns a map of CompositeResult for all input stages and support composite defined in your model.
+
+		"""
+		return self._get_composition_result('GetCompositeResults',CompositeResult, stages)
+
+	def GetStructuralResults(self, stages: list[int]) -> dict[int, list[StructuralResult]]:
+		"""
+		:ref:`Support Structural Results Example`
+		
+		|  Returns a map of StructuralResult for all input stages and support structural defined in your model.
+
+		"""
+		return self._get_composition_result('GetStructuralResults',StructuralResult, stages)
+
+	def _get_composition_result(
+	self,
+	function_name: str,
+	ResultType,
+	stages: list[int]) -> dict[int, list[LinerResult]]:
+
+		map_data = self._callFunction(function_name, [stages])
+		structured_data = {}
+		for stage_idx, stage_data in map_data.items():
+			structured_data[stage_idx] = []
+			for entity_name, entity_data in stage_data.items():
+				liner_result = self._process_liner_data(entity_data, entity_name)
+				joint_result = self._process_joint_data(entity_data, entity_name)
+				composition_result = ResultType(entity_name,joint_result,liner_result)
+				structured_data[stage_idx].append(composition_result)
+
+		return structured_data
+
+
+	def getCriticalSRF(self):
+		'''
+		|  Get Critical SRF
+		'''
+		return ResetInvalid.validate_double(self._callFunction('getCriticalSRF', []))

rs2/interpreter/RS2Interpreter.py

@@ -0,0 +1,78 @@
+from rsmessages.requestFormat import functionRequest
+from rs2._common.Client import Client
+from rs2.utilities.ApplicationManager import ApplicationManager
+from rs2.interpreter.InterpreterModel import Model
+import winreg
+import time
+
+class RS2Interpreter:
+	def __init__(self, host = 'localhost', port=60055):
+		self.client = Client(host, port)
+
+	def openFile(self, fileName : str) -> Model:
+		'''
+		Takes in the absolute path to an rs2 file to be opened in the modeler.
+
+		Example:
+
+		.. code-block:: python
+			
+			model = modeler.openFile('C:/simple_3_stage.fez')
+		'''
+		request = functionRequest('open_file', [fileName], keepReturnValueReference=True)
+		modelObjectId = self.client.callFunction(request)
+		model = Model(self.client, modelObjectId)
+		return model
+	
+	@classmethod
+	def startApplication(cls, port : int, overridePathToExecutable : str = None, timeout : float = 30) -> None:
+		"""Opens the most recently installed RS2 application. Starts the python server and binds it to the given port.
+
+		Args:
+			port (int): the port to bind the python server to. Use this same port when initializing RS2Modeler
+			overridePathToExecutable (str, optional): full path to the desired executable to be opened. If not provided, the latest installation of rs2 is used
+			timeout (float, optional): the maximum amount of time to wait for the application and server to start.
+		
+		Raises:
+			ValueError: Port range must be between ``49152`` and ``65535``, otherwise ValueError is raised
+			TimeoutError: if timeout is provided, raises TimeoutError if not able to connect to the server within that time.
+		"""
+		appManager = ApplicationManager()
+		executablePath = overridePathToExecutable if overridePathToExecutable else cls._getApplicationPath()
+		appManager.startApplication(executablePath, port, timeout)
+
+	@staticmethod
+	def _getApplicationPath() -> str:
+
+		registry = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+		key = winreg.OpenKey(registry, r'SOFTWARE\Rocscience\RS2 11.0')
+		installationLocation, type = winreg.QueryValueEx(key, "Install")
+
+		rs2ModelerInstallLocation =  rf"{installationLocation}\Interpret"
+
+		return rs2ModelerInstallLocation
+	
+	def closeProgram(self, saveModels=True, timeout=30):
+		'''
+		Closes the modeler program. All unsaved models are saved by default.
+
+		Example:
+
+		.. code-block:: python
+			
+			#Saves all models before closing
+			modeler.closeProgram(True)
+
+			#Closes without saving any models
+			modeler.closeProgram(False)
+		'''
+		request = functionRequest('closeProgram', [saveModels])
+		portUsed = self.client.callFunction(request)
+		self.client.closeConnection()
+		appManager = ApplicationManager()
+		portIsAvailable = False
+		startTime = time.time()
+		while not portIsAvailable:
+			if (time.time() - startTime) > timeout:
+				raise TimeoutError("The application did not close within the given timeout time.")
+			portIsAvailable = appManager._isPortAvailable(portUsed)

rs2/interpreter/_UtilityResult.py

@@ -0,0 +1,20 @@
+import sys
+
+class ResetInvalid:
+	# used by interpretor
+    flt_max = 3.402823466e+38
+
+    @staticmethod
+    def validate(self):
+        for key, value in vars(self).items():
+            if isinstance(value, (int, float)) and value == sys.float_info.max:
+                setattr(self, key, None)
+        pass
+    @staticmethod
+    def validate_double(value):
+        if isinstance(value, float) and (value >= ResetInvalid.flt_max):
+            value = None
+        return value
+
+
+

rs2/interpreter/queryResults/HistoryQueryResults.py

@@ -0,0 +1,30 @@
+class HistoryQueryResult:
+    def __init__(self, x_location, y_location, horizontal_axis_result, vertical_axis_result):
+        self.horizontal_axis_result = horizontal_axis_result
+        self.vertical_axis_result = vertical_axis_result
+        self.location_x = x_location
+        self.location_y = y_location
+    
+    def GetXCoordinate(self):
+        '''
+        Returns the X-Coordinate of the point
+        '''
+        return self.location_x
+    
+    def GetYCoordinate(self):
+        '''
+        Returns the Y-Coordinate of the point
+        '''
+        return self.location_y
+
+    def GetHorizontalAxisResult(self):
+        '''
+        Returns the horizontal axis result for the specific stage
+        '''
+        return self.horizontal_axis_result
+    
+    def GetVerticalAxisResult(self):
+        '''
+        Returns the vertical axis result for the specific stage
+        '''
+        return self.vertical_axis_result

rs2/interpreter/queryResults/MaterialQueryResults.py

@@ -0,0 +1,67 @@
+from rs2.interpreter._UtilityResult import *
+
+class QueryResult:
+    def __init__(self, x_location, y_location, distance, value):
+        self.x_location = x_location
+        self.y_location = y_location
+        self.distance = distance
+        self.value = value
+        ResetInvalid.validate(self)
+    
+    def GetXCoordinate(self) -> float:
+        '''
+        Returns the X-Coordinate of the query
+        '''
+        return self.x_location
+    
+    def GetYCoordinate(self) -> float:
+        '''
+        Returns the Y-Coordinate of the query
+        '''
+        return self.y_location
+
+    def GetDistance(self) -> float:
+        '''
+        Returns the distance of the query
+        '''
+        return self.distance
+    
+    def GetValue(self) -> float:
+        '''
+        Returns the value of the query based on model's current result type
+        '''
+        return self.value
+
+class MaterialQueryResults:
+    def __init__(self, entity_ID, material_id, query_values):
+        self.entity_ID = entity_ID
+        self.material_id = material_id
+        # Construct QueryResult objects
+        query_values_obj = []
+        for value in query_values:
+            query_values_obj.append(QueryResult(*value))
+        self.query_values = query_values_obj
+    
+    def GetUniqueIdentifier(self) -> int:
+        '''
+        Returns the unique identifier for the material query
+        '''
+        return self.entity_ID
+    
+    def GetMaterialID(self) -> int:
+        '''
+        Returns the material ID of the query
+        '''
+        return self.material_id
+    
+    def GetAllValues(self) -> list[QueryResult]:
+        '''
+        |  Returns a list[QueryResult] representing result at all nodes of the material query
+        |  To get the x-coordinate, y-coordinate, distance, or value, please call the supporting class methods:
+        
+        * QueryResult.GetXCoordinate()
+        * QueryResult.GetYCoordinate()
+        * QueryResult.GetDistance()
+        * QueryResult.GetValue()
+        '''
+        return self.query_values

rs2/interpreter/queryResults/MeshResults.py

@@ -0,0 +1,12 @@
+class MeshResults:
+    results = None
+
+    def __init__(self, results):
+        self.results = results
+
+    def getXCoordinate(self, index):
+        return self.results[index][0]
+    def getYCoordinate(self, index):
+        return self.results[index][1]
+    def getValue(self, index):
+        return self.results[index][2]