913 lines
31 KiB
Python
913 lines
31 KiB
Python
"""
|
|
Building module
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2022 Concordia CERC group
|
|
Project Coder Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
|
|
Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
|
|
"""
|
|
|
|
import logging
|
|
from typing import List, Union, TypeVar
|
|
|
|
import numpy as np
|
|
import hub.helpers.constants as cte
|
|
from hub.city_model_structure.attributes.polyhedron import Polyhedron
|
|
from hub.city_model_structure.building_demand.household import Household
|
|
from hub.city_model_structure.building_demand.internal_zone import InternalZone
|
|
from hub.city_model_structure.building_demand.thermal_zone import ThermalZone
|
|
from hub.city_model_structure.building_demand.surface import Surface
|
|
from hub.city_model_structure.city_object import CityObject
|
|
from hub.city_model_structure.energy_systems.energy_system import EnergySystem
|
|
from hub.helpers.peak_loads import PeakLoads
|
|
|
|
City = TypeVar('City')
|
|
|
|
|
|
class Building(CityObject):
|
|
"""
|
|
Building(CityObject) class
|
|
"""
|
|
def __init__(self, name, surfaces, year_of_construction, function, terrains=None, city=None):
|
|
super().__init__(name, surfaces)
|
|
self._city = city
|
|
self._households = None
|
|
self._basement_heated = None
|
|
self._attic_heated = None
|
|
self._terrains = terrains
|
|
self._year_of_construction = year_of_construction
|
|
self._function = function
|
|
self._average_storey_height = None
|
|
self._storeys_above_ground = None
|
|
self._floor_area = None
|
|
self._roof_type = None
|
|
self._internal_zones = None
|
|
self._thermal_zones_from_internal_zones = None
|
|
self._shell = None
|
|
self._aliases = []
|
|
self._type = 'building'
|
|
self._cold_water_temperature = {}
|
|
self._heating_demand = {}
|
|
self._cooling_demand = {}
|
|
self._lighting_electrical_demand = {}
|
|
self._appliances_electrical_demand = {}
|
|
self._domestic_hot_water_heat_demand = {}
|
|
self._heating_consumption = {}
|
|
self._cooling_consumption = {}
|
|
self._domestic_hot_water_consumption = {}
|
|
self._distribution_systems_electrical_consumption = {}
|
|
self._onsite_electrical_production = {}
|
|
self._eave_height = None
|
|
self._energy_systems = None
|
|
self._systems_archetype_name = None
|
|
self._grounds = []
|
|
self._roofs = []
|
|
self._walls = []
|
|
self._internal_walls = []
|
|
self._ground_walls = []
|
|
self._attic_floors = []
|
|
self._interior_slabs = []
|
|
for surface_id, surface in enumerate(self.surfaces):
|
|
self._min_x = min(self._min_x, surface.lower_corner[0])
|
|
self._min_y = min(self._min_y, surface.lower_corner[1])
|
|
self._min_z = min(self._min_z, surface.lower_corner[2])
|
|
self._max_x = max(self._max_x, surface.upper_corner[0])
|
|
self._max_y = max(self._max_y, surface.upper_corner[1])
|
|
self._max_z = max(self._max_z, surface.upper_corner[2])
|
|
surface.id = surface_id
|
|
if surface.type == cte.GROUND:
|
|
self._grounds.append(surface)
|
|
elif surface.type == cte.WALL:
|
|
self._walls.append(surface)
|
|
elif surface.type == cte.ROOF:
|
|
self._roofs.append(surface)
|
|
elif surface.type == cte.INTERIOR_WALL:
|
|
self._internal_walls.append(surface)
|
|
elif surface.type == cte.GROUND_WALL:
|
|
self._ground_walls.append(surface)
|
|
elif surface.type == cte.ATTIC_FLOOR:
|
|
self._attic_floors.append(surface)
|
|
elif surface.type == cte.INTERIOR_SLAB:
|
|
self._interior_slabs.append(surface)
|
|
else:
|
|
logging.error('Building %s [%s] has an unexpected surface type %s.', self.name, self.aliases, surface.type)
|
|
self._domestic_hot_water_peak_load = None
|
|
self._fuel_consumption_breakdown = {}
|
|
|
|
@property
|
|
def shell(self) -> Polyhedron:
|
|
"""
|
|
Get building's external polyhedron
|
|
:return: [Polyhedron]
|
|
"""
|
|
polygons = []
|
|
for surface in self.surfaces:
|
|
if surface.type is not cte.INTERIOR_WALL:
|
|
polygons.append(surface.solid_polygon)
|
|
if surface.holes_polygons is not None:
|
|
for hole in surface.holes_polygons:
|
|
polygons.append(hole)
|
|
if self._shell is None:
|
|
self._shell = Polyhedron(polygons)
|
|
return self._shell
|
|
|
|
@property
|
|
def internal_zones(self) -> List[InternalZone]:
|
|
"""
|
|
Get building internal zones
|
|
For Lod up to 3, there is only one internal zone which corresponds to the building shell.
|
|
In LoD 4 there can be more than one. In this case the definition of surfaces and floor area must be redefined.
|
|
:return: [InternalZone]
|
|
"""
|
|
if self._internal_zones is None:
|
|
self._internal_zones = [InternalZone(self.surfaces, self.floor_area, self.volume)]
|
|
return self._internal_zones
|
|
|
|
@property
|
|
def thermal_zones_from_internal_zones(self) -> Union[None, List[ThermalZone]]:
|
|
"""
|
|
Get building thermal zones
|
|
:return: [ThermalZone]
|
|
"""
|
|
if self._thermal_zones_from_internal_zones is None:
|
|
self._thermal_zones_from_internal_zones = []
|
|
for internal_zone in self.internal_zones:
|
|
if internal_zone.thermal_zones_from_internal_zones is None:
|
|
self._thermal_zones_from_internal_zones = None
|
|
return self._thermal_zones_from_internal_zones
|
|
self._thermal_zones_from_internal_zones.append(internal_zone.thermal_zones_from_internal_zones[0])
|
|
return self._thermal_zones_from_internal_zones
|
|
|
|
@property
|
|
def grounds(self) -> List[Surface]:
|
|
"""
|
|
Get building ground surfaces
|
|
:return: [Surface]
|
|
"""
|
|
return self._grounds
|
|
|
|
@property
|
|
def roofs(self) -> List[Surface]:
|
|
"""
|
|
Get building roof surfaces
|
|
:return: [Surface]
|
|
"""
|
|
return self._roofs
|
|
|
|
@property
|
|
def walls(self) -> List[Surface]:
|
|
"""
|
|
Get building wall surfaces
|
|
:return: [Surface]
|
|
"""
|
|
return self._walls
|
|
|
|
@property
|
|
def internal_walls(self) -> List[Surface]:
|
|
"""
|
|
Get building internal wall surfaces
|
|
:return: [Surface]
|
|
"""
|
|
return self._internal_walls
|
|
|
|
@property
|
|
def terrains(self) -> Union[None, List[Surface]]:
|
|
"""
|
|
Get city object terrain surfaces
|
|
:return: [Surface]
|
|
"""
|
|
return self._terrains
|
|
|
|
@property
|
|
def attic_heated(self) -> Union[None, int]:
|
|
"""
|
|
Get if the city object attic is heated
|
|
0: no attic in the building
|
|
1: attic exists but is not heated
|
|
2: attic exists and is heated
|
|
:return: None or int
|
|
"""
|
|
return self._attic_heated
|
|
|
|
@attic_heated.setter
|
|
def attic_heated(self, value):
|
|
"""
|
|
Set if the city object attic is heated
|
|
0: no attic in the building
|
|
1: attic exists but is not heated
|
|
2: attic exists and is heated
|
|
:param value: int
|
|
"""
|
|
if value is not None:
|
|
self._attic_heated = int(value)
|
|
|
|
@property
|
|
def basement_heated(self) -> Union[None, int]:
|
|
"""
|
|
Get if the city object basement is heated
|
|
0: no basement in the building
|
|
1: basement exists but is not heated
|
|
2: basement exists and is heated
|
|
:return: None or int
|
|
"""
|
|
return self._basement_heated
|
|
|
|
@basement_heated.setter
|
|
def basement_heated(self, value):
|
|
"""
|
|
Set if the city object basement is heated
|
|
0: no basement in the building
|
|
1: basement exists but is not heated
|
|
2: basement exists and is heated
|
|
:param value: int
|
|
"""
|
|
if value is not None:
|
|
self._basement_heated = int(value)
|
|
|
|
@property
|
|
def year_of_construction(self):
|
|
"""
|
|
Get building year of construction
|
|
:return: int
|
|
"""
|
|
return self._year_of_construction
|
|
|
|
@year_of_construction.setter
|
|
def year_of_construction(self, value):
|
|
"""
|
|
Set building year of construction
|
|
:param value: int
|
|
"""
|
|
if value is not None:
|
|
self._year_of_construction = int(value)
|
|
|
|
@property
|
|
def function(self) -> Union[None, str]:
|
|
"""
|
|
Get building function
|
|
:return: None or str
|
|
"""
|
|
return self._function
|
|
|
|
@function.setter
|
|
def function(self, value):
|
|
"""
|
|
Set building function
|
|
:param value: str
|
|
"""
|
|
if value is not None:
|
|
self._function = str(value)
|
|
|
|
@property
|
|
def average_storey_height(self) -> Union[None, float]:
|
|
"""
|
|
Get building average storey height in meters
|
|
:return: None or float
|
|
"""
|
|
if len(self.internal_zones) > 1:
|
|
self._average_storey_height = 0
|
|
for internal_zone in self.internal_zones:
|
|
self._average_storey_height += internal_zone.mean_height / len(self.internal_zones)
|
|
else:
|
|
if self.internal_zones[0].thermal_archetype is None:
|
|
self._average_storey_height = None
|
|
else:
|
|
self._average_storey_height = self.internal_zones[0].thermal_archetype.average_storey_height
|
|
return self._average_storey_height
|
|
|
|
@average_storey_height.setter
|
|
def average_storey_height(self, value):
|
|
"""
|
|
Set building average storey height in meters
|
|
:param value: float
|
|
"""
|
|
if value is not None:
|
|
self._average_storey_height = float(value)
|
|
|
|
@property
|
|
def storeys_above_ground(self) -> Union[None, int]:
|
|
"""
|
|
Get building storeys number above ground
|
|
:return: None or int
|
|
"""
|
|
if self._storeys_above_ground is None:
|
|
if self.eave_height is not None and self.average_storey_height is not None:
|
|
self._storeys_above_ground = int(self.eave_height / self.average_storey_height)
|
|
return self._storeys_above_ground
|
|
|
|
@storeys_above_ground.setter
|
|
def storeys_above_ground(self, value):
|
|
"""
|
|
Set building storeys number above ground
|
|
:param value: int
|
|
"""
|
|
if value is not None:
|
|
self._storeys_above_ground = int(value)
|
|
|
|
@property
|
|
def cold_water_temperature(self) -> {float}:
|
|
"""
|
|
Get cold water temperature in degrees Celsius
|
|
:return: dict{[float]}
|
|
"""
|
|
return self._cold_water_temperature
|
|
|
|
@cold_water_temperature.setter
|
|
def cold_water_temperature(self, value):
|
|
"""
|
|
Set cold water temperature in degrees Celsius
|
|
:param value: dict{[float]}
|
|
"""
|
|
self._cold_water_temperature = value
|
|
|
|
@property
|
|
def heating_demand(self) -> dict:
|
|
"""
|
|
Get heating demand in J
|
|
:return: dict{[float]}
|
|
"""
|
|
return self._heating_demand
|
|
|
|
@heating_demand.setter
|
|
def heating_demand(self, value):
|
|
"""
|
|
Set heating demand in J
|
|
:param value: dict{[float]}
|
|
"""
|
|
self._heating_demand = value
|
|
|
|
@property
|
|
def cooling_demand(self) -> dict:
|
|
"""
|
|
Get cooling demand in J
|
|
:return: dict{[float]}
|
|
"""
|
|
return self._cooling_demand
|
|
|
|
@cooling_demand.setter
|
|
def cooling_demand(self, value):
|
|
"""
|
|
Set cooling demand in J
|
|
:param value: dict{[float]}
|
|
"""
|
|
self._cooling_demand = value
|
|
|
|
@property
|
|
def lighting_electrical_demand(self) -> dict:
|
|
"""
|
|
Get lighting electrical demand in J
|
|
:return: dict{[float]}
|
|
"""
|
|
return self._lighting_electrical_demand
|
|
|
|
@lighting_electrical_demand.setter
|
|
def lighting_electrical_demand(self, value):
|
|
"""
|
|
Set lighting electrical demand in J
|
|
:param value: dict{[float]}
|
|
"""
|
|
self._lighting_electrical_demand = value
|
|
|
|
@property
|
|
def appliances_electrical_demand(self) -> dict:
|
|
"""
|
|
Get appliances electrical demand in J
|
|
:return: dict{[float]}
|
|
"""
|
|
return self._appliances_electrical_demand
|
|
|
|
@appliances_electrical_demand.setter
|
|
def appliances_electrical_demand(self, value):
|
|
"""
|
|
Set appliances electrical demand in J
|
|
:param value: dict{[float]}
|
|
"""
|
|
self._appliances_electrical_demand = value
|
|
|
|
@property
|
|
def domestic_hot_water_heat_demand(self) -> dict:
|
|
"""
|
|
Get domestic hot water heat demand in J
|
|
:return: dict{[float]}
|
|
"""
|
|
return self._domestic_hot_water_heat_demand
|
|
|
|
@domestic_hot_water_heat_demand.setter
|
|
def domestic_hot_water_heat_demand(self, value):
|
|
"""
|
|
Set domestic hot water heat demand in J
|
|
:param value: dict{[float]}
|
|
"""
|
|
self._domestic_hot_water_heat_demand = value
|
|
|
|
@property
|
|
def lighting_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get lighting peak load in W
|
|
:return: dict{[float]}
|
|
"""
|
|
results = {}
|
|
peak_lighting = 0
|
|
peak = 0
|
|
for thermal_zone in self.thermal_zones_from_internal_zones:
|
|
lighting = thermal_zone.lighting
|
|
for schedule in lighting.schedules:
|
|
peak = max(schedule.values) * lighting.density * thermal_zone.total_floor_area
|
|
if peak > peak_lighting:
|
|
peak_lighting = peak
|
|
results[cte.MONTH] = [peak for _ in range(0, 12)]
|
|
results[cte.YEAR] = [peak]
|
|
return results
|
|
|
|
@property
|
|
def appliances_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get appliances peak load in W
|
|
:return: dict{[float]}
|
|
"""
|
|
results = {}
|
|
peak_appliances = 0
|
|
peak = 0
|
|
for thermal_zone in self.thermal_zones_from_internal_zones:
|
|
appliances = thermal_zone.appliances
|
|
for schedule in appliances.schedules:
|
|
peak = max(schedule.values) * appliances.density * thermal_zone.total_floor_area
|
|
if peak > peak_appliances:
|
|
peak_appliances = peak
|
|
results[cte.MONTH] = [peak for _ in range(0, 12)]
|
|
results[cte.YEAR] = [peak]
|
|
return results
|
|
|
|
@property
|
|
def heating_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get heating peak load in W
|
|
:return: dict{[float]}
|
|
"""
|
|
results = {}
|
|
if cte.HOUR in self.heating_demand:
|
|
monthly_values = PeakLoads().peak_loads_from_hourly(self.heating_demand[cte.HOUR])
|
|
else:
|
|
monthly_values = PeakLoads(self).heating_peak_loads_from_methodology
|
|
if monthly_values is None:
|
|
return None
|
|
results[cte.MONTH] = [x * cte.WATTS_HOUR_TO_JULES for x in monthly_values]
|
|
results[cte.YEAR] = [max(monthly_values)]
|
|
return results
|
|
|
|
@property
|
|
def cooling_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get cooling peak load in W
|
|
:return: dict{[float]}
|
|
"""
|
|
results = {}
|
|
if cte.HOUR in self.cooling_demand:
|
|
monthly_values = PeakLoads().peak_loads_from_hourly(self.cooling_demand[cte.HOUR])
|
|
else:
|
|
monthly_values = PeakLoads(self).cooling_peak_loads_from_methodology
|
|
if monthly_values is None:
|
|
return None
|
|
results[cte.MONTH] = [x * cte.WATTS_HOUR_TO_JULES for x in monthly_values]
|
|
results[cte.YEAR] = [max(monthly_values)]
|
|
return results
|
|
|
|
@property
|
|
def domestic_hot_water_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get cooling peak load in W
|
|
:return: dict{[float]}
|
|
"""
|
|
results = {}
|
|
monthly_values = None
|
|
if cte.HOUR in self.domestic_hot_water_heat_demand:
|
|
monthly_values = PeakLoads().peak_loads_from_hourly(self.domestic_hot_water_heat_demand[cte.HOUR])
|
|
if monthly_values is None:
|
|
return None
|
|
results[cte.MONTH] = [x for x in monthly_values]
|
|
results[cte.YEAR] = [max(monthly_values)]
|
|
return results
|
|
|
|
@property
|
|
def eave_height(self):
|
|
"""
|
|
Get building eave height in meters
|
|
:return: float
|
|
"""
|
|
if self._eave_height is None:
|
|
self._eave_height = 0
|
|
for wall in self.walls:
|
|
self._eave_height = max(self._eave_height, wall.upper_corner[2]) - self.simplified_polyhedron.min_z
|
|
return self._eave_height
|
|
|
|
@property
|
|
def roof_type(self):
|
|
"""
|
|
Get roof type for the building flat or pitch
|
|
:return: str
|
|
"""
|
|
if self._roof_type is None:
|
|
self._roof_type = 'flat'
|
|
for roof in self.roofs:
|
|
grads = np.rad2deg(roof.inclination)
|
|
if 355 > grads > 5:
|
|
self._roof_type = 'pitch'
|
|
break
|
|
return self._roof_type
|
|
|
|
@roof_type.setter
|
|
def roof_type(self, value):
|
|
"""
|
|
Set roof type for the building flat or pitch
|
|
:return: str
|
|
"""
|
|
self._roof_type = value
|
|
|
|
@property
|
|
def floor_area(self):
|
|
"""
|
|
Get building floor area in square meters
|
|
:return: float
|
|
"""
|
|
if self._floor_area is None:
|
|
self._floor_area = 0
|
|
for surface in self.surfaces:
|
|
if surface.type == 'Ground':
|
|
self._floor_area += surface.perimeter_polygon.area
|
|
return self._floor_area
|
|
|
|
@property
|
|
def households(self) -> List[Household]:
|
|
"""
|
|
Get the list of households inside the building
|
|
:return: List[Household]
|
|
"""
|
|
return self._households
|
|
|
|
@property
|
|
def is_conditioned(self):
|
|
"""
|
|
Get building heated flag
|
|
:return: Boolean
|
|
"""
|
|
if self.internal_zones is None:
|
|
return False
|
|
for internal_zone in self.internal_zones:
|
|
if internal_zone.usages is not None:
|
|
for usage in internal_zone.usages:
|
|
if usage.thermal_control is not None:
|
|
return True
|
|
return False
|
|
|
|
@property
|
|
def aliases(self):
|
|
"""
|
|
Get the alias name for the building
|
|
:return: str
|
|
"""
|
|
return self._aliases
|
|
|
|
def add_alias(self, value):
|
|
"""
|
|
Add a new alias for the building
|
|
"""
|
|
self._aliases.append(value)
|
|
if self.city is not None:
|
|
self.city.add_building_alias(self, value)
|
|
|
|
@property
|
|
def city(self) -> City:
|
|
"""
|
|
Get the city containing the building
|
|
:return: City
|
|
"""
|
|
return self._city
|
|
|
|
@city.setter
|
|
def city(self, value):
|
|
"""
|
|
Set the city containing the building
|
|
"""
|
|
self._city = value
|
|
|
|
@property
|
|
def usages_percentage(self):
|
|
"""
|
|
Get the usages and percentages for the building
|
|
"""
|
|
_usage = ''
|
|
for internal_zone in self.internal_zones:
|
|
if internal_zone.usages is None:
|
|
continue
|
|
for usage in internal_zone.usages:
|
|
_usage = f'{_usage}{usage.name}_{usage.percentage} '
|
|
return _usage.rstrip()
|
|
|
|
@property
|
|
def energy_systems(self) -> Union[None, List[EnergySystem]]:
|
|
"""
|
|
Get list of energy systems installed to cover the building demands
|
|
:return: [EnergySystem]
|
|
"""
|
|
return self._energy_systems
|
|
|
|
@energy_systems.setter
|
|
def energy_systems(self, value):
|
|
"""
|
|
Set list of energy systems installed to cover the building demands
|
|
:param value: [EnergySystem]
|
|
"""
|
|
self._energy_systems = value
|
|
|
|
@property
|
|
def energy_systems_archetype_name(self):
|
|
"""
|
|
Get energy systems archetype name
|
|
:return: str
|
|
"""
|
|
return self._systems_archetype_name
|
|
|
|
@energy_systems_archetype_name.setter
|
|
def energy_systems_archetype_name(self, value):
|
|
"""
|
|
Set energy systems archetype name
|
|
:param value: str
|
|
"""
|
|
self._systems_archetype_name = value
|
|
|
|
@property
|
|
def heating_consumption(self):
|
|
"""
|
|
Get energy consumption for heating according to the heating system installed in J
|
|
return: dict
|
|
"""
|
|
if len(self._heating_consumption) == 0:
|
|
for heating_demand_key in self.heating_demand:
|
|
demand = self.heating_demand[heating_demand_key]
|
|
consumption_type = cte.HEATING
|
|
final_energy_consumed = self._calculate_consumption(consumption_type, demand)
|
|
if final_energy_consumed is None:
|
|
continue
|
|
self._heating_consumption[heating_demand_key] = final_energy_consumed
|
|
return self._heating_consumption
|
|
|
|
@property
|
|
def cooling_consumption(self):
|
|
"""
|
|
Get energy consumption for cooling according to the cooling system installed in J
|
|
return: dict
|
|
"""
|
|
if len(self._cooling_consumption) == 0:
|
|
for cooling_demand_key in self.cooling_demand:
|
|
demand = self.cooling_demand[cooling_demand_key]
|
|
consumption_type = cte.COOLING
|
|
final_energy_consumed = self._calculate_consumption(consumption_type, demand)
|
|
if final_energy_consumed is None:
|
|
continue
|
|
self._cooling_consumption[cooling_demand_key] = final_energy_consumed
|
|
return self._cooling_consumption
|
|
|
|
@property
|
|
def domestic_hot_water_consumption(self):
|
|
"""
|
|
Get energy consumption for domestic according to the domestic hot water system installed in J
|
|
return: dict
|
|
"""
|
|
if len(self._domestic_hot_water_consumption) == 0:
|
|
for domestic_hot_water_demand_key in self.domestic_hot_water_heat_demand:
|
|
demand = self.domestic_hot_water_heat_demand[domestic_hot_water_demand_key]
|
|
consumption_type = cte.DOMESTIC_HOT_WATER
|
|
final_energy_consumed = self._calculate_consumption(consumption_type, demand)
|
|
if final_energy_consumed is None:
|
|
continue
|
|
self._domestic_hot_water_consumption[domestic_hot_water_demand_key] = final_energy_consumed
|
|
return self._domestic_hot_water_consumption
|
|
|
|
def _calculate_working_hours(self):
|
|
_working_hours = {}
|
|
for internal_zone in self.internal_zones:
|
|
for thermal_zone in internal_zone.thermal_zones_from_internal_zones:
|
|
_working_hours_per_thermal_zone = {}
|
|
for schedule in thermal_zone.thermal_control.hvac_availability_schedules:
|
|
_working_hours_per_schedule = [0] * len(schedule.values)
|
|
for i, value in enumerate(schedule.values):
|
|
if value > 0:
|
|
_working_hours_per_schedule[i] = 1
|
|
for day_type in schedule.day_types:
|
|
_working_hours_per_thermal_zone[day_type] = _working_hours_per_schedule
|
|
if len(_working_hours) == 0:
|
|
_working_hours = _working_hours_per_thermal_zone
|
|
else:
|
|
for key, item in _working_hours.items():
|
|
saved_values = _working_hours_per_thermal_zone[key]
|
|
for i, value in enumerate(item):
|
|
_working_hours[key][i] = max(_working_hours[key][i], saved_values[i])
|
|
|
|
working_hours = {}
|
|
values_months = []
|
|
for month in cte.WEEK_DAYS_A_MONTH.keys():
|
|
_total_hours_month = 0
|
|
for key in _working_hours:
|
|
hours = sum(_working_hours[key])
|
|
_total_hours_month += hours * cte.WEEK_DAYS_A_MONTH[month][key]
|
|
values_months.append(_total_hours_month)
|
|
working_hours[cte.MONTH] = values_months
|
|
working_hours[cte.YEAR] = sum(working_hours[cte.MONTH])
|
|
return working_hours
|
|
|
|
@property
|
|
def distribution_systems_electrical_consumption(self):
|
|
"""
|
|
Get total electricity consumption for distribution and emission systems in J
|
|
return: dict
|
|
"""
|
|
_distribution_systems_electrical_consumption = {}
|
|
if len(self._distribution_systems_electrical_consumption) != 0:
|
|
return self._distribution_systems_electrical_consumption
|
|
_peak_load = self.heating_peak_load[cte.YEAR][0]
|
|
_peak_load_type = cte.HEATING
|
|
if _peak_load < self.cooling_peak_load[cte.YEAR][0]:
|
|
_peak_load = self.cooling_peak_load[cte.YEAR][0]
|
|
_peak_load_type = cte.COOLING
|
|
|
|
_working_hours = self._calculate_working_hours()
|
|
_consumption_fix_flow = 0
|
|
if self.energy_systems is None:
|
|
return self._distribution_systems_electrical_consumption
|
|
for energy_system in self.energy_systems:
|
|
distribution_systems = energy_system.distribution_systems
|
|
for distribution_system in distribution_systems:
|
|
emission_systems = distribution_system.emission_systems
|
|
parasitic_energy_consumption = 0
|
|
if emission_systems is not None:
|
|
for emission_system in emission_systems:
|
|
parasitic_energy_consumption += emission_system.parasitic_energy_consumption
|
|
consumption_variable_flow = distribution_system.distribution_consumption_variable_flow
|
|
for demand_type in energy_system.demand_types:
|
|
if demand_type.lower() == cte.HEATING.lower():
|
|
if _peak_load_type == cte.HEATING.lower():
|
|
_consumption_fix_flow = distribution_system.distribution_consumption_fix_flow
|
|
for heating_demand_key in self.heating_demand:
|
|
_consumption = [0]*len(self.heating_demand[heating_demand_key])
|
|
_demand = self.heating_demand[heating_demand_key]
|
|
for i, _ in enumerate(_consumption):
|
|
_consumption[i] += (parasitic_energy_consumption + consumption_variable_flow) * _demand[i]
|
|
self._distribution_systems_electrical_consumption[heating_demand_key] = _consumption
|
|
if demand_type.lower() == cte.COOLING.lower():
|
|
if _peak_load_type == cte.COOLING.lower():
|
|
_consumption_fix_flow = distribution_system.distribution_consumption_fix_flow
|
|
for demand_key in self.cooling_demand:
|
|
_consumption = self._distribution_systems_electrical_consumption[demand_key]
|
|
_demand = self.cooling_demand[demand_key]
|
|
for i, _ in enumerate(_consumption):
|
|
_consumption[i] += (parasitic_energy_consumption + consumption_variable_flow) * _demand[i]
|
|
self._distribution_systems_electrical_consumption[demand_key] = _consumption
|
|
|
|
for key, item in self._distribution_systems_electrical_consumption.items():
|
|
for i in range(0, len(item)):
|
|
_working_hours_value = _working_hours[key]
|
|
if len(item) == 12:
|
|
_working_hours_value = _working_hours[key][i]
|
|
self._distribution_systems_electrical_consumption[key][i] += (
|
|
_peak_load * _consumption_fix_flow * _working_hours_value * cte.WATTS_HOUR_TO_JULES
|
|
)
|
|
|
|
return self._distribution_systems_electrical_consumption
|
|
|
|
def _calculate_consumption(self, consumption_type, demand):
|
|
# todo: modify when COP depends on the hour
|
|
coefficient_of_performance = 0
|
|
if self.energy_systems is None:
|
|
return None
|
|
for energy_system in self.energy_systems:
|
|
generation_systems = energy_system.generation_systems
|
|
for demand_type in energy_system.demand_types:
|
|
if demand_type.lower() == consumption_type.lower():
|
|
if consumption_type in (cte.HEATING, cte.DOMESTIC_HOT_WATER):
|
|
for generation_system in generation_systems:
|
|
if generation_system.heat_efficiency is not None:
|
|
coefficient_of_performance = float(generation_system.heat_efficiency)
|
|
elif consumption_type == cte.COOLING:
|
|
for generation_system in generation_systems:
|
|
if generation_system.cooling_efficiency is not None:
|
|
coefficient_of_performance = float(generation_system.cooling_efficiency)
|
|
elif consumption_type == cte.ELECTRICITY:
|
|
for generation_system in generation_systems:
|
|
if generation_system.electricity_efficiency is not None:
|
|
coefficient_of_performance = float(generation_system.electricity_efficiency)
|
|
if coefficient_of_performance == 0:
|
|
values = [0]*len(demand)
|
|
final_energy_consumed = values
|
|
else:
|
|
final_energy_consumed = []
|
|
for demand_value in demand:
|
|
final_energy_consumed.append(demand_value / coefficient_of_performance)
|
|
return final_energy_consumed
|
|
|
|
@property
|
|
def onsite_electrical_production(self):
|
|
"""
|
|
Get total electricity produced onsite in J
|
|
return: dict
|
|
"""
|
|
orientation_losses_factor = {cte.MONTH: {'north': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
'east': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
'south': [2.137931, 1.645503, 1.320946, 1.107817, 0.993213, 0.945175,
|
|
0.967949, 1.065534, 1.24183, 1.486486, 1.918033, 2.210526],
|
|
'west': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]},
|
|
cte.YEAR: {'north': [0],
|
|
'east': [0],
|
|
'south': [1.212544],
|
|
'west': [0]}
|
|
}
|
|
|
|
# Add other systems whenever new ones appear
|
|
if self.energy_systems is None:
|
|
return self._onsite_electrical_production
|
|
for energy_system in self.energy_systems:
|
|
for generation_system in energy_system.generation_systems:
|
|
if generation_system.system_type == cte.PHOTOVOLTAIC:
|
|
if generation_system.electricity_efficiency is not None:
|
|
_efficiency = float(generation_system.electricity_efficiency)
|
|
else:
|
|
_efficiency = 0
|
|
self._onsite_electrical_production = {}
|
|
for _key in self.roofs[0].global_irradiance.keys():
|
|
_results = [0 for _ in range(0, len(self.roofs[0].global_irradiance[_key]))]
|
|
for surface in self.roofs:
|
|
if _key in orientation_losses_factor:
|
|
_results = [x + y * _efficiency * surface.perimeter_area
|
|
* surface.solar_collectors_area_reduction_factor * z
|
|
for x, y, z in zip(_results, surface.global_irradiance[_key],
|
|
orientation_losses_factor[_key]['south'])]
|
|
self._onsite_electrical_production[_key] = _results
|
|
return self._onsite_electrical_production
|
|
|
|
@property
|
|
def lower_corner(self):
|
|
"""
|
|
Get building lower corner.
|
|
"""
|
|
return [self._min_x, self._min_y, self._min_z]
|
|
|
|
@property
|
|
def upper_corner(self):
|
|
"""
|
|
Get building upper corner.
|
|
"""
|
|
return [self._max_x, self._max_y, self._max_z]
|
|
|
|
@property
|
|
def energy_consumption_breakdown(self) -> dict:
|
|
"""
|
|
Get energy consumption of different sectors
|
|
return: dict
|
|
"""
|
|
fuel_breakdown = {cte.ELECTRICITY: {cte.LIGHTING: self.lighting_electrical_demand[cte.YEAR][0],
|
|
cte.APPLIANCES: self.appliances_electrical_demand[cte.YEAR][0]}}
|
|
energy_systems = self.energy_systems
|
|
for energy_system in energy_systems:
|
|
demand_types = energy_system.demand_types
|
|
generation_systems = energy_system.generation_systems
|
|
for demand_type in demand_types:
|
|
for generation_system in generation_systems:
|
|
if generation_system.system_type != cte.PHOTOVOLTAIC:
|
|
if generation_system.fuel_type not in fuel_breakdown:
|
|
fuel_breakdown[generation_system.fuel_type] = {}
|
|
if demand_type in generation_system.energy_consumption:
|
|
fuel_breakdown[f'{generation_system.fuel_type}'][f'{demand_type}'] = (
|
|
generation_system.energy_consumption)[f'{demand_type}'][cte.YEAR][0]
|
|
#TODO: When simulation models of all energy system archetypes are created, this part can be removed
|
|
heating = 0
|
|
cooling = 0
|
|
dhw = 0
|
|
for key in fuel_breakdown:
|
|
if cte.HEATING not in fuel_breakdown[key]:
|
|
heating += 1
|
|
if key == cte.ELECTRICITY and cte.COOLING not in fuel_breakdown[key]:
|
|
cooling += 1
|
|
if cte.DOMESTIC_HOT_WATER not in fuel_breakdown[key]:
|
|
dhw += 1
|
|
if heating > 0:
|
|
for energy_system in energy_systems:
|
|
if cte.HEATING in energy_system.demand_types:
|
|
for generation_system in energy_system.generation_systems:
|
|
fuel_breakdown[generation_system.fuel_type][cte.HEATING] = self.heating_consumption[cte.YEAR][0] / 3600
|
|
if dhw > 0:
|
|
for energy_system in energy_systems:
|
|
if cte.DOMESTIC_HOT_WATER in energy_system.demand_types:
|
|
for generation_system in energy_system.generation_systems:
|
|
fuel_breakdown[generation_system.fuel_type][cte.DOMESTIC_HOT_WATER] = \
|
|
self.domestic_hot_water_consumption[cte.YEAR][0] / 3600
|
|
if cooling > 0:
|
|
for energy_system in energy_systems:
|
|
if cte.COOLING in energy_system.demand_types:
|
|
for generation_system in energy_system.generation_systems:
|
|
fuel_breakdown[generation_system.fuel_type][cte.COOLING] = self.cooling_consumption[cte.YEAR][0] / 3600
|
|
|
|
|
|
|
|
|
|
|
|
self._fuel_consumption_breakdown = fuel_breakdown
|
|
return self._fuel_consumption_breakdown
|