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

examples/rfem/nested_tables.py

@@ -0,0 +1,81 @@
+import dlubal.api.rfem as rfem
+from dlubal.api.common import Vector3d
+
+with rfem.Application() as client:
+    client.close_all_models(save_changes=False)
+    client.create_model(name="nested_tables")
+    client.delete_all_objects()
+
+    ############################################
+    # Test NURBS line with nested tables:
+    ############################################
+
+    client.create_object_list([
+        rfem.structure_core.Node(no=1, global_coordinates=Vector3d(x=3.000, y=-1.000, z=0.000)),
+        rfem.structure_core.Node(no=2, global_coordinates=Vector3d(x=4.000, y=-1.000, z=0.000))
+    ])
+
+    # Prepare NURBS control points table.
+    # The first and last row correspond to the end nodes so we don't need to set any data for them.
+    control_points = rfem.structure_core.Line.NurbsControlPointsTable(
+        rows=[
+            rfem.structure_core.Line.NurbsControlPointsRow(),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=1.205, y=-2.793, z=0.000), weight=1.100),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=1.000, y=-4.000, z=0.000), weight=1.200),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=3.000, y=-4.000, z=0.000), weight=1.300),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=2.000, y=-6.000, z=0.000), weight=1.400),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=1.000, y=-8.000, z=0.000), weight=1.500),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=3.000, y=-8.000, z=0.000), weight=1.600),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=5.000, y=-5.000, z=0.000), weight=1.700),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=4.000, y=-3.000, z=0.000), weight=1.800),
+            rfem.structure_core.Line.NurbsControlPointsRow(global_coordinates=Vector3d(x=6.000, y=-1.000, z=0.000), weight=1.900),
+            rfem.structure_core.Line.NurbsControlPointsRow(),
+        ]
+    )
+
+    # If we use the 'no' attribute, we are able to set specific rows.
+    # If we don't use the 'no' attribute, the entire table will be reset,
+    # and table will be truncated or enlarged to the number of rows set (if possible).
+    # If the 'no' attribute is set, the table will only be enlarged to fit the largest row number,
+    # but never truncated.
+    # In this case, we set only row number 5 and other rows are left to be default.
+    knot_values = rfem.structure_core.Line.NurbsKnotsTable(
+        rows=[
+            rfem.structure_core.Line.NurbsKnotsRow(no=5, knot_value=0.15),
+        ]
+    )
+
+    line = rfem.structure_core.Line(
+        no=1,
+        type=rfem.structure_core.Line.TYPE_NURBS,
+        definition_nodes=[1, 2],
+        nurbs_control_points=control_points,
+        nurbs_order=3,
+        nurbs_knots=knot_values)
+
+    client.create_object(line)
+
+    ############################################
+    # Test load combination nested tables:
+    ############################################
+
+    load_cases = [
+        rfem.loading.LoadCase(no=1, name="Self weight"),
+        rfem.loading.LoadCase(no=2, name="Live Load")
+    ]
+
+    client.create_object_list(load_cases)
+
+    # Prepare load combination items table.
+    items = rfem.loading.LoadCombination.ItemsTable(
+        rows=[
+            rfem.loading.LoadCombination.ItemsRow(load_case=1, factor=1.35),
+            rfem.loading.LoadCombination.ItemsRow(load_case=2, factor=1.5)
+        ]
+    )
+    co = rfem.loading.LoadCombination(no=1, items=items)
+    client.create_object(co)
+
+    # Get the created load combination and print it - we get the table data as well.
+    co = client.get_object(rfem.loading.LoadCombination(no=1))
+    print(co)

examples/rfem/pydantic_streamlit.py

