iso52016 0.0.1__py3-none-any.whl

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/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/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)

iso52016/functions.py

@@ -0,0 +1,241 @@
+"""
+script for different functions
+"""
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import TYPE_CHECKING
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+    from iso52016.layer import Layer
+    from iso52016.zone import Zone
+
+
+class ThermalCase(IntEnum):
+    """Thermal calculation cases per ISO 52016."""
+
+    FREE_FLOAT = 0
+    HEATING = 1
+    COOLING = 2
+    MAX_HEATING = 3
+    MAX_COOLING = 4
+
+
+# Internal convective heat transfer coefficient interpolation anchors [W/(m2K)]
+# per ISO 52016 Table B.12
+H_CI_DOWNWARD = 0.7  # angle 0 deg (heat flow downward)
+H_CI_HORIZONTAL = 2.5  # angle 90 deg (heat flow horizontal)
+H_CI_UPWARD = 5.0  # angle 180 deg (heat flow upward)
+
+
+def moving_average(vector: NDArray[np.float64], n: int) -> NDArray[np.float64]:
+    """Compute a circular moving average of *vector* with window size *n*."""
+    vector = np.append(vector, vector[: n - 1])
+    ret = np.cumsum(vector, dtype=float)
+    ret[n:] = ret[n:] - ret[:-n]
+    return ret[n - 1 :] / n
+
+
+def determine_capacity_class(layers: list[Layer]) -> str:
+    """
+    determines the capacity class
+
+    Parameters
+    ----------
+    layers: list[Layer]
+        layers list
+
+    Returns
+    -------
+        str
+    """
+    total_capacity = sum(lay.thermal_capacity for lay in layers)
+    capacity_class = (
+        "IE"
+        if layers[0].thermal_capacity > total_capacity * 0.45 and layers[-1].thermal_capacity > total_capacity * 0.45
+        else "I"
+        if layers[0].thermal_capacity > 2 / 3 * total_capacity
+        else "E"
+        if layers[-1].thermal_capacity > 2 / 3 * total_capacity
+        else "D"
+    )
+    return capacity_class
+
+
+def determine_capacities(layers: list[Layer]) -> list[float]:
+    total_capacity = sum(lay.thermal_capacity for lay in layers)
+    capacity_class = determine_capacity_class(layers)
+    capacities: list[float] = (
+        [0, 0, 0, 0, total_capacity]
+        if capacity_class == "I"
+        else [total_capacity, 0, 0, 0, 0]
+        if capacity_class == "E"
+        else [total_capacity / 2, 0, 0, 0, total_capacity / 2]
+        if capacity_class == "IE"
+        else ([total_capacity / 8, total_capacity / 4, total_capacity / 4, total_capacity / 4, total_capacity / 8])
+    )
+
+    return capacities
+
+
+def determine_capacities_real(layers: list[Layer]) -> list[float]:
+    length_n = sum(lay.thickness for lay in layers) / 5
+    x_pos = np.cumsum([lay.thickness for lay in layers])
+    y_val = np.array([lay.material.density_kg_m3 * lay.material.thermal_capacity_J_kgK for lay in layers])
+    x_pos = np.append([0.0], x_pos)
+    y_val = np.append(y_val, y_val[-1])
+    f = interp1d(x_pos, y_val, kind="previous", fill_value="extrapolate")
+    res = [np.mean(f(np.arange(length_n * i, length_n * (i + 1), 0.0001).round(4))) * length_n for i in range(5)]
+    return res
+
+
+def determine_capacities_in_earth_contact(layers: list[Layer], capacity_ground: float) -> list[float]:
+    total_capacity = sum(lay.thermal_capacity for lay in layers)
+    capacity_class = determine_capacity_class(layers)
+    capacities: list[float] = (
+        [0, capacity_ground, 0, 0, total_capacity]
+        if capacity_class == "I"
+        else [0, capacity_ground, total_capacity, 0, 0]
+        if capacity_class == "E"
+        else [0, capacity_ground, total_capacity / 2, 0, total_capacity / 2]
+        if capacity_class == "IE"
+        else ([0, capacity_ground, total_capacity / 4, total_capacity / 2, total_capacity / 4])
+    )
+
+    return capacities
+
+
+def determine_heat_resistance(layers: list[Layer]) -> list[float]:
+    r_tot = sum(lay.thermal_resistance for lay in layers)
+    return [6 / r_tot, 3 / r_tot, 3 / r_tot, 6 / r_tot]
+
+
+def determine_heat_resistance_real(layers: list[Layer]) -> list[float]:
+    """
+    determines equally distributed heat resistances
+
+    Parameters
+    ----------
+    layers: list[Layer]
+        list of layers
+
+    Returns
+    -------
+        list[float]
+    """
+    # Calculate the length per quarter
+    total_length = sum(layer.thickness for layer in layers)
+    length_per_quarter = total_length / 4
+
+    # Calculate positions and resistance values
+    positions = np.cumsum([layer.thickness for layer in layers])
+    resistance_values = np.array([0.000_01 / layer.material.conductivity_W_mK for layer in layers])
+
+    # Ensure the arrays have appropriate lengths for interpolation
+    positions = np.append([0.0], positions)
+    resistance_values = np.append(resistance_values, resistance_values[-1])
+
+    # Interpolate the resistance values
+    interpolated_function = interp1d(positions, resistance_values, kind="previous", fill_value="extrapolate")
+
+    # Calculate resistances at quarter lengths
+    resistances = [np.sum(interpolated_function(np.arange(length_per_quarter * i, length_per_quarter * (i + 1), 0.000_01).round(5))) for i in range(4)]
+    resistances = [1 / val for val in resistances]
+    return resistances
+
+
+def determine_heat_resistances_in_earth_contact(layers: list[Layer], r_g: float) -> list[float]:
+    r_tot = sum(lay.thermal_resistance for lay in layers)
+    return [4 / r_tot, 2 / r_tot, 1 / (r_tot / 4 + r_g / 2), 2 / r_g]
+
+
+def determine_hci(angle: float | int) -> float:
+    angle = angle if 0 <= angle <= 180 else -1 * angle if angle < 0 else (360 - angle)  # noqa: PLR2004
+    if angle < 90:  # noqa: PLR2004
+        h_ci = H_CI_DOWNWARD + (H_CI_HORIZONTAL - H_CI_DOWNWARD) * angle / 90
+    else:
+        h_ci = H_CI_HORIZONTAL + (H_CI_UPWARD - H_CI_HORIZONTAL) * (angle - 90) / 90
+    return h_ci
+
+
+def determine_case(temps: NDArray[np.float64], zone: Zone, time_step: int) -> ThermalCase:
+    """
+    Determines the thermal calculation case for the zone.
+
+    Parameters
+    ----------
+    temps: NDArray[np.float64]
+        previous results
+    zone: Zone
+        zone to determine case for
+    time_step: int
+        time step
+
+    Returns
+    -------
+    ThermalCase
+    """
+    if temps[zone.heat_load_var.idx] > zone.max_heat:
+        return ThermalCase.MAX_HEATING
+    if temps[zone.cool_load_var.idx] > zone.max_cool:
+        return ThermalCase.MAX_COOLING
+    if temps[zone.reference_temp.idx] <= zone.t_min[time_step] * 1.000_01:
+        return ThermalCase.HEATING
+    if temps[zone.reference_temp.idx] >= zone.t_max[time_step] * 0.999_99:
+        return ThermalCase.COOLING
+
+    return ThermalCase.FREE_FLOAT
+
+
+def calculate_mean_temperature(
+    annual_mean: float, amplitude_int: float, minimal_temperature_month: float | int, month: float | NDArray[np.float64]
+) -> float | NDArray[np.float64]:
+    """
+    Calculates the monthly mean temperature for the given month number
+
+    :param annual_mean: float, annual mean of yearly temperature, in °C
+    :param amplitude_int: float, amplitude of fluctuations of the monthly mean of yearly temperature, in K
+    :param minimal_temperature_month: int, the month number with the lowest exterior temperature
+    :param month: int, the number of the month
+    :return: float, the calculated monthly mean of indoor temperature for the given month number
+    """
+    return annual_mean - amplitude_int * np.cos(2 * np.pi * (month - minimal_temperature_month) / 12)
+
+def are_months_close(month1: float, month2: float) -> bool:
+    # Ensure months are within the range of 1 to 12
+    month1 = (month1 - 1) % 12 + 1
+    month2 = (month2 - 1) % 12 + 1
+
+    # Calculate the difference in months considering the circular nature of months
+    month_difference = min((month2 - month1) % 12, (month1 - month2) % 12)
+
+    # Check if the months are close (within 1 months difference, considering circularity)
+    return month_difference <= 1
+
+
+def get_yearly_mean_amplitude_min_temp_month(temperature: NDArray[np.float64]) -> tuple[float, float, float]:
+    """
+    determines the yearly mean temperature, the month amplitude and the minimal temperate month.
+
+    Parameters
+    ----------
+    temperature: NDArray[np.float64]
+        hourly temperature profile
+
+    Returns
+    -------
+        yearly mean, monthly amplitude, minimal temperature month
+    """
+    t_mean: float = np.mean(temperature)
+    month_hours: int = int(len(temperature) / 12)
+    t_month_mean: NDArray[np.float64] = np.array([np.mean(temperature[t : t + month_hours]) for t in range(0, len(temperature), month_hours)])
+    n_min_month = float(t_month_mean.argmin())
+    n_min_hourly = temperature.argmin() / len(temperature) * 12
+    n_min = n_min_hourly if are_months_close(n_min_month, n_min_hourly) else n_min_month
+    t_amplitude = np.max(np.abs(t_mean - t_month_mean))
+    return t_mean, t_amplitude, n_min

