ifctrano 0.1.11__py3-none-any.whl → 0.2.0__py3-none-any.whl

ifctrano/building.py

@@ -1,6 +1,6 @@
 import re
 from pathlib import Path
-from typing import List, Tuple, Any, Optional
+from typing import List, Tuple, Any, Optional, Set
 
 import ifcopenshell
 from ifcopenshell import file, entity_instance
@@ -9,15 +9,16 @@ from trano.elements import InternalElement  # type: ignore
 from trano.elements.library.library import Library  # type: ignore
 from trano.elements.types import Tilt  # type: ignore
 from trano.topology import Network  # type: ignore
+from vedo import Line  # type: ignore
 
-from ifctrano.base import BaseModelConfig, Libraries, Vector
+from ifctrano.base import BaseModelConfig, Libraries, Vector, BaseShow, CommonSurface
 from ifctrano.exceptions import IfcFileNotFoundError, NoIfcSpaceFoundError
 from ifctrano.space_boundary import (
     SpaceBoundaries,
     initialize_tree,
     Space,
-    construction,
 )
+from ifctrano.construction import Constructions, default_construction
 
 
 def get_spaces(ifcopenshell_file: file) -> List[entity_instance]:
@@ -28,6 +29,7 @@ class IfcInternalElement(BaseModelConfig):
     spaces: List[Space]
     element: entity_instance
     area: float
+    common_surface: CommonSurface
 
     def __hash__(self) -> int:
         return hash(
@@ -49,23 +51,108 @@ class IfcInternalElement(BaseModelConfig):
             self.area,
         )
 
+    def lines(self) -> List[Line]:
+        lines = []
+        if self.common_surface:
+            lines += self.common_surface.lines()
+        return lines
 
-class InternalElements(BaseModelConfig):
+
+class InternalElements(BaseShow):
     elements: List[IfcInternalElement] = Field(default_factory=list)
 
     def internal_element_ids(self) -> List[str]:
         return list({e.element.GlobalId for e in self.elements})
 
-    def description(self) -> List[Tuple[Any, Any, str, float]]:
-        return sorted([element.description() for element in self.elements])
+    def description(self) -> Set[Tuple[Any, Any, str, float]]:
+        return set(  # noqa: C414
+            sorted([element.description() for element in self.elements])
+        )
+
+
+def get_internal_elements(space1_boundaries: List[SpaceBoundaries]) -> InternalElements:
+    elements = []
+    seen = set()
+    common_boundaries = []
+    for space_boundaries_ in space1_boundaries:
+        for space_boundaries__ in space1_boundaries:
+            space_1 = space_boundaries_.space
+            space_2 = space_boundaries__.space
+
+            if (
+                space_1.global_id == space_2.global_id
+                and (space_1.global_id, space_2.global_id) in seen
+            ):
+                continue
+            seen.update(
+                {
+                    (space_1.global_id, space_2.global_id),
+                    (space_2.global_id, space_1.global_id),
+                }
+            )
+            common_surface = space_1.bounding_box.intersect_faces(space_2.bounding_box)
+
+            for boundary in space_boundaries_.boundaries:
+                for boundary_ in space_boundaries__.boundaries:
+                    if (
+                        boundary.entity.GlobalId == boundary_.entity.GlobalId
+                        and boundary.common_surface
+                        and boundary_.common_surface
+                        and common_surface
+                        and (
+                            boundary.common_surface.orientation
+                            * common_surface.orientation
+                        ).is_a_zero()
+                        and (
+                            boundary_.common_surface.orientation
+                            * common_surface.orientation
+                        ).is_a_zero()
+                    ) and boundary.common_surface.orientation.dot(
+                        boundary_.common_surface.orientation
+                    ) < 0:
+                        common_boundaries.extend([boundary, boundary_])
+                        common_surface = sorted(
+                            [boundary.common_surface, boundary_.common_surface],
+                            key=lambda s: s.area,
+                        )[0]
+                        common_surface.exterior = False
+                        elements.append(
+                            IfcInternalElement(
+                                spaces=[space_1, space_2],
+                                element=boundary_.entity,
+                                area=common_surface.area,
+                                common_surface=common_surface,
+                            )
+                        )
+    for space_boundaries_ in space1_boundaries:
+        space_boundaries_.remove(common_boundaries)
+    return InternalElements(elements=list(set(elements)))
 
 
-class Building(BaseModelConfig):
+class Building(BaseShow):
     name: str
     space_boundaries: List[SpaceBoundaries]
     ifc_file: file
     parent_folder: Path
     internal_elements: InternalElements = Field(default_factory=InternalElements)
