ifctrano 0.4.0__tar.gz → 0.8.0__tar.gz

{ifctrano-0.4.0 → ifctrano-0.8.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: ifctrano
-Version: 0.4.0
+Version: 0.8.0
 Summary: Package for generating building energy simulation model from IFC
 License: GPL V3
+License-File: LICENSE
 Keywords: BIM,IFC,energy simulation,modelica,building energy simulation,buildings,ideas
 Author: Ando Andriamamonjy
 Author-email: andoludovic.andriamamonjy@gmail.com
@@ -15,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: ifcopenshell (>=0.8.1.post1,<0.9.0)
 Requires-Dist: open3d (>=0.19.0,<0.20.0)
 Requires-Dist: shapely (>=2.0.7,<3.0.0)
-Requires-Dist: trano (>=0.6.0,<0.7.0)
+Requires-Dist: trano (>=0.10.0,<0.11.0)
 Requires-Dist: typer (>=0.12.5,<0.13.0)
 Requires-Dist: vedo (>=2025.5.3,<2026.0.0)
 Project-URL: Repository, https://github.com/andoludo/ifctrano

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/base.py

@@ -398,6 +398,7 @@ class CommonSurface(BaseShow):
     main_vertices: FaceVertices
     common_vertices: FaceVertices
     exterior: bool = True
+    polygon: str
 
     def __hash__(self) -> int:
         return hash(

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/bounding_box.py

@@ -78,6 +78,7 @@ class ExtendCommonSurface(CommonSurface):
             orientation=self.orientation,
             main_vertices=self.main_vertices,
             common_vertices=self.common_vertices,
+            polygon=self.polygon,
         )
 
 
@@ -137,6 +138,7 @@ class OrientedBoundingBox(BaseShow):
                                 common_vertices=projected_face_1.common_vertices(
                                     intersection
                                 ),
+                                polygon=intersection.wkt,
                             )
                         )
 

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/building.py

@@ -1,8 +1,10 @@
+import logging
 import re
 from pathlib import Path
-from typing import List, Tuple, Any, Optional, Set
+from typing import List, Tuple, Any, Optional, Set, Dict
 
 import ifcopenshell
+import yaml
 from ifcopenshell import file, entity_instance
 from pydantic import validate_call, Field, model_validator, field_validator
 from trano.elements import InternalElement  # type: ignore
@@ -12,13 +14,23 @@ from trano.topology import Network  # type: ignore
 from vedo import Line  # type: ignore
 
 from ifctrano.base import BaseModelConfig, Libraries, Vector, BaseShow, CommonSurface
-from ifctrano.exceptions import IfcFileNotFoundError, NoIfcSpaceFoundError
+from ifctrano.exceptions import (
+    IfcFileNotFoundError,
+    NoIfcSpaceFoundError,
+    NoSpaceBoundariesError,
+)
 from ifctrano.space_boundary import (
     SpaceBoundaries,
     initialize_tree,
     Space,
 )
-from ifctrano.construction import Constructions, default_construction
+from ifctrano.construction import (
+    Constructions,
+    default_construction,
+    default_internal_construction,
+)
+
+logger = logging.getLogger(__name__)
 
 
 def get_spaces(ifcopenshell_file: file) -> List[entity_instance]:
@@ -180,9 +192,18 @@ class Building(BaseShow):
             ]
         if not spaces:
             raise NoIfcSpaceFoundError("No IfcSpace found in the file.")
