dlubal.api 2.12.11__py3-none-any.whl

examples/rstab/column.py

@@ -0,0 +1,184 @@
+from dlubal.api import rstab
+from math import inf
+
+def define_structure() -> list:
+    """Returns a list of structural objects to be created."""
+
+    return [
+        rstab.structure_core.Material(
+            no=1,
+            name='S235',
+        ),
+        rstab.structure_core.CrossSection(
+            no=1,
+            name='HEB 300',
+            material=1,
+            shear_stiffness_deactivated=True,
+        ),
+        rstab.structure_core.Node(
+            no=1,
+        ),
+        rstab.structure_core.Node(
+            no=2,
+            coordinate_3=10.0,
+        ),
+        rstab.structure_core.Member(
+            no = 1,
+            node_start=1,
+            node_end=2,
+            cross_section_start = 1
+        ),
+        rstab.types_for_nodes.NodalSupport(
+            no=1,
+            nodes=[1],
+            spring_x=inf,
+            spring_y=inf,
+            spring_z=inf,
+            rotational_restraint_x=5000000,
+            rotational_restraint_y=5000000,
+            rotational_restraint_z=inf,
+        ),
+        rstab.types_for_nodes.NodalSupport(
+            no=2,
+            nodes=[2],
+            spring_x=inf,
+            spring_y=inf,
+            spring_z=0,
+            rotational_restraint_x=0,
+            rotational_restraint_y=0,
+            rotational_restraint_z=inf,
+        ),
+    ]
+
+def define_loading() -> list:
+    """Returns a list of loading objects to be created."""
+
+    return [
+        rstab.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rstab.loading.StaticAnalysisSettings.ANALYSIS_TYPE_GEOMETRICALLY_LINEAR
+        ),
+        rstab.loading.StabilityAnalysisSettings(
+            no=1,
+            analysis_type=rstab.loading.StabilityAnalysisSettings.ANALYSIS_TYPE_EIGENVALUE_METHOD,
+            number_of_lowest_eigenvalues=2,
+        ),
+        rstab.loading.LoadCase(
+            no=1,
+            stability_analysis_settings=1,
+            calculate_critical_load=True,
+            self_weight_active=False,
+        ),
+        rstab.loads.NodalLoad(
+            no=1,
+            load_case=1,
+            nodes=[2],
+            load_type=rstab.loads.NodalLoad.LOAD_TYPE_COMPONENTS,
+            components_force_z=-1000000,
+        ),
+        rstab.loading.DesignSituation(
+            no=1,
+            design_situation_type=rstab.loading.DesignSituation.DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10,
+        ),
+        rstab.loading.LoadCombination(
+            no=1,
+            name='CO1',
+            items =  rstab.loading.LoadCombination.ItemsTable(
+                    rows=[
+                        rstab.loading.LoadCombination.ItemsRow(
+                            load_case=1,
+                            factor=1,
+                        ),
+                    ]
+            ),
+            design_situation=1,
+        ),
+    ]
+
+def define_steel_design() -> list:
+    """Returns a list of steel design related objects to be created."""
+
+    return [
+        rstab.steel_design_objects.SteelDesignUlsConfiguration(
+            no=1,
+            assigned_to_all_members=True,
+        ),
+        rstab.steel_design.SteelEffectiveLengths(
+            no=1,
+            members=[1],
+            import_from_stability_analysis_enabled=True,
+            stability_import_data_loading_y=rstab.ObjectId(no=1, object_type=rstab.ObjectType.OBJECT_TYPE_LOAD_CASE),
+            stability_import_data_loading_z=rstab.ObjectId(no=1, object_type =rstab.ObjectType.OBJECT_TYPE_LOAD_CASE),
+            stability_import_data_mode_number_y=2,
+            stability_import_data_mode_number_z=1,
+            stability_import_data_member_y=1,
+            stability_import_data_member_z=1,
+        ),
+    ]
+
+
+"""Runs the example of column stability analysis."""
+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='column_stability')
+
+    # Configure Add-ons, Design Standards, and Global Settings in Base Data
+    base_data = rstab_app.get_base_data()
+    base_data.addons.structure_stability_active = True
+    base_data.addons.steel_design_active = True
+    base_data.standards.steel_design_standard = rstab.BaseData.Standards.STEEL_DESIGN_NATIONAL_ANNEX_AND_EDITION_EN_1993_DIN_2020_11_STANDARD
+    base_data.general_settings.global_axes_orientation = rstab.BaseData.GeneralSettings.GLOBAL_AXES_ORIENTATION_ZUP
+    rstab_app.set_base_data(base_data=base_data)
+
+    # Step 3: Create Structure and Loading in Empty Model
+    rstab_app.delete_all_objects()
+    objects = define_structure() + define_loading()
+    rstab_app.create_object_list(objects)
+
+    # Step 4: Perform the Stability analysis
+    stability_analysis = rstab_app.calculate_all(skip_warnings=True)
+    print(f"\nStability Analysis:\n{stability_analysis}")
+
+    # Step 5: Define Steel Design related objects
+    objects = define_steel_design()
+    rstab_app.create_object_list(objects)
+
+    # Step 6: Perform the Steel design check
+    steel_design = rstab_app.calculate_all(skip_warnings=True)
+    print(f"\nSteel Design Check:\n{steel_design}")
+
+    # Step 7: Get steel design check results
+    steel_design_check = rstab_app.get_results(
+        results_type=rstab.results.STEEL_DESIGN_MEMBERS_DESIGN_RATIOS_BY_LOCATION
+    ).data
+    print(f"\nResults | Steel Design Ratios by Location | All:")
+    print(steel_design_check)
+
+    # Step 8: Get steel design check details for the maximum ratio
+    max_design_ratio_row = steel_design_check.loc[steel_design_check['design_ratio'].idxmax()]
+    design_check_details_id = max_design_ratio_row['design_check_details_id']
+
+    steel_design_details = rstab_app.get_results(
+        results_type=rstab.results.STEEL_DESIGN_DESIGN_CHECK_DETAILS,
+        filters=[rstab.results.ResultsFilter(
+            column_id="design_check_details_id",
+            filter_expression=str(design_check_details_id))],
+    ).data
+    print(steel_design_details)
+
+     # Step 9: Get detail row for specific variable
+    symbol = 'N<sub>c,Ed</sub>'
+    n_ed_value = steel_design_details.loc[steel_design_details['symbol']==symbol, 'value'].values[0]
+    n_ed_unit = steel_design_details.loc[steel_design_details['symbol']==symbol, 'unit'].values[0]
+    print(f"\nN_Ed= {n_ed_value} [{n_ed_unit}]")
+
+    symbol = 'N<sub>b,z,Rd</sub>'
+    n_rd_value = steel_design_details.loc[steel_design_details['symbol']==symbol, 'value'].values[0]
+    n_rd_unit = steel_design_details.loc[steel_design_details['symbol']==symbol, 'unit'].values[0]
+    print(f"N_Rd= {n_rd_value} [{n_rd_unit}]")
+
+    symbol = 'η'
+    ratio_value = steel_design_details.loc[steel_design_details['symbol']==symbol, 'value_si'].values[0]
+    print(f"η= {ratio_value} [-]")

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_configuration.py

