system_assignation/hub/city_model_structure/building.py

"""
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._heating_consumption_disaggregated = {}

  @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 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)):
          self._distribution_systems_electrical_consumption[key][i] += _peak_load * _consumption_fix_flow \
                                                                       * _working_hours[key] * 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 heating_consumption_disaggregated(self) -> dict:
    """
    Get energy consumed for heating from different fuels in J
    return: dict
    """
    return self._heating_consumption_disaggregated

  @heating_consumption_disaggregated.setter
  def heating_consumption_disaggregated(self, value):
    """
    Get energy consumed for heating from different fuels in J
    return: dict
    """
    self._heating_consumption_disaggregated = value