686 lines
22 KiB
Python
686 lines
22 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 sys
|
|
from typing import List, Union
|
|
import numpy as np
|
|
import pandas as pd
|
|
|
|
from hub.hub_logger import logger
|
|
import hub.helpers.constants as cte
|
|
from hub.helpers.peak_loads import PeakLoads
|
|
from hub.city_model_structure.building_demand.surface import Surface
|
|
from hub.city_model_structure.city_object import CityObject
|
|
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.attributes.polyhedron import Polyhedron
|
|
from hub.city_model_structure.energy_systems.energy_system import EnergySystem
|
|
|
|
|
|
class Building(CityObject):
|
|
"""
|
|
Building(CityObject) class
|
|
"""
|
|
def __init__(self, name, surfaces, year_of_construction, function, terrains=None):
|
|
super().__init__(name, surfaces)
|
|
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._shell = None
|
|
self._alias = None
|
|
self._type = 'building'
|
|
self._cold_water_temperature = dict()
|
|
self._heating = dict()
|
|
self._cooling = dict()
|
|
self._lighting_electrical_demand = dict()
|
|
self._appliances_electrical_demand = dict()
|
|
self._domestic_hot_water_heat_demand = dict()
|
|
self._heating_consumption = dict()
|
|
self._cooling_consumption = dict()
|
|
self._domestic_hot_water_consumption = dict()
|
|
self._distribution_systems_electrical_consumption = dict()
|
|
self._onsite_electrical_production = dict()
|
|
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])
|
|
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:
|
|
logger.error(f'Building {self.name} [alias {self.alias}] has an unexpected surface type {surface.type}.\n')
|
|
sys.stderr.write(f'Building {self.name} [alias {self.alias}] has an unexpected surface type {surface.type}.\n')
|
|
|
|
@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)]
|
|
return self._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
|
|
"""
|
|
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
|
|
"""
|
|
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{DataFrame(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{DataFrame(float)}
|
|
"""
|
|
self._cold_water_temperature = value
|
|
|
|
@property
|
|
def heating(self) -> dict:
|
|
"""
|
|
Get heating demand in Wh
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._heating
|
|
|
|
@heating.setter
|
|
def heating(self, value):
|
|
"""
|
|
Set heating demand in Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._heating = value
|
|
|
|
@property
|
|
def cooling(self) -> dict:
|
|
"""
|
|
Get cooling demand in Wh
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._cooling
|
|
|
|
@cooling.setter
|
|
def cooling(self, value):
|
|
"""
|
|
Set cooling demand in Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._cooling = value
|
|
|
|
@property
|
|
def lighting_electrical_demand(self) -> dict:
|
|
"""
|
|
Get lighting electrical demand in Wh
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._lighting_electrical_demand
|
|
|
|
@lighting_electrical_demand.setter
|
|
def lighting_electrical_demand(self, value):
|
|
"""
|
|
Set lighting electrical demand in Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._lighting_electrical_demand = value
|
|
|
|
@property
|
|
def appliances_electrical_demand(self) -> dict:
|
|
"""
|
|
Get appliances electrical demand in Wh
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._appliances_electrical_demand
|
|
|
|
@appliances_electrical_demand.setter
|
|
def appliances_electrical_demand(self, value):
|
|
"""
|
|
Set appliances electrical demand in Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._appliances_electrical_demand = value
|
|
|
|
@property
|
|
def domestic_hot_water_heat_demand(self) -> dict:
|
|
"""
|
|
Get domestic hot water heat demand in Wh
|
|
:return: dict{DataFrame(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 Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._domestic_hot_water_heat_demand = value
|
|
|
|
@property
|
|
def heating_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get heating peak load in W
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
results = {}
|
|
if cte.HOUR in self.heating:
|
|
monthly_values = PeakLoads().\
|
|
peak_loads_from_hourly(self.heating[cte.HOUR][next(iter(self.heating[cte.HOUR]))].values)
|
|
else:
|
|
monthly_values = PeakLoads(self).heating_peak_loads_from_methodology
|
|
if monthly_values is None:
|
|
return None
|
|
results[cte.MONTH] = pd.DataFrame(monthly_values, columns=['heating peak loads'])
|
|
results[cte.YEAR] = pd.DataFrame([max(monthly_values)], columns=['heating peak loads'])
|
|
return results
|
|
|
|
@property
|
|
def cooling_peak_load(self) -> Union[None, dict]:
|
|
"""
|
|
Get cooling peak load in W
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
results = {}
|
|
monthly_values = None
|
|
if cte.HOUR in self.cooling:
|
|
# todo: .values???????? Like heating
|
|
monthly_values = PeakLoads().peak_loads_from_hourly(self.cooling[cte.HOUR][next(iter(self.cooling[cte.HOUR]))])
|
|
else:
|
|
monthly_values = PeakLoads(self).cooling_peak_loads_from_methodology
|
|
if monthly_values is None:
|
|
return None
|
|
results[cte.MONTH] = pd.DataFrame(monthly_values, columns=['cooling peak loads'])
|
|
results[cte.YEAR] = pd.DataFrame([max(monthly_values)], columns=['cooling peak loads'])
|
|
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])
|
|
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 alias(self):
|
|
"""
|
|
Get the alias name for the building
|
|
:return: str
|
|
"""
|
|
return self._alias
|
|
|
|
@alias.setter
|
|
def alias(self, value):
|
|
"""
|
|
Set the alias name for the building
|
|
"""
|
|
self._alias = value
|
|
|
|
@property
|
|
def usages_percentage(self):
|
|
"""
|
|
Get the usages and percentages for the building
|
|
"""
|
|
_usage = ''
|
|
for internal_zone in self.internal_zones:
|
|
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 Wh
|
|
return: dict
|
|
"""
|
|
if len(self._heating_consumption) == 0:
|
|
for heating_demand_key in self.heating:
|
|
demand = self.heating[heating_demand_key][cte.INSEL_MEB]
|
|
consumption_type = cte.HEATING
|
|
final_energy_consumed = self._calculate_consumption(consumption_type, demand)
|
|
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 Wh
|
|
return: dict
|
|
"""
|
|
if len(self._cooling_consumption) == 0:
|
|
for cooling_demand_key in self.cooling:
|
|
demand = self.cooling[cooling_demand_key][cte.INSEL_MEB]
|
|
consumption_type = cte.COOLING
|
|
final_energy_consumed = self._calculate_consumption(consumption_type, demand)
|
|
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 Wh
|
|
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][cte.INSEL_MEB]
|
|
consumption_type = cte.DOMESTIC_HOT_WATER
|
|
final_energy_consumed = self._calculate_consumption(consumption_type, demand)
|
|
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:
|
|
_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 in _working_hours.keys():
|
|
saved_values = _working_hours_per_thermal_zone[key]
|
|
for i, value in enumerate(_working_hours[key]):
|
|
if saved_values[i] == 1:
|
|
_working_hours[key][i] = 1
|
|
_total_hours = 0
|
|
for key in _working_hours:
|
|
_total_hours += _working_hours[key] * cte.DAYS_A_YEAR[key]
|
|
return _total_hours
|
|
|
|
@property
|
|
def distribution_systems_electrical_consumption(self):
|
|
"""
|
|
Get total electricity consumption for distribution and emission systems in Wh
|
|
return: dict
|
|
"""
|
|
if len(self._distribution_systems_electrical_consumption) == 0:
|
|
_peak_load = self.heating_peak_load[cte.YEAR]['heating peak loads'][0]
|
|
_peak_load_type = cte.HEATING
|
|
if _peak_load < self.cooling_peak_load[cte.YEAR]['cooling peak loads'][0]:
|
|
_peak_load = self.cooling_peak_load[cte.YEAR]['cooling peak loads'][0]
|
|
_peak_load_type = cte.COOLING
|
|
|
|
_consumption_fix_flow = 0
|
|
for energy_system in self.energy_systems:
|
|
emission_system = energy_system.emission_system.generic_emission_system
|
|
parasitic_energy_consumption = emission_system.parasitic_energy_consumption
|
|
distribution_system = energy_system.distribution_system.generic_distribution_system
|
|
consumption_variable_flow = distribution_system.distribution_consumption_variable_flow
|
|
for demand_type in energy_system.demand_types:
|
|
if demand_type.lower() == cte.HEATING:
|
|
if _peak_load_type == cte.HEATING:
|
|
_consumption_fix_flow = distribution_system.distribution_consumption_fix_flow
|
|
for heating_demand_key in self.heating:
|
|
_consumption = [0]*len(self.heating)
|
|
_demand = self.heating[heating_demand_key][cte.INSEL_MEB]
|
|
for i in range(0, len(_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:
|
|
if _peak_load_type == cte.COOLING:
|
|
_consumption_fix_flow = distribution_system.distribution_consumption_fix_flow
|
|
for demand_key in self.cooling:
|
|
_consumption = self._distribution_systems_electrical_consumption[demand_key]
|
|
_demand = self.cooling[demand_key][cte.INSEL_MEB]
|
|
for i in range(0, len(_consumption)):
|
|
_consumption[i] += (parasitic_energy_consumption + consumption_variable_flow) * _demand[i]
|
|
self._distribution_systems_electrical_consumption[demand_key] = _consumption
|
|
|
|
for key in self._distribution_systems_electrical_consumption:
|
|
for i in range(0, len(self._distribution_systems_electrical_consumption[key])):
|
|
self._distribution_systems_electrical_consumption[key][i] += _peak_load * _consumption_fix_flow \
|
|
* self._calculate_working_hours()
|
|
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
|
|
for energy_system in self.energy_systems:
|
|
for demand_type in energy_system.demand_types:
|
|
if demand_type.lower() == consumption_type.lower():
|
|
if consumption_type == cte.HEATING or consumption_type == cte.DOMESTIC_HOT_WATER:
|
|
coefficient_of_performance = energy_system.generation_system.generic_generation_system.heat_efficiency
|
|
elif consumption_type == cte.COOLING:
|
|
coefficient_of_performance = energy_system.generation_system.generic_generation_system.cooling_efficiency
|
|
elif consumption_type == cte.ELECTRICITY:
|
|
coefficient_of_performance = \
|
|
energy_system.generation_system.generic_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 Wh
|
|
return: dict
|
|
"""
|
|
# Add other systems whenever new ones appear
|
|
for energy_system in self.energy_systems:
|
|
if energy_system.generation_system.generic_generation_system.type == cte.PHOTOVOLTAIC:
|
|
_efficiency = energy_system.generation_system.generic_generation_system.electricity_efficiency
|
|
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.surfaces:
|
|
_results = [x + y * _efficiency * surface.perimeter_area * surface.solar_collectors_area_reduction_factor
|
|
for x, y in zip(_results, surface.global_irradiance[_key])]
|
|
self._onsite_electrical_production[_key] = _results
|
|
return self._onsite_electrical_production
|