-        space_boundaries = [
-            SpaceBoundaries.from_space_entity(ifc_file, tree, space) for space in spaces
-        ]
+        space_boundaries = []
+        for space in spaces:
+            try:
+                space_boundaries.append(
+                    SpaceBoundaries.from_space_entity(ifc_file, tree, space)
+                )
+            except Exception as e:  # noqa: PERF203
+                logger.error(f"Cannot process space {space.id()}. Reason {e}")
+                continue
+        if not space_boundaries:
+            raise NoSpaceBoundariesError("No valid space boundaries found.")
+
         return cls(
             space_boundaries=space_boundaries,
             ifc_file=ifc_file,
@@ -199,6 +220,71 @@ class Building(BaseShow):
     def get_adjacency(self) -> InternalElements:
         return get_internal_elements(self.space_boundaries)
 
+    @validate_call
+    def to_config(
+        self,
+        north_axis: Optional[Vector] = None,
+    ) -> Dict[str, Any]:
+        north_axis = north_axis or Vector(x=0, y=1, z=0)
+        spaces = [
+            space_boundary.to_config(
+                self.internal_elements.internal_element_ids(),
+                north_axis,
+                self.constructions,
+            )
+            for space_boundary in self.space_boundaries
+        ]
+        internal_walls = []
+        for internal_element in self.internal_elements.elements:
+            space_1 = internal_element.spaces[0]
+            space_2 = internal_element.spaces[1]
+            construction = self.constructions.get_construction(
+                internal_element.element, default_internal_construction
+            )
+            if internal_element.element.is_a() in ["IfcSlab"]:
+                space_1_tilt = (
+                    Tilt.floor.value
+                    if space_1.bounding_box.centroid.z > space_2.bounding_box.centroid.z
+                    else Tilt.ceiling.value
+                )
+                space_2_tilt = (
+                    Tilt.floor.value
+                    if space_2.bounding_box.centroid.z > space_1.bounding_box.centroid.z
+                    else Tilt.ceiling.value
+                )
+                if space_1_tilt == space_2_tilt:
+                    raise ValueError("Space tilts are not compatible.")
+                internal_walls.append(
+                    {
+                        "space_1": space_1.space_unique_name(),
+                        "space_2": space_2.space_unique_name(),
+                        "construction": construction.name,
+                        "surface": internal_element.area,
+                        "space_1_tilt": space_1_tilt,
+                        "space_2_tilt": space_2_tilt,
+                    }
+                )
+            else:
+                internal_walls.append(
+                    {
+                        "space_1": space_1.space_unique_name(),
+                        "space_2": space_2.space_unique_name(),
+                        "construction": construction.name,
+                        "surface": internal_element.area,
+                    }
+                )
+        construction_config = self.constructions.to_config()
+        return construction_config | {
+            "spaces": spaces,
+            "internal_walls": internal_walls,
+        }
+
+    @validate_call
+    def to_yaml(self, yaml_path: Path, north_axis: Optional[Vector] = None) -> None:
+        config = self.to_config(north_axis=north_axis)
+        yaml_data = yaml.dump(config)
+        yaml_path.write_text(yaml_data)
+
     @validate_call
     def create_network(
         self,

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/construction.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 from ifcopenshell import file, entity_instance
 
@@ -38,6 +38,12 @@ default_construction = Construction(
         Layer(material=material_1, thickness=0.18),
     ],
 )
+default_internal_construction = Construction(
+    name="default_internal_construction",
+    layers=[
+        Layer(material=material_1, thickness=0.18),
+    ],
+)
 id_100 = GlassMaterial(
     name="id_100",
     thermal_conductivity=1,
@@ -186,14 +192,16 @@ class Constructions(BaseModel):
             )
         return cls(constructions=constructions)
 
-    def get_construction(self, entity: entity_instance) -> Construction:
+    def get_construction(
+        self, entity: entity_instance, default: Optional[Construction] = None
+    ) -> Construction:
         construction_id = self._get_construction_id(entity)
         if construction_id is None:
             logger.warning(
                 f"Construction ID not found for {entity.GlobalId} ({entity.is_a()}). "
                 f"Using default construction."
             )
-            return default_construction
+            return default or default_construction
         constructions = [
             construction.to_construction()
             for construction in self.constructions
@@ -225,3 +233,79 @@ class Constructions(BaseModel):
         else:
             logger.error("Unexpected material type found.")
             return None
+
+    def to_config(self) -> Dict[str, Any]:
+        constructions_all = [*self.constructions, default_construction, glass]
+        constructions = [
+            {
+                "id": construction.name,
+                "layers": [
+                    {"material": layer.material.name, "thickness": layer.thickness}
+                    for layer in construction.layers
+                ],
+            }
+            for construction in constructions_all
+            if isinstance(construction, Construction)
+        ]
+        glazings = [
+            {
+                "id": construction.name,
+                "layers": [
+                    {
+                        (
+                            "glass" if isinstance(layer, GlassLayer) else "gas"
+                        ): layer.material.name,
+                        "thickness": layer.thickness,
+                    }
+                    for layer in construction.layers
+                ],
+            }
+            for construction in constructions_all
+            if isinstance(construction, Glass)
+        ]
+        materials = {
+            layer.material
+            for construction in constructions_all
+            for layer in construction.layers
+            if type(layer.material) is Material
+        }
+        gas = {
+            layer.material
+            for construction in constructions_all
+            for layer in construction.layers
+            if type(layer.material) is Gas
+        }
+        glass_ = {
+            layer.material
+            for construction in constructions_all
+            for layer in construction.layers
+            if type(layer.material) is GlassMaterial
+        }
+
+        materials_ = [
+            (material.model_dump(exclude={"name"}) | {"id": material.name})
+            for material in materials
+        ]
+        gas_ = [
+            (material.model_dump(exclude={"name"}) | {"id": material.name})
+            for material in gas
+        ]
+        glass_material = [
+            (_convert_glass(material) | {"id": material.name}) for material in glass_
+        ]
+        return {
+            "constructions": constructions,
+            "material": materials_,
+            "glazings": glazings,
+            "gas": gas_,
+            "glass_material": glass_material,
+        }
+
+
+def _convert_glass(glass_: Material) -> Dict[str, Any]:
+    return {
+        key: (
+            value if not isinstance(value, list) else f"{{{','.join(map(str, value))}}}"
+        )
+        for key, value in glass_.model_dump().items()
+    }

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/exceptions.py

@@ -18,6 +18,10 @@ class NoIfcSpaceFoundError(Exception):
     pass
 
 
+class NoSpaceBoundariesError(Exception):
+    pass
+
+
 class InvalidLibraryError(Exception):
     pass
 

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/main.py

@@ -22,6 +22,38 @@ CHECKMARK = "[green]✔[/green]"
 CROSS_MARK = "[red]✘[/red]"
 
 
+@app.command()
+def config(
+    model: Annotated[
+        str,
+        typer.Argument(help="Local path to the ifc file."),
+    ],
+    show_space_boundaries: Annotated[
+        bool,
+        typer.Option(help="Show computed space boundaries."),
+    ] = False,
+) -> None:
+    working_directory = Path.cwd()
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        modelica_model_path = Path(model).resolve().with_suffix(".mo")
+        config_path = working_directory.joinpath(f"{modelica_model_path.stem}.yaml")
+        task = progress.add_task(
+            description=f"Generating {config_path} configuration file.",
+            total=None,
+        )
+        building = Building.from_ifc(Path(model))
+        if show_space_boundaries:
+            print(f"{CHECKMARK} Showing space boundaries.")
+            building.show()
+        building.to_yaml(config_path)
+        progress.remove_task(task)
+        print(f"{CHECKMARK} configuration file generated: {config_path}.")
+
+
 @app.command()
 def create(
     model: Annotated[

{ifctrano-0.4.0 → ifctrano-0.8.0}/ifctrano/space_boundary.py

@@ -1,11 +1,14 @@
+import logging
+import math
 import multiprocessing
-from typing import Optional, List, Tuple, Any, Annotated
+from typing import Optional, List, Tuple, Any, Annotated, Dict
 
 import ifcopenshell
 import ifcopenshell.geom
 import ifcopenshell.util.shape
 from ifcopenshell import entity_instance, file
-from pydantic import Field, BeforeValidator, BaseModel
+from pydantic import Field, BeforeValidator, BaseModel, ConfigDict
+from shapely import wkt  # type: ignore
 from trano.data_models.conversion import SpaceParameter  # type: ignore
 from trano.elements import Space as TranoSpace, ExternalWall, Window, BaseWall, ExternalDoor  # type: ignore
 from trano.elements.system import Occupancy  # type: ignore
@@ -33,6 +36,8 @@ from ifctrano.utils import (
 
 ROOF_VECTOR = Vector(x=0, y=0, z=1)
 
+logger = logging.getLogger(__name__)
+
 
 def initialize_tree(ifc_file: file) -> ifcopenshell.geom.tree:
     tree = ifcopenshell.geom.tree()
@@ -88,6 +93,14 @@ class Space(GlobalId):
         main_name = f"{remove_non_alphanumeric(self.name)}_" if self.name else ""
         return f"space_{main_name}{remove_non_alphanumeric(self.entity.GlobalId)}"
 
+    def space_unique_name(self) -> str:
+        base_name = remove_non_alphanumeric(self.name) if self.name else ""
+        main_name = f"{base_name}_" if base_name else ""
+        space_name = f"{main_name}{remove_non_alphanumeric(self.entity.GlobalId)[-3:]}"
+        if "space" not in space_name:
+            return f"space_{space_name}"
+        return space_name
+
 
 class ExternalSpaceBoundaryGroup(BaseModelConfig):
     constructions: List[BaseWall]
@@ -146,6 +159,10 @@ class ExternalSpaceBoundaryGroups(BaseModelConfig):
         )
 
 
+def deg_to_rad(deg: float) -> float:
+    return deg * math.pi / 180.0
+
+
 class Azimuths(BaseModel):
     north: List[float] = [0.0, 360]
     east: List[float] = [90.0]
@@ -277,6 +294,63 @@ class SpaceBoundaries(BaseShow):
             if space_boundary in self.boundaries:
                 self.boundaries.remove(space_boundary)
 
+    def to_config(
+        self,
+        exclude_entities: List[str],
+        north_axis: Vector,
+        constructions: Constructions,
+    ) -> Dict[str, Any]:
+        external_boundaries: Dict[str, Any] = {
+            "external_walls": [],
+            "floor_on_grounds": [],
+            "windows": [],
+        }
+        external_boundaries_check = []
+        for boundary in self.boundaries:
+            boundary_model = boundary.model_element(
+                exclude_entities, north_axis, constructions
+            )
+            if boundary_model:
+                external_boundaries_check.append(boundary_model)
+                element = {
+                    "surface": boundary_model.surface,
+                    "azimuth": deg_to_rad(boundary_model.azimuth),
+                    "tilt": boundary_model.tilt.value,
+                    "construction": boundary_model.construction.name,
+                }
+                if isinstance(
+                    boundary_model, (ExternalWall, ExternalDoor)
+                ) and boundary_model.tilt in [Tilt.wall, Tilt.ceiling]:
+                    external_boundaries["external_walls"].append(element)
+                elif isinstance(boundary_model, (Window)):
+                    external_boundaries["windows"].append(element)
+                elif isinstance(
+                    boundary_model, (ExternalWall)
+                ) and boundary_model.tilt in [Tilt.floor]:
+                    external_boundaries["floor_on_grounds"].append(element)
+                else:
+                    raise ValueError("Unknown boundary type")
+        external_space_boundaries_group = (
+            ExternalSpaceBoundaryGroups.from_external_boundaries(
+                external_boundaries_check
+            )
+        )
+        if not external_space_boundaries_group.has_windows_without_wall():
+            logger.error(
+                f"Space {self.space.global_id} has a boundary that has a windows but without walls."
+            )
+        occupancy_parameters = Occupancy().parameters.model_dump(mode="json")
+        space_parameters = SpaceParameter(
+            floor_area=self.space.floor_area,
+            average_room_height=self.space.average_room_height,
+        ).model_dump(mode="json")
+        return {
+            "id": self.space.space_unique_name(),
+            "occupancy": {"parameters": occupancy_parameters},
+            "parameters": space_parameters,
+            "external_boundaries": external_boundaries,
+        }
+
     def model(
         self,
         exclude_entities: List[str],
@@ -340,4 +414,109 @@ class SpaceBoundaries(BaseShow):
             )
             if space_boundary:
                 space_boundaries.append(space_boundary)
-        return cls(space=space_, boundaries=space_boundaries)
+        merged_boundaries = MergedSpaceBoundaries.from_boundaries(space_boundaries)
+        space_boundaries_ = merged_boundaries.merge_boundaries_from_part()
+        space_boundaries__ = remove_duplicate_boundaries(space_boundaries_)
+        return cls(space=space_, boundaries=space_boundaries__)
+
+
+def remove_duplicate_boundaries(
+    boundaries: List[SpaceBoundary],
+) -> List[SpaceBoundary]:
+    types = ["IfcRoof", "IfcSlab"]
+    boundaries = sorted(boundaries, key=lambda b: b.entity.GlobalId)
+    boundaries_without_types = [
+        sp for sp in boundaries if sp.entity.is_a() not in types
+    ]
+    new_boundaries = []
+    for type_ in types:
+        references = [sp for sp in boundaries if sp.entity.is_a() == type_]
+        while True:
+            reference = next(iter(references), None)
+            if not reference:
+                break
+            others = [p_ for p_ in references if p_ != reference]
+            intersecting = [
+                o
+                for o in others
+                if (
+                    wkt.loads(o.common_surface.polygon).intersects(
+                        wkt.loads(reference.common_surface.polygon)
+                    )
+                    and o.common_surface.orientation
+                    == reference.common_surface.orientation
+                )
+                and (
+                    wkt.loads(o.common_surface.polygon).intersection(
+                        wkt.loads(reference.common_surface.polygon)
+                    )
+                ).area
+                > 0
+            ]
+            current_group = sorted(
+                [*intersecting, reference], key=lambda p: p.entity.GlobalId
+            )
+            new_boundaries.append(next(iter(current_group)))
+            references = [p_ for p_ in references if p_ not in current_group]
+    return [*boundaries_without_types, *new_boundaries]
+
+
+class MergedSpaceBoundary(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    parent: entity_instance
+    related_boundaries: List[SpaceBoundary]
+
+    def get_new_boundary(self) -> Optional[SpaceBoundary]:
+        related_boundaries = sorted(
+            self.related_boundaries, key=lambda b: b.entity.GlobalId
+        )
+        boundary = next(iter(related_boundaries), None)
+        if boundary:
+            return SpaceBoundary.model_validate(
+                boundary.model_dump() | {"entity": self.parent}
+            )
+        return None
+
+
+class MergedSpaceBoundaries(BaseModel):
+    part_boundaries: List[MergedSpaceBoundary]
+    original_boundaries: List[SpaceBoundary]
+
+    @classmethod
+    def from_boundaries(
+        cls, space_boundaries: List[SpaceBoundary]
+    ) -> "MergedSpaceBoundaries":
+        building_element_part_boundaries = [
+            boundary
+            for boundary in space_boundaries
+            if boundary.entity.is_a() in ["IfcBuildingElementPart"]
+        ]
+        existing_parent_entities = {
+            decompose.RelatingObject
+            for b in building_element_part_boundaries
+            for decompose in b.entity.Decomposes
+        }
+        part_boundaries = [
+            MergedSpaceBoundary(
+                parent=parent,
+                related_boundaries=[
+                    b
+                    for b in building_element_part_boundaries
+                    for decompose in b.entity.Decomposes
+                    if decompose.RelatingObject == parent
+                ],
+            )
+            for parent in existing_parent_entities
+        ]
+        return cls(
+            part_boundaries=part_boundaries, original_boundaries=space_boundaries
+        )
+
+    def merge_boundaries_from_part(self) -> List[SpaceBoundary]:
+        new_boundaries = [b.get_new_boundary() for b in self.part_boundaries]
+        new_boundaries_ = [nb for nb in new_boundaries if nb is not None]
+        return [
+            b
+            for b in self.original_boundaries
+            if b.entity.is_a() not in ["IfcBuildingElementPart"]
+        ] + new_boundaries_

ifctrano-0.8.0/ifctrano/types.py

@@ -0,0 +1,11 @@
+from typing import Literal
+
+BuildingElements = Literal[
+    "IfcWall",
+    "IfcSlab",
+    "IfcRoof",
+    "IfcDoor",
+    "IfcWindow",
+    "IfcPlate",
+    "IfcBuildingElementPart",
+]

{ifctrano-0.4.0 → ifctrano-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ifctrano"
-version = "0.4.0"
+version = "0.8.0"
 description = "Package for generating building energy simulation model from IFC"
 authors = ["Ando Andriamamonjy <andoludovic.andriamamonjy@gmail.com>"]
 license = "GPL V3"
@@ -11,7 +11,7 @@ keywords = ["BIM","IFC","energy simulation", "modelica", "building energy simula
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
 ifcopenshell = "^0.8.1.post1"
-trano = "^0.6.0"
+trano = "^0.10.0"
 shapely = "^2.0.7"
 typer = "^0.12.5"
 vedo = "^2025.5.3"
@@ -33,6 +33,7 @@ isort = "^5.13.2"
 jsf = "^0.11.2"
 black = "^24.10.0"
 pytest = "^7.4.3"
+deepdiff = "^8.6.1"
 
 [tool.poetry.scripts]
 ifctrano = "ifctrano.main:app"

ifctrano-0.4.0/ifctrano/types.py

@@ -1,5 +0,0 @@
-from typing import Literal
-
-BuildingElements = Literal[
-    "IfcWall", "IfcSlab", "IfcRoof", "IfcDoor", "IfcWindow", "IfcPlate"
-]