update straight wall

Author: Crowder44

src/ifcplus/api/building_element.py renamed to src/ifcplus/api/built_element.py

@@ -1,5 +1,23 @@
 # Copyright 2025, Battelle Energy Alliance, LLC All Rights Reserved
 
+"""Built Element Creation Module
+
+Checklist for built element creation:
+- Add Material/MaterialLayerSet/MaterialProfileSet
+- Add Type
+- Declare Type on Project
+- Assign Material to Type
+- Add Element
+- Assign Type to Element
+- Add MaterialLayerSetUsage/MaterialProfileSetUsage
+- Assign MaterialLayerSetUsage/MaterialProfileSetUsage to Wall
+- Add Representation
+- Assign Representation to Element
+- Place Element in Spatial Container
+- Edit Element Placement
+
+"""
+
 import ifcopenshell
 import ifcopenshell.api.geometry
 from typing import Literal
@@ -15,13 +33,16 @@
 import ifcopenshell.api.spatial
 import ifcplus.api.geometry
 import ifcplus.api.profile
+import ifcplus.api.material
+import ifcopenshell.util.representation
+from typing import cast
 
 BUILT_ELEMENT_FRAME_MEMBER = Literal["IfcBeam", "IfcColumn", "IfcMember"]
 
 
 def create_3pt_beam_or_column_or_member(
     ifc_class: BUILT_ELEMENT_FRAME_MEMBER,
-    p1: tuple[float, float, float],
+    start_point_2d: tuple[float, float, float],
     p2: tuple[float, float, float],
     p3: tuple[float, float, float],
     profile_def: ifcopenshell.entity_instance,
@@ -71,8 +92,8 @@ def create_3pt_beam_or_column_or_member(
     assert material.is_a("IfcMaterial")
 
     # Calculate Axes
-    z_axis = np.array(p2) - np.array(p1)
-    y_axis = np.array(p3) - np.array(p1)
+    z_axis = np.array(p2) - np.array(start_point_2d)
+    y_axis = np.array(p3) - np.array(start_point_2d)
     x_axis = np.cross(y_axis, z_axis)
 
     # Calculate length
@@ -102,7 +123,7 @@ def create_3pt_beam_or_column_or_member(
     # Edit Placement
     ifcplus.api.placement.edit_object_placement(
         product=beam_or_column_or_member,
-        repositioned_origin=p1,
+        repositioned_origin=start_point_2d,
         repositioned_z_axis=tuple(z_axis.tolist()),
         repositioned_x_axis=tuple(x_axis.tolist()),
         place_object_relative_to_parent=should_transform_relative_to_parent,
@@ -214,23 +235,36 @@ def create_opening_element(
 
 
 def create_2pt_wall(
-    p1: tuple[float, float],  # global XY
-    p2: tuple[float, float],  # global XY
+    start_point_2d: tuple[float, float],
+    end_point_2d: tuple[float, float],
+    elevation: float,
     height: float,
-    elevation: float,  # global Z
     materials: list[ifcopenshell.entity_instance],
     thicknesses: list[float],
-    inner_openings: list[list[tuple[float, float]]] = [],  # Local XZ
     wall: ifcopenshell.entity_instance | None = None,
     name: str | None = None,
-    structure_contained_in: ifcopenshell.entity_instance | None = None,
-    should_transform_relative_to_parent: bool = False,
-) -> ifcopenshell.entity_instance:
+    parent: ifcopenshell.entity_instance | None = None,
+    place_object_relative_to_parent: bool = False,
+):
+    """Add straight IfcWall with IfcMaterialLayerSetUsage based on two points in
+    XY space."""
 
-    # Get IFC4 File
     ifc4_file = materials[0].file
 
-    # Create Wall
+    material_layer_set = ifcplus.api.material.add_material_layer_set(
+        materials=materials,
+        thicknesses=thicknesses,
+        name=None,
+        check_for_duplicate=True,
+    )
+
+    wall_type = ifcplus.api.element_type.add_element_type_for_material_layer_set(
+        ifc_class="IfcWallType",
+        material_layer_set=material_layer_set,
+        name=material_layer_set.LayerSetName,
+        check_for_duplicate=True,
+    )
+
     if wall is None:
         wall = ifcopenshell.api.root.create_entity(
             file=ifc4_file,
@@ -239,112 +273,85 @@ def create_2pt_wall(
             predefined_type="NOTDEFINED",
         )
 
-    # Assign spatial container
-    if isinstance(structure_contained_in, ifcopenshell.entity_instance):
-        ifcopenshell.api.spatial.assign_container(
-            file=ifc4_file,
-            products=[wall],
-            relating_structure=structure_contained_in,
-        )
-        ifcplus.api.placement.edit_object_placement(
-            product=wall,
-            place_object_relative_to_parent=True,
-        )
+    ifcopenshell.api.type.assign_type(
+        file=ifc4_file,
+        related_objects=[wall],
+        relating_type=wall_type,
+    )
 
-    # Calculate thickness
-    thickness = sum(thicknesses)
+    total_thickness = 0.0
+    for material_layer in material_layer_set.MaterialLayers:
+        total_thickness += material_layer.LayerThickness
 
-    # Calculate Axes
-    z_axis = np.array([0.0, 0.0, 1.0])
-    v12 = np.array(p2) - np.array(p1)
-    x_axis = (v12[0], v12[1], 0.0)
+    rel_associates_material = ifcopenshell.api.material.assign_material(
+        file=ifc4_file,
+        products=[wall],
+        type="IfcMaterialLayerSetUsage",
+        material=None,  # inferred from assigned IfcElementType
+    )
+    material_layer_set_usage = cast(
+        ifcopenshell.entity_instance, rel_associates_material
+    ).RelatingMaterial
+    material_layer_set_usage.OffsetFromReferenceLine = -total_thickness / 2
 
-    # Calculate length
-    length = float(np.linalg.norm(x_axis))
+    start_point_3d = (start_point_2d[0], start_point_2d[1], elevation)
+    end_point_3d = (end_point_2d[0], end_point_2d[1], elevation)
+    vector_from_start_point_to_end_point = np.array(end_point_3d) - np.array(
+        start_point_3d
+    )
+    length = float(np.linalg.norm(vector_from_start_point_to_end_point))
 
-    # Add and assign representation
-    representation_item = ifcplus.api.geometry.add_extruded_area_solid(
+    extruded_area_solid = ifcplus.api.geometry.add_extruded_area_solid(
         ifc4_file=ifc4_file,
         profile=ifcplus.api.profile.add_arbitrary_profile_with_or_without_voids(
             file=ifc4_file,
             outer_profile=[
-                (0.0, 0.0 - thickness / 2),
-                (0.0 + length, 0.0 - thickness / 2),
-                (0.0 + length, 0.0 + thickness - thickness / 2),
-                (0.0 + length - length, 0.0 + thickness - thickness / 2),
-                (0.0, 0.0 - thickness / 2),
+                (0.0, 0.0 - total_thickness / 2),
+                (0.0 + length, 0.0 - total_thickness / 2),
+                (0.0 + length, 0.0 + total_thickness - total_thickness / 2),
+                (0.0 + length - length, 0.0 + total_thickness - total_thickness / 2),
+                (0.0, 0.0 - total_thickness / 2),
             ],
             inner_profiles=[],
             name=None,
         ),
         extrusion_depth=height,
     )
+
+    representation_type = ifcopenshell.util.representation.guess_type(
+        items=[extruded_area_solid]
+    )
+
     shape_model = ifcplus.api.geometry.add_shape_model(
         ifc4_file=ifc4_file,
         shape_model_class="IfcShapeRepresentation",
         representation_identifier="Body",
-        representation_type="SweptSolid",
+        representation_type=cast(str, representation_type),  # SweptSolid
         context_type="Model",
         target_view="MODEL_VIEW",
-        items=[representation_item],
+        items=[extruded_area_solid],
     )
+
     ifcopenshell.api.geometry.assign_representation(
         file=ifc4_file,
         product=wall,
         representation=shape_model,
     )
 
-    # Edit Placement
+    if isinstance(parent, ifcopenshell.entity_instance):
+        ifcopenshell.api.spatial.assign_container(
+            file=ifc4_file,
+            products=[wall],
+            relating_structure=parent,
+        )
+
     ifcplus.api.placement.edit_object_placement(
         product=wall,
-        repositioned_origin=(p1[0], p1[1], elevation),
-        repositioned_z_axis=tuple(z_axis.tolist()),
-        repositioned_x_axis=x_axis,
-        place_object_relative_to_parent=should_transform_relative_to_parent,
-    )
-
-    # Add and assign Type
-    wall_type = ifcplus.api.element_type.add_slab_or_wall_or_plate_element_type(
-        ifc_class="IfcWallType",
-        materials=materials,
-        thicknesses=thicknesses,
-        check_for_duplicate=True,
-    )
-    ifcopenshell.api.type.assign_type(
-        file=ifc4_file,
-        related_objects=[wall],
-        relating_type=wall_type,
-    )
-
-    # Declare Type on Project
-    project = ifc4_file.by_type(type="IfcProject", include_subtypes=False)[0]
-    ifcopenshell.api.project.assign_declaration(
-        file=ifc4_file,
-        definitions=[wall_type],
-        relating_context=project,
-    )
-
-    # Assign MaterialProfileSetUsage (material deduced from assigned element type
-    # automatically)
-    rel_associates_material = ifcopenshell.api.material.assign_material(
-        file=ifc4_file,
-        products=[wall],
-        type="IfcMaterialLayerSetUsage",
+        repositioned_origin=start_point_3d,
+        repositioned_x_axis=tuple(vector_from_start_point_to_end_point.tolist()),
+        repositioned_z_axis=(0.0, 0.0, 1.0),
+        place_object_relative_to_parent=place_object_relative_to_parent,
     )
-    assert isinstance(rel_associates_material, ifcopenshell.entity_instance)
-    material_layer_set_usage = rel_associates_material.RelatingMaterial
-    material_layer_set_usage.OffsetFromReferenceLine = -thickness / 2
-
-    # Openings
-    for inner_opening_coordinates in inner_openings:
-        create_opening_element(
-            voided_element=wall,
-            profile_points=inner_opening_coordinates,
-            depth=thickness,
-            origin_relative_to_voided_element=(0.0, thickness / 2, 0.0),
-            x_axis_relative_to_voided_element=(1.0, 0.0, 0.0),
-            z_axis_relative_to_voided_element=(0.0, -1.0, 0.0),
-        )
 
     return wall
 

src/ifcplus/api/element_type.py

@@ -6,7 +6,7 @@
 import ifcopenshell.util.element
 import ifcplus.api.material
 from typing import Literal
-
+import ifcopenshell.api.project
 
 LINEAR_ELEMENT_TYPE_CLASS = Literal[
     "IfcBeamType",
@@ -50,11 +50,13 @@ def add_prismatic_homogenous_linear_elment_type(
         name=name if name else f"{material.Name} {profile.ProfileName}",
     )
 
-    material_profile_set = ifcplus.api.material.add_material_profile_set_with_single_material_profile(
-        material=material,
-        profile=profile,
-        name=beam_or_column_or_element_type.Name,
-        check_for_duplicate=check_for_duplicate,
+    material_profile_set = (
+        ifcplus.api.material.add_material_profile_set_with_single_material_profile(
+            material=material,
+            profile=profile,
+            name=beam_or_column_or_element_type.Name,
+            check_for_duplicate=check_for_duplicate,
+        )
     )
 
     ifcopenshell.api.material.assign_material(
@@ -151,3 +153,48 @@ def add_element_type(
     assert element_type.is_a("IfcElementType")
 
     return element_type
+
+
+def add_element_type_for_material_layer_set(
+    ifc_class: str,
+    material_layer_set: ifcopenshell.entity_instance,
+    name: str | None = None,
+    check_for_duplicate: bool = False,
+) -> ifcopenshell.entity_instance:
+    """Add an IfcElementType based on an IfcMaterialLayerSet. This function also
+    automates material assignment and project declaration for the type."""
+
+    ifc4_file = material_layer_set.file
+
+    if check_for_duplicate:
+        for old_type in ifc4_file.by_type(type="IfcWallType", include_subtypes=False):
+            old_material_layer_set = ifcopenshell.util.element.get_material(
+                element=old_type,
+                should_skip_usage=True,
+            )
+            if not isinstance(old_material_layer_set, ifcopenshell.entity_instance):
+                continue
+            if material_layer_set == old_material_layer_set:
+                return old_type
+
+    element_type = ifcopenshell.api.root.create_entity(
+        file=ifc4_file,
+        ifc_class=ifc_class,
+        name=name,
+    )
+
+    ifcopenshell.api.material.assign_material(
+        file=ifc4_file,
+        products=[element_type],
+        material=material_layer_set,
+    )
+
+    project = ifc4_file.by_type(type="IfcProject", include_subtypes=False)[0]
+
+    ifcopenshell.api.project.assign_declaration(
+        file=ifc4_file,
+        definitions=[element_type],
+        relating_context=project,
+    )
+
+    return element_type

src/ifcplus/api/material.py

@@ -5,7 +5,9 @@
 import pickle
 import os
 import ifcplus.api.style
+import ifcplus.util.project
 from ifcplus import REGION, RGB_STEEL, RGB_CONCRETE
+import numpy as np
 
 
 def add_material_with_structural_properties(
@@ -215,6 +217,14 @@ def add_material_layer_set(
 
     ifc4_file = materials[0].file
 
+    numeric_scale = ifcplus.util.project.get_numeric_scale_of_project(
+        ifc4_file=ifc4_file,
+    )
+
+    thicknesses = [
+        float(np.round(thickness, numeric_scale)) for thickness in thicknesses
+    ]
+
     if check_for_duplicate:
         for old_material_layer_set in ifc4_file.by_type(
             type="IfcMaterialLayerSet", include_subtypes=False
@@ -237,14 +247,16 @@ def add_material_layer_set(
                     break
             return old_material_layer_set
 
+    if name is None:
+        total_thickness = float(np.round(sum(thicknesses), numeric_scale))
+        name = (
+            " | ".join([material.Name for material in materials])
+            + f" {total_thickness}"
+        )
+
     material_layer_set = ifcopenshell.api.material.add_material_set(
         file=ifc4_file,
-        name=(
-            name
-            if name
-            else " | ".join([material.Name for material in materials])
-            + f" {sum(thicknesses)}"
-        ),
+        name=name,
         set_type="IfcMaterialLayerSet",
     )