iso52016/generals.py

@@ -0,0 +1,38 @@
+"""
+script for general properties
+"""
+import dataclasses
+
+from iso52016.material import Material
+
+# Default heat transfer coefficients per ISO 52016 / ISO 6946 [W/(m2K)]
+H_CE_DEFAULT = 20.0  # external convective
+H_RE_DEFAULT = 4.14  # external radiative
+H_RI_DEFAULT = 5.13  # internal radiative
+
+# Default solar absorption factor for opaque surfaces [-]
+A_SOL_DEFAULT = 0.6
+
+# Zone distribution factors per ISO 52016 Table B.11 [-]
+F_INTERNAL_DEFAULT = 0.4  # fraction of internal gains to air node
+F_HEAT_COOL_DEFAULT = 0.4  # fraction of heating/cooling to air node
+F_SOL_DEFAULT = 0.1  # fraction of solar gains to air node
+
+# Maximum load limiter [W/m2]
+MAX_LOAD_PER_M2 = 100_000
+
+# Seconds per hour (for capacity / time-step conversion)
+SECONDS_PER_HOUR = 3600
+
+
+@dataclasses.dataclass(slots=True)
+class General:
+    """
+    Dataclass for general simulation properties
+    """
+
+    air: Material
+    simulation_length: int
+
+
+general = General(Material(1.204, 1006, 0.02), 8760)