Merge pull request #35 from mitchell-tesch/frame_updates_temp

Updates for frame force extraction, sections and group assignments, model saving

Author: mitchell-tesch

src/pytabs/analysis_results.py

@@ -64,6 +64,24 @@ class BucklingFactor(TypedDict):
     step_number: list[float]
     factor: list[float]
 
+class FrameForce(TypedDict):
+    """TypedDict class for frame_force return"""
+    number_results: int
+    object_name: list[str]
+    object_station: list[float]
+    element_name: list[str]
+    element_station: list[float]
+    load_case: list[str]
+    step_type: list[str]
+    step_number: list[int]
+    axial_force: list[float]
+    shear_2: list[float]
+    shear_3: list[float]
+    torsion: list[float]
+    moment_2: list[float]
+    moment_3: list[float]
+
+
 
 class JointDisplacement(TypedDict):
     """TypedDict class for joint_displacement return"""
@@ -379,7 +397,62 @@ def buckling_factor(self) -> BucklingFactor:
                 'step_number': list(step_number),
                 'factor': list(factor)}
 
-    # TODO: FrameForce
+
+    def frame_force(self, name, item_type_element: etabs.eItemTypeElm) -> FrameForce:
+        """Reports the frame forces for specified line elements
+
+        :param name: The name of an existing point object, point element, or group of objects depending on the value of the ItemTypeElm item
+        :type name: str
+        :param item_type_element: one of the following items in the `eItemTypeElm` enumeration.
+            `ObjectElm` - the point element corresponding to the point object specified by the `name`
+            `Element` - the point element specified by `name`
+            `GroupElm` - all point elements directly or indirectly specified in the group specified by `name`
+            `SelectionElm` - all point elements directly or indirectly selected and `name` is ignored
+        :type item_type_element: etabs.eItemTypeElm
+        :return: Frame force analysis results
+        :rtype: FrameForce
+        """
+
+        number_results = int()
+        object_name = [str()]
+        object_station = [float()]
+        element_name = [str()]
+        element_station = [float()]
+        load_case = [str()]
+        step_type = [str()]
+        step_number = [int()]
+        axial_force = [float()]
+        shear_2 = [float()]
+        shear_3 = [float()]
+        torsion = [float()]
+        moment_2 = [float()]
+        moment_3 = [float()]
+
+        [ret, number_results, object_name, object_station, 
+         element_name, element_station, load_case, step_type, 
+         step_number, axial_force, shear_2, shear_3, torsion, 
+                                        moment_2, moment_3] = self.analysis_results.FrameForce(name, item_type_element, number_results, object_name, object_station, 
+                                                                                                element_name, element_station, load_case, step_type, 
+                                                                                                step_number, axial_force, shear_2, shear_3, torsion, 
+                                                                                                                                moment_2, moment_3)
+
+        handle(ret)
+        return {'number_results': number_results,
+                'object_name': list(object_name),
+                'object_station': list(object_station),
+                'element_name': list(element_name),
+                'element_station': list(element_station),
+                'load_case': list(load_case),
+                'step_type': list(step_type),
+                'step_number': list(step_number),
+                'axial_force': list(axial_force),
+                'shear_2': list(shear_2),
+                'shear_3': list(shear_3),
+                'torsion': list(torsion),
+                'moment_2': list(moment_2),
+                'moment_3': list(moment_3)}
+
+
     # TODO: FrameJointForce
     # TODO: GeneraliszeDispl
     # TODO: JointAcc

src/pytabs/frame_obj.py

