ifctrano 0.1.1__py3-none-any.whl

ifctrano/base.py

@@ -0,0 +1,163 @@
+from typing import Tuple, Literal, List, Annotated, Sequence
+
+import ifcopenshell.geom
+import numpy as np
+from numpy import ndarray
+from pydantic import BaseModel, BeforeValidator, ConfigDict
+
+settings = ifcopenshell.geom.settings()  # type: ignore
+Coordinate = Literal["x", "y", "z"]
+AREA_TOLERANCE = 0.5
+
+
+class BaseModelConfig(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+def round_two_decimals(value: float) -> float:
+    return round(value, 10)
+
+
+class BasePoint(BaseModel):
+    x: Annotated[float, BeforeValidator(round_two_decimals)]
+    y: Annotated[float, BeforeValidator(round_two_decimals)]
+    z: Annotated[float, BeforeValidator(round_two_decimals)]
+
+    @classmethod
+    def from_coordinate(cls, point: Tuple[float, float, float]) -> "BasePoint":
+        return cls(x=point[0], y=point[1], z=point[2])
+
+    def to_array(self) -> np.ndarray:  # type: ignore
+        return np.array([self.x, self.y, self.z])
+
+    def to_list(self) -> List[float]:
+        return [self.x, self.y, self.z]
+
+    def to_tuple(self) -> Tuple[float, float, float]:
+        return (self.x, self.y, self.z)
+
+    @classmethod
+    def from_array(cls, array: np.ndarray) -> "BasePoint":  # type: ignore
+        try:
+            return cls(x=array[0], y=array[1], z=array[2])
+        except IndexError as e:
+            raise ValueError("Array must have three components") from e
+
+    def __eq__(self, other: "BasePoint") -> bool:  # type: ignore
+        return all([self.x == other.x, self.y == other.y, self.z == other.z])
+
+
+Signs = Literal[-1, 1]
+
+
+class Sign(BaseModel):
+    x: Signs = 1
+    y: Signs = 1
+    z: Signs = 1
+
+    def __hash__(self) -> int:
+        return hash((self.x, self.y, self.z))
+
+
+class Vector(BasePoint):
+    def __mul__(self, other: "Vector") -> "Vector":
+
+        array = np.cross(self.to_array(), other.to_array())
+        return Vector(x=array[0], y=array[1], z=array[2])
+
+    def dot(self, other: "Vector") -> float:
+        return np.dot(self.to_array(), other.to_array())  # type: ignore
+
+    def project(self, other: "Vector") -> "Vector":
+        a = self.dot(other) / other.dot(other)
+        return Vector(x=a * other.x, y=a * other.y, z=a * other.z)
+
+    def norm(self) -> "Vector":
+        normalized_vector = self.to_array() / np.linalg.norm(self.to_array())
+        return Vector(
+            x=normalized_vector[0], y=normalized_vector[1], z=normalized_vector[2]
+        )
+
+    def to_array(self) -> np.ndarray:  # type: ignore
+        return np.array([self.x, self.y, self.z])
+
+    def get_normal_index(self) -> int:
+        normal_index_list = [abs(v) for v in self.to_list()]
+        return normal_index_list.index(max(normal_index_list))
+
+    def is_a_zero(self) -> bool:
+        return all(abs(value) < 0.1 for value in self.to_list())
+
+    @classmethod
+    def from_array(cls, array: np.ndarray) -> "Vector":  # type: ignore
+        return cls.model_validate(super().from_array(array).model_dump())
+
+
+class Point(BasePoint):
+    def __sub__(self, other: "Point") -> Vector:
+
+        return Vector(x=self.x - other.x, y=self.y - other.y, z=self.z - other.z)
+
+    def __add__(self, other: "Point") -> "Point":
+        return Point(x=self.x + other.x, y=self.y + other.y, z=self.z + other.z)
+
+    def s(self, signs: Sign) -> "Point":
+        return Point(x=self.x * signs.x, y=self.y * signs.y, z=self.z * signs.z)
+
+
+class P(Point):
+    pass
+
+
+class GlobalId(BaseModelConfig):
+    global_id: str
+
+
+class CoordinateSystem(BaseModel):
+    x: Vector
+    y: Vector
+    z: Vector
+
+    @classmethod
+    def from_array(cls, array: np.ndarray) -> "CoordinateSystem":  # type: ignore
+        return cls(
+            x=Vector.from_array(array[0]),
+            y=Vector.from_array(array[1]),
+            z=Vector.from_array(array[2]),
+        )
+
+    def to_array(self) -> np.ndarray:  # type: ignore
+        return np.array([self.x.to_array(), self.y.to_array(), self.z.to_array()])
+
+    def project(self, array: np.array) -> np.array:  # type: ignore
+        return np.dot(array, self.to_array())  # type: ignore
+
+    def inverse(self, array: np.array) -> np.ndarray:  # type: ignore
+        return np.dot(array, np.linalg.inv(self.to_array()))  # type: ignore
+
+
+class Vertices(BaseModel):
+    points: List[Point]
+
+    @classmethod
+    def from_arrays(cls, arrays: Sequence[np.ndarray[np.float64]]) -> "Vertices":  # type: ignore
+        return cls(
+            points=[Point(x=array[0], y=array[1], z=array[2]) for array in arrays]
+        )
+
+    def to_array(self) -> ndarray:  # type: ignore
+        return np.array([point.to_array() for point in self.points])
+
+    def to_list(self) -> List[List[float]]:
+        return self.to_array().tolist()  # type: ignore
+
+
+class CommonSurface(BaseModel):
+    area: float
+    orientation: Vector
+
+    def description(self) -> Tuple[float, List[float]]:
+        return self.area, self.orientation.to_list()
+
+
+Libraries = Literal["IDEAS", "Buildings", "reduced_order", "iso_13790"]

ifctrano/bounding_box.py

@@ -0,0 +1,245 @@
+from logging import getLogger
+from typing import List, Optional, Any, Tuple
+
+import ifcopenshell
+import numpy as np
+from ifcopenshell import entity_instance
+import ifcopenshell.geom
+import ifcopenshell.util.shape
+from pydantic import (
+    BaseModel,
+    Field,
+)
+from shapely import Polygon  # type: ignore
+
+from ifctrano.base import (
+    Point,
+    Vector,
+    P,
+    Sign,
+    CoordinateSystem,
+    Vertices,
+    BaseModelConfig,
+    settings,
+    CommonSurface,
+    AREA_TOLERANCE,
+)
+from ifctrano.exceptions import BoundingBoxFaceError
+
+logger = getLogger(__name__)
+
+
+def get_normal(
+    centroid: Point,
+    difference: Point,
+    face_signs: List[Sign],
+    coordinate_system: CoordinateSystem,
+) -> Vector:
+    point_0 = centroid + difference.s(face_signs[0])
+    point_1 = centroid + difference.s(face_signs[1])
+    point_2 = centroid + difference.s(face_signs[2])
+    vector_1 = coordinate_system.project((point_1 - point_0).to_array())
+    vector_2 = coordinate_system.project((point_2 - point_0).to_array())
+    array = (
+        (Vector.from_array(vector_1) * Vector.from_array(vector_2)).norm().to_array()
+    )
+    return Vector.from_array(array)
+
+
+class Polygon2D(BaseModelConfig):
+    polygon: Polygon
+    normal: Vector
+    length: float
+
+
+class BoundingBoxFace(BaseModelConfig):
+    vertices: Vertices
+    normal: Vector
+    coordinate_system: CoordinateSystem
+
+    @classmethod
+    def build(
+        cls,
+        centroid: Point,
+        difference: Point,
+        face_signs: List[Sign],
+        coordinate_system: CoordinateSystem,
+    ) -> "BoundingBoxFace":
+        if len(face_signs) != len(set(face_signs)):
+            raise BoundingBoxFaceError("Face signs must be unique")
+        normal = get_normal(centroid, difference, face_signs, coordinate_system)
+        vertices_ = [(centroid + difference.s(s)).to_list() for s in face_signs]
+        vertices_ = [*vertices_, vertices_[0]]
+        vertices__ = [coordinate_system.project(v) for v in vertices_]
+        vertices = Vertices.from_arrays(vertices__)
+
+        return cls(
+            vertices=vertices, normal=normal, coordinate_system=coordinate_system
+        )
+
+    def get_2d_polygon(self, coordinate_system: CoordinateSystem) -> Polygon2D:
+        projected_vertices = coordinate_system.inverse(self.vertices.to_array())
+        projected_normal_index = Vector.from_array(
+            coordinate_system.inverse(self.normal.to_array())
+        ).get_normal_index()
+        polygon = Polygon(
+            [
+                [v_ for i, v_ in enumerate(v) if i != projected_normal_index]
+                for v in projected_vertices.tolist()
+            ]
+        )
+
+        return Polygon2D(
+            polygon=polygon,
+            normal=self.normal,
+            length=projected_vertices.tolist()[0][projected_normal_index],
+        )
+
+
+class BoundingBoxFaces(BaseModel):
+    faces: List[BoundingBoxFace]
+
+    def description(self) -> List[tuple[Any, Tuple[float, float, float]]]:
+        return sorted([(f.vertices.to_list(), f.normal.to_tuple()) for f in self.faces])
+
+    @classmethod
+    def build(
+        cls, centroid: Point, difference: Point, coordinate_system: CoordinateSystem
+    ) -> "BoundingBoxFaces":
+        face_signs = [
+            [Sign(x=-1, y=-1, z=-1), Sign(y=-1, z=-1), Sign(z=-1), Sign(x=-1, z=-1)],
+            [Sign(x=-1, y=-1), Sign(y=-1), Sign(), Sign(x=-1)],
+            [
+                Sign(x=-1, y=-1, z=-1),
+                Sign(x=-1, y=1, z=-1),
+                Sign(x=-1, y=1, z=1),
+                Sign(x=-1, y=-1, z=1),
+            ],
+            [
+                Sign(x=1, y=-1, z=-1),
+                Sign(x=1, y=1, z=-1),
+                Sign(x=1, y=1, z=1),
+                Sign(x=1, y=-1, z=1),
+            ],
+            [
+                Sign(x=-1, y=-1, z=-1),
+                Sign(x=1, y=-1, z=-1),
+                Sign(x=1, y=-1, z=1),
+                Sign(x=-1, y=-1, z=1),
+            ],
+            [
+                Sign(x=-1, y=1, z=-1),
+                Sign(x=1, y=1, z=-1),
+                Sign(x=1, y=1, z=1),
+                Sign(x=-1, y=1, z=1),
+            ],
+        ]
+        faces = [
+            BoundingBoxFace.build(centroid, difference, face_sign, coordinate_system)
+            for face_sign in face_signs
+        ]
+        return cls(faces=faces)
+
+
+class ExtendCommonSurface(CommonSurface):
+    distance: float
+
+    def to_common_surface(self) -> CommonSurface:
+        return CommonSurface(area=self.area, orientation=self.orientation)
+
+
+class OrientedBoundingBox(BaseModel):
+    faces: BoundingBoxFaces
+    centroid: Point
+    area_tolerance: float = Field(default=AREA_TOLERANCE)
+
+    def intersect_faces(self, other: "OrientedBoundingBox") -> Optional[CommonSurface]:
+        extend_surfaces = []
+        for face in self.faces.faces:
+
+            for other_face in other.faces.faces:
+                vector = face.normal * other_face.normal
+                if vector.is_a_zero():
+
+                    polygon_1 = other_face.get_2d_polygon(face.coordinate_system)
+                    polygon_2 = face.get_2d_polygon(face.coordinate_system)
+                    intersection = polygon_2.polygon.intersection(polygon_1.polygon)
+
+                    if intersection.area > self.area_tolerance:
+                        distance = abs(polygon_1.length - polygon_2.length)
+                        area = intersection.area
+                        direction_vector = (other.centroid - self.centroid).norm()
+                        orientation = direction_vector.project(face.normal).norm()
+                        extend_surfaces.append(
+                            ExtendCommonSurface(
+                                distance=distance, area=area, orientation=orientation
+                            )
+                        )
+        if extend_surfaces:
+            if not all(
+                e.orientation == extend_surfaces[0].orientation for e in extend_surfaces
+            ):
+                logger.warning("Different orientations found. taking the max area")
+                max_area = max([e.area for e in extend_surfaces])
+                extend_surfaces = [e for e in extend_surfaces if e.area == max_area]
+            extend_surface = sorted(
+                extend_surfaces, key=lambda x: x.distance, reverse=True
+            )[-1]
+            return extend_surface.to_common_surface()
+        return None
+
+    @classmethod
+    def from_vertices(
+        cls, vertices: np.ndarray[tuple[int, ...], np.dtype[np.float64]]
+    ) -> "OrientedBoundingBox":
+        vertices_np = np.array(vertices)
+        points = np.asarray(vertices_np)
+        cov = np.cov(points, y=None, rowvar=0, bias=1)  # type: ignore
+        v, vect = np.linalg.eig(cov)
+        tvect = np.transpose(vect)
+        points_r = np.dot(points, np.linalg.inv(tvect))
+
+        co_min = np.min(points_r, axis=0)
+        co_max = np.max(points_r, axis=0)
+
+        xmin, xmax = co_min[0], co_max[0]
+        ymin, ymax = co_min[1], co_max[1]
+        zmin, zmax = co_min[2], co_max[2]
+
+        xdif = (xmax - xmin) * 0.5
+        ydif = (ymax - ymin) * 0.5
+        zdif = (zmax - zmin) * 0.5
+
+        cx = xmin + xdif
+        cy = ymin + ydif
+        cz = zmin + zdif
+        corners = np.array(
+            [
+                [cx - xdif, cy - ydif, cz - zdif],
+                [cx - xdif, cy + ydif, cz - zdif],
+                [cx - xdif, cy + ydif, cz + zdif],
+                [cx - xdif, cy - ydif, cz + zdif],
+                [cx + xdif, cy + ydif, cz + zdif],
+                [cx + xdif, cy + ydif, cz - zdif],
+                [cx + xdif, cy - ydif, cz + zdif],
+                [cx + xdif, cy - ydif, cz - zdif],
+            ]
+        )
+        corners = np.dot(corners, tvect)
+        coordinate_system = CoordinateSystem.from_array(tvect)
+        c = P(x=cx, y=cy, z=cz)
+        d = P(x=xdif, y=ydif, z=zdif)
+        faces = BoundingBoxFaces.build(c, d, coordinate_system)
+        return cls(
+            faces=faces,
+            centroid=Point.from_array(coordinate_system.project(c.to_array())),
+        )
+
+    @classmethod
+    def from_entity(cls, entity: entity_instance) -> "OrientedBoundingBox":
+        entity_shape = ifcopenshell.geom.create_shape(settings, entity)
+
+        vertices = ifcopenshell.util.shape.get_shape_vertices(
+            entity_shape, entity_shape.geometry  # type: ignore
+        )
+        return cls.from_vertices(vertices)

ifctrano/building.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from typing import List
+
+import ifcopenshell
+from ifcopenshell import file, entity_instance
+from pydantic import validate_call
+from trano.elements.library.library import Library  # type: ignore
+
+from trano.topology import Network  # type: ignore
+
+from ifctrano.base import BaseModelConfig, Libraries
+from ifctrano.exceptions import IfcFileNotFoundError
+from ifctrano.space_boundary import SpaceBoundaries, initialize_tree
+
+
+def get_spaces(ifcopenshell_file: file) -> List[entity_instance]:
+    return ifcopenshell_file.by_type("IfcSpace")
+
+
+class Building(BaseModelConfig):
+    name: str
+    space_boundaries: List[SpaceBoundaries]
+    ifc_file: file
+    parent_folder: Path
+
+    @classmethod
+    def from_ifc(cls, ifc_file_path: Path) -> "Building":
+        if not ifc_file_path.exists():
+            raise IfcFileNotFoundError(
+                f"File specified {ifc_file_path} does not exist."
+            )
+        ifc_file = ifcopenshell.open(str(ifc_file_path))
+        tree = initialize_tree(ifc_file)
+        spaces = get_spaces(ifc_file)
+        space_boundaries = [
+            SpaceBoundaries.from_space_entity(ifc_file, tree, space) for space in spaces
+        ]
+        return cls(
+            space_boundaries=space_boundaries,
+            ifc_file=ifc_file,
+            parent_folder=ifc_file_path.parent,
+            name=ifc_file_path.stem,
+        )
+
+    @validate_call
+    def create_model(self, library: Libraries = "Buildings") -> str:
+        network = Network(name=self.name, library=Library.from_configuration(library))
+        network.add_boiler_plate_spaces(
+            [space_boundary.model() for space_boundary in self.space_boundaries]
+        )
+        return network.model()  # type: ignore
+
+    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_)

