dlubal.api 2.12.11__py3-none-any.whl

examples/rfem/stress_strain_analysis.py

@@ -0,0 +1,95 @@
+from dlubal.api import rfem
+
+with rfem.Application() as rfem_app:
+
+    # Activate stress-strain analysis add-on
+    base_data_update = rfem_app.get_base_data()
+    base_data_update.addons.stress_strain_analysis_active = True
+    rfem_app.set_base_data(base_data=base_data_update)
+
+    # Create line welded joint
+    rfem_app.create_object(
+        rfem.types_for_lines.LineWeldedJoint(
+            no=1,
+            weld_type=rfem.types_for_lines.LineWeldedJoint.WeldType.WELD_TYPE_SINGLE_FILLET,
+            joint_type=rfem.types_for_lines.LineWeldedJoint.JointType.JOINT_TYPE_TEE_JOINT,
+            longitudinal_arrangement=rfem.types_for_lines.LineWeldedJoint.LONGITUDINAL_ARRANGEMENT_CONTINUOUS,
+            weld_size_a1=0.004, #[m],
+        )
+    )
+
+    # Assign line welded joint to line and surfaces
+    rfem_app.update_object_list(
+        objs = [
+            rfem.structure_core.Line(
+                no=89,
+                line_weld_assignment=rfem.structure_core.Line.LineWeldAssignmentTable(
+                    rows=[
+                        rfem.structure_core.Line.LineWeldAssignmentRow(
+                            no=1,
+                            weld=1,
+                            surface1=16,
+                            surface2=1,
+                            surface3=2
+                        )
+                    ]
+                )
+            ),
+        ]
+    )
+
+    # Assign objects to stress-strain analysis
+    rfem_app.update_object_list(
+        objs = [
+            rfem.stress_analysis_objects.LineWeldedJointConfiguration(
+                no=1,
+                assigned_to_line_welded_joints=[1],
+            ),
+            rfem.stress_analysis_objects.SurfaceConfiguration(
+                no=1,
+                assigned_to_surfaces=[1,2,16],
+            ),
+        ]
+    )
+
+    # Calculate the analysis
+    rfem_app.calculate_all(skip_warnings=True)
+
+
+    # Retrieves results of line weld stresses
+    line_weld_stresses = rfem_app.get_results(
+        results_type=rfem.results.STRESS_STRAIN_ANALYSIS_LINE_WELDS_STRESSES
+    ).data
+    print(f"\nLine Weld Stresses:\n{line_weld_stresses}")
+    line_weld_stresses.to_csv('line_weld_stresses.csv', index=False)
+
+    # Retrieves results of surface stresses
+    surface_stresses = rfem_app.get_results(
+        results_type=rfem.results.STRESS_STRAIN_ANALYSIS_SURFACES_STRESSES
+    ).data
+    print(f"\nSurface Stresses:\n{surface_stresses}")
+    surface_stresses.to_csv('surface_stresses.csv', index=False)
+
+
+    # Get maximum design ratio of surface stresses
+    surface_stresses_max = surface_stresses.loc[surface_stresses['design_ratio'].idxmax()]
+    print(f"\nSurface Stresses | Maximum:\n{surface_stresses_max}")
+
+
+    # Get details for maximum design ratio of surface stresses
+    surface_stresses_details_id = surface_stresses_max['design_check_details_id']
+    surface_stresses_max_details = rfem_app.get_results(
+        results_type=rfem.results.STRESS_STRAIN_ANALYSIS_DESIGN_CHECK_DETAILS,
+        filters=[rfem.results.ResultsFilter(
+            column_id="design_check_details_id",
+            filter_expression=str(surface_stresses_details_id))],
+    ).data
+    print(f"\nSurface Stresses | Maximum - Details:\n{surface_stresses_max_details}")
+    # surface_stresses_max_details.to_csv('surface_stresses_max_details.csv', index=False)
+    surface_stresses_max_details.to_excel('surface_stresses_max_details.xlsx', index=False, engine='openpyxl')
+
+
+
+
+
+

