dlubal.api 0.1.293714a1__py3-none-any.whl → 2.12.2__py3-none-any.whl

examples/rstab/dataframe.py

@@ -0,0 +1,20 @@
+from dlubal.api import rstab
+
+# Connect to the RSTAB application
+with rstab.Application() as rstab_app:
+
+    rstab_app.close_all_models(save_changes=False)
+    rstab_app.create_model(name='dataframe')
+
+    # GetResults returns Table, which is just a convenience wrapper around a Pandas Dataframe.
+    # The Dataframe can be directly accessed as .data
+
+    print("Filtered results:")
+    results = rstab_app.get_results(
+        rstab.results.TEST,
+        filters=[rstab.results.ResultsFilter(
+            column_id="support_force_p_x",
+            filter_expression="max")],
+    )
+
+    print(results.data)

examples/rstab/design_settings.py

@@ -0,0 +1,37 @@
+from dlubal.api import rstab, common
+
+# Connect to the rstab application
+with rstab.Application() as rstab_app:
+
+    # Step 1: Retrieve the global settings tree table for Steel Design (active model)
+    design_settings: rstab.GlobalSettingsTreeTable = rstab_app.get_design_settings(
+        addon=rstab.DesignAddons.STEEL_DESIGN
+    )
+    print(f"DESIGN SETTINGS:\n{design_settings}")
+
+    # Step 2: Retrieve a specific value
+    # Path to access the member slenderness setting
+    member_slendernesses_path = [
+        'member_slendernesses',
+        'member_slendernesses_tension_ec3'
+    ]
+    # Fetch the value of the specific setting
+    member_slendernesses_val = common.get_tree_value(
+        tree=design_settings,
+        path=member_slendernesses_path
+    )
+    print(f"\nMember slendernesses: {member_slendernesses_val}")
+
+    # Step 3: Modify the value and save the updated design settings
+    # Set a new value
+    common.set_tree_value(
+        tree=design_settings,
+        path=member_slendernesses_path,
+        value=250,
+    )
+    # Apply the updated design settings to the model
+    rstab_app.set_design_settings(
+        addon=rstab.DesignAddons.STEEL_DESIGN,
+        global_settings_tree_table=design_settings
+    )
+

examples/rstab/excel.py

@@ -0,0 +1,86 @@
+import os
+import xlwings as xw
+from dlubal.api import rstab
+
+def open_work_book():
+    """Open excel file."""
+
+    dirname = os.path.join(os.getcwd(), os.path.dirname(__file__))
+    path = os.path.join(dirname,'src/Nodes.xlsx')
+
+    wb = xw.Book(path)
+
+    return wb
+
+def close_work_book(wb):
+    """Close excel file."""
+
+    wb.save()
+    app = wb.app
+    wb.close()
+    app.kill()
+
+def get_node_from_excel(work_book) -> dict:
+    """Retrieve node from excel file."""
+
+    input_sheet = work_book.sheets('Nodes')
+
+    node1 = {'no' : int(input_sheet["A2"].value),
+              'x' : input_sheet["B2"].value,
+              'y' : input_sheet["C2"].value,
+              'z' : input_sheet["D2"].value}
+
+    return node1
+
+def write_node_to_excel(node, work_book) -> None:
+    """Write data to excel file."""
+
+    input_sheet = work_book.sheets('Nodes')
+
+    input_sheet["A3"].value = node.no
+    input_sheet["B3"].value = node.coordinate_1
+    input_sheet["C3"].value = node.coordinate_2
+    input_sheet["D3"].value = node.coordinate_3
+    if node.comment:
+        input_sheet["E3"].value = node.comment
+
+
+if __name__ == "__main__":
+    """Main routine."""
+
+    with rstab.Application() as rstab_app:
+
+        # Step 1: Create a new model
+        rstab_app.close_all_models(save_changes=False)
+        rstab_app.create_model(name='excel')
+
+        # Step 2: Clear existing objects
+        rstab_app.delete_all_objects()
+
+        # Step 3: Get data for node from excel
+        work_book = open_work_book()
+
+        # Step 4: Create nodes in RSTAB
+        node1 = get_node_from_excel(work_book)
+
+        rstab_app.create_object_list(objs = [
+            rstab.structure_core.Node(
+                no = node1['no'],
+                coordinate_1 = node1['x'],
+                coordinate_2 = node1['y'],
+                coordinate_3 = node1['z']),
+            rstab.structure_core.Node(
+                no = 2,
+                coordinate_1 = 1,
+                coordinate_2 = 2,
+                coordinate_3 = 4,
+                comment = 'Node 2')])
+
+        # Step 4: Get node 2 from RSTAB
+        node2 = rstab_app.get_object(
+            obj = rstab.structure_core.Node(
+                no = 2))
+        write_node_to_excel(node2, work_book)
+
+        # Step 5: Save and close excel file
+        close_work_book(work_book)