ifctrano/exceptions.py

@@ -0,0 +1,10 @@
+class NoIntersectionAreaFoundError(Exception):
+    """Raised when no intersection area is found between two polygons"""
+
+
+class BoundingBoxFaceError(Exception):
+    pass
+
+
+class IfcFileNotFoundError(FileNotFoundError):
+    pass

ifctrano/main.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic import validate_call
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ifctrano.base import Libraries
+from ifctrano.building import Building
+
+app = typer.Typer()
+CHECKMARK = "[green]✔[/green]"
+CROSS_MARK = "[red]✘[/red]"
+
+
+@app.command()
+@validate_call
+def create(
+    model: Annotated[
+        str,
+        typer.Argument(help="Local path to the ifc file."),
+    ],
+    library: Annotated[
+        Libraries,
+        typer.Argument(help="Modelica library to be used for simulation."),
+    ] = "Buildings",
+) -> None:
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        modelica_model_path = Path(model).resolve().with_suffix(".mo")
+        task = progress.add_task(
+            description=f"Generating model {modelica_model_path.name} with library {library} from {model}",
+            total=None,
+        )
+        building = Building.from_ifc(Path(model))
+        modelica_model = building.create_model()
+        progress.update(task, completed=True)
+        task = progress.add_task(description="Writing model to file...", total=None)
+        modelica_model_path.write_text(modelica_model)
+        progress.remove_task(task)
+        print(f"{CHECKMARK} Model generated at {modelica_model_path}")