examples/rfem/tank_wind_load.py

@@ -0,0 +1,180 @@
+import dlubal.api.rfem as rfem
+import math
+
+with rfem.Application() as rfem_app:
+
+    rfem_app.close_all_models(save_changes=False)
+    rfem_app.create_model(name='tank_wind_load')
+
+    rfem_app.delete_all_objects()
+
+    inf=float("inf")
+    structure=[
+        rfem.structure_core.Material(no=1, name="S355"),
+
+        rfem.structure_core.CrossSection(no=1, material=1, name="HE 320 A"),
+        rfem.structure_core.CrossSection(no=2, material=1, name="IPE 450"),
+
+        rfem.structure_core.Thickness(no=1, uniform_thickness=0.01, material=1),
+
+        rfem.structure_core.Node(no=2, coordinate_1=-4, coordinate_2=0, coordinate_3=0),
+        rfem.structure_core.Node(no=3, coordinate_1=-4, coordinate_2=0, coordinate_3=-3),
+        rfem.structure_core.Node(no=10, coordinate_1=0, coordinate_2=0, coordinate_3=-3.6),
+
+        rfem.structure_core.Line(no=2, definition_nodes=[2,3]),
+        rfem.structure_core.Line(no=3, type=rfem.structure_core.Line.TYPE_ARC,
+                                 arc_first_node=3, arc_second_node=10,
+                                 arc_control_point_x=-2.022, arc_control_point_y=0, arc_control_point_z=-3.449,
+                                 arc_center_x=0, arc_center_y=0, arc_center_z=10.033,
+                                 arc_height=0.151, arc_radius=13.633, arc_alpha=0.2977533),
+        rfem.structure_core.Line(no=4, type=rfem.structure_core.Line.TYPE_CIRCLE,
+                                 circle_center_coordinate_1=0, circle_center_coordinate_2=0, circle_center_coordinate_3=-3,
+                                 circle_radius=4,
+                                 circle_rotation=3.141594,
+                                 circle_normal_coordinate_1=0, circle_normal_coordinate_2=0, circle_normal_coordinate_3=1),
+        rfem.structure_core.Line(no=5, type=rfem.structure_core.Line.TYPE_CIRCLE,
+                                 circle_center_coordinate_1=0, circle_center_coordinate_2=0, circle_center_coordinate_3=0,
+                                 circle_radius=4,
+                                 circle_rotation=3.141594,
+                                 circle_normal_coordinate_1=0, circle_normal_coordinate_2=0, circle_normal_coordinate_3=1),
+
+        rfem.structure_core.Surface(no=1, geometry=rfem.structure_core.Surface.GEOMETRY_ROTATED,
+                                    rotated_boundary_line=3,
+                                    rotated_angle_of_rotation=6.283188,
+                                    thickness=1, material=1),
+        rfem.structure_core.Surface(no=2, geometry=rfem.structure_core.Surface.GEOMETRY_ROTATED,
+                                    rotated_boundary_line=2,
+                                    rotated_angle_of_rotation=6.283188,
+                                    thickness=1, material=1),
+
+        rfem.types_for_lines.LineSupport(no=1, lines=[5], spring_x=inf, spring_y=inf, spring_z=inf)
+    ]
+
+    rfem_app.create_object_list(structure)
+    print("Structure created")
+
+    loading = [
+        rfem.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rfem.loading.StaticAnalysisSettings.ANALYSIS_TYPE_GEOMETRICALLY_LINEAR,
+        ),
+        rfem.loading.LoadCase(
+            no=1,
+            name="wind-load",
+            analysis_type=rfem.loading.LoadCase.ANALYSIS_TYPE_STATIC_ANALYSIS,
+            action_category=rfem.loading.LoadCase.ACTION_CATEGORY_PERMANENT_G,
+            static_analysis_settings=1,
+            self_weight_active=True,
+            self_weight_factor_z=1,
+        ),
+    ]
+    rfem_app.create_object_list(loading)
+    print("Loading created")
+
+    #calculating inputs for free rectangular load
+    circle_radius = 4
+    calculation_height = 3.6
+    v_ref = 20
+    z_0 = 0.2
+    angles = [0, 15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285, 300, 315, 330, 345, 360]
+    cp0 = [[1.0, 0.7, 0.1, -0.65, -1.45, -1.97, -2.15, -1.95, -1.25, -0.40, -0.40, -0.40, -0.40, -0.40, -0.40, -0.40, -1.25, -1.95, -2.15, -1.97, -1.45, -0.65, 0.1, 0.7, 1.0],
+           [1.0, 0.7, 0.1, -0.60, -1.35, -1.76, -1.73, -1.40, -0.70, -0.70, -0.70, -0.70, -0.70, -0.70, -0.70, -0.70, -0.70, -1.40, -1.73, -1.76, -1.35, -0.60, 0.1, 0.7, 1.0],
+           [1.0, 0.7, 0.1, -0.55, -1.20, -1.50, -1.30, -0.80, -0.80, -0.80, -0.80, -0.80, -0.80, -0.80, -0.80, -0.80, -0.80, -0.80, -1.30, -1.50, -1.20, -0.55, 0.1, 0.7, 1.0]]
+    Re_vals = [5e5, 2e6, 1e7]
+    alpha_min = [85, 80, 75]
+    alpha_a = [135, 120, 105]
+
+    l = calculation_height / (circle_radius * 2)
+    psi_lambda = 1 / (1 + l**2)
+
+    v_ze = v_ref * math.log(calculation_height / z_0)
+
+    # Reynolds_number
+    Re = (circle_radius * v_ze) / 15e-6
+
+    #End_effect_factor_Psi_lambda_a
+    def End_effect_factor_psi_lambda_a(angles, alpha_min, alpha_a, psi_lambda):
+        psi_lambda_a = []
+        for alpha in angles:
+            if (0 < alpha < alpha_min):
+                psi_lambda_a.append(1),
+            elif (alpha < alpha_a):
+                psi_lambda_a.append(psi_lambda + (1 - psi_lambda) * math.cos(math.pi / 2 * (alpha - alpha_min) / (alpha_a - alpha_min))),
+            else:
+                psi_lambda_a.append(psi_lambda)
+        return psi_lambda_a
+
+    q_p = 0.613 * v_ref**2
+    # External_pressure_coefficient_cpe:
+    lvps = [None] * (len(angles))
+
+    for i, alpha in enumerate(angles):
+        factor = 1
+        alpha_min_int = 0
+        alpha_A_int = 0
+        psi_lambda_a = End_effect_factor_psi_lambda_a(angles, alpha_min_int, alpha_A_int, psi_lambda)
+
+        # Calculate cpe
+        if Re < Re_vals[0]:
+            alpha_min_int = alpha_min[0]
+            alpha_A_int = alpha_a[0]
+            cpe = cp0[0][i] * psi_lambda_a[i]
+        elif Re <= Re_vals[1]:
+            factor = (Re - Re_vals[0]) / (Re_vals[1] - Re_vals[0])
+            alpha_min_int = alpha_min[0] + (alpha_min[1] - alpha_min[0]) * factor
+            alpha_A_int = alpha_a[0] + (alpha_a[1] - alpha_a[0]) * factor
+            cpe = (cp0[0][i] + (cp0[1][i] - cp0[0][i]) * factor) * psi_lambda_a[i]
+        elif Re <= Re_vals[2]:
+            factor = (Re - Re_vals[1]) / (Re_vals[2] - Re_vals[1])
+            alpha_min_int = alpha_min[1] + (alpha_min[2] - alpha_min[1]) * factor
+            alpha_A_int = alpha_a[1] + (alpha_a[2] - alpha_a[1]) * factor
+            cpe = (cp0[1][i] + (cp0[2][i] - cp0[1][i]) * factor) * psi_lambda_a[i]
+        else:
+            alpha_min_int = alpha_min[2]
+            alpha_A_int = alpha_a[2]
+            cpe = cp0[2][i] * psi_lambda_a[i]
+
+        # Assign values to lvps
+        lvps[i] = {
+            'no': i + 1,
+            'row': {
+                'factor': cpe,
+                'alpha': alpha / 180.0 * math.pi
+            }
+        }
+
+    #Create the table with rows
+    rows = []
+    for i, data in enumerate(lvps):
+        row = rfem.loads.FreeRectangularLoad.LoadVaryingAlongPerimeterParametersRow(
+            no=data['no'],
+            description="",
+            alpha=data['row']['alpha'],
+            recalculated_magnitude=q_p * 1000,
+            factor=data['row']['factor'],
+            note=""
+        )
+        rows.append(row)
+
+    # Create the table and assign rows
+    load_varying_table = rfem.loads.FreeRectangularLoad.LoadVaryingAlongPerimeterParametersTable(rows=rows)
+
+    rfem_app.create_object(
+        rfem.loads.FreeRectangularLoad(
+            no=1, surfaces=[2], load_case=1,
+            load_distribution=rfem.loads.FreeRectangularLoad.LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER,
+            load_direction=rfem.loads.FreeRectangularLoad.LOAD_DIRECTION_LOCAL_Z,
+            load_projection=rfem.loads.FreeRectangularLoad.LOAD_PROJECTION_XY_OR_UV,
+            load_location_rectangle=rfem.loads.FreeRectangularLoad.LOAD_LOCATION_RECTANGLE_CENTER_AND_SIDES,
+            load_location_center_x=0,
+            load_location_center_y=0,
+            load_location_center_side_a=9,
+            load_location_center_side_b=9,
+            axis_start_angle=math.pi,
+            magnitude_uniform=q_p * 1000,
+            axis_definition_p1={'x': 0, 'y': 0, 'z': 0},
+            axis_definition_p2={'x': 0, 'y': 0, 'z': -1},
+            load_varying_along_perimeter_parameters=load_varying_table
+        )
+    )
+    print("Loads created")

