ifctrano 0.7.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ifctrano
-Version: 0.7.0
+Version: 0.8.0
 Summary: Package for generating building energy simulation model from IFC
 License: GPL V3
 License-File: LICENSE

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

@@ -1,9 +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
@@ -23,7 +24,11 @@ from ifctrano.space_boundary import (
     initialize_tree,
     Space,
 )
-from ifctrano.construction import Constructions, default_construction
+from ifctrano.construction import (
+    Constructions,
+    default_construction,
+    default_internal_construction,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -215,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.7.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.7.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.7.0 → ifctrano-0.8.0}/ifctrano/space_boundary.py

@@ -1,5 +1,7 @@
+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
@@ -34,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()
@@ -89,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]
@@ -147,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]
@@ -278,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],

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ifctrano"
-version = "0.7.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"
@@ -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"