Cantilever

In this example we will demonstrate: Connecting to RFEM and creating new model Basic modeling Calculation Read the comments for detailed instructions.

from math import inf
from dlubal.api import rfem
import os

def define_structure() -> list:
    """Define and return a list of structural objects."""

    return [
        # Define material
        rfem.structure_core.Material(
            no=1,
            name='S235'
        ),

        # Define section
        rfem.structure_core.Section(
            no=1,
            name='HE 300 A',
            material=1
        ),

        # Define nodes
        rfem.structure_core.Node(
            no=1
        ),
        rfem.structure_core.Node(
            no=2,
            coordinate_1=6.0
        ),

        # Define line
        rfem.structure_core.Line(
            no=1,
            definition_nodes=[1, 2]
        ),

        # Define member
        rfem.structure_core.Member(
            no=1,
            line=1,
            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
        ),
    ]

def define_loading() -> list:
    """Define and return a list of loading objects."""

    return [
        # Static analysis settings
        rfem.loading.StaticAnalysisSettings(
            no=1,
            analysis_type=rfem.loading.StaticAnalysisSettingsAnalysisType.
            STATIC_ANALYSIS_SETTINGS_ANALYSIS_TYPE_GEOMETRICALLY_LINEAR
        ),

        # Define load cases
        rfem.loading.LoadCase(
            no=1,
            static_analysis_settings=1
        ),
        rfem.loading.LoadCase(
            no=2,
            static_analysis_settings=1
        ),

        # Define nodal loads
        rfem.loads.NodalLoad(
            no=1,
            load_case=1,
            nodes=[2],
            load_type=rfem.loads.NodalLoadLoadType.
            NODAL_LOAD_LOAD_TYPE_COMPONENTS,
            components_force_y=5000,  # Force in Y direction (N)
            components_force_z=100000  # Force in Z direction (N)
        ),
        rfem.loads.NodalLoad(
            no=2,
            load_case=2,
            nodes=[2],
            load_type=rfem.loads.NodalLoadLoadType.
            NODAL_LOAD_LOAD_TYPE_COMPONENTS,
            components_force_y=20000,
            components_force_z=5000
        ),

        # Define design situation
        rfem.loading.DesignSituation(
            no=1,
            design_situation_type="DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10"
        ),

        # Define load combination
        rfem.loading.LoadCombination(
            no=1,
            items =  rfem.loading.LoadCombinationItemsTable(
                    rows=[
                        rfem.loading.LoadCombinationItemsRow(
                            load_case=1,
                            factor=1.35
                        ),
                        rfem.loading.LoadCombinationItemsRow(
                            load_case=2,
                            factor=1.5
                        )
                    ]
            ),
            design_situation=1
        )
    ]

def main() -> None:
    """Runs the structural analysis example."""

    with rfem.Application() as rfem_app:

        # Step 1: Create a new model
        rfem_app.create_model(name='cantilever')

        # Step 2: Clear existing objects
        rfem_app.delete_all_objects()

        # Step 3: Define and create all objects
        objects = define_structure() + define_loading()
        rfem_app.create_object_list(objects)

        # Step 4: Retrieve and display information about a specific member
        member = rfem_app.get_object(rfem.structure_core.Member(no=1))
        print(f"Member Details:\n{member}")

        # Step 5: Run Plausibility check
        plausibility_check = rfem_app.plausibility_check(
            type=rfem.PLAUSIBILITY_CHECK_CALCULATION,
            skip_warnings=True
        )
        print(f"Plausibility Check:\n{plausibility_check}")

        if plausibility_check.succeeded:
            # Step 6: Perform calculation
            calculation = rfem_app.calculate_all(skip_warnings=True)
            print(f"Calculation Info:\n{calculation}")

            # Step 7: Save model with results
            model_path = os.path.abspath('./cantilever.rf6')
            rfem_app.save_model(path=model_path)
            print(f"Model File Path:\n{rfem_app.get_model_main_parameters().model_path}")

if __name__ == "__main__":
    main()