dlubal.api 2.12.11__py3-none-any.whl

examples/rstab/frame.py

@@ -0,0 +1,285 @@
+from dlubal.api import rstab
+
+
+def define_structure() -> list:
+    """Define and return a list of structural objects."""
+
+    inf = float('inf')
+
+    return [
+        # Define material
+        rstab.structure_core.Material(no=1, name='S235'),
+
+        # Define cross-section
+        rstab.structure_core.CrossSection(no=1, name='HE 200 A', material=1),
+
+        # Define nodes
+        rstab.structure_core.Node(no=1),
+        rstab.structure_core.Node(no=2, coordinate_3=-3.0),
+        rstab.structure_core.Node(no=3, coordinate_1=4.0, coordinate_3=-3.0),
+        rstab.structure_core.Node(no=4, coordinate_1=4.0),
+
+        # Define member
+        rstab.structure_core.Member(no=1, node_start=1, node_end=2, cross_section_start=1),
+        rstab.structure_core.Member(no=2, node_start=2, node_end=3, cross_section_start=1),
+        rstab.structure_core.Member(no=3, node_start=3, node_end=4, cross_section_start=1),
+
+        # Define nodal support at Node 1 (fully fixed)
+        rstab.types_for_nodes.NodalSupport(
+            no=1,
+            nodes=[1,4],
+            spring_x=inf, spring_y=inf, spring_z=inf,
+            rotational_restraint_x=inf,
+            rotational_restraint_y=inf,
+            rotational_restraint_z=inf
+        ),
+    ]
+
+
+def define_loads() -> list:
+    """Define and return a list of loading objects."""
+
+    return [
+        # Static analysis settings
+        rstab.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rstab.loading.StaticAnalysisSettings.ANALYSIS_TYPE_GEOMETRICALLY_LINEAR,
+        ),
+
+        # Define load cases
+        rstab.loading.LoadCase(
+            no=1,
+            name='Self-weight',
+            self_weight_active=True,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=2,
+            name='Snow',
+            action_category=rstab.loading.LoadCase.ACTION_CATEGORY_SNOW_ICE_LOADS_H_LESS_OR_EQUAL_TO_1000_M_QS,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=3,
+            name='Wind +x',
+            action_category=rstab.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=4,
+            name='Wind +x, with wind suction',
+            action_category=rstab.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=5,
+            name='Wind -x',
+            action_category=rstab.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=6,
+            name='Wind -x, with wind suction',
+            action_category=rstab.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+
+        # Define loads
+        rstab.loads.MemberLoad(
+            no=1,
+            load_case=1,
+            members=[2],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=1000
+        ),
+        rstab.loads.MemberLoad(
+            no=2,
+            load_case=2,
+            members=[2],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=3000
+        ),
+        rstab.loads.MemberLoad(
+            no=3,
+            load_case=3,
+            members=[1],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=2000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=4,
+            load_case=3,
+            members=[3],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=1000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=5,
+            load_case=4,
+            members=[1],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=2000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=6,
+            load_case=4,
+            members=[3],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=1000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=7,
+            load_case=4,
+            members=[2],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-500
+        ),
+        rstab.loads.MemberLoad(
+            no=8,
+            load_case=5,
+            members=[1],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-2000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=9,
+            load_case=5,
+            members=[3],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-1000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=10,
+            load_case=6,
+            members=[1],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-2000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=11,
+            load_case=6,
+            members=[3],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-1000,
+            load_direction=rstab.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rstab.loads.MemberLoad(
+            no=12,
+            load_case=6,
+            members=[2],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-500
+        ),
+        rstab.loading.CombinationWizard(
+            no=1,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.DesignSituation(
+            no=1,
+            design_situation_type=rstab.loading.DesignSituation.DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10,
+            combination_wizard=1,
+        ),
+    ]
+
+
+with rstab.Application() as rstab_app:
+
+    # Step 1: Create a new model and clear existing objects
+    rstab_app.create_model(name='frame')
+    rstab_app.delete_all_objects()
+
+    # Step 2: Define and create the structure and load objects
+    base_data = rstab_app.get_base_data()
+    base_data.combinations_settings.combination_wizard_active = True
+    base_data.combinations_settings.result_combinations_active = True
+    rstab_app.set_base_data(base_data=base_data)
+
+    # Step 3: Define and create the structure and load objects
+    objects = define_structure() + define_loads()
+    rstab_app.create_object_list(objects)
+
+    # Step 4: Generate Load Combinations
+    print("\nLoad Combinations:")
+    rstab_app.generate_combinations()
+    all_load_combi = rstab_app.get_object_list([rstab.loading.LoadCombination()])
+
+    # Step 5: Create Result Combination as an envelope from all Load Combinations
+    result_combi_rows = []
+    for i, load_combi in enumerate(all_load_combi):
+        # Check if this is the last item in the list
+        print(f"CO{load_combi.no} - {load_combi.combination_rule_str}")
+
+        if i < len(all_load_combi) - 1:
+            operator = rstab.loading.ResultCombination.ItemsRow.OPERATOR_OR
+        else:
+            operator = rstab.loading.ResultCombination.ItemsRow.OPERATOR_NONE
+
+        result_combi_rows.append(
+            rstab.loading.ResultCombination.ItemsRow(
+                case_object_item=rstab.ObjectId(
+                    no=load_combi.no,
+                    object_type=rstab.OBJECT_TYPE_LOAD_COMBINATION,
+                ),
+                case_object_factor=1,
+                operator=operator,
+            )
+        )
+
+    print("\nResult Combination:")
+    rstab_app.create_object(
+        rstab.loading.ResultCombination(
+            no=1,
+            user_defined_name_enabled=True,
+            name='All ULS',
+            design_situation=1,
+            items=rstab.loading.ResultCombination.ItemsTable(
+                rows = result_combi_rows,
+            )
+        )
+    )
+    result_combi = rstab_app.get_object(rstab.loading.ResultCombination(no=1))
+    print(f"{result_combi.name} - {result_combi.combination_rule_str}")
+
+    # Step 6: Calculate specific
+    rstab_app.calculate_specific(
+        loadings=[
+            rstab.ObjectId(
+                no=1,
+                object_type=rstab.OBJECT_TYPE_RESULT_COMBINATION
+            )
+        ],
+        skip_warnings=False,
+    )
+
+    # Step 7: Read results using optional filtering
+    member_filter = rstab.results.ResultsFilter(
+        column_id='member_no',
+        filter_expression='2'
+    )
+
+    results_df = rstab_app.get_results(
+        results_type=rstab.results.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        filters=[member_filter],
+    ).data
+
+    print("\nAll Results:")
+    print(results_df)
+
+    # Step 8: Find maximum m_y envelope on specific member
+    loading = "RC1"
+    tag = 'm_y_max'
+
+    my_max_df = results_df[
+        (results_df['loading'] == loading) &
+        (results_df['tag'] == tag)
+    ]
+
+    print("\nMaximum My:")
+    print(my_max_df)

examples/rstab/import_from_ifc.py

@@ -0,0 +1,46 @@
+import os
+from dlubal.api import rstab, common
+
+
+# Connect to the RSTAB application
+with rstab.Application() as rstab_app:
+
+    rstab_app.create_model(name='import_from_ifc')
+
+    # Step 1: Import IFC model from the file
+    ifc_file_path = os.path.join(os.path.dirname(__file__), 'src', 'ifc_structure.ifc')
+
+    rstab_app.import_from(
+        filepath=ifc_file_path,
+        import_attributes=common.import_export.IfcImportAttributes()
+    )
+
+    # Step 2: Edit IFC model (e.g., mirror it along the Z-axis)
+    ifc_model: rstab.ifc_objects.IfcFileModelObject = rstab_app.get_object(
+        rstab.ifc_objects.IfcFileModelObject(no=1)
+    )
+    ifc_model.mirror_axis_z=True
+    rstab_app.update_object(ifc_model)
+
+
+    # Step 3: Categorize IFC model objects for conversion
+    ifc_object_list = rstab_app.get_object_list(
+        objs=[
+            rstab.ifc_objects.IfcModelObject()
+        ]
+    )
+
+    members = []
+
+    for ifc_object in ifc_object_list:
+        ifc_type = ifc_object.ifc_type
+        if ifc_type in ["IfcColumn", "IfcBeam"]:
+            members.append(ifc_object)
+
+    # Step 4: Convert IFC model objects to appropriate RSTAB model objects
+    # Convert columns and beams to RSTAB straight members
+    rstab_app.convert_objects(
+        convert_into=common.ConvertObjectInto.CONVERT_IFC_OBJECT_INTO_STRAIGHT_MEMBER,
+        objs=members
+    )
+

examples/rstab/import_from_rsection.py

@@ -0,0 +1,107 @@
+import os
+from dlubal.api import rstab, rsection, common
+
+
+def define_rsection_shape() -> list:
+
+    objs = []
+
+    # Define material
+    objs.append(
+        rsection.structure_core.Material(
+            no=1,
+            name='S235',
+        )
+    )
+
+    # --- Points table ---
+    points = [
+        (1, 0.0000, -0.0040), (2, 0.0000, 0.0000), (3, 0.0000, 0.0040), (4, 0.0000, 0.1680), (5, 0.0000, 0.1720), (6, 0.0000, 0.1760),
+        (7, 0.0338, 0.0040), (8, 0.0338, 0.1680), (9, 0.0402, 0.0066), (10, 0.0402, 0.1654), (11, 0.0429, 0.0130), (12, 0.0429, 0.1590),
+        (13, 0.0455, 0.0000), (14, 0.0455, 0.1720), (15, 0.0455, -0.0040), (16, 0.0455, 0.1760), (17, 0.0481, 0.0130), (18, 0.0481, 0.1590),
+        (19, 0.0508, 0.0066), (20, 0.0508, 0.1654), (21, 0.0571, 0.0040), (22, 0.0571, 0.1680), (23, 0.0910, 0.0000), (24, 0.0910, 0.1720),
+        (25, 0.0910, -0.0040), (26, 0.0910, 0.0005), (27, 0.0910, 0.0040), (28, 0.0910, 0.1680), (29, 0.0910, 0.1760), (30, 0.0920, 0.0030),
+        (31, 0.0945, 0.0040), (32, 0.1560, 0.0040), (33, 0.1609, 0.0061), (34, 0.1630, 0.011), (35, 0.1630, 0.0325), (36, 0.1640, 0.0350),
+        (37, 0.1665, 0.0360), (38, 0.1670, 0.0000), (39, 0.1670, 0.0360), (40, 0.1670, -0.0040), (41, 0.1710, -0.0040), (42, 0.1710, 0.0000),
+        (43, 0.1710, 0.0360)
+    ]
+
+    for p in points:
+        objs.append(
+            rsection.structure_core.Point(
+                no=p[0],
+                coordinate_1=p[1],
+                coordinate_2=p[2],
+            )
+        )
+
+    # --- Lines table ---
+    # For Polyline: (line_no, start, end, type, None, None, None, None)
+    # For Arc:      (line_no, start, end, type, arc_control_y, arc_control_z, arc_center_y, arc_center_z)
+
+    lines = [
+        (1, 1, 3, 'Polyline', None, None, None, None), (2, 4, 6, 'Polyline', None, None, None, None), (3, 3, 7, 'Polyline', None, None, None, None),
+        (4, 8, 4, 'Polyline', None, None, None, None), (5, 15, 1, 'Polyline', None, None, None, None), (6, 6, 16, 'Polyline', None, None, None, None),
+        (7, 12, 8, 'Arc', 0.0402, 0.1654, 0.0339, 0.1590), (8, 7, 11, 'Arc', 0.0402, 0.0066, 0.0339, 0.0130), (9, 11, 12, 'Polyline', None, None, None, None),
+        (10, 18, 17, 'Polyline', None, None, None, None), (11, 17, 21, 'Arc', 0.0508, 0.0066, 0.0571, 0.0130), (12, 18, 22, 'Arc', 0.0508, 0.1654, 0.0571, 0.1590),
+        (13, 25, 15, 'Polyline', None, None, None, None), (14, 16, 29, 'Polyline', None, None, None, None), (15, 21, 27, 'Polyline', None, None, None, None),
+        (16, 28, 22, 'Polyline', None, None, None, None), (17, 27, 26, 'Polyline', None, None, None, None), (18, 29, 28, 'Polyline', None, None, None, None),
+        (19, 26, 31, 'Arc', 0.0920, 0.0030, 0.0945, 0.0005), (20, 31, 32, 'Polyline', None, None, None, None), (21, 40, 25, 'Polyline', None, None, None, None),
+        (22, 32, 34, 'Arc', 0.1609, 0.0061, 0.1560, 0.0110), (23, 34, 35, 'Polyline', None, None, None, None), (24, 35, 37, 'Arc', 0.1640, 0.0350, 0.1665, 0.0325),
+        (25, 37, 43, 'Polyline', None, None, None, None), (26, 41, 40, 'Polyline', None, None, None, None), (27, 42, 41, 'Polyline', None, None, None, None),
+        (28, 43, 42, 'Polyline', None, None, None, None)
+    ]
+
+    type_map = {
+        'Polyline': rsection.structure_core.Line.TYPE_POLYLINE,
+        'Arc': rsection.structure_core.Line.TYPE_ARC
+    }
+
+    boundary_lines = []
+    for l in lines:
+        line_no, start, end, type_str, arc_control_y, arc_control_z, arc_center_y, arc_center_z = l
+        objs.append(
+            rsection.structure_core.Line(
+                no=line_no,
+                definition_points=[start, end],
+                type=type_map[type_str],
+                arc_control_point_y=arc_control_y,
+                arc_control_point_z=arc_control_z,
+                arc_center_y=arc_center_y,
+                arc_center_z=arc_center_z,
+            )
+        )
+        boundary_lines.append(line_no)
+
+    # Define part
+    objs.append(
+        rsection.structure_core.Part(
+            material=1,
+            boundary_lines=boundary_lines,
+        )
+    )
+
+    return objs
+
+# Create RSection model
+with rsection.Application(port=9001) as rsection_app:
+
+    rsection_app.create_model(name='steel_section')
+    rsection_app.delete_all_objects()
+    rsection_app.create_object_list(objs=define_rsection_shape())
+
+    rsection_filepath = os.path.join(os.path.abspath('.'), 'steel_section.rsc')
+    rsection_app.save_model(path=rsection_filepath)
+
+
+# Import the RSection into RSTAB
+with rstab.Application(port=9000) as rstab_app:
+
+    rstab_app.create_model(name='steel_member_with_rsection')
+    rstab_app.delete_all_objects()
+
+    rstab_app.import_from(
+        filepath=rsection_filepath,
+        import_attributes=common.import_export.RsectionImportAttributes()
+    )
+

examples/rstab/import_from_xml.py

@@ -0,0 +1,29 @@
+import os
+from dlubal.api import rstab, common
+
+# Connect to the RSTAB application
+with rstab.Application() as rstab_app:
+
+    # Reset RSTAB by closing models, creating a new one, and clearing all objects
+    rstab_app.close_all_models(save_changes=False)
+    rstab_app.create_model(name='xml_structure')
+    rstab_app.delete_all_objects()
+
+    # Step 1: Import IFC model from the file
+    xml_path = os.path.join(os.path.dirname(__file__), 'src', 'xml_structure.xml')
+
+    rstab_app.import_from(
+        filepath=xml_path,
+        import_attributes=common.import_export.XmlImportAttributes()
+    )
+
+    # Step 2: Get object ID list
+    object_id_list = rstab_app.get_object_id_list()
+
+    # Iterate through object IDs and print their types and IDs
+    for obj in object_id_list.object_id:
+
+        object_id = obj.no
+        object_type = obj.object_type
+
+        print(f"{rstab.ObjectType.Name(object_type)}: {object_id}")

examples/rstab/modal_analysis.py

@@ -0,0 +1,238 @@
+from dlubal.api import rstab, common
+from math import inf
+
+
+def initialize_model():
+
+    # Create new empty model
+    rstab_app.close_all_models(save_changes=False)
+    rstab_app.create_model(name="Modal Analysis")
+
+    # Set global model settings:
+    base_data: rstab.BaseData = rstab_app.get_base_data()
+
+    # Activate add-ons
+    base_data.addons.modal_analysis_active = True
+    # Set standard
+    base_data.standards.dynamic_analysis_standard = rstab.BaseData.Standards.DYNAMIC_ANALYSIS_NATIONAL_ANNEX_AND_EDITION_EN_1998_1_DIN_2023_11_STANDARD
+    # Adjust general settings
+    base_data.general_settings.gravitational_acceleration = 9.81
+
+    # Activate combination wizard
+    base_data.combinations_settings.combination_wizard_active = True
+
+    rstab_app.set_base_data(base_data=base_data)
+    rstab_app.delete_all_objects()
+
+
+def create_structure():
+
+    structure = [
+
+            # Material
+            rstab.structure_core.Material(
+                no=1,
+                name="S235 | EN 1993-1-1:2005-05",
+            ),
+
+            # CrossSection
+            rstab.structure_core.CrossSection(
+                no=1,
+                name="IPE 550 | DIN 1025-5:1994-03 | Ferona",
+                material=1,
+            ),
+
+            # Nodes
+            rstab.structure_core.Node(
+                no=1,
+                coordinate_2=-2,
+            ),
+            rstab.structure_core.Node(
+                no=2,
+                coordinate_2=-2,
+                coordinate_3=-4,
+            ),
+
+            # Member
+            rstab.structure_core.Member(
+                no=1,
+                node_start=1,
+                node_end=2,
+                cross_section_start=1,
+            ),
+
+            # Support
+            rstab.types_for_nodes.NodalSupport(
+                no=1,
+                user_defined_name_enabled=True,
+                name="Fixed",
+                nodes=[1],
+                spring=common.Vector3d(x=inf, y=inf, z=inf),
+                rotational_restraint=common.Vector3d(x=inf, y=inf, z=inf),
+            )
+    ]
+
+    rstab_app.create_object_list(structure)
+
+
+def create_loading():
+
+    loading = [
+        # Load Case | LC1
+        rstab.loading.LoadCase(
+            no=1,
+            name="Static | Self-weight",
+            static_analysis_settings=1,
+        ),
+        # Nodal Loads | LC1
+        rstab.loads.NodalLoad(   # Force
+            no=1,
+            nodes=[2],
+            force_magnitude=1000,
+            load_direction=rstab.loads.NodalLoad.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE_LENGTH,
+            load_case=1,
+        ),
+        rstab.loads.NodalLoad(   # Mass
+            no=2,
+            load_type=rstab.loads.NodalLoad.LOAD_TYPE_MASS,
+            nodes=[2],
+            individual_mass_components=True,
+            mass=common.Vector3d(x=100, y=100, z=100),
+            mass_moment_of_inertia=common.Vector3d(x=100, y=100, z=100),
+            load_case=1,
+        ),
+
+        # Static Analysis Settings
+        rstab.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rstab.loading.StaticAnalysisSettings.ANALYSIS_TYPE_SECOND_ORDER_P_DELTA,
+            mass_conversion_enabled=True,
+        ),
+
+        # --- Combinatoric for Seismic Mass ---
+
+        # Combination Wizard
+        rstab.loading.CombinationWizard(
+            no=1,
+            static_analysis_settings=1,
+            consider_imperfection_case=True,
+        ),
+
+        # Design Situations
+        rstab.loading.DesignSituation(
+            no=1,
+            name="Seismic/Mass Combination - psi-E,i",
+            design_situation_type=rstab.loading.DesignSituation.DESIGN_SITUATION_TYPE_SEISMIC_MASS,
+            combination_wizard=1,
+        ),
+    ]
+
+    rstab_app.create_object_list(loading)
+
+
+def define_modal_analysis_cases():
+
+    modal_analysis = [
+
+        # Modal Analysis Settings
+        rstab.loading.ModalAnalysisSettings(
+            no=1,
+            name='User-defined | Mode=2',
+            user_defined_name_enabled=True,
+            acting_masses_about_axis_x_enabled=False,
+            acting_masses_about_axis_y_enabled=False,
+            acting_masses_about_axis_z_enabled=False,
+            acting_masses_in_direction_z_enabled=False,
+            activate_minimum_initial_prestress=True,
+            solution_method=rstab.loading.ModalAnalysisSettings.SOLUTION_METHOD_SHIFTED_INVERSE_POWER_METHOD,
+            number_of_modes=2,
+        ),
+        rstab.loading.ModalAnalysisSettings(
+            no=2,
+            name='Automated | Mass=95%',
+            user_defined_name_enabled=True,
+            acting_masses_about_axis_x_enabled=False,
+            acting_masses_about_axis_y_enabled=False,
+            acting_masses_about_axis_z_enabled=False,
+            acting_masses_in_direction_z_enabled=False,
+            activate_minimum_initial_prestress=True,
+            solution_method=rstab.loading.ModalAnalysisSettings.SOLUTION_METHOD_SHIFTED_INVERSE_POWER_METHOD,
+            number_of_modes_method=rstab.loading.ModalAnalysisSettings.NUMBER_OF_MODES_METHOD_EFFECTIVE_MASS_FACTORS,
+            effective_modal_mass_factor=0.95
+        ),
+
+        # Modal Load Cases
+        rstab.loading.LoadCase(
+            no=2,
+            analysis_type=rstab.loading.LoadCase.ANALYSIS_TYPE_MODAL_ANALYSIS,
+            name="Modal | Self-mass",
+            modal_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=3,
+            analysis_type=rstab.loading.LoadCase.ANALYSIS_TYPE_MODAL_ANALYSIS,
+            name="Modal | Mass=95%",
+            modal_analysis_settings=2,
+        ),
+    ]
+
+    rstab_app.create_object_list(modal_analysis)
+
+
+def import_masses_to_cases():
+
+    rstab_app.generate_combinations()
+
+    object_list = rstab_app.get_object_list(
+        objs=[
+            rstab.loading.LoadCase()
+        ]
+    )
+
+    for obj in object_list:
+
+        lc: rstab.loading.LoadCase = obj
+
+        if lc.analysis_type is rstab.loading.LoadCase.ANALYSIS_TYPE_MODAL_ANALYSIS:
+
+            lc.import_masses_from.no = 1
+            lc.import_masses_from.object_type = rstab.ObjectType.OBJECT_TYPE_LOAD_COMBINATION
+
+    rstab_app.update_object_list(object_list)
+
+
+def get_effective_modal_masses():
+
+    rstab_app.calculate_all(skip_warnings=True)
+
+    results = rstab_app.get_results(
+        results_type=rstab.results.ResultsType.MODAL_ANALYSIS_EFFECTIVE_MODAL_MASSES
+    )
+    print(f"\nEffective Modal Masses:\n{results.data}")
+
+
+
+
+
+with rstab.Application() as rstab_app:
+
+    # Modal Analysis Procedure
+
+    initialize_model()              # Activate add-on, ...
+
+    create_structure()              # Column IPE 550 (fixed)
+    create_loading()                # Force + Mass
+
+    define_modal_analysis_cases()   # Self-mass (Mode=2) | Mass=95% (Mode=auto)
+    import_masses_to_cases()        # Import masses from generated combination
+
+    get_effective_modal_masses()    # Calculation + reading results
+
+
+
+
+
+
+
+
+