@@ -0,0 +1,101 @@
+from math import inf
+from dlubal.api import rfem
+from pydantic import BaseModel, Field
+import streamlit as st
+
+"""
+Cantilever beam design using RFEM API and Pydantic for input validation.
+To run this script install Streamlit and execute the following command in the terminal:
+'python -m streamlit run pydantic_streamlit.py'
+"""
+
+class CantileverData(BaseModel):
+    """
+    Pydantic class defining the model parameters.
+    This class is used to validate the input parameters for the RFEM model.
+    """
+    length: float = Field(None, gt=0, le=10)
+    material: str = 'S235'
+    section: str = 'IPE 120'
+
+
+def define_structure(model : CantileverData) -> None:
+    """
+    Define and return a list of structural objects.
+    This function creates a cantilever beam with the specified parameters.
+    """
+    object_lst = [
+        # Define material
+        rfem.structure_core.Material(
+            no=1,
+            name=model.material,
+        ),
+
+        # Define section
+        rfem.structure_core.Section(
+            no=1,
+            name=model.section,
+            material=1,
+        ),
+
+        # Define nodes
+        rfem.structure_core.Node(
+            no=1,
+        ),
+        rfem.structure_core.Node(
+            no=2,
+            coordinate_1=model.length,
+        ),
+
+        # Define member
+        rfem.structure_core.Member(
+            no=1,
+            node_start=1,
+            node_end=2,
+            section_start=1,
+        ),
+
+        # Define nodal support at Node 1 (fully fixed)
+        rfem.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,
+        ),
+    ]
+    rfem_app.create_object_list(objs=object_lst)
+
+if __name__ == '__main__':
+
+    # Streamlit app
+    st.title("RFEM API Cantilever Design")
+    form = st.form(key='cantilever_form')
+    l = form.slider(label='Select length [m] (0, 10>)', min_value=0.00, max_value=15.00)
+    mat = form.selectbox('Select material', ['S235', 'S275', 'S355', 'S450'])
+    sec = form.selectbox('Select section', ['IPE 100', 'IPE 120','HEA 100', 'HEB 100'])
+    submit_button = form.form_submit_button(label='Submit')
+
+    if submit_button:
+        try:
+            model = CantileverData(length=l, material=mat, section=sec)
+
+            form.write('Parameters OK. Creating cantilever in RFEM...')
+            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='cantilever')
+
+                # Step 2: Clear existing objects
+                rfem_app.delete_all_objects()
+
+                # Step 3: Define and create all objects.
+                define_structure(model)
+                st.badge("Success", icon=":material/check:", color="green")
+
+        except ValueError as e:
+            st.badge("Error", icon="⚠️", color="red")
+            st.error(f"Pydantic output: {e}")

examples/rfem/results_access.py

@@ -0,0 +1,38 @@
+from dlubal.api import rfem, common
+
+with rfem.Application() as rfem_app:
+
+    # --- get_results ---
+    # Retrieves complete, unprocessed results from the RFEM database.
+    # These results are returned wrapped in a DataFrame (.data).
+    results:common.Table = rfem_app.get_results(
+        results_type=rfem.results.ResultsType.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES
+    )
+    print(f"\nResults:\n{results.data}")
+
+
+
+    # --- get_result_table ---
+    # Retrieves a pre-processed result table wrapped in a DataFrame (.data),
+    # containing only the most relevant values as displayed in the RFEM desktop application.
+    result_table:common.Table = rfem_app.get_result_table(
+        table = rfem.results.ResultTable.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+        loading= rfem.ObjectId(
+            no=1,
+            object_type=rfem.OBJECT_TYPE_LOAD_COMBINATION
+        )
+    )
+    print(f"\nResult Table:\n{result_table.data}")
+
+    # --- has_results ---
+    # Checks if results exist for a specified loading condition.
+    # This is useful to confirm results availability before retrieving them,
+    # preventing errors or unnecessary data requests.
+    has_results = rfem_app.has_results(
+        loading = rfem.ObjectId
+        (
+            no = 1,
+            object_type = rfem.OBJECT_TYPE_LOAD_COMBINATION,
+        )
+    )
+    print(f"\nResults Available: {has_results.value}")

examples/rfem/results_axes_system.py