examples/rsection/base_data.py

@@ -0,0 +1,20 @@
+from dlubal.api import rsection
+
+with rsection.Application() as rsection_app:
+
+    # Step 1: Retrieve the Base data (active model)
+    base_data: rsection.BaseData  = rsection_app.get_base_data()
+    print(f"BASE DATA:\n{base_data}")
+
+    # Step 2: Modify the values in Base data object
+    # Main model data
+    base_data.main.model_description = "cold_formed"
+    base_data.main.comment = "thin_walled"
+    base_data.main.analysis_method = rsection.BaseData.Main.ANALYSIS_METHOD_THIN_WALLED
+    # Add-ons activation
+    base_data.addons.has_effective_section_properties_active = True
+    # Standards assignment
+    base_data.standards.effective_section_standard = rsection.BaseData.Standards.EFFECTIVE_SECTION_STANDARD_EN_1993_1_3_COLD_FORMED
+
+    # Step 3: Apply the updated Base data to the model
+    rsection_app.set_base_data(base_data=base_data)

examples/rsection/steel_section.py

@@ -0,0 +1,114 @@
+from dlubal.api import rsection
+import os
+
+def define_structure() -> 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
+
+with rsection.Application() as rsection_app:
+
+    # Step 1: Create a new model
+    rsection_app.create_model(name='steel_cross_section')
+
+    # Step 2: Clear existing objects
+    rsection_app.delete_all_objects()
+
+    # Step 3: Define and create all objects
+    objects = define_structure()
+    rsection_app.create_object_list(objects)
+
+    # Step 4: Fetch the list of specific object type = StressPoint
+    stress_point_list = rsection_app.get_object_list(
+        objs=[rsection.structure_core.StressPoint()]
+    )
+    # Iterate over each item in the list
+    for stress_point in stress_point_list:
+        print(f"{stress_point.DESCRIPTOR.name} No: {stress_point.no}")
+
+    # Step 5: Calculate cross-section
+    rsection_app.calculate_all(
+        skip_warnings=True
+    )
+
+    # Step 6: Save model with results
+    model_path = os.path.abspath('./steel_cross_section')
+    rsection_app.save_model(path=model_path)
+    print(f"\nModel File Path:\n{rsection_app.get_model_main_parameters().model_path}")
+

examples/rstab/base_data.py

@@ -0,0 +1,27 @@
+from dlubal.api import rstab
+
+with rstab.Application() as rstab_app:
+
+    rstab_app.create_model(name="base_data")
+
+    # Retrieve the Base data (active model)
+    base_data: rstab.BaseData  = rstab_app.get_base_data()
+    print(f"BASE DATA:\n{base_data}")
+
+    # Modify the values in Base data object
+    # Main model data
+    base_data.main.model_description = "model_type_2D"
+    base_data.main.comment = "test version"
+    base_data.main.model_type = rstab.BaseData.Main.MODEL_TYPE_2D_XZ
+    # Add-ons activation
+    base_data.addons.steel_design_active = True
+    base_data.addons.load_wizards_active = True
+    base_data.addons.combination_wizard_and_classification_active = True
+    # Standards assignment
+    base_data.standards.load_wizard_standard_group = rstab.BaseData.Standards.LOAD_WIZARD_STANDARD_GROUP_EN_1991_STANDARD_GROUP
+    base_data.standards.load_wizard_standard = rstab.BaseData.Standards.LOAD_WIZARD_NATIONAL_ANNEX_AND_EDITION_EN_1991_DIN_2019_04_STANDARD
+    base_data.standards.combination_wizard_standard = rstab.BaseData.Standards.COMBINATION_WIZARD_NATIONAL_ANNEX_AND_EDITION_EN_1990_DIN_2012_08_STANDARD
+    base_data.standards.steel_design_standard = rstab.BaseData.Standards.STEEL_DESIGN_NATIONAL_ANNEX_AND_EDITION_EN_1993_DIN_2020_11_STANDARD
+
+    # Apply the updated Base data to the model
+    rstab_app.set_base_data(base_data=base_data)

examples/rstab/cantilever.py

@@ -0,0 +1,166 @@
+import os
+from math import inf
+from dlubal.api import rstab
+
+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,
+        ),
+    ]
+
+
+""" ----- Creat and calculate a Cantilever model in RSTAB ----- """
+
+with rstab.Application() as rstab_app:
+
+    # Step 1: Create a new RFEM model for the cantilever structure
+    rstab_app.create_model(name='cantilever')
+
+    # Step 2: Ensure the model is empty by removing all pre-existing objects
+    rstab_app.delete_all_objects()
+
+    # Step 3: Define and generate all structure and loading objects
+    objects = define_structure() + define_loading()
+    rstab_app.create_object_list(objects)
+
+    # Step 4: Retrieve and print information about load combinations in the model
+    print("\nLoad Combinations:")
+    object_list = rstab_app.get_object_list([rstab.loading.LoadCombination()])
+    for object in object_list:
+        print(f"{object.DESCRIPTOR.name} | {object.name} | {object.combination_rule_str}")
+
+    # Step 5: Calculate the model
+    calculation = rstab_app.calculate_all(skip_warnings=True)
+    print(f"\nCalculation Info:\n{calculation}")
+
+    # Step 6: Get results for nodal support forces (reactions) after calculation
+    supp_forces = rstab_app.get_results(
+        results_type=rstab.results.STATIC_ANALYSIS_NODES_SUPPORT_FORCES
+    ).data
+    print(f"\nResults | Nodes Support Forces:\n{supp_forces}")
+
+    # Step 7: Save the model with results to the specified path
+    model_path = os.path.abspath('./cantilever')
+    rstab_app.save_model(path=model_path)
+    print(f"\nModel File Path:\n{rstab_app.get_model_main_parameters().model_path}")