dlubal.api 2.12.11__py3-none-any.whl

examples/rfem/export_model_to.py

@@ -0,0 +1,159 @@
+import os
+from math import inf
+from dlubal.api import rfem, common
+
+def define_structure() -> list:
+    """Define and return a list of structural objects."""
+
+    return [
+        # Define material
+        rfem.structure_core.Material(
+            no=1,
+            name='S235',
+        ),
+
+        # Define cross-section
+        rfem.structure_core.CrossSection(
+            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,
+            cross_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.StaticAnalysisSettings.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.NodalLoad.LOAD_TYPE_COMPONENTS,
+            components_force_y=5000,  # Force in Y direction (N)
+            components_force_z=10000,  # Force in Z direction (N)
+        ),
+        rfem.loads.MemberLoad(
+            no=1,
+            load_case=2,
+            members=[1],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=10000,
+        ),
+
+        # Define design situation
+        rfem.loading.DesignSituation(
+            no=1,
+            design_situation_type=rfem.loading.DesignSituation.DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10,
+        ),
+
+        # Define load combination
+        rfem.loading.LoadCombination(
+            no=1,
+            name='CO1',
+            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,
+                        )
+                    ]
+            ),
+            design_situation=1,
+        ),
+        rfem.loading.LoadCombination(
+            no=2,
+            name='CO2',
+            items =  rfem.loading.LoadCombination.ItemsTable(
+                    rows=[
+                        rfem.loading.LoadCombination.ItemsRow(
+                            load_case=1,
+                            factor=0.85,
+                        ),
+                        rfem.loading.LoadCombination.ItemsRow(
+                            load_case=2,
+                            factor=1.0,
+                        )
+                    ]
+            ),
+            design_situation=1,
+        ),
+    ]
+
+
+"""Runs the structural analysis example."""
+
+with rfem.Application() as rfem_app:
+
+    # Step 1: Create a model
+    rfem_app.create_model(name='cantilever')
+    rfem_app.delete_all_objects()
+    rfem_app.create_object_list(
+        objs=define_structure() + define_loading()
+    )
+
+    # Step 2: Export the model to Python script
+    rfem_app.export_to(
+        filepath=os.path.abspath('./model_export.py'),
+        export_attributes=common.import_export.PythonGrpcExportAttributes()
+    )
+
+    # Step 3: Export the model to IFC
+    rfem_app.export_to(
+        filepath=os.path.abspath('./model_export.ifc'),
+        export_attributes=common.import_export.IfcExportAttributes()
+    )

examples/rfem/frame.py