@@ -0,0 +1,87 @@
+from dlubal.api import rstab, common
+import google.protobuf.json_format as pbjson
+
+# Connect to the rstab application
+with rstab.Application() as rstab_app:
+
+    # --- Steel Design | ULS Configuration ---
+
+    # Retrieve Design ULS Configuration TreeTable
+    steel_uls_config: rstab.steel_design_objects.SteelDesignUlsConfiguration = rstab_app.get_object(
+        obj=rstab.steel_design_objects.SteelDesignUlsConfiguration(no=1)
+    )
+    settings_ec3_uls = steel_uls_config.settings_ec3
+    print(f"\nSETTINGS_EC3_ULS:\n{settings_ec3_uls}")
+
+    # Retrieve a specific value from the configuration
+    # Path to the specific value
+    elastic_design_path=[
+        "options",
+        "options_elastic_design_root",
+        "options_elastic_design"
+    ]
+    # Get specific value
+    elastic_design_val = common.get_tree_value(
+        tree=settings_ec3_uls,
+        path=elastic_design_path
+    )
+    print(f"\nElastic Design: {elastic_design_val}")
+
+    # Modify the value
+    # Create empty TreeTable and set only the values that we want to change
+    settings_ec3_uls_updated = rstab.steel_design_objects.SteelDesignUlsConfiguration.SettingsEc3TreeTable()
+    common.set_tree_value(
+        tree=settings_ec3_uls_updated,
+        path=elastic_design_path,
+        value=True
+    )
+
+    # Apply the updated configuration to the model
+    rstab_app.update_object(
+        obj=rstab.steel_design_objects.SteelDesignUlsConfiguration(
+            no=1,
+            settings_ec3=settings_ec3_uls_updated
+        )
+    )
+
+
+    # --- Steel Design | SLS Configuration ---
+
+    # Retrieve Design SLS Configuration TreeTable
+    steel_sls_config: rstab.steel_design_objects.SteelDesignSlsConfiguration = rstab_app.get_object(
+        obj=rstab.steel_design_objects.SteelDesignSlsConfiguration(no=1)
+    )
+    settings_ec3_sls = steel_sls_config.settings_ec3
+    print(f"\nSETTINGS_EC3_SLS:\n{settings_ec3_sls}")
+
+    # Retrieve a specific value from the configuration
+    # Path to the specific value
+    beam_rel_deflection_limit_path=[
+        "serviceability_limits",
+        "sl_check_limit_characteristic",
+        "sl_check_deformation_z_or_resulting_axis_characteristic",
+        "l_", # Beam | Relative limit
+    ]
+    # Get specific value
+    beam_rel_deflection_limit_val = common.get_tree_value(
+        tree=settings_ec3_sls,
+        path=beam_rel_deflection_limit_path
+    )
+    print(f"\nBeam | Relative deflection limit: L/{beam_rel_deflection_limit_val}")
+
+    # Modify the value
+    # Create empty TreeTable and set only the values that we want to change
+    settings_ec3_sls_updated =rstab.steel_design_objects.SteelDesignSlsConfiguration.SettingsEc3TreeTable()
+    common.set_tree_value(
+        tree=settings_ec3_sls_updated,
+        path=beam_rel_deflection_limit_path,
+        value=250
+    )
+
+    # Apply the updated configuration to the model
+    rstab_app.update_object(
+        obj=rstab.steel_design_objects.SteelDesignSlsConfiguration(
+            no=1,
+            settings_ec3=settings_ec3_sls_updated
+        )
+    )

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 cross-section
+        rstab.structure_core.CrossSection(
+            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,
+            cross_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()
+    )