dlubal.api 2.12.11__py3-none-any.whl

examples/rfem/material_user_defined.py

@@ -0,0 +1,64 @@
+from dlubal.api import rfem
+from dlubal.api import common
+
+# Connect to the RFEM application
+with rfem.Application() as rfem_app:
+
+    # --- Create a new material ---
+
+    rfem_app.create_model(name='user_defined_material')
+
+    base_data = rfem_app.get_base_data()
+    base_data.addons.concrete_design_active = True
+    rfem_app.set_base_data(base_data=base_data)
+
+    rfem_app.create_object(
+        rfem.structure_core.Material(no=1, name='C30/37')
+    )
+
+    # Retrieve a specific material (ID = 1) from the active model
+    material:rfem.structure_core.Material = rfem_app.get_object(
+        rfem.structure_core.Material(no=1)
+    )
+
+    # --- Update material properties ---
+
+    # Print material values for all temperatures (=rows)
+    for material_values in material.material_values.rows:
+        print(material_values)
+
+    # Define paths for material properties to be updated
+    fck_path = ['strengths', 'f_ck']
+    ecm_path = ['moduli', 'e_cm']
+
+    # Create an empty MaterialValuesTreeTable and set the desired material property values
+    material_values_tree = rfem.structure_core.Material.MaterialValuesRow.MaterialValuesTreeTable()
+    common.set_tree_value(material_values_tree, fck_path, 28000000.0)
+    common.set_tree_value(material_values_tree, ecm_path, 25000000000.0)
+
+   # Copy the updated material values to the first temperature row of the material's values table.
+    material.material_values.rows[0].material_values_tree.CopyFrom(material_values_tree)
+
+    # --- Update standard parameters ---
+
+    # Print material values for all temperature rows
+    standard_params = material.standard_parameters
+    print(standard_params)
+
+    # Define paths for material properties to be updated
+    gamma_c_path = ['2_basis_of_design', '2_4_2_4_partial_factors_for_materials', 'gamma_c']
+
+    # Create an empty MaterialValuesTreeTable and set the desired material property values
+    standard_params_tree = rfem.structure_core.Material.StandardParametersTreeTable()
+    common.set_tree_value(standard_params_tree, gamma_c_path, 1.35)
+
+
+    # --- Apply modified Material back to the model ---
+    rfem_app.update_object(
+        obj=rfem.structure_core.Material(
+            no=1,
+            user_defined=True,
+            material_values=material.material_values, # material values
+            standard_parameters=standard_params_tree  # standard parameters
+        )
+    )

examples/rfem/mesh_settings.py

@@ -0,0 +1,25 @@
+from dlubal.api import rfem
+
+with rfem.Application() as rfem_app:
+
+    mesh_settings: rfem.mesh.MeshSettings = rfem_app.get_mesh_settings()
+    print(mesh_settings)
+
+
+    mesh_stats_current = rfem_app.get_mesh_statistics()
+    print(mesh_stats_current)
+
+
+    mesh_settings.general_target_length_of_fe = 0.005
+    rfem_app.set_mesh_settings(
+        mesh_settings=mesh_settings
+    )
+
+    rfem_app.delete_mesh()
+
+    rfem_app.generate_mesh(
+        skip_warnings=True
+    )
+
+    mesh_stats_new = rfem_app.get_mesh_statistics()
+    print(mesh_stats_new)

examples/rfem/modal_analysis.py

@@ -0,0 +1,243 @@
+from dlubal.api import rfem, common
+from math import inf
+
+
+def initialize_model():
+
+    # Create new empty model
+    rfem_app.close_all_models(save_changes=False)
+    rfem_app.create_model(name="Modal Analysis")
+
+    # Set global model settings:
+    base_data: rfem.BaseData = rfem_app.get_base_data()
+
+    # Activate add-ons
+    base_data.addons.modal_analysis_active = True
+    # Set standard
+    base_data.standards.dynamic_analysis_standard = rfem.BaseData.Standards.DYNAMIC_ANALYSIS_NATIONAL_ANNEX_AND_EDITION_EN_1998_1_DIN_2023_11_STANDARD
+    # Adjust general settings
+    base_data.general_settings.gravitational_acceleration = 9.81
+
+    # Activate combination wizard
+    base_data.combinations_settings.combination_wizard_active = True
+
+    rfem_app.set_base_data(base_data=base_data)
+    rfem_app.delete_all_objects()
+
+
+def create_structure():
+
+    structure = [
+
+            # Material
+            rfem.structure_core.Material(
+                no=1,
+                name="S235 | EN 1993-1-1:2005-05",
+            ),
+
+            # CrossSection
+            rfem.structure_core.CrossSection(
+                no=1,
+                name="IPE 550 | DIN 1025-5:1994-03 | Ferona",
+                material=1,
+            ),
+
+            # Nodes
+            rfem.structure_core.Node(
+                no=1,
+                coordinate_2=-2,
+            ),
+            rfem.structure_core.Node(
+                no=2,
+                coordinate_2=-2,
+                coordinate_3=-4,
+            ),
+
+            # Line
+            rfem.structure_core.Line(
+                no=1,
+                definition_nodes=[1, 2],
+            ),
+
+            # Member
+            rfem.structure_core.Member(
+                no=1,
+                line=1,
+                cross_section_start=1,
+            ),
+
+            # Support
+            rfem.types_for_nodes.NodalSupport(
+                no=1,
+                user_defined_name_enabled=True,
+                name="Fixed",
+                nodes=[1],
+                spring=common.Vector3d(x=inf, y=inf, z=inf),
+                rotational_restraint=common.Vector3d(x=inf, y=inf, z=inf),
+            )
+    ]
+
+    rfem_app.create_object_list(structure)
+
+
+def create_loading():
+
+    loading = [
+        # Load Case | LC1
+        rfem.loading.LoadCase(
+            no=1,
+            name="Static | Self-weight",
+            static_analysis_settings=1,
+        ),
+        # Nodal Loads | LC1
+        rfem.loads.NodalLoad(   # Force
+            no=1,
+            nodes=[2],
+            force_magnitude=1000,
+            load_direction=rfem.loads.NodalLoad.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE_LENGTH,
+            load_case=1,
+        ),
+        rfem.loads.NodalLoad(   # Mass
+            no=2,
+            load_type=rfem.loads.NodalLoad.LOAD_TYPE_MASS,
+            nodes=[2],
+            individual_mass_components=True,
+            mass=common.Vector3d(x=100, y=100, z=100),
+            mass_moment_of_inertia=common.Vector3d(x=100, y=100, z=100),
+            load_case=1,
+        ),
+
+        # Static Analysis Settings
+        rfem.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rfem.loading.StaticAnalysisSettings.ANALYSIS_TYPE_SECOND_ORDER_P_DELTA,
+            mass_conversion_enabled=True,
+        ),
+
+        # --- Combinatoric for Seismic Mass ---
+
+        # Combination Wizard
+        rfem.loading.CombinationWizard(
+            no=1,
+            static_analysis_settings=1,
+            consider_imperfection_case=True,
+        ),
+
+        # Design Situations
+        rfem.loading.DesignSituation(
+            no=1,
+            name="Seismic/Mass Combination - psi-E,i",
+            design_situation_type=rfem.loading.DesignSituation.DESIGN_SITUATION_TYPE_SEISMIC_MASS,
+            combination_wizard=1,
+        ),
+    ]
+
+    rfem_app.create_object_list(loading)
+
+
+def define_modal_analysis_cases():
+
+    modal_analysis = [
+
+        # Modal Analysis Settings
+        rfem.loading.ModalAnalysisSettings(
+            no=1,
+            name='User-defined | Mode=2',
+            user_defined_name_enabled=True,
+            acting_masses_about_axis_x_enabled=False,
+            acting_masses_about_axis_y_enabled=False,
+            acting_masses_about_axis_z_enabled=False,
+            acting_masses_in_direction_z_enabled=False,
+            activate_minimum_initial_prestress=True,
+            solution_method=rfem.loading.ModalAnalysisSettings.SOLUTION_METHOD_ROOT_OF_CHARACTERISTIC_POLYNOMIAL,
+            number_of_modes=2,
+        ),
+        rfem.loading.ModalAnalysisSettings(
+            no=2,
+            name='Automated | Mass=95%',
+            user_defined_name_enabled=True,
+            acting_masses_about_axis_x_enabled=False,
+            acting_masses_about_axis_y_enabled=False,
+            acting_masses_about_axis_z_enabled=False,
+            acting_masses_in_direction_z_enabled=False,
+            activate_minimum_initial_prestress=True,
+            solution_method=rfem.loading.ModalAnalysisSettings.SOLUTION_METHOD_ROOT_OF_CHARACTERISTIC_POLYNOMIAL,
+            number_of_modes_method=rfem.loading.ModalAnalysisSettings.NUMBER_OF_MODES_METHOD_EFFECTIVE_MASS_FACTORS,
+            effective_modal_mass_factor=0.95
+        ),
+
+        # Modal Load Cases
+        rfem.loading.LoadCase(
+            no=2,
+            analysis_type=rfem.loading.LoadCase.ANALYSIS_TYPE_MODAL_ANALYSIS,
+            name="Modal | Self-mass",
+            modal_analysis_settings=1,
+        ),
+        rfem.loading.LoadCase(
+            no=3,
+            analysis_type=rfem.loading.LoadCase.ANALYSIS_TYPE_MODAL_ANALYSIS,
+            name="Modal | Mass=95%",
+            modal_analysis_settings=2,
+        ),
+    ]
+
+    rfem_app.create_object_list(modal_analysis)
+
+
+def import_masses_to_cases():
+
+    rfem_app.generate_combinations()
+
+    object_list = rfem_app.get_object_list(
+        objs=[
+            rfem.loading.LoadCase()
+        ]
+    )
+
+    for obj in object_list:
+
+        lc: rfem.loading.LoadCase = obj
+
+        if lc.analysis_type is rfem.loading.LoadCase.ANALYSIS_TYPE_MODAL_ANALYSIS:
+
+            lc.import_masses_from.no = 1
+            lc.import_masses_from.object_type = rfem.ObjectType.OBJECT_TYPE_LOAD_COMBINATION
+
+    rfem_app.update_object_list(object_list)
+
+
+def get_effective_modal_masses():
+
+    rfem_app.calculate_all(skip_warnings=True)
+
+    results = rfem_app.get_results(
+        results_type=rfem.results.ResultsType.MODAL_ANALYSIS_EFFECTIVE_MODAL_MASSES
+    )
+    print(f"\nEffective Modal Masses:\n{results.data}")
+
+
+
+
+
+with rfem.Application() as rfem_app:
+
+    # Modal Analysis Procedure
+
+    initialize_model()              # Activate add-on, ...
+
+    create_structure()              # Column IPE 550 (fixed)
+    create_loading()                # Force + Mass
+
+    define_modal_analysis_cases()   # Self-mass (Mode=2) | Mass=95% (Mode=auto)
+    import_masses_to_cases()        # Import masses from generated combination
+
+    get_effective_modal_masses()    # Calculation + reading results
+
+
+
+
+
+
+
+
+

examples/rfem/multiple_models.py

@@ -0,0 +1,93 @@
+from dlubal.api import rfem, common
+
+# -------------------------------------------------------
+# This example demonstrates how to interact with multiple RFEM models
+# using the RFEM API. The script includes creating, updating,
+# and querying model object/s in two separate models in one script.
+# -------------------------------------------------------
+
+# Function to create, update, and query model object/s
+def create_update_and_query_objects(rfem_app, model_id=None):
+
+    # Create a list of objects
+    rfem_app.create_object_list(
+        objs=[
+            rfem.structure_core.Node(no=1, coordinate_1=0.0),
+            rfem.structure_core.Node(no=2, coordinate_1=2.0),
+            rfem.structure_core.Node(no=3, coordinate_1=3.0),
+            rfem.structure_core.Line(no=1, definition_nodes=[1, 2, 3]),
+            rfem.structure_core.Material(no=1, name='S235'),
+            rfem.structure_core.CrossSection(no=1, name='IPE 200', material=1)
+        ],
+        model_id=model_id
+    )
+
+    # Create a single object
+    rfem_app.create_object(
+        obj=rfem.structure_core.Member(no=1, line=1, cross_section_start=1),
+        model_id=model_id
+    )
+
+    # Update a list of objects
+    rfem_app.update_object_list(
+        objs=[
+            rfem.structure_core.Node(no=1, coordinate_2=1.0),
+            rfem.structure_core.Node(no=2, coordinate_2=1.0),
+            rfem.structure_core.Node(no=3, coordinate_2=1.0),
+            rfem.structure_core.Line(no=1, definition_nodes=[1, 3]),
+        ],
+        model_id=model_id
+    )
+
+    # Update a single object
+    rfem_app.update_object(
+        obj=rfem.structure_core.Node(
+            no=2,
+            type=rfem.structure_core.Node.TYPE_ON_MEMBER,
+            on_member_reference_member=1,
+            distance_from_start_absolute=2.0
+        ),
+        model_id=model_id
+    )
+
+    # Retrieve a list of objects
+    node_list = rfem_app.get_object_list(
+        objs=[rfem.structure_core.Node()],
+        model_id=model_id
+    )
+    for node in node_list:
+        print(f"{node.DESCRIPTOR.name}: {node.no} [X={node.coordinate_1}, Y={node.coordinate_2}] | Type: {node.type}")
+
+    # Retrieve a single objects
+    member = rfem_app.get_object(
+        obj=rfem.structure_core.Member(no=1)
+    )
+    print(f"{member.DESCRIPTOR.name}: {member.no},  Length: {member.length} [m]")
+
+
+# --- MAIN SCRIPT ---
+
+# Connect to the RFEM application
+with rfem.Application() as rfem_app:
+
+    rfem_app.close_all_models(save_changes=False)
+
+    # Create two separate models and store their model IDs
+    model_1: common.ModelId = rfem_app.create_model(name="model_1")
+    model_2: common.ModelId = rfem_app.create_model(name="model_2")
+    model_list = rfem_app.get_model_list()
+    print(f"\nModel list:\n {model_list}")
+
+    # Make operations on currently active model (default is model_2)
+    active_model = rfem_app.get_active_model()
+    print(f"\nCurrently active model_2:\n {active_model}")
+    create_update_and_query_objects(rfem_app)  # Use default active model
+
+    # Perform operations on model_1 by passing its model ID
+    print(f"\nSwitching to model_1 (by ID):\n {model_1}")
+    create_update_and_query_objects(rfem_app, model_id=model_1)
+
+    # Set model_1 as the active model
+    rfem_app.set_active_model(model_id=model_1)
+    active_model = rfem_app.get_active_model()
+    print(f"\nSetting model_1 as active:\n {active_model}")

examples/rfem/nurbs_topology.py

@@ -0,0 +1,54 @@
+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="nurbs_topology")
+    client.delete_all_objects()
+
+    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)
+

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_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)