@@ -0,0 +1,285 @@
+from dlubal.api import rfem
+
+
+def define_structure() -> list:
+    """Define and return a list of structural objects."""
+
+    inf = float('inf')
+
+    return [
+        # Define material
+        rfem.structure_core.Material(no=1, name='S235'),
+
+        # Define cross-section
+        rfem.structure_core.CrossSection(no=1, name='HE 200 A', material=1),
+
+        # Define nodes
+        rfem.structure_core.Node(no=1),
+        rfem.structure_core.Node(no=2, coordinate_3=-3.0),
+        rfem.structure_core.Node(no=3, coordinate_1=4.0, coordinate_3=-3.0),
+        rfem.structure_core.Node(no=4, coordinate_1=4.0),
+
+        # Define line
+        rfem.structure_core.Line(no=1, definition_nodes=[1, 2]),
+        rfem.structure_core.Line(no=2, definition_nodes=[2, 3]),
+        rfem.structure_core.Line(no=3, definition_nodes=[3, 4]),
+
+        # Define member
+        rfem.structure_core.Member(no=1, line=1, cross_section_start=1),
+        rfem.structure_core.Member(no=2, line=2, cross_section_start=1),
+        rfem.structure_core.Member(no=3, line=3, cross_section_start=1),
+
+        # Define nodal support at Node 1 (fully fixed)
+        rfem.types_for_nodes.NodalSupport(
+            no=1,
+            nodes=[1,4],
+            spring_x=inf, spring_y=inf, spring_z=inf,
+            rotational_restraint_x=inf,
+            rotational_restraint_y=inf,
+            rotational_restraint_z=inf
+        ),
+    ]
+
+
+def define_loads() -> list:
+    """Define and return a list of loading objects."""
+
+    return [
+        # Static analysis settings
+        rfem.loading.StaticAnalysisSettings(
+            no=1,
+            analysis_type=rfem.loading.StaticAnalysisSettings.ANALYSIS_TYPE_GEOMETRICALLY_LINEAR,
+        ),
+
+        # Define load cases
+        rfem.loading.LoadCase(
+            no=1,
+            name='Self-weight',
+            self_weight_active=True,
+            static_analysis_settings=1,
+        ),
+        rfem.loading.LoadCase(
+            no=2,
+            name='Snow',
+            action_category=rfem.loading.LoadCase.ACTION_CATEGORY_SNOW_ICE_LOADS_H_LESS_OR_EQUAL_TO_1000_M_QS,
+            static_analysis_settings=1,
+        ),
+        rfem.loading.LoadCase(
+            no=3,
+            name='Wind +x',
+            action_category=rfem.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+        rfem.loading.LoadCase(
+            no=4,
+            name='Wind +x, with wind suction',
+            action_category=rfem.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+        rfem.loading.LoadCase(
+            no=5,
+            name='Wind -x',
+            action_category=rfem.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+        rfem.loading.LoadCase(
+            no=6,
+            name='Wind -x, with wind suction',
+            action_category=rfem.loading.LoadCase.ACTION_CATEGORY_WIND_QW,
+            static_analysis_settings=1,
+        ),
+
+        # Define loads
+        rfem.loads.MemberLoad(
+            no=1,
+            load_case=1,
+            members=[2],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=1000
+        ),
+        rfem.loads.MemberLoad(
+            no=2,
+            load_case=2,
+            members=[2],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=3000
+        ),
+        rfem.loads.MemberLoad(
+            no=3,
+            load_case=3,
+            members=[1],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=2000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=4,
+            load_case=3,
+            members=[3],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=1000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=5,
+            load_case=4,
+            members=[1],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=2000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=6,
+            load_case=4,
+            members=[3],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=1000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=7,
+            load_case=4,
+            members=[2],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-500
+        ),
+        rfem.loads.MemberLoad(
+            no=8,
+            load_case=5,
+            members=[1],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-2000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=9,
+            load_case=5,
+            members=[3],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-1000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=10,
+            load_case=6,
+            members=[1],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-2000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=11,
+            load_case=6,
+            members=[3],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-1000,
+            load_direction=rfem.loads.MemberLoad.LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE_LENGTH,
+        ),
+        rfem.loads.MemberLoad(
+            no=12,
+            load_case=6,
+            members=[2],
+            load_type=rfem.loads.MemberLoad.LOAD_TYPE_FORCE,
+            magnitude=-500
+        ),
+        rfem.loading.CombinationWizard(
+            no=1,
+            static_analysis_settings=1,
+        ),
+        rfem.loading.DesignSituation(
+            no=1,
+            design_situation_type=rfem.loading.DesignSituation.DESIGN_SITUATION_TYPE_STR_PERMANENT_AND_TRANSIENT_6_10,
+            combination_wizard=1,
+        ),
+    ]
+
+
+with rfem.Application() as rfem_app:
+
+    # Step 1: Create a new model and clear existing objects
+    rfem_app.create_model(name='frame')
+    rfem_app.delete_all_objects()
+
+    # Step 2: Define and create the structure and load objects
+    base_data = rfem_app.get_base_data()
+    base_data.combinations_settings.combination_wizard_active = True
+    base_data.combinations_settings.result_combinations_active = True
+    rfem_app.set_base_data(base_data=base_data)
+
+    # Step 3: Define and create the structure and load objects
+    objects = define_structure() + define_loads()
+    rfem_app.create_object_list(objects)
+
+    # Step 4: Generate Load Combinations
+    print("\nLoad Combinations:")
+    rfem_app.generate_combinations()
+    all_load_combi = rfem_app.get_object_list([rfem.loading.LoadCombination()])
+
+    # Step 5: Create Result Combination as an envelope from all Load Combinations
+    result_combi_rows = []
+    for i, load_combi in enumerate(all_load_combi):
+        # Check if this is the last item in the list
+        print(f"CO{load_combi.no} - {load_combi.combination_rule_str}")
+
+        if i < len(all_load_combi) - 1:
+            operator = rfem.loading.ResultCombination.ItemsRow.OPERATOR_OR
+        else:
+            operator = rfem.loading.ResultCombination.ItemsRow.OPERATOR_NONE
+
+        result_combi_rows.append(
+            rfem.loading.ResultCombination.ItemsRow(
+                case_object_item=rfem.ObjectId(
+                    no=load_combi.no,
+                    object_type=rfem.OBJECT_TYPE_LOAD_COMBINATION,
+                ),
+                case_object_factor=1,
+                operator=operator,
+            )
+        )
+
+    print("\nResult Combination:")
+    rfem_app.create_object(
+        rfem.loading.ResultCombination(
+            no=1,
+            user_defined_name_enabled=True,
+            name='All ULS',
+            design_situation=1,
+            items=rfem.loading.ResultCombination.ItemsTable(
+                rows = result_combi_rows,
+            )
+        )
+    )
+    result_combi = rfem_app.get_object(rfem.loading.ResultCombination(no=1))
+    print(f"{result_combi.name} - {result_combi.combination_rule_str}")
+
+
+    # Step 6: Calculate specific
+    rfem_app.calculate_specific(
+        loadings=[
+            rfem.ObjectId(
+                no=1,
+                object_type=rfem.OBJECT_TYPE_RESULT_COMBINATION
+            )
+        ],
+        skip_warnings=False,
+    )
+
+    # Step 7: Read results using the pre-processed filtering
+    results_df = rfem_app.get_results(
+        results_type=rfem.results.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES,
+        filters=[
+            rfem.results.ResultsFilter(column_id='member_no',filter_expression='2'),
+            rfem.results.ResultsFilter(column_id='loading',filter_expression='RC1'),
+        ],
+    ).data
+    print("\nAll Results:")
+    print(results_df)
+
+
+    # Step 8: Find maximum m_y envelope on specific member
+    my_max_df = results_df[results_df['tag'] == 'm_y_max']
+    print("\nMaximum My:")
+    print(my_max_df)
+
+
+

examples/rfem/import_from_ifc.py

@@ -0,0 +1,60 @@
+import os
+from dlubal.api import rfem, common
+
+
+# Connect to the RFEM application
+with rfem.Application() as rfem_app:
+
+    rfem_app.create_model(name='import_from_ifc')
+
+    # Step 1: Import IFC model from the file
+    ifc_file_path = os.path.join(os.path.dirname(__file__), 'src', 'ifc_structure.ifc')
+
+    rfem_app.import_from(
+        filepath=ifc_file_path,
+        import_attributes=common.import_export.IfcImportAttributes()
+    )
+
+    # Step 2: Edit IFC model (e.g., mirror it along the Z-axis)
+    ifc_model: rfem.ifc_objects.IfcFileModelObject = rfem_app.get_object(
+        rfem.ifc_objects.IfcFileModelObject(no=1)
+    )
+    ifc_model.mirror_axis_z=True
+    rfem_app.update_object(ifc_model)
+
+
+    # Step 3: Categorize IFC model objects for conversion
+    ifc_object_list = rfem_app.get_object_list(
+        objs=[
+            rfem.ifc_objects.IfcModelObject()
+        ]
+    )
+
+    members, surfaces, solids = [], [], []
+
+    for ifc_object in ifc_object_list:
+        ifc_type = ifc_object.ifc_type
+        if ifc_type in ["IfcColumn", "IfcBeam"]:
+            members.append(ifc_object)
+        elif ifc_type in ["IfcWallStandardCase", "IfcSlab",]:
+            surfaces.append(ifc_object)
+        elif ifc_type in ["IfcFooting"]:
+            solids.append(ifc_object)
+
+    # Step 4: Convert IFC model objects to appropriate RFEM model objects
+    # Convert columns and beams to RFEM straight members
+    rfem_app.convert_objects(
+        convert_into=common.ConvertObjectInto.CONVERT_IFC_OBJECT_INTO_STRAIGHT_MEMBER,
+        objs=members
+    )
+    # Convert walls and slabs to RFEM surfaces
+    rfem_app.convert_objects(
+        convert_into=common.ConvertObjectInto.CONVERT_IFC_OBJECT_INTO_SURFACE,
+        objs=surfaces
+    )
+    # Convert footings to RFEM solids
+    rfem_app.convert_objects(
+        convert_into=common.ConvertObjectInto.CONVERT_IFC_OBJECT_INTO_SOLID,
+        objs=solids
+    )
+

examples/rfem/import_from_rsection.py

@@ -0,0 +1,107 @@
+import os
+from dlubal.api import rfem, rsection, common
+
+# Step 1: Define cross-section
+def define_cross_section() -> 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
+
+# Step 2: Create and save cross-section in RSECTION
+with rsection.Application(port=9001) as rsection_app:
+
+    rsection_app.create_model(name='steel_section')
+    rsection_app.delete_all_objects()
+    rsection_app.create_object_list(objs=define_cross_section())
+
+    rsection_filepath = os.path.join(os.path.abspath('.'), 'steel_section.rsc')
+    rsection_app.save_model(path=rsection_filepath)
+
+
+# Step 3: Import cross-section from .rsc file into RFEM
+with rfem.Application(port=9000) as rfem_app:
+
+    rfem_app.create_model(name='steel_member_with_rsection')
+    rfem_app.delete_all_objects()
+
+    rfem_app.import_from(
+        filepath=rsection_filepath,
+        import_attributes=common.import_export.RsectionImportAttributes()
+    )
+

examples/rfem/import_from_xml.py

@@ -0,0 +1,29 @@
+import os
+from dlubal.api import rfem, common
+
+# Connect to the RFEM application
+with rfem.Application() as rfem_app:
+
+    # Reset RFEM by closing models, creating a new one, and clearing all objects
+    rfem_app.close_all_models(save_changes=False)
+    rfem_app.create_model(name='xml_structure')
+    rfem_app.delete_all_objects()
+
+    # Step 1: Import IFC model from the file
+    xml_path = os.path.join(os.path.dirname(__file__), 'src', 'xml_structure.xml')
+
+    rfem_app.import_from(
+        filepath=xml_path,
+        import_attributes=common.import_export.XmlImportAttributes()
+    )
+
+    # Step 2: Get object ID list
+    object_id_list = rfem_app.get_object_id_list()
+
+    # Iterate through object IDs and print their types and IDs
+    for obj in object_id_list.object_id:
+
+        object_id = obj.no
+        object_type = obj.object_type
+
+        print(f"{rfem.ObjectType.Name(object_type)}: {object_id}")