examples/rstab/export_model_to.py

@@ -0,0 +1,154 @@
+import os
+from math import inf
+from dlubal.api import rstab, common
+
+def define_structure() -> list:
+    """Define and return a list of structural objects."""
+
+    return [
+        # Define material
+        rstab.structure_core.Material(
+            no=1,
+            name='S235',
+        ),
+
+        # Define section
+        rstab.structure_core.Section(
+            no=1,
+            name='HE 300 A',
+            material=1,
+        ),
+
+        # Define nodes
+        rstab.structure_core.Node(
+            no=1,
+        ),
+        rstab.structure_core.Node(
+            no=2,
+            coordinate_1=6.0,
+        ),
+
+        # Define member
+        rstab.structure_core.Member(
+            no=1,
+            node_start=1,
+            node_end=2,
+            section_start=1,
+        ),
+
+        # Define nodal support at Node 1 (fully fixed)
+        rstab.types_for_nodes.NodalSupport(
+            no=1,
+            nodes=[1],
+            spring_x=inf,
+            spring_y=inf,
+            spring_z=inf,
+            rotational_restraint_x=inf,
+            rotational_restraint_y=inf,
+            rotational_restraint_z=inf,
+        ),
+    ]
+
+def define_loading() -> 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,
+            static_analysis_settings=1,
+        ),
+        rstab.loading.LoadCase(
+            no=2,
+            static_analysis_settings=1,
+        ),
+
+        # Define nodal loads
+        rstab.loads.NodalLoad(
+            no=1,
+            load_case=1,
+            nodes=[2],
+            load_type=rstab.loads.NodalLoad.LOAD_TYPE_COMPONENTS,
+            components_force_y=5000,  # Force in Y direction (N)
+            components_force_z=10000,  # Force in Z direction (N)
+        ),
+        rstab.loads.MemberLoad(
+            no=1,
+            load_case=2,
+            members=[1],
+            load_type=rstab.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=10000,
+        ),
+
+        # Define design situation
+        rstab.loading.DesignSituation(
+            no=1,
+            design_situation_type=rstab.loading.DesignSituation.DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10,
+        ),
+
+        # Define load combination
+        rstab.loading.LoadCombination(
+            no=1,
+            name='CO1',
+            items =  rstab.loading.LoadCombination.ItemsTable(
+                    rows=[
+                        rstab.loading.LoadCombination.ItemsRow(
+                            load_case=1,
+                            factor=1.35,
+                        ),
+                        rstab.loading.LoadCombination.ItemsRow(
+                            load_case=2,
+                            factor=1.5,
+                        )
+                    ]
+            ),
+            design_situation=1,
+        ),
+        rstab.loading.LoadCombination(
+            no=2,
+            name='CO2',
+            items =  rstab.loading.LoadCombination.ItemsTable(
+                    rows=[
+                        rstab.loading.LoadCombination.ItemsRow(
+                            load_case=1,
+                            factor=0.85,
+                        ),
+                        rstab.loading.LoadCombination.ItemsRow(
+                            load_case=2,
+                            factor=1.0,
+                        )
+                    ]
+            ),
+            design_situation=1,
+        ),
+    ]
+
+
+"""Runs the structural analysis example."""
+
+with rstab.Application() as rstab_app:
+
+    # Step 1: Create a model
+    rstab_app.create_model(name='cantilever')
+    rstab_app.delete_all_objects()
+    rstab_app.create_object_list(
+        objs=define_structure() + define_loading()
+    )
+
+    # Step 2: Export the model to Python script
+    rstab_app.export_to(
+        filepath=os.path.abspath('./model_export.py'),
+        export_attributes=common.import_export.PythonGrpcExportAttributes()
+    )
+
+    # Step 3: Export the model to IFC
+    rstab_app.export_to(
+        filepath=os.path.abspath('./model_export.ifc'),
+        export_attributes=common.import_export.IfcExportAttributes()
+    )

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 section
+        rstab.structure_core.Section(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, section_start=1),
+        rstab.structure_core.Member(no=2, node_start=2, node_end=3, section_start=1),
+        rstab.structure_core.Member(no=3, node_start=3, node_end=4, 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
+    )
+