@@ -0,0 +1,53 @@
+from dlubal.api import rfem, common
+
+with rfem.Application() as rfem_app:
+
+    # --- Support Forces ---
+    # The direction of support forces can be defined in either the Local (default) or Global
+    # Coordinate System (CS). This choice affects how the support reactions are
+    # recalculated and aligned with the selected coordinate system for correct results.
+
+    # Get results
+    support_forces: common.Table = rfem_app.get_results(
+        results_type=rfem.results.ResultsType.STATIC_ANALYSIS_NODES_SUPPORT_FORCES,
+        support_coordinate_system=rfem.results.settings.CoordinateSystem.COORDINATE_SYSTEM_GLOBAL
+    )
+    print(f"\nSupport Forces:\n{support_forces.data}")
+
+    # Get result table
+    support_forces_table: common.Table = rfem_app.get_result_table(
+        table=rfem.results.ResultTable.STATIC_ANALYSIS_NODES_SUPPORT_FORCES_TABLE,
+        loading= rfem.ObjectId(
+            no=1,
+            object_type=rfem.OBJECT_TYPE_LOAD_CASE
+        ),
+        support_coordinate_system=rfem.results.settings.CoordinateSystem.COORDINATE_SYSTEM_GLOBAL
+    )
+    print(f"\nSupport Forces Table:\n{support_forces_table.data}")
+
+
+    # --- Member Forces ---
+    # Member forces can be defined in either the Member Local XYZ (default)
+    # or the Principal Axes XUV coordinate system. This choice determines how
+    # the forces are calculated and aligned according to the respective axes
+    # system of the member's geometry.
+
+    # Get results
+    member_forces: common.Table = rfem_app.get_results(
+        results_type=rfem.results.ResultsType.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        member_axes_system=rfem.results.settings.MEMBER_AXES_SYSTEM_PRINCIPAL_AXES_X_U_V,
+    )
+    print(f"\nMember Forces:\n{member_forces.data}")
+
+    # Get result table
+    member_forces_table: common.Table = rfem_app.get_result_table(
+        table=rfem.results.ResultTable.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+        loading= rfem.ObjectId(
+            no=1,
+            object_type=rfem.OBJECT_TYPE_LOAD_CASE
+        ),
+        member_axes_system=rfem.results.settings.MEMBER_AXES_SYSTEM_PRINCIPAL_AXES_X_U_V,
+    )
+    print(f"\nMember Forces Table:\n{member_forces_table.data}")
+
+

examples/rfem/results_design_addons.py

@@ -0,0 +1,58 @@
+from dlubal.api import rfem
+
+with rfem.Application() as rfem_app:
+
+    calculation_info = rfem_app.calculate_all(
+        skip_warnings=False
+    )
+
+    if calculation_info.succeeded:
+
+        # --- Retriev results from the active model (already calculated) ---
+
+        # 1. get_results: Returns all results of the specified type directly from the database.
+        #    This is the full dataset, including all possible columns and data. Use this for custom analytics,
+        #    advanced filtering, or to access values not shown in the GUI summary.
+        design_ratios_df = rfem_app.get_results(
+            results_type=rfem.results.ResultsType.STEEL_DESIGN_MEMBERS_DESIGN_RATIOS
+        ).data
+        print(f"\n\nSteel Design | Design Ratios | Raw Data")
+        print(design_ratios_df)
+
+
+        # 2. get_result_table: Returns a specific result table as it appears in the desktop GUI in default state.
+        #    Only the most important values are included, mirroring what end users see for quick review or export.
+        design_ratios_by_member_df = rfem_app.get_result_table(
+            table = rfem.results.ResultTable.STEEL_DESIGN_MEMBERS_DESIGN_RATIOS_BY_MEMBER_TABLE,
+            loading = None
+        ).data
+        print(f"\n\nSteel Design | Design Ratios by Member | Table:")
+        print(design_ratios_by_member_df)
+
+
+        # 1. get_results: Returns all results of the specified type directly from the database.
+        #    This is the full dataset, including all possible columns and data. Use this for custom analytics,
+        #    advanced filtering, or to access values not shown in the GUI summary.
+        design_check_details = rfem_app.get_results(
+            results_type=rfem.results.ResultsType.STEEL_DESIGN_DESIGN_CHECK_DETAILS,
+            filters=[
+                rfem.results.ResultsFilter(
+                    column_id='design_check_details_id', filter_expression="13"
+                )
+            ]
+        ).data
+        print(f"\n\nSteel Design | Details:")
+        print(design_check_details)
+
+    else:
+        # 2. get_result_table: Returns a specific result table as it appears in the desktop GUI in default state.
+        #    Only the most important values are included, mirroring what end users see for quick review or export.
+        errors_warning_df = rfem_app.get_result_table(
+            table = rfem.results.ResultTable.ERRORS_AND_WARNINGS_TABLE,
+            loading = None
+        ).data
+        print(f"\n\nErrors and Warnings | Table:")
+        print(errors_warning_df)
+
+
+

examples/rfem/results_filtering.py

@@ -0,0 +1,43 @@
+from dlubal.api import rfem
+import pandas, os
+
+with rfem.Application() as rfem_app:
+
+    # --- Pre-processing results by Filters ---
+
+    # Add optional filters to limit the amount of data retrieved from the database.
+    # Currently, filters can only be applied to 'object_no' and/or 'loading'!
+    filters=[
+        rfem.results.ResultsFilter(column_id='member_no', filter_expression='1,3,6'),
+        rfem.results.ResultsFilter(column_id='loading', filter_expression='LC1, CO1'),
+    ]
+
+     # Retrieve filtered results as a Pandas DataFrame (.data)
+    results: pandas.DataFrame  = rfem_app.get_results(
+        results_type=rfem.results.ResultsType.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        filters=filters
+    ).data
+    print(f"\nResults Pre-processed (Filters):\n{results}")
+
+
+    # --- Post-processing results by Pandas DataFrame  ---
+
+    # Once the relevant data has been filtered, we can further process and analyze it using the Pandas DataFrame.
+    # Pandas provides powerful tools to manipulate and analyze data in an efficient and flexible manner.
+
+    # Retrieve the entire row that corresponds to this minimum 'n' value
+    row_n_min = results.loc[results['n'].idxmin()]
+    print(f"\nResults Post-processed (Pandas):\n{row_n_min}")
+
+    # Find the minimum value of the 'n' column
+    n_min = results['n'].min()
+    print("n_min:", n_min)
+
+
+    # # --- Export the results to a CSV file ---
+
+    # Save the Pandas dataframe to a CSV file in the current working directory.
+    file_path = os.path.abspath('./results.csv')
+    results.to_csv(path_or_buf=file_path)
+    print(f"\nResults Exported:\n{file_path}")
+

examples/rfem/results_in_location.py

@@ -0,0 +1,39 @@
+
+from dlubal.api import rfem
+import numpy
+
+def get_member_internal_force(member_no: int, loading: str = 'LC1', force: str = 'm_y', location: float = 0) -> float:
+    df_results = rfem_app.get_results(
+        results_type=rfem.results.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        filters=[
+            rfem.results.ResultsFilter(
+                column_id="member_no",
+                filter_expression=str(member_no)
+            ),
+            rfem.results.ResultsFilter(
+                column_id="loading",
+                filter_expression=str(loading)
+            ),
+        ]
+    ).data
+
+    # Get locations and forces as arrays
+    locations = df_results['location_x'].to_numpy(dtype=float)
+    forces = df_results[force].to_numpy(dtype=float)
+
+    # Check range
+    if not (locations[0] <= location <= locations[-1]):
+        print('Location is out of range')
+        return 0
+
+    # Linear interpolation
+    return float(numpy.interp(location, locations, forces))
+
+
+
+with rfem.Application() as rfem_app:
+
+    # --- Retriev results from the active model (already calculated) ---
+
+    v_z = get_member_internal_force(member_no=46, loading = 'CO2', force = 'v_z', location = 0.4)
+    print(v_z)

examples/rfem/results_multiple_models.py

@@ -0,0 +1,45 @@
+from dlubal.api import rfem, common
+
+with rfem.Application() as rfem_app:
+
+
+    model_list = rfem_app.get_model_list()
+    print(f"\nModel List:\n{model_list}")
+
+    for model_id in model_list.model_info:
+
+        if rfem_app.has_results(
+            model_id=common.ModelId(
+                guid=model_id.guid
+            )).value :
+
+            # --- Retriev results from the specified model (already calculated) ---
+
+            # 1. get_results: Returns all results of the specified type from the specified model's database.
+            #    This retrieves the complete result dataset, including all possible columns. It is suitable for
+            #    detailed analytics, filtering, or accessing values not shown in the RFEM GUI.
+            #    The `model_id` parameter ensures results are pulled from the correct model context.
+
+            df_internal_forces = rfem_app.get_results(
+                results_type=rfem.results.ResultsType.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+                model_id=common.ModelId(guid=model_id.guid)
+            ).data
+            print(f"\nInternal Forces | All | {model_id.name}:")
+            print(df_internal_forces)
+
+
+
+            # 2. get_result_table: Returns a simplified result table as shown in the RFEM GUI by default.
+            #    This includes only the key summary values, providing a quick overview for end users or exports.
+            #    The `model_id` parameter ensures the table is retrieved for the correct model instance.
+
+            df_internal_forces_table = rfem_app.get_result_table(
+                table = rfem.results.ResultTable.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+                loading= rfem.ObjectId(
+                    no=1,
+                    object_type=rfem.OBJECT_TYPE_LOAD_CASE,
+                ),
+                model_id = common.ModelId(guid=model_id.guid)
+            ).data
+            print(f"\nInternal Forces | Table | {model_id.name}:")
+            print(df_internal_forces_table)