ifctrano/space_boundary.py

@@ -0,0 +1,164 @@
+import multiprocessing
+import re
+from typing import Optional, List, Tuple, Any
+
+import ifcopenshell
+import ifcopenshell.geom
+import ifcopenshell.util.shape
+from ifcopenshell import entity_instance, file
+from pydantic import BaseModel, Field
+from trano.elements import Space as TranoSpace, ExternalWall, Window, BaseWall  # type: ignore
+from trano.elements.construction import Construction, Layer, Material  # type: ignore
+from trano.elements.system import Occupancy  # type: ignore
+from trano.elements.types import Azimuth, Tilt  # type: ignore
+
+from ifctrano.base import GlobalId, settings, BaseModelConfig, CommonSurface
+from ifctrano.bounding_box import OrientedBoundingBox
+
+
+def initialize_tree(ifc_file: file) -> ifcopenshell.geom.tree:
+
+    tree = ifcopenshell.geom.tree()
+
+    iterator = ifcopenshell.geom.iterator(
+        settings, ifc_file, multiprocessing.cpu_count()
+    )
+    if iterator.initialize():  # type: ignore
+        while True:
+            tree.add_element(iterator.get())  # type: ignore
+            if not iterator.next():  # type: ignore
+                break
+    return tree
+
+
+def remove_non_alphanumeric(text: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9]", "", text).lower()
+
+
+class Space(GlobalId):
+    name: Optional[str] = None
+    bounding_box: OrientedBoundingBox
+    entity: entity_instance
+
+    def space_name(self) -> str:
+        main_name = (
+            remove_non_alphanumeric(self.name)
+            if self.name
+            else remove_non_alphanumeric(self.entity.GlobalId)
+        )
+        return f"space_{main_name}_{self.entity.GlobalId}"
+
+
+material_1 = Material(
+    name="material_1",
+    thermal_conductivity=0.046,
+    specific_heat_capacity=940,
+    density=80,
+)
+construction = Construction(
+    name="construction_4",
+    layers=[
+        Layer(material=material_1, thickness=0.18),
+    ],
+)
+
+
+class SpaceBoundary(BaseModelConfig):
+    bounding_box: OrientedBoundingBox
+    entity: entity_instance
+    common_surface: CommonSurface
+    adjacent_space: Optional[Space] = None
+
+    def model_element(self) -> Optional[BaseWall]:
+        if "wall" in self.entity.is_a().lower():
+            return ExternalWall(
+                surface=6.44,
+                azimuth=Azimuth.south,
+                tilt=Tilt.wall,
+                construction=construction,
+            )
+        if "window" in self.entity.is_a().lower():
+            return Window(
+                surface=6.44,
+                azimuth=Azimuth.south,
+                tilt=Tilt.wall,
+                construction=construction,
+            )
+
+        return None
+
+    @classmethod
+    def from_space_and_element(
+        cls, bounding_box: OrientedBoundingBox, entity: entity_instance
+    ) -> Optional["SpaceBoundary"]:
+        bounding_box_ = OrientedBoundingBox.from_entity(entity)
+        common_surface = bounding_box.intersect_faces(bounding_box_)
+        if common_surface:
+            return cls(
+                bounding_box=bounding_box_, entity=entity, common_surface=common_surface
+            )
+        return None
+
+    def description(self) -> Tuple[float, Tuple[float, ...], Any, str]:
+        return (
+            self.common_surface.area,
+            self.common_surface.orientation.to_tuple(),
+            self.entity.GlobalId,
+            self.entity.is_a(),
+        )
+
+
+class SpaceBoundaries(BaseModel):
+    space: Space
+    boundaries: List[SpaceBoundary] = Field(default_factory=list)
+
+    def model(self) -> TranoSpace:
+        return TranoSpace(
+            name=self.space.space_name(),
+            occupancy=Occupancy(),
+            external_boundaries=[
+                boundary.model_element()
+                for boundary in self.boundaries
+                if boundary.model_element()
+            ],
+        )
+
+    @classmethod
+    def from_space_entity(
+        cls,
+        ifcopenshell_file: file,
+        tree: ifcopenshell.geom.tree,
+        space: entity_instance,
+    ) -> "SpaceBoundaries":
+        bounding_box = OrientedBoundingBox.from_entity(space)
+        space_ = Space(
+            global_id=space.GlobalId,
+            name=space.Name,
+            bounding_box=bounding_box,
+            entity=space,
+        )
+        clashes = tree.clash_clearance_many(
+            [space],
+            ifcopenshell_file.by_type("IfcWall")
+            + ifcopenshell_file.by_type("IfcSlab")
+            + ifcopenshell_file.by_type("IfcRoof")
+            + ifcopenshell_file.by_type("IfcDoor")
+            + ifcopenshell_file.by_type("IfcWindow"),
+            clearance=0.1,
+        )
+        space_boundaries = []
+
+        for clash in clashes:
+            elements = [
+                ifcopenshell_file.by_guid(clash.a.get_argument(0)),
+                ifcopenshell_file.by_guid(clash.b.get_argument(0)),
+            ]
+            for element in elements:
+                if element.GlobalId == space.GlobalId:
+                    continue
+                space_boundary = SpaceBoundary.from_space_and_element(
+                    bounding_box, element
+                )
+                if space_boundary:
+                    space_boundaries.append(space_boundary)
+        return cls(space=space_, boundaries=space_boundaries)