iso52016 0.0.1__tar.gz

iso52016-0.0.1/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Tobias Blanke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

iso52016-0.0.1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: iso52016
+Version: 0.0.1
+Summary: Python package for a ISO 52016 calculation
+Home-page: https://git.fh-aachen.de/tb5152e/din-en-iso-52016
+Author: Tobias Blanke
+Author-email: blanke@fh-aachen.de
+License: BSD-3-Clause
+Keywords: iso52016,building,energy,thermal,hvac,heating,cooling
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.4
+Requires-Dist: pandas>=2.0.3
+Requires-Dist: pvlib>=0.10.1
+Requires-Dist: scipy>=1.10.1
+Provides-Extra: dev
+Requires-Dist: flake8>=4.0.1; extra == "dev"
+Requires-Dist: pytest>=7.1.2; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: mypy>=0.961; extra == "dev"
+Requires-Dist: bandit>=1.7.4; extra == "dev"
+Requires-Dist: pylint>=2.14.5; extra == "dev"
+Requires-Dist: isort>=5.10.1; extra == "dev"
+Requires-Dist: black>=22.6.0; extra == "dev"
+Requires-Dist: anybadge==1.9.0; extra == "dev"
+Requires-Dist: pandas-stubs>=2.1.1; extra == "dev"
+Dynamic: license-file
+
+# DIN EN ISO 52016
+
+[![pipeline status](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/badges/main/pipeline.svg)](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/-/commits/main)
+[![coverage report](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/badges/main/coverage.svg)](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/-/commits/main)
+[![Documentation Status](https://readthedocs.org/projects/din-en-iso-52016/badge/?version=latest)](https://din-en-iso-52016.readthedocs.io/en/latest/?badge=latest)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Python implementation of the **DIN EN ISO 52016** standard for calculating the energy performance of buildings. The package computes hourly heating and cooling loads for thermal zones using a 5-node thermal-network model per opaque element, solar irradiation via `pvlib`, and ground-temperature coupling per ISO 13370.
+
+## Installation
+
+```bash
+pip install .
+```
+
+Or for development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+from iso52016 import (
+    Building, Layer, Material, OpaqueElement, Orientation,
+    Ventilation, Weather, Window, Zone,
+)
+
+# Create materials and layers
+concrete = Material(density_kg_m3=2300, thermal_capacity_J_kgK=880, conductivity_W_mK=1.7)
+insulation = Material(density_kg_m3=20, thermal_capacity_J_kgK=1450, conductivity_W_mK=0.035)
+wall_layers = [Layer(0.2, concrete), Layer(0.1, insulation)]
+
+# Set up weather (8760 hourly values)
+weather = Weather(air_temperature=t_air, wind=wind)
+
+# Define building envelope
+wall = OpaqueElement(area=50, orientation=Orientation(90, 0), layers=wall_layers)
+# ... add more walls, roof, floor
+
+zone = Zone(
+    opaque_elements=[wall, ...],
+    usable_floor_area=100,
+    internal_gains=[np.zeros(8760)],
+    lower_temperature_limit=20,
+    upper_temperature_limit=26,
+)
+
+building = Building(zones=zone, weather=weather)
+building.calculate()
+
+print(f"Heating: {zone.heat_load.sum() / 1000:.0f} kWh")
+print(f"Cooling: {zone.cool_load.sum() / 1000:.0f} kWh")
+```
+
+See `examples/easy_example.py` for a complete working example.
+
+## Features
+
+- Hourly heating and cooling load calculation per ISO 52016
+- 5-node thermal network for opaque elements, 2-node for windows
+- Solar irradiation via `pvlib` (any orientation/tilt)
+- Ground-temperature coupling per ISO 13370
+- Multi-zone support
+- Ventilation with heat recovery
+
+## License
+
+BSD 3-Clause.
+
+Independent implementation of the calculation method described in DIN EN ISO 52016-1. This project is not affiliated with, authorized by, or endorsed by ISO, CEN, or DIN, and does not reproduce the text of the standard.

iso52016-0.0.1/README.md

@@ -0,0 +1,73 @@
+# DIN EN ISO 52016
+
+[![pipeline status](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/badges/main/pipeline.svg)](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/-/commits/main)
+[![coverage report](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/badges/main/coverage.svg)](https://git.fh-aachen.de/tb5152e/din-en-iso-52016/-/commits/main)
+[![Documentation Status](https://readthedocs.org/projects/din-en-iso-52016/badge/?version=latest)](https://din-en-iso-52016.readthedocs.io/en/latest/?badge=latest)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Python implementation of the **DIN EN ISO 52016** standard for calculating the energy performance of buildings. The package computes hourly heating and cooling loads for thermal zones using a 5-node thermal-network model per opaque element, solar irradiation via `pvlib`, and ground-temperature coupling per ISO 13370.
+
+## Installation
+
+```bash
+pip install .
+```
+
+Or for development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+from iso52016 import (
+    Building, Layer, Material, OpaqueElement, Orientation,
+    Ventilation, Weather, Window, Zone,
+)
+
+# Create materials and layers
+concrete = Material(density_kg_m3=2300, thermal_capacity_J_kgK=880, conductivity_W_mK=1.7)
+insulation = Material(density_kg_m3=20, thermal_capacity_J_kgK=1450, conductivity_W_mK=0.035)
+wall_layers = [Layer(0.2, concrete), Layer(0.1, insulation)]
+
+# Set up weather (8760 hourly values)
+weather = Weather(air_temperature=t_air, wind=wind)
+
+# Define building envelope
+wall = OpaqueElement(area=50, orientation=Orientation(90, 0), layers=wall_layers)
+# ... add more walls, roof, floor
+
+zone = Zone(
+    opaque_elements=[wall, ...],
+    usable_floor_area=100,
+    internal_gains=[np.zeros(8760)],
+    lower_temperature_limit=20,
+    upper_temperature_limit=26,
+)
+
+building = Building(zones=zone, weather=weather)
+building.calculate()
+
+print(f"Heating: {zone.heat_load.sum() / 1000:.0f} kWh")
+print(f"Cooling: {zone.cool_load.sum() / 1000:.0f} kWh")
+```
+
+See `examples/easy_example.py` for a complete working example.
+
+## Features
+
+- Hourly heating and cooling load calculation per ISO 52016
+- 5-node thermal network for opaque elements, 2-node for windows
+- Solar irradiation via `pvlib` (any orientation/tilt)
+- Ground-temperature coupling per ISO 13370
+- Multi-zone support
+- Ventilation with heat recovery
+
+## License
+
+BSD 3-Clause.
+
+Independent implementation of the calculation method described in DIN EN ISO 52016-1. This project is not affiliated with, authorized by, or endorsed by ISO, CEN, or DIN, and does not reproduce the text of the standard.

iso52016-0.0.1/iso52016/__init__.py

@@ -0,0 +1,16 @@
+"""
+iso 52016 base instance
+"""
+from .building import Building
+from .door import Door
+from .functions import ThermalCase
+from .generals import general
+from .layer import Layer
+from .material import Material
+from .opaque_element import OpaqueElement
+from .orientation import Orientation
+from .thermal_bridges import ThermalBridge
+from .ventilation import Ventilation
+from .weather import Weather
+from .window import Window
+from .zone import Zone

iso52016-0.0.1/iso52016/building.py

@@ -0,0 +1,314 @@
+"""
+iso 52016 classes
+"""
+from __future__ import annotations
+
+import typing
+
+import numpy as np
+from scipy import linalg  # type: ignore
+
+from .functions import ThermalCase, determine_case
+from .generals import SECONDS_PER_HOUR, general
+
+if typing.TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+    from .weather import Weather
+    from .zone import Zone
+
+
+class Building:
+    """
+    Building class for including the zones and weather and performing the calculation
+    """
+
+    def __init__(self, weather: Weather, zones: list[Zone] | Zone):
+        """
+        init building class
+        Parameters
+        ----------
+        weather: Weather
+            the weather in which the building is placed
+        zones: list[Zone]
+            list of all zones in the building
+        """
+        self.weather: Weather = weather
+        self.zones: list[Zone] = [zones] if not isinstance(zones, list) else zones
+        self._basic_matrix: NDArray[np.float64] = np.empty(0)
+
+        self.res_multiplication: NDArray[np.float64] = np.empty(0)
+        self.res_constant: NDArray[np.float64] = np.empty(0)
+
+    def set_node_indexes(self) -> None:
+        """
+        determines all nodes indexes for the matrix calculation
+        Returns
+        -------
+            None
+        """
+        number = 0
+        for zone in self.zones:
+            zone.operative_temperature.idx = number  # + 1
+            number += 1
+            for area in zone.opaque_elements:
+                for node in area.nodes:
+                    node.idx = number
+                    number += 1
+                for window in area.windows:
+                    for node in window.nodes:
+                        node.idx = number
+                        number += 1
+
+            zone.air_temperature.idx = number
+            zone.heat_load_var.idx = number + 1
+            zone.cool_load_var.idx = number + 2
+            number += 3
+
+    def calculate(self) -> None:
+        """
+        calculate the loads for all zones in this building
+
+        Returns
+        -------
+            None
+        """
+        nodes: int = sum(zone.nodes for zone in self.zones)
+        for zone in self.zones:
+            zone.update_values(self.weather)
+            _ = [element.set_default_external_temperature(self.weather.t_air) for element in zone.opaque_elements]
+
+        self.set_node_indexes()
+        self.create_basic_matrix(nodes)
+        self.create_results_matrices(nodes)
+        temps_old = np.ones(nodes) * 20
+        for time_step in range(general.simulation_length):
+            temps = self.determine_load(time_step, [ThermalCase.FREE_FLOAT] * len(self.zones), temps_old)
+            cases = [determine_case(temps, zone, time_step) for zone in self.zones]
+            if any(case != ThermalCase.FREE_FLOAT for case in cases):
+                temps = self.determine_load(time_step, cases, temps_old)
+            cases_new = [determine_case(temps, zone, time_step) for zone in self.zones]
+            if any(case_old != cases_new for case_old, case_new in zip(cases, cases_new)):
+                temps = self.determine_load(time_step, cases_new, temps_old)
+
+            temps_old = temps
+            for zone in self.zones:
+                zone.air_temperature[time_step] = temps[zone.air_temperature.idx]
+                zone.operative_temperature[time_step] = temps[zone.operative_temperature.idx]
+                zone.heat_load_var[time_step] = temps[zone.heat_load_var.idx]
+                zone.cool_load_var[time_step] = temps[zone.cool_load_var.idx]
+                for elem in zone.opaque_elements:
+                    for node in elem.nodes:
+                        node[time_step] = temps[node.idx]
+                    for window in elem.windows:
+                        for node in window.nodes:
+                            node[time_step] = temps[node.idx]
+
+    def determine_load(self, time_step: int, cases: list[ThermalCase], temps_old: NDArray[np.float64]) -> NDArray[np.float64]:
+        """
+        solves the matrix
+
+        Parameters
+        ----------
+        time_step: int
+            time step
+        cases: list[ThermalCase]
+            list of thermal cases for the different zones
+        temps_old: NDArray[np.float64]
+            old temperature results array
+        Returns
+        -------
+        NDArray[np.float64]:
+            solved nodes matrix
+        """
+        mat = self._basic_matrix.copy()
+        res = self.set_general_result_vector_values(temps_old, time_step)
+        for zone, case in zip(self.zones, cases):
+            mat[zone.air_temperature.idx, zone.air_temperature.idx] += zone.h_vent[time_step]
+            if case == ThermalCase.FREE_FLOAT:
+                mat[zone.heat_load_var.idx, zone.heat_load_var.idx] = 1
+                mat[zone.cool_load_var.idx, zone.cool_load_var.idx] = 1
+                continue
+            if case == ThermalCase.HEATING:
+                mat[zone.heat_load_var.idx, zone.reference_temp.idx] = 1
+                mat[zone.cool_load_var.idx, zone.cool_load_var.idx] = 1
+                res[zone.heat_load_var.idx] = zone.t_min[time_step]
+                continue
+            if case == ThermalCase.MAX_HEATING:
+                mat[zone.heat_load_var.idx, zone.heat_load_var.idx] = 1
+                mat[zone.cool_load_var.idx, zone.cool_load_var.idx] = 1
+                res[zone.heat_load_var.idx] = zone.max_heat
+                continue
+            if case == ThermalCase.MAX_COOLING:
+                mat[zone.heat_load_var.idx, zone.heat_load_var.idx] = 1
+                mat[zone.cool_load_var.idx, zone.cool_load_var.idx] = 1
+                res[zone.cool_load_var.idx] = zone.max_cool
+                continue
+
+            mat[zone.cool_load_var.idx, zone.reference_temp.idx] = 1
+            mat[zone.heat_load_var.idx, zone.heat_load_var.idx] = 1
+            res[zone.cool_load_var.idx] = zone.t_max[time_step]
+
+        try:
+            temps = linalg.lu_solve(
+                linalg.lu_factor(mat[: res.size, : res.size], overwrite_a=False, check_finite=False), res, overwrite_b=False, check_finite=False
+            )
+        except linalg.LinAlgError as exc:
+            raise linalg.LinAlgError(
+                f"Singular matrix at time step {time_step}. "
+                "Check that all building elements have valid thermal properties (non-zero area, conductivity, etc.)."
+            ) from exc
+        return temps
+
+    def create_basic_matrix(self, nodes: int) -> None:
+        """
+        Create the basic matrix to use it later.
+
+        Parameters
+        ----------
+        nodes: int
+            number of nodes
+
+        Returns
+        -------
+            None
+        """
+        matrix = np.zeros((nodes, nodes))
+        for zone in self.zones:
+            self._fill_zone_rows(matrix, zone)
+            for elem in zone.opaque_elements:
+                self._fill_opaque_element_rows(matrix, zone, elem)
+                for window in elem.windows:
+                    self._fill_window_rows(matrix, zone, elem, window)
+        self._basic_matrix = matrix
+
+    @staticmethod
+    def _other_surfaces(zone: Zone, exclude_parent: object) -> list:
+        """Collect all surfaces in the zone except *exclude_parent* and its own windows."""
+        return zone.opaque_elements + [w for e in zone.opaque_elements for w in e.windows if e != exclude_parent]
+
+    def _fill_zone_rows(self, matrix: NDArray[np.float64], zone: Zone) -> None:
+        """Fill the air-temperature and operative-temperature rows for a zone."""
+        all_surfaces = zone.opaque_elements + [w for e in zone.opaque_elements for w in e.windows]
+        matrix[zone.air_temperature.idx, zone.air_temperature.idx] = (
+            zone.c_internal / SECONDS_PER_HOUR + sum(s.area * s.h_ci for s in all_surfaces) + zone.h_th_bridge
+        )
+        matrix[zone.air_temperature.idx, zone.heat_load_var.idx] = -zone.f_heat_cool
+        matrix[zone.air_temperature.idx, zone.cool_load_var.idx] = zone.f_heat_cool
+        matrix[zone.operative_temperature.idx, zone.operative_temperature.idx] = -2
+        matrix[zone.operative_temperature.idx, zone.air_temperature.idx] = 1
+
+    def _fill_opaque_element_rows(self, matrix: NDArray[np.float64], zone: Zone, elem: object) -> None:
+        """Fill matrix rows for an opaque element's 5 nodes."""
+        # zone-level coupling
+        matrix[zone.air_temperature.idx, elem.nodes[4].idx] = -1 * elem.area * elem.h_ci
+        matrix[zone.operative_temperature.idx, elem.nodes[4].idx] = elem.area / zone.total_area
+        # internal surface node (node 4)
+        matrix[elem.nodes[4].idx, zone.air_temperature.idx] = -1 * elem.h_ci
+        for window in elem.windows:
+            matrix[window.nodes[1].idx, zone.air_temperature.idx] = -1 * window.h_ci
+        matrix[elem.nodes[4].idx, elem.nodes[3].idx] = -1 * elem.heat_coefficient[3]
+        others = [s for s in self._other_surfaces(zone, elem) if s != elem]
+        matrix[elem.nodes[4].idx, elem.nodes[4].idx] = (
+            elem.heat_coefficient[3]
+            + elem.h_ci
+            + elem.capacities[4] / SECONDS_PER_HOUR
+            + elem.h_ri / zone.total_area * sum(s.area for s in others)
+        )
+        matrix[elem.nodes[4].idx, zone.heat_load_var.idx] = -1 * (1 - zone.f_heat_cool) / zone.total_area
+        matrix[elem.nodes[4].idx, zone.cool_load_var.idx] = (1 - zone.f_heat_cool) / zone.total_area
+        # radiative exchange with other surfaces
+        for elem_i in zone.opaque_elements:
+            if elem_i == elem:
+                continue
+            matrix[elem.nodes[4].idx, elem_i.nodes[4].idx] = -1 * elem.h_ri * elem_i.area / zone.total_area
+            for window_i in elem_i.windows:
+                matrix[elem.nodes[4].idx, window_i.nodes[1].idx] = -1 * elem.h_ri * window_i.area / zone.total_area
+        # intermediate nodes (1-3)
+        for i in range(1, 4):
+            matrix[elem.nodes[i].idx, elem.nodes[i - 1].idx] = -1 * elem.heat_coefficient[i - 1]
+            matrix[elem.nodes[i].idx, elem.nodes[i].idx] = elem.capacities[i] / SECONDS_PER_HOUR + elem.heat_coefficient[i] + elem.heat_coefficient[i - 1]
+            matrix[elem.nodes[i].idx, elem.nodes[i + 1].idx] = -1 * elem.heat_coefficient[i]
+        # external node (node 0)
+        matrix[elem.nodes[0].idx, elem.nodes[0].idx] = elem.capacities[0] / SECONDS_PER_HOUR + elem.h_ce + elem.h_re + elem.heat_coefficient[0]
+        matrix[elem.nodes[0].idx, elem.nodes[1].idx] = -1 * elem.heat_coefficient[0]
+
+    def _fill_window_rows(self, matrix: NDArray[np.float64], zone: Zone, parent_elem: object, window: object) -> None:
+        """Fill matrix rows for a window's 2 nodes."""
+        matrix[zone.air_temperature.idx, window.nodes[1].idx] = -1 * window.area * window.h_ci
+        matrix[zone.operative_temperature.idx, window.nodes[1].idx] = window.area / zone.total_area
+        # external node
+        matrix[window.nodes[0].idx, window.nodes[0].idx] = window.h_ce + window.h_re + window.heat_coefficient
+        matrix[window.nodes[0].idx, window.nodes[1].idx] = -1 * window.heat_coefficient
+        # internal node
+        matrix[window.nodes[1].idx, window.nodes[0].idx] = -1 * window.heat_coefficient
+        others = [s for s in self._other_surfaces(zone, parent_elem) if s != parent_elem]
+        matrix[window.nodes[1].idx, window.nodes[1].idx] = (
+            window.heat_coefficient + window.h_ci + window.h_ri / zone.total_area * sum(s.area for s in others)
+        )
+        matrix[window.nodes[1].idx, zone.heat_load_var.idx] = -1 * (1 - zone.f_heat_cool) / zone.total_area
+        matrix[window.nodes[1].idx, zone.cool_load_var.idx] = (1 - zone.f_heat_cool) / zone.total_area
+        # radiative exchange with other surfaces
+        for elem_i in zone.opaque_elements:
+            if parent_elem == elem_i:
+                continue
+            matrix[window.nodes[1].idx, elem_i.nodes[4].idx] = -1 * window.h_ri * elem_i.area / zone.total_area
+            for window_i in elem_i.windows:
+                matrix[window.nodes[1].idx, window_i.nodes[1].idx] = -1 * window.h_ri * window_i.area / zone.total_area
+
+    def create_results_matrices(self, nodes: int) -> None:
+        """
+        create the results matrix
+
+        Parameters
+        ----------
+        nodes: int
+            number of nodes
+
+        Returns
+        -------
+            None
+        """
+        self.res_multiplication = np.zeros((nodes, nodes))
+        self.res_constant = np.zeros((nodes, general.simulation_length))
+
+        for zone in self.zones:
+            self.res_multiplication[zone.air_temperature.idx, zone.air_temperature.idx] = zone.c_internal / SECONDS_PER_HOUR
+            self.res_constant[zone.air_temperature.idx, :] = (
+                sum((vent.h_air * vent.t_supply) for vent in zone.ventilation)
+                + zone.h_th_bridge * self.weather.t_air
+                + zone.internal_gains * zone.f_internal
+                + zone.f_sol * zone.solar_gains
+            )
+            for elem in zone.opaque_elements:
+                self.res_multiplication[elem.nodes[4].idx, elem.nodes[4].idx] = elem.capacities[4] / SECONDS_PER_HOUR
+                self.res_constant[elem.nodes[4].idx, :] = ((1 - zone.f_internal) * zone.internal_gains + (1 - zone.f_sol) * zone.solar_gains) / zone.total_area
+                for i in range(1, 4):
+                    self.res_multiplication[elem.nodes[i].idx, elem.nodes[i].idx] = elem.capacities[i] / SECONDS_PER_HOUR
+                self.res_multiplication[elem.nodes[0].idx, elem.nodes[0].idx] = elem.capacities[0] / SECONDS_PER_HOUR
+                self.res_constant[elem.nodes[0].idx, :] = (
+                    (elem.h_ce + elem.h_re) * elem.external_temperature + elem.a_sol * (elem.diffuse_irradiation + elem.direct_irradiation) - elem.sky_heat_flux
+                )
+
+                for window in elem.windows:
+                    self.res_constant[window.nodes[0].idx, :] = (window.h_ce + window.h_re) * window.external_temperature - window.sky_heat_flux
+                    self.res_constant[window.nodes[1].idx, :] = (
+                        (1 - zone.f_internal) * zone.internal_gains + (1 - zone.f_sol) * zone.solar_gains
+                    ) / zone.total_area
+
+    def set_general_result_vector_values(self, temps_old: NDArray[np.float64], time_step: int) -> NDArray[np.float64]:
+        """
+        update results vector with new temperatures.
+
+        Parameters
+        ----------
+        temps_old: NDArray[np.float64]
+            old temperature values
+        time_step: int
+            current time step
+
+        Returns
+        -------
+            NDArray[np.float64]
+        """
+        return self.res_multiplication.dot(temps_old) + self.res_constant[:, time_step]

iso52016-0.0.1/iso52016/door.py

@@ -0,0 +1,23 @@
+"""
+script for door class
+"""
+from iso52016.window import Window
+
+
+class Door(Window):
+    """
+    Door data class
+    """
+
+    def __init__(self, *, area: float, u_value: float):
+        """
+        init window
+
+        Parameters
+        ----------
+        area: float
+            window area in m²
+        u_value: float
+            U value of window in W/m²K
+        """
+        super().__init__(area=area, u_value=u_value, g_value=0, frame_fraction=1)