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

examples/rfem/column.py

@@ -0,0 +1,185 @@
+from dlubal.api import rfem
+from math import inf
+
+def define_structure() -> list:
+    """Returns a list of structural objects to be created."""
+
+    return [
+        rfem.structure_core.Material(
+            no=1,
+            name='S235',
+        ),
+        rfem.structure_core.Section(
+            no=1,
+            name='HEB 300',
+            material=1,
+            shear_stiffness_deactivated=True,
+        ),
+        rfem.structure_core.Node(
+            no=1,
+        ),
+        rfem.structure_core.Node(
+            no=2,
+            coordinate_3=10.0,
+        ),
+        rfem.structure_core.Member(
+            no = 1,
+            line = 1,
+            node_start=1,
+            node_end=2,
+            section_start = 1
+        ),
+        rfem.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,
+        ),
+        rfem.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 [
+        rfem.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rfem.loading.StaticAnalysisSettings.ANALYSIS_TYPE_GEOMETRICALLY_LINEAR
+        ),
+        rfem.loading.StabilityAnalysisSettings(
+            no=1,
+            analysis_type=rfem.loading.StabilityAnalysisSettings.ANALYSIS_TYPE_EIGENVALUE_METHOD,
+            number_of_lowest_eigenvalues=2,
+        ),
+        rfem.loading.LoadCase(
+            no=1,
+            stability_analysis_settings=1,
+            calculate_critical_load=True,
+            self_weight_active=False,
+        ),
+        rfem.loads.NodalLoad(
+            no=1,
+            load_case=1,
+            nodes=[2],
+            load_type=rfem.loads.NodalLoad.LOAD_TYPE_COMPONENTS,
+            components_force_z=-1000000,
+        ),
+        rfem.loading.DesignSituation(
+            no=1,
+            design_situation_type=rfem.loading.DesignSituation.DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10,
+        ),
+        rfem.loading.LoadCombination(
+            no=1,
+            name='CO1',
+            items =  rfem.loading.LoadCombination.ItemsTable(
+                    rows=[
+                        rfem.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 [
+        rfem.steel_design_objects.SteelDesignUlsConfiguration(
+            no=1,
+            assigned_to_all_members=True,
+        ),
+        rfem.types_for_steel_design.SteelEffectiveLengths(
+            no=1,
+            members=[1],
+            import_from_stability_analysis_enabled=True,
+            stability_import_data_loading_y=rfem.ObjectId(no=1, object_type=rfem.ObjectType.OBJECT_TYPE_LOAD_CASE),
+            stability_import_data_loading_z=rfem.ObjectId(no=1, object_type =rfem.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 rfem.Application() as rfem_app:
+
+    # Step 1: Create a New Model
+    rfem_app.close_all_models(save_changes=False)
+    rfem_app.create_model(name='column_stability')
+
+    # Configure Add-ons, Design Standards, and Global Settings in Base Data
+    base_data = rfem_app.get_base_data()
+    base_data.addons.structure_stability_active = True
+    base_data.addons.steel_design_active = True
+    base_data.standards.steel_design_standard = rfem.BaseData.Standards.STEEL_DESIGN_NATIONAL_ANNEX_AND_EDITION_EN_1993_DIN_2020_11_STANDARD
+    base_data.general_settings.global_axes_orientation = rfem.BaseData.GeneralSettings.GLOBAL_AXES_ORIENTATION_ZUP
+    rfem_app.set_base_data(base_data=base_data)
+
+    # Step 3: Create Structure and Loading in Empty Model
+    rfem_app.delete_all_objects()
+    objects = define_structure() + define_loading()
+    rfem_app.create_object_list(objects)
+
+    # Step 4: Perform the Stability analysis
+    stability_analysis = rfem_app.calculate_all(skip_warnings=True)
+    print(f"\nStability Analysis:\n{stability_analysis}")
+
+    # Step 5: Define Steel Design related objects
+    objects = define_steel_design()
+    rfem_app.create_object_list(objects)
+
+    # Step 6: Perform the Steel design check
+    steel_design = rfem_app.calculate_all(skip_warnings=True)
+    print(f"\nSteel Design Check:\n{steel_design}")
+
+    # Step 7: Get steel design check results
+    steel_design_check = rfem_app.get_results(
+        results_type=rfem.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 = rfem_app.get_results(
+        results_type=rfem.results.STEEL_DESIGN_DESIGN_CHECK_DETAILS,
+        filters=[rfem.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/rfem/component_design.py

@@ -0,0 +1,161 @@
+from dlubal.api import rfem, common
+from typing import List, Dict
+import pandas
+
+
+class DesignCheck:
+
+    def __init__(self, app: rfem.Application, component_no: int, loading: str):
+
+        self.app = app
+        self.component_no = component_no
+        self.loading = loading
+
+        self.checks = pandas.DataFrame()
+
+    def define_design_checks(self) -> List[Dict]:
+        """
+        Returns a list of design checks for this component.
+        Each check can have a different description and parameters.
+        """
+        # Define multiple checks for the same component
+        return [
+            {"type": "CP-10.001", "description": "Ultimate Limit State | Load Capacity on F1", "category": "ULS", "subcategory": "Capacity"},
+            {"type": "CP-10.002", "description": "Ultimate Limit State | Load Capacity on F3", "category": "ULS", "subcategory": "Capacity"},
+        ]
+
+
+    def parse_member_location(self, member_location: str) -> {int, str}:
+        if member_location[-1] in ['E', 'S']:
+            return int(member_location[:-1]), member_location[-1]
+        return int(member_location), 'B'
+
+
+    def evaluate_design_check(self): # -> pandas.DataFrame:
+
+        """
+        Perform the specific design check based on the 'check' dictionary passed in.
+        """
+
+        component: rfem.component_design_objects.Component  = self.app.get_object(
+            rfem.component_design_objects.Component(no=self.component_no)
+        )
+        print(component)
+
+        nail_type = common.get_tree_value(
+            tree=component.component_settings,
+            path=["fastening", "nail_type", "nail_type_nail_type"]
+        )
+
+        results = self.app.get_results(
+            results_type=rfem.results.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        ).data
+
+        design_check_types = []
+
+        member_ends = [m.strip() for m in component.assigned_to_member_ends.split(',')]
+
+        for member_end in member_ends:
+
+            member_no, location = self.parse_member_location(member_end)
+
+            member: rfem.structure_core.Member = self.app.get_object(
+                rfem.structure_core.Member(no=member_no)
+            )
+
+            nodes = []
+            if location in ['S', 'B']:  # S=start, 3=Both
+                nodes.append((member.node_start, "S"))
+            if location in ['E', 'B']:  # E=end, 3=Both
+                nodes.append((member.node_end, "E"))
+
+            for node_no, assignment in nodes:
+                print(node_no)
+
+                forces = results[
+                    (results['member_no'] == member_no) &
+                    (results['node_no'] == node_no) &
+                    (results['loading'] == self.loading)
+                ]
+                print(forces)
+
+                checks_definition = self.define_design_checks()
+
+                for check in checks_definition:
+
+                    check_type = check["type"]
+                    check_description = check["description"]
+
+                    # Define design check for each check type  Fd / Rd
+                    if check_type == "CP-10.001": # F1 = Vz
+                        applied_force = forces['v_z'].abs().max() / 1000    # kN
+                        print(applied_force)
+                        if nail_type == "Full Nailing":
+                            capacity = common.get_tree_value(
+                                tree=component.component_parameters,
+                                path=["characteristic_capacities", "full_nailing", "load_capacity_on_f1_r_1_k_cna4_0x40"]
+                            )
+                        else:
+                            capacity = common.get_tree_value(
+                                tree=component.component_parameters,
+                                path=["characteristic_capacities", "partial_nailing", "load_capacity_on_f1_r_1_k_cna4_0x40"]
+                            )
+                        design_ratio = (applied_force / float(capacity)) # * gamma_m
+
+                    elif check_type == "CP-10.002": # F3 = Vy
+                        applied_force = forces['v_y'].abs().max() / 1000    # kN
+                        print(applied_force)
+                        if nail_type == "Full Nailing":
+                            capacity = common.get_tree_value(
+                                tree=component.component_parameters,
+                                path=["characteristic_capacities", "full_nailing", "load_capacity_on_f3_r_3_k_cna4_0x40"]
+                            )
+                        else:
+                            capacity = common.get_tree_value(
+                                tree=component.component_parameters,
+                                path=["characteristic_capacities", "partial_nailing", "load_capacity_on_f3_r_3_k_cna4_0x40"]
+                            )
+                        design_ratio = (applied_force / float(capacity)) # * gamma_m
+
+                    else:
+                        design_ratio = 3.0
+
+                    design_check_types.append({
+                        "Component No.": component.no,
+                        "Member No.": member_no,
+                        "Assignment": assignment,
+                        "Node No.": node_no,
+                        "Loading": self.loading,
+                        "Applied Force": applied_force,         #kN
+                        "Capacity": capacity,                   #kN
+                        "Ratio": design_ratio,
+                        "Type": check_type,
+                        "Description": check_description,
+                    })
+
+        self.checks = pandas.concat([self.checks, pandas.DataFrame(design_check_types)])
+        return self.checks
+
+
+
+if __name__ == "__main__":
+
+    rfem_app = rfem.Application()
+
+    try:
+        design_check = DesignCheck(
+            app=rfem_app,
+            component_no=1,
+            loading='CO3'
+        )
+
+        design_check_df = design_check.evaluate_design_check()
+
+        print("\nDesign Check:")
+        print(design_check_df.to_string(index=False))
+
+        rfem_app.close_connection()
+
+    except Exception as e:
+        rfem_app.close_connection()
+        print(f"Error: {e}")