@@ -204,11 +204,36 @@ def set_group_assign(self, name: str, group_name: str, remove: bool = False,
         :type group_name: str
         :param remove: `True` for add, False for remove, defaults to `False`
         :type remove: bool, optional
-        :param item_type: one of eItemType enumeration (`Objects` : frame object specified by name is added/removed from group, `Group` : all frame objects in the group specified by name are added/removed from group, `SelectedObjects` : all selected frame objects are added/removed from group, name is ignored), defaults to `eItemType.Objects`
+        :param item_type: one of eItemType enumeration 
+                            `Objects` : frame object specified by name is added/removed from group, 
+                            `Group` : all frame objects in the group specified by name are added/removed from group, 
+                            `SelectedObjects` : all selected frame objects are added/removed from group, name is ignored, 
+                            defaults to `eItemType.Objects`
         :type item_type: eItemType, optional
         """
         handle(self.frame_obj.SetGroupAssign(name, group_name, remove, item_type))
 
+    def set_section_assign(self, frame_name: str, prop_name: str, item_type: etabs.eItemType  = etabs.eItemType.Objects, SVarRelStartLoc = 0.0, SVarrTotalLength = 0.0) -> None:
+        """Assigns a frame section property to a frame object. 
+
+        :param frame_name: name of an existing frame object or group depending on the value of item_type
+        :type frame_name: str
+        :param prop_name: name of a frame section property to be assigned to the specified frame object(s)
+        :type prop_name: str
+        :param item_type: one of eItemType enumeration 
+                            `Object` : frame object specified by name is added/removed from group, 
+                            `Group` : all frame objects in the group specified by name are added/removed from group, 
+                            `SelectedObjects` : all selected frame objects are added/removed from group, name is ignored, 
+                            defaults to `eItemType.Objects`
+        :type item_type: etabs.eItemType
+        :param SVarRelStartLoc: _description_, defaults to 0.0
+        :type SVarRelStartLoc: float, optional
+        :param SVarrTotalLength: _description_, defaults to 0.0
+        :type SVarrTotalLength: float, optional
+        """
+
+        handle(self.frame_obj.SetSection(frame_name, prop_name, item_type))
+
     def set_spring_assignment(self, frame_name: str, line_spring_prop: str,
                               item_type: etabs.eItemType = etabs.eItemType.Objects) -> None:
         """Assigns an existing line spring property to frame objects of the value item_type.

src/pytabs/model.py

@@ -268,6 +268,32 @@ def new_model(self, new_model_path: Union[str, Path]) -> None:
         self.model_path = new_model_path
         self.model_open = True
 
+    def save_model(self, save_model_path: Union[str, Path]) -> None:
+        """Saves the present model.
+        If no file name is specified, the file is saved using its current name.
+        If there is no current name for the file (the file has not been saved previously) 
+        and this function is called with no file name specified, an error will be returned. 
+
+        :param save_model_path: file path to save new blank ETABS model file
+        :type save_model_path: Union[str, Path]
+        """
+
+        handle(self.file.Save(str(save_model_path)))
+        self.model_path = save_model_path
+        self.model_open = True
+
+    def get_model_file_name(self, IncludePath: bool = True) -> str:
+        """Returns a string that represents the filename of the current model, with or without the full path
+
+        :param IncludePath: Include full path or not, defaults to True
+        :type IncludePath: bool, optional
+        :return: filename of current model, with or without the full path
+        :rtype: str
+        """
+
+        return str(self.sap_model.GetModelFilename(IncludePath))
+
+
     def get_database_units(self) -> etabs.eUnits:
         """Returns a value from the eUnits enumeration indicating the database units for the model.
         All data is internally stored in the model in these units and converted to the present units as needed.
@@ -373,4 +399,4 @@ def set_present_units_components(self, force_units: etabs.eForce, length_units:
         :param temperature_units: Temperature enumeration to set
         :type temperature_units: eTemperature
         """
-        handle(self.sap_model.SetPresentUnits_2(force_units, length_units, temperature_units))
+        handle(self.sap_model.SetPresentUnits_2(force_units, length_units, temperature_units))

src/pytabs/properties/prop_frame.py

@@ -10,6 +10,20 @@
 
 
 # import typing
+from typing import TypedDict
+
+class FrameProp(TypedDict):
+    """TypedDict class for frame_prop return"""
+    number_results: int
+    name: list[str]
+    prop_type: list[etabs.eFramePropType]
+    t3: list[float]
+    t2: list[float]
+    tf: list[float]
+    tw: list[float]
+    t2b: list[float]
+    tfb: list[float]
+    area: list[float]
 
 
 class PropFrame:
@@ -26,3 +40,68 @@ def __init__(self, sap_model: etabs.cSapModel) -> None:
         """EtabsModel `FramePropType` enumeration"""
 
         # relate custom enumerations
+
+
+    def get_all_frame_prop(self) -> FrameProp:
+        """Retrieves select data for all frame properties in the model
+
+        :return: All frame properties defined in the model
+        :rtype: FrameProp
+        """
+        
+        number_results = int()
+        name = [str()]
+        prop_type = [] # self.eFramePropType(int)
+        t3 = [float()]
+        t2 = [float()]
+        tf = [float()]
+        tw = [float()]
+        t2b = [float()]
+        tfb = [float()]
+        area = [float()]
+
+        [ret, number_results, 
+         name, prop_type, t3, t2, 
+         tf, tw, t2b, tfb, area] = self.prop_frame.GetAllFrameProperties_2(number_results, name, 
+                                                                           prop_type, t3, t2, tf, 
+                                                                           tw, t2b, tfb, area)
+        
+        handle(ret)
+
+        return {'number_results': number_results,
+                'prop_name': list(name),
+                #'prop_type': self.eFramePropType(list(prop_type)), ## enum to be resolved
+                'prop_type': prop_type,
+                't3': list(t3),
+                't2': list(t2),
+                'tf': list(tf),
+                'tw': list(tw),
+                't2b': list(t2b),
+                'tfb': list(tfb),
+                'area': list(area)}
+    
+
+    def set_rectangle_prop(self, name: str, mat_prop: str, t3: float, t2: float, colour: float = -1, notes: str = '', guid: str = '') -> None:
+        """Initializes a solid rectangular frame section property. If this function is called for an existing frame section property, 
+        all items for the section are reset to their default value. 
+
+        :param name: name of the fame section property
+        :type name: str
+        :param mat_prop: name of the material property to assign
+        :type mat_prop: str
+        :param t3: section depth, defined according to model units
+        :type t3: float
+        :param t2: section width, defined according to model units
+        :type t2: float
+        :param colour: _description_, defaults to -1
+        :type colour: float, optional
+        :param notes: _description_, defaults to ''
+        :type notes: str, optional
+        :param guid: _description_, defaults to ''
+        :type guid: str, optional
+        :return: _description_
+        :rtype: _type_
+        """
+
+        return handle(self.prop_frame.SetRectangle(name, mat_prop, t3, t2, colour, notes, guid))
+