+    constructions: Constructions
+
+    def get_boundaries(self, space_id: str) -> SpaceBoundaries:
+        return next(
+            sb for sb in self.space_boundaries if sb.space.global_id == space_id
+        )
+
+    def description(self) -> list[list[tuple[float, tuple[float, ...], Any, str]]]:
+        return sorted([sorted(b.description()) for b in self.space_boundaries])
+
+    def lines(self) -> List[Line]:
+        lines = []
+        for space_boundaries_ in [
+            *self.space_boundaries,
+            *self.internal_elements.elements,
+        ]:
+            lines += space_boundaries_.lines()  # type: ignore
+        return lines
 
     @field_validator("name")
     @classmethod
@@ -86,6 +173,7 @@ class Building(BaseModelConfig):
         ifc_file = ifcopenshell.open(str(ifc_file_path))
         tree = initialize_tree(ifc_file)
         spaces = get_spaces(ifc_file)
+        constructions = Constructions.from_ifc(ifc_file)
         if selected_spaces_global_id:
             spaces = [
                 space for space in spaces if space.GlobalId in selected_spaces_global_id
@@ -100,6 +188,7 @@ class Building(BaseModelConfig):
             ifc_file=ifc_file,
             parent_folder=ifc_file_path.parent,
             name=ifc_file_path.stem,
+            constructions=constructions,
         )
 
     @model_validator(mode="after")
@@ -108,58 +197,21 @@ class Building(BaseModelConfig):
         return self
 
     def get_adjacency(self) -> InternalElements:
-        elements = []
-        for space_boundaries_ in self.space_boundaries:
-            for space_boundaries__ in self.space_boundaries:
-                space_1 = space_boundaries_.space
-                space_2 = space_boundaries__.space
-                if space_1.global_id == space_2.global_id:
-                    continue
-                common_surface = space_1.bounding_box.intersect_faces(
-                    space_2.bounding_box
-                )
-                for boundary in space_boundaries_.boundaries:
-                    for boundary_ in space_boundaries__.boundaries:
-                        if (
-                            boundary.entity.GlobalId == boundary_.entity.GlobalId
-                            and boundary.common_surface
-                            and boundary_.common_surface
-                            and common_surface
-                            and (
-                                boundary.common_surface.orientation
-                                * common_surface.orientation
-                            ).is_a_zero()
-                            and (
-                                boundary_.common_surface.orientation
-                                * common_surface.orientation
-                            ).is_a_zero()
-                        ) and boundary.common_surface.orientation.dot(
-                            boundary_.common_surface.orientation
-                        ) < 0:
-                            elements.append(  # noqa: PERF401
-                                IfcInternalElement(
-                                    spaces=[space_1, space_2],
-                                    element=boundary_.entity,
-                                    area=min(
-                                        common_surface.area,
-                                        boundary.common_surface.area,
-                                        boundary_.common_surface.area,
-                                    ),
-                                )
-                            )
-        return InternalElements(elements=list(set(elements)))
+        return get_internal_elements(self.space_boundaries)
 
     @validate_call
     def create_model(
         self,
         library: Libraries = "Buildings",
         north_axis: Optional[Vector] = None,
-    ) -> str:
+    ) -> Network:
         north_axis = north_axis or Vector(x=0, y=1, z=0)
         network = Network(name=self.name, library=Library.from_configuration(library))
         spaces = {
             space_boundary.space.global_id: space_boundary.model(
-                self.internal_elements.internal_element_ids(), north_axis
+                self.internal_elements.internal_element_ids(),
+                north_axis,
+                self.constructions,
             )
             for space_boundary in self.space_boundaries
         }
@@ -173,13 +225,13 @@ class Building(BaseModelConfig):
                 spaces[space_2.global_id],
                 InternalElement(
                     azimuth=10,
-                    construction=construction,
+                    construction=default_construction,
                     surface=internal_element.area,
                     tilt=Tilt.wall,
                 ),
             )
-        return network.model()  # type: ignore
+        return network
 
     def save_model(self, library: Libraries = "Buildings") -> None:
         model_ = self.create_model(library)
-        Path(self.parent_folder.joinpath(f"{self.name}.mo")).write_text(model_)
+        Path(self.parent_folder.joinpath(f"{self.name}.mo")).write_text(model_.model())

ifctrano/construction.py

@@ -0,0 +1,227 @@
+import logging
+from typing import List, Optional
+
+from ifcopenshell import file, entity_instance
+
+from pydantic import BaseModel
+from trano.elements.construction import (  # type: ignore
+    Material,
+    Layer,
+    Construction,
+    GlassMaterial,
+    Gas,
+    Glass,
+    GlassLayer,
+    GasLayer,
+)
+from ifctrano.utils import remove_non_alphanumeric, generate_alphanumeric_uuid
+
+logger = logging.getLogger(__name__)
+
+
+DEFAULT_MATERIAL = {
+    "thermal_conductivity": 0.046,
+    "specific_heat_capacity": 940,
+    "density": 80,
+}
+
+
+material_1 = Material(
+    name="material_1",
+    thermal_conductivity=0.046,
+    specific_heat_capacity=940,
+    density=80,
+)
+default_construction = Construction(
+    name="default_construction",
+    layers=[
+        Layer(material=material_1, thickness=0.18),
+    ],
+)
+id_100 = GlassMaterial(
+    name="id_100",
+    thermal_conductivity=1,
+    density=2500,
+    specific_heat_capacity=840,
+    solar_transmittance=[0.646],
+    solar_reflectance_outside_facing=[0.062],
+    solar_reflectance_room_facing=[0.063],
+    infrared_transmissivity=0,
+    infrared_absorptivity_outside_facing=0.84,
+    infrared_absorptivity_room_facing=0.84,
+)
+air = Gas(
+    name="Air",
+    thermal_conductivity=0.025,
+    density=1.2,
+    specific_heat_capacity=1005,
+)
+glass = Glass(
+    name="double_glazing",
+    u_value_frame=1.4,
+    layers=[
+        GlassLayer(thickness=0.003, material=id_100),
+        GasLayer(thickness=0.0127, material=air),
+        GlassLayer(thickness=0.003, material=id_100),
+    ],
+)
+
+
+class MaterialId(Material):  # type: ignore
+    id: int
+
+    def to_material(self) -> Material:
+        return Material.model_validate(self.model_dump(exclude={"id"}))
+
+
+class LayerId(Layer):  # type: ignore
+    id: int
+
+    def to_layer(self) -> Layer:
+        return Layer.model_validate(self.model_dump(exclude={"id"}))
+
+
+class ConstructionId(Construction):  # type: ignore
+    id: int
+
+    def to_construction(self) -> Construction:
+        return Construction.model_validate(self.model_dump(exclude={"id"}))
+
+
+class Materials(BaseModel):
+    materials: List[MaterialId]
+
+    @classmethod
+    def from_ifc(cls, ifc_file: file) -> "Materials":
+        materials = ifc_file.by_type("IfcMaterial")
+        return cls.from_ifc_materials(materials)
+
+    @classmethod
+    def from_ifc_materials(cls, ifc_materials: List[entity_instance]) -> "Materials":
+        materials = []
+        for material in ifc_materials:
+            material_name = remove_non_alphanumeric(material.Name)
+            materials.append(
+                MaterialId.model_validate(
+                    {"name": material_name, "id": material.id(), **DEFAULT_MATERIAL}
+                )
+            )
+        return cls(materials=materials)
+
+    def get_material(self, id: int) -> Material:
+        for material in self.materials:
+            if material.id == id:
+                return material.to_material()
+        raise ValueError(f"Material {id} not found in materials list.")
+
+
+def _get_unit_factor(ifc_file: file) -> float:
+    length_unit = next(
+        unit for unit in ifc_file.by_type("IfcSiUnit") if unit.UnitType == "LENGTHUNIT"
+    )
+    if length_unit.Prefix == "MILLI" and length_unit.Name == "METRE":
+        return 0.001
+    return 1
+
+
+class Layers(BaseModel):
+    layers: List[LayerId]
+
+    @classmethod
+    def from_ifc(cls, ifc_file: file, materials: Materials) -> "Layers":
+        material_layers = ifc_file.by_type("IfcMaterialLayer")
+        unit_factor = _get_unit_factor(ifc_file)
+        return cls.from_ifc_material_layers(
+            material_layers, materials, unit_factor=unit_factor
+        )
+
+    @classmethod
+    def from_ifc_material_layers(
+        cls,
+        ifc_material_layers: List[entity_instance],
+        materials: Materials,
+        unit_factor: float = 1,
+    ) -> "Layers":
+        layers = []
+        for layer in ifc_material_layers:
+            thickness = layer.LayerThickness * unit_factor
+            layers.append(
+                LayerId(
+                    id=layer.id(),
+                    thickness=thickness,
+                    material=materials.get_material(layer.Material.id()),
+                )
+            )
+        return cls(layers=layers)
+
+    def from_ids(self, ids: List[int]) -> List[Layer]:
+        return [layer.to_layer() for layer in self.layers if layer.id in ids]
+
+
+class Constructions(BaseModel):
+    constructions: List[ConstructionId]
+
+    @classmethod
+    def from_ifc(cls, ifc_file: file) -> "Constructions":
+        materials = Materials.from_ifc(ifc_file)
+        layers = Layers.from_ifc(ifc_file, materials)
+        material_layers_sets = ifc_file.by_type("IfcMaterialLayerSet")
+        return cls.from_ifc_material_layer_sets(material_layers_sets, layers)
+
+    @classmethod
+    def from_ifc_material_layer_sets(
+        cls, ifc_material_layer_sets: List[entity_instance], layers: Layers
+    ) -> "Constructions":
+        constructions = []
+        for layer_set in ifc_material_layer_sets:
+            name_ = layer_set.LayerSetName or generate_alphanumeric_uuid()
+            name = remove_non_alphanumeric(name_)
+            layer_ids = [
+                int(material_layer.id()) for material_layer in layer_set.MaterialLayers
+            ]
+            constructions.append(
+                ConstructionId(
+                    id=layer_set.id(), name=name, layers=layers.from_ids(layer_ids)
+                )
+            )
+        return cls(constructions=constructions)
+
+    def get_construction(self, entity: entity_instance) -> Construction:
+        construction_id = self._get_construction_id(entity)
+        if construction_id is None:
+            logger.error(
+                f"Construction ID not found for {entity.GlobalId} ({entity.is_a()}) "
+                f"({entity.Name}). Using default construction."
+            )
+            return default_construction
+        constructions = [
+            construction.to_construction()
+            for construction in self.constructions
+            if construction.id == construction_id
+        ]
+        if not constructions:
+            raise ValueError(f"No construction found for {entity.GlobalId}")
+        return constructions[0]
+
+    def _get_construction_id(self, entity: entity_instance) -> Optional[int]:
+        associates_materials = [
+            association
+            for association in entity.HasAssociations
+            if association.is_a() == "IfcRelAssociatesMaterial"
+        ]
+        if not associates_materials:
+            logger.error(f"Associate materials not found for {entity.GlobalId}.")
+            return None
+        relating_material = associates_materials[0].RelatingMaterial
+        if relating_material.is_a() == "IfcMaterialList":
+            logger.error(
+                f"Material list found for {entity.GlobalId}, but no construction ID available."
+            )
+            return None
+        elif relating_material.is_a() == "IfcMaterialLayerSetUsage":
+            return int(associates_materials[0].RelatingMaterial.ForLayerSet.id())
+        elif relating_material.is_a() == "IfcMaterialLayerSet":
+            return int(relating_material.id())
+        else:
+            logger.error("Unexpected material type found.")
+            return None