dlubal.api 2.12.11__py3-none-any.whl

examples/rstab/multiple_models.py

@@ -0,0 +1,91 @@
+from dlubal.api import rstab, common
+
+# -------------------------------------------------------
+# This example demonstrates how to interact with multiple RSTAB models
+# using the RSTAB 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(rstab_app, model_id=None):
+
+    # Create a list of objects
+    rstab_app.create_object_list(
+        objs=[
+            rstab.structure_core.Node(no=1, coordinate_1=0.0),
+            rstab.structure_core.Node(no=2, coordinate_1=2.0),
+            rstab.structure_core.Node(no=3, coordinate_1=3.0),
+            rstab.structure_core.Material(no=1, name='S235'),
+            rstab.structure_core.CrossSection(no=1, name='IPE 200', material=1)
+        ],
+        model_id=model_id
+    )
+
+    # Create a single object
+    rstab_app.create_object(
+        obj=rstab.structure_core.Member(no=1, cross_section_start=1, node_start=1, node_end=3),
+        model_id=model_id
+    )
+
+    # Update a list of objects
+    rstab_app.update_object_list(
+        objs=[
+            rstab.structure_core.Node(no=1, coordinate_2=1.0),
+            rstab.structure_core.Node(no=2, coordinate_2=1.0),
+            rstab.structure_core.Node(no=3, coordinate_2=1.0),
+        ],
+        model_id=model_id
+    )
+
+    # Update a single object
+    rstab_app.update_object(
+        obj=rstab.structure_core.Node(
+            no=2,
+            type=rstab.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 = rstab_app.get_object_list(
+        objs=[rstab.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 = rstab_app.get_object(
+        obj=rstab.structure_core.Member(no=1)
+    )
+    print(f"{member.DESCRIPTOR.name}: {member.no},  Length: {member.length} [m]")
+
+
+# --- MAIN SCRIPT ---
+
+# Connect to the RSTAB application
+with rstab.Application() as rstab_app:
+
+    rstab_app.close_all_models(save_changes=False)
+
+    # Create two separate models and store their model IDs
+    model_1: common.ModelId = rstab_app.create_model(name="model_1")
+    model_2: common.ModelId = rstab_app.create_model(name="model_2")
+    model_list = rstab_app.get_model_list()
+    print(f"\nModel list:\n {model_list}")
+
+    # Make operations on currently active model (default is model_2)
+    active_model = rstab_app.get_active_model()
+    print(f"\nCurrently active model_2:\n {active_model}")
+    create_update_and_query_objects(rstab_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(rstab_app, model_id=model_1)
+
+    # Set model_1 as the active model
+    rstab_app.set_active_model(model_id=model_1)
+    active_model = rstab_app.get_active_model()
+    print(f"\nSetting model_1 as active:\n {active_model}")

examples/rstab/results_access.py

@@ -0,0 +1,38 @@
+from dlubal.api import rstab, common
+
+with rstab.Application() as rstab_app:
+
+    # --- get_results ---
+    # Retrieves complete, unprocessed results from the RSTAB database.
+    # These results are returned wrapped in a DataFrame (.Data).
+    results:common.Table = rstab_app.get_results(
+        results_type=rstab.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 RSTAB desktop application.
+    result_table:common.Table = rstab_app.get_result_table(
+        table = rstab.results.ResultTable.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+        loading= rstab.ObjectId(
+            no=1,
+            object_type=rstab.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 = rstab_app.has_results(
+        loading = rstab.ObjectId
+        (
+            no = 1,
+            object_type = rstab.OBJECT_TYPE_LOAD_COMBINATION,
+        )
+    )
+    print(f"\nResults Available: {has_results.value}")

examples/rstab/results_axes_system.py

@@ -0,0 +1,53 @@
+from dlubal.api import rstab, common
+
+with rstab.Application() as rstab_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 = rstab_app.get_results(
+        results_type=rstab.results.ResultsType.STATIC_ANALYSIS_NODES_SUPPORT_FORCES,
+        support_coordinate_system=rstab.results.settings.CoordinateSystem.COORDINATE_SYSTEM_GLOBAL
+    )
+    print(f"\nSupport Forces:\n{support_forces.data}")
+
+    # Get result table
+    support_forces_table: common.Table = rstab_app.get_result_table(
+        table=rstab.results.ResultTable.STATIC_ANALYSIS_NODES_SUPPORT_FORCES_TABLE,
+        loading= rstab.ObjectId(
+            no=1,
+            object_type=rstab.OBJECT_TYPE_LOAD_CASE
+        ),
+        support_coordinate_system=rstab.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 = rstab_app.get_results(
+        results_type=rstab.results.ResultsType.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        member_axes_system=rstab.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 = rstab_app.get_result_table(
+        table=rstab.results.ResultTable.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+        loading= rstab.ObjectId(
+            no=1,
+            object_type=rstab.OBJECT_TYPE_LOAD_CASE
+        ),
+        member_axes_system=rstab.results.settings.MEMBER_AXES_SYSTEM_PRINCIPAL_AXES_X_U_V,
+    )
+    print(f"\nMember Forces Table:\n{member_forces_table.data}")
+
+

examples/rstab/results_in_location.py

@@ -0,0 +1,39 @@
+
+from dlubal.api import rstab
+import numpy
+
+def get_member_internal_force(member_no: int, loading: str = 'LC1', force: str = 'm_y', location: float = 0) -> float:
+    df_results = rstab_app.get_results(
+        results_type=rstab.results.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        filters=[
+            rstab.results.ResultsFilter(
+                column_id="member_no",
+                filter_expression=str(member_no)
+            ),
+            rstab.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 rstab.Application() as rstab_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/rstab/results_multiple_models.py

@@ -0,0 +1,40 @@
+from dlubal.api import rstab, common
+
+with rstab.Application() as rstab_app:
+
+
+    model_list = rstab_app.get_model_list()
+    print(f"\nModel List:\n{model_list}")
+
+    for model_id in model_list.model_info:
+
+        # --- 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 rstab GUI.
+        #    The `model_id` parameter ensures results are pulled from the correct model context.
+
+        df_internal_forces = rstab_app.get_results(
+            results_type=rstab.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 rstab 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 = rstab_app.get_result_table(
+            table = rstab.results.ResultTable.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+            loading= rstab.ObjectId(
+                no=1,
+                object_type=rstab.OBJECT_TYPE_LOAD_COMBINATION,
+            ),
+            model_id = common.ModelId(guid=model_id.guid)
+        ).data
+        print(f"\nInternal Forces | Table | {model_id.name}:")
+        print(df_internal_forces_table)

examples/rstab/select_objects.py

@@ -0,0 +1,39 @@
+from dlubal.api import rstab
+
+with rstab.Application() as rstab_app:
+
+
+    print(f"Get object list | All")
+    selected_members = rstab_app.get_object_list(
+        objs=[rstab.structure_core.Member()],
+    )
+    for member in selected_members:
+        print(f"Member No.: {member.no}")
+
+
+    print(f"Get object list | Only selected")
+    selected_members = rstab_app.get_object_list(
+        objs=[rstab.structure_core.Member()],
+        only_selected=True,
+    )
+    for member in selected_members:
+        print(f"Member No.: {member.no}")
+
+
+    print(f"Get object list | Select different")
+    rstab_app.select_objects(objs=[])
+    rstab_app.select_objects(
+        objs=[
+            rstab.structure_core.Member(no=46),
+            rstab.structure_core.Member(no=52),
+        ]
+    )
+    selected_members = rstab_app.get_object_list(
+        objs=[
+            rstab.structure_core.Member(),
+        ],
+        only_selected=True,
+    )
+    for member in selected_members:
+        print(f"Member No.: {member.no}")
+

examples/rstab/steel_hall.py

@@ -0,0 +1,165 @@
+"""
+Parametric steel hall example using manipulation functions.
+"""
+
+from dlubal.api import rstab, common
+
+# Editable parameters (SI units)
+FRAME_SPACING = 5.0
+FRAME_COUNT = 5
+FRAME_WIDTH = 13.0
+FRAME_HEIGHT_MIN = 4.5
+FRAME_HEIGHT_MAX = 6.0
+RAFTER_SLOPE_LENGTH = 0.2
+RAFTER_FIELDS = 2
+
+STEEL_GRADE = "S235 | EN 10025-2:2004-11"
+SECTION_COLUMN = "IPE 300"
+SECTION_RAFTER = "I 0.3/0.11/0.006/0.014/0/0/H"
+SECTION_RAFTER_TAPPERED = "I 0.6/0.11/0.006/0.014/0/0/H"
+SECTION_PURLINS = "CHC 139.7x8.0"
+SECTION_BRACING = "R 20"
+
+
+def build_frame() -> list:
+
+    inf = float('inf')
+
+    frame_objs = [
+
+        # Material
+        rstab.structure_core.Material(no=1, name=STEEL_GRADE),
+
+        # Cross-section
+        rstab.structure_core.CrossSection(no=1, name=SECTION_COLUMN, material=1),
+        rstab.structure_core.CrossSection(no=2, name=SECTION_RAFTER, material=1),
+        rstab.structure_core.CrossSection(no=3, name=SECTION_RAFTER_TAPPERED, material=1),
+
+        # Nodes
+        rstab.structure_core.Node(no=1),
+        rstab.structure_core.Node(no=2, coordinate_3=-FRAME_HEIGHT_MIN),
+        rstab.structure_core.Node(no=3, coordinate_1=FRAME_WIDTH/2, coordinate_3=-FRAME_HEIGHT_MAX),
+        rstab.structure_core.Node(no=4, coordinate_1=FRAME_WIDTH, coordinate_3=-FRAME_HEIGHT_MIN),
+        rstab.structure_core.Node(no=5, coordinate_1=FRAME_WIDTH),
+
+        # Members
+        rstab.structure_core.Member(
+            no=1, node_start=1, node_end=2, cross_section_start=1, type=rstab.structure_core.Member.TYPE_BEAM
+        ),
+        rstab.structure_core.Member(
+            no=2, node_start=2, node_end=3, cross_section_start=3, cross_section_end=2,
+            type=rstab.structure_core.Member.TYPE_BEAM,
+            cross_section_distribution_type=rstab.structure_core.Member.CROSS_SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER,
+            cross_section_distance_from_start_is_defined_as_relative=True,
+            section_distance_from_start_relative=RAFTER_SLOPE_LENGTH
+        ),
+        rstab.structure_core.Member(
+            no=3, node_start=3, node_end=4, cross_section_start=2, cross_section_end=3,
+            type=rstab.structure_core.Member.TYPE_BEAM,
+            cross_section_distribution_type=rstab.structure_core.Member.CROSS_SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER,
+            cross_section_distance_from_end_is_defined_as_relative=True,
+            cross_section_distance_from_end_relative=RAFTER_SLOPE_LENGTH
+        ),
+        rstab.structure_core.Member(
+            no=4, node_start=4, node_end=5, cross_section_start=1, type=rstab.structure_core.Member.TYPE_BEAM
+        ),
+
+        # Nodal support (hinge)
+        rstab.types_for_nodes.NodalSupport(
+            no=1,
+            nodes=[1, 5],
+            spring_x=inf,
+            spring_y=inf,
+            spring_z=inf,
+            rotational_restraint_z=inf
+        ),
+
+    ]
+
+    # Rafter internal nodes for purlins connection
+    node_no = 8
+    for member_ref in (2, 3):
+        for j in range(1, RAFTER_FIELDS):
+            frame_objs.append(
+                rstab.structure_core.Node(
+                    no=node_no,
+                    type=rstab.structure_core.Node.TYPE_ON_MEMBER,
+                    on_member_reference_member=member_ref,
+                    distance_from_start_relative=j / RAFTER_FIELDS,
+                )
+            )
+            node_no += 1
+
+
+    return frame_objs
+
+
+def build_purlins() -> list:
+
+    nodes_per_frame = 7 + 2* (RAFTER_FIELDS-1)
+    member_no = 4 * FRAME_COUNT
+
+    purlin_objs = [
+        rstab.structure_core.CrossSection(no=4, name=SECTION_PURLINS, material=1),
+        rstab.structure_core.Member(
+            no=member_no+1, node_start=2, node_end=nodes_per_frame+2, cross_section_start=4,
+            type=rstab.structure_core.Member.TYPE_TRUSS
+        ),
+        rstab.structure_core.Member(
+            no=member_no+2, node_start=3, node_end=nodes_per_frame+3, cross_section_start=4,
+            type=rstab.structure_core.Member.TYPE_TRUSS
+        ),
+        rstab.structure_core.Member(
+            no=member_no+3, node_start=4, node_end=nodes_per_frame+4, cross_section_start=4,
+            type=rstab.structure_core.Member.TYPE_TRUSS
+        ),
+    ]
+
+    member_no += 3
+
+    for j in range(1, RAFTER_FIELDS*2 - 1):
+        purlin_objs.extend([
+            rstab.structure_core.Member(
+                no=member_no+1, node_start=7+j, node_end=nodes_per_frame+7+j, cross_section_start=4,
+                type=rstab.structure_core.Member.TYPE_TRUSS
+            )
+        ])
+        member_no += 1
+
+    return purlin_objs
+
+# --- Main function to execute ---
+with rstab.Application() as rstab_app:
+
+    # Close all existing models and create a new empty one
+    rstab_app.close_all_models(save_changes=False)
+    model_id = rstab_app.create_model(name='steel_hall_parametric')
+    rstab_app.delete_all_objects()
+
+    # Build the frame
+    frame_objs = build_frame()
+    rstab_app.create_object_list(objs=frame_objs)
+
+    # Copy the frame by vector
+    rstab_app.move_objects(
+        objects=frame_objs,
+        create_copy=True,
+        number_of_steps=FRAME_COUNT-1,
+        direction_through=rstab.manipulation.DIRECTION_THROUGH_DISPLACEMENT_VECTOR,
+        displacement_vector=common.Vector3d(x=0.0, y=FRAME_SPACING, z=0.0),
+        spacing=FRAME_SPACING
+    )
+
+    # Build purlins
+    purlin_objs = build_purlins()
+    rstab_app.create_object_list(objs=purlin_objs)
+
+    # Copy the purlins parallel to axis
+    rstab_app.move_objects(
+        objects=purlin_objs,
+        create_copy=True,
+        number_of_steps=FRAME_COUNT-2,
+        direction_through=rstab.manipulation.DIRECTION_THROUGH_PARALLEL_TO_AXIS,
+        axis=rstab.manipulation.COORDINATE_AXIS_Y,
+        spacing=FRAME_SPACING
+    )

google/protobuf/any_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: google/protobuf/any.proto
+# Protobuf Python Version: 5.28.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    28,
+    1,
+    '',
+    'google/protobuf/any.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf\"&\n\x03\x41ny\x12\x10\n\x08type_url\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c\x42v\n\x13\x63om.google.protobufB\x08\x41nyProtoP\x01Z,google.golang.org/protobuf/types/known/anypb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.any_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\010AnyProtoP\001Z,google.golang.org/protobuf/types/known/anypb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+  _globals['_ANY']._serialized_start=46
+  _globals['_ANY']._serialized_end=84
+# @@protoc_insertion_point(module_scope)

google/protobuf/any_pb2.pyi

@@ -0,0 +1,14 @@
+from google.protobuf.internal import well_known_types as _well_known_types
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Any(_message.Message, _well_known_types.Any):
+    __slots__ = ("type_url", "value")
+    TYPE_URL_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    type_url: str
+    value: bytes
+    def __init__(self, type_url: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ...