diff --git a/hub/RECOGNIZED_FUNTIONS_AND_USAGES.md b/hub/RECOGNIZED_FUNTIONS_AND_USAGES.md index b3439b5f..107ba6f2 100644 --- a/hub/RECOGNIZED_FUNTIONS_AND_USAGES.md +++ b/hub/RECOGNIZED_FUNTIONS_AND_USAGES.md @@ -15,6 +15,7 @@ Output formats accepted: * ca * hft * comnet + * Eilat Libs_functions: * single family house diff --git a/hub/catalog_factories/usage/comnet_catalog.py b/hub/catalog_factories/usage/comnet_catalog.py index 1d527573..e78fed67 100644 --- a/hub/catalog_factories/usage/comnet_catalog.py +++ b/hub/catalog_factories/usage/comnet_catalog.py @@ -33,7 +33,6 @@ class ComnetCatalog(Catalog): self._archetypes = self._read_archetype_file() self._schedules = self._read_schedules_file() - # todo: comment with @Guille, this hypotheses should go in the import factory? sensible_convective = ch().comnet_occupancy_sensible_convective sensible_radiative = ch().comnet_occupancy_sensible_radiant lighting_convective = ch().comnet_lighting_convective diff --git a/hub/catalog_factories/usage/eilat_catalog.py b/hub/catalog_factories/usage/eilat_catalog.py new file mode 100644 index 00000000..4b70c47c --- /dev/null +++ b/hub/catalog_factories/usage/eilat_catalog.py @@ -0,0 +1,234 @@ +""" +Eilat usage catalog +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2022 Concordia CERC group +Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +""" +import io +from typing import Dict + +import pandas as pd + +import hub.helpers.constants as cte +from hub.catalog_factories.catalog import Catalog +from hub.catalog_factories.data_models.usages.appliances import Appliances +from hub.catalog_factories.data_models.usages.content import Content +from hub.catalog_factories.data_models.usages.lighting import Lighting +from hub.catalog_factories.data_models.usages.occupancy import Occupancy +from hub.catalog_factories.data_models.usages.domestic_hot_water import DomesticHotWater +from hub.catalog_factories.data_models.usages.schedule import Schedule +from hub.catalog_factories.data_models.usages.thermal_control import ThermalControl +from hub.catalog_factories.data_models.usages.usage import Usage +from hub.catalog_factories.usage.usage_helper import UsageHelper +from hub.helpers.configuration_helper import ConfigurationHelper as ch + + +class EilatCatalog(Catalog): + """ + Eilat catalog class + """ + def __init__(self, path): + self._eilat_archetypes_path = str(path / 'eilat_archetypes.xlsx') + self._eilat_schedules_path = str(path / 'eilat_schedules_archetypes.xlsx') + self._archetypes = self._read_archetype_file() + self._schedules = self._read_schedules_file() + + sensible_convective = ch().comnet_occupancy_sensible_convective + sensible_radiative = ch().comnet_occupancy_sensible_radiant + lighting_convective = ch().comnet_lighting_convective + lighting_radiative = ch().comnet_lighting_radiant + lighting_latent = ch().comnet_lighting_latent + appliances_convective = ch().comnet_plugs_convective + appliances_radiative = ch().comnet_plugs_radiant + appliances_latent = ch().comnet_plugs_latent + + usages = [] + for schedule_key in self._archetypes['schedules_key']: + eilat_usage = schedule_key + schedule_name = self._archetypes['schedules_key'][schedule_key] + hours_day = None + days_year = None + occupancy_archetype = self._archetypes['occupancy'][eilat_usage] + lighting_archetype = self._archetypes['lighting'][eilat_usage] + appliances_archetype = self._archetypes['plug loads'][eilat_usage] + mechanical_air_change = None # eilat provides ventilation rate only + ventilation_rate = self._archetypes['ventilation rate'][eilat_usage] + # convert cfm/ft2 to m3/m2.s + ventilation_rate = ventilation_rate / (cte.METERS_TO_FEET * cte.MINUTES_TO_SECONDS) + domestic_hot_water_archetype = self._archetypes['water heating'][eilat_usage] + + # get occupancy + occupancy_density = occupancy_archetype[0] / pow(cte.METERS_TO_FEET, 2) + sensible_heat_gain = occupancy_archetype[1] * cte.BTU_H_TO_WATTS + latent_heat_gain = occupancy_archetype[1] * cte.BTU_H_TO_WATTS + if occupancy_density != 0: + occupancy_density = 1 / occupancy_density + sensible_convective_internal_gain = occupancy_density * sensible_heat_gain * sensible_convective + sensible_radiative_internal_gain = occupancy_density * sensible_heat_gain * sensible_radiative + latent_internal_gain = occupancy_density * latent_heat_gain + occupancy = Occupancy(occupancy_density, + sensible_convective_internal_gain, + sensible_radiative_internal_gain, + latent_internal_gain, + self._schedules[schedule_name]['Occupancy']) + + # get lighting + density = lighting_archetype[4] * pow(cte.METERS_TO_FEET, 2) + lighting = Lighting(density, + lighting_convective, + lighting_radiative, + lighting_latent, + self._schedules[schedule_name]['Lights']) + + # get appliances + density = appliances_archetype[0] + if density == 'n.a.': + density = 0 + # convert W/ft2 to W/m2 + density = float(density) * pow(cte.METERS_TO_FEET, 2) + appliances = Appliances(density, + appliances_convective, + appliances_radiative, + appliances_latent, + self._schedules[schedule_name]['Receptacle']) + + # get thermal control + thermal_control = ThermalControl(None, + None, + None, + self._schedules[schedule_name]['HVAC Avail'], + self._schedules[schedule_name]['HtgSetPt'], + self._schedules[schedule_name]['ClgSetPt'] + ) + + # get domestic hot water + density = domestic_hot_water_archetype + # convert Btu/h/occ to W/m2 + density = float(density) * cte.BTU_H_TO_WATTS * occupancy_density + domestic_hot_water_service_temperature = self._schedules[schedule_name]['WtrHtrSetPt'][0].values[0] + domestic_hot_water = DomesticHotWater(density, + None, + domestic_hot_water_service_temperature, + self._schedules[schedule_name]['Service Hot Water'] + ) + usages.append(Usage(eilat_usage, + hours_day, + days_year, + mechanical_air_change, + ventilation_rate, + occupancy, + lighting, + appliances, + thermal_control, + domestic_hot_water)) + + self._content = Content(usages) + + def _read_schedules_file(self) -> Dict: + dictionary = {} + eilat_usages = UsageHelper().eilat_schedules_key_to_eilat_schedules + eilat_days = UsageHelper().comnet_days + eilat_data_types = UsageHelper().comnet_data_type_to_hub_data_type + for usage_name in eilat_usages: + with open(self._eilat_schedules_path, 'rb') as xls: + _extracted_data = pd.read_excel( + io.BytesIO(xls.read()), + sheet_name=eilat_usages[usage_name], + skiprows=[0, 1, 2, 3], nrows=39, usecols="A:AA" + ) + _schedules = {} + for row in range(0, 39, 3): + _schedule_values = {} + schedule_name = _extracted_data.loc[row:row, 'Description'].item() + schedule_data_type = eilat_data_types[_extracted_data.loc[row:row, 'Type'].item()] + for day in eilat_days: + # Monday to Friday + start = row + end = row + 1 + if day == cte.FRIDAY: + start = start + 1 + end = end + 1 + elif day in (cte.SATURDAY, cte.HOLIDAY): + start = start + 2 + end = end + 2 + _schedule_values[day] = _extracted_data.iloc[start:end, 3:27].to_numpy().tolist()[0] + _schedule = [] + for day in _schedule_values: + if schedule_name in ('ClgSetPt', 'HtgSetPt', 'WtrHtrSetPt'): + # to celsius + if 'n.a.' in _schedule_values[day]: + _schedule_values[day] = None + else: + _schedule_values[day] = [(float(value)-32)*5/9 for value in _schedule_values[day]] + _schedule.append(Schedule(schedule_name, _schedule_values[day], schedule_data_type, cte.HOUR, cte.DAY, [day])) + _schedules[schedule_name] = _schedule + dictionary[usage_name] = _schedules + return dictionary + + def _read_archetype_file(self) -> Dict: + """ + reads xlsx files containing usage information into a dictionary + :return : Dict + """ + number_usage_types = 3 + with open(self._eilat_archetypes_path, 'rb') as xls: + _extracted_data = pd.read_excel( + io.BytesIO(xls.read()), + sheet_name="Modeling Data", + skiprows=[0, 1, 2], + nrows=number_usage_types + 1, usecols="A:AB" + ) + + lighting_data = {} + plug_loads_data = {} + occupancy_data = {} + ventilation_rate = {} + water_heating = {} + process_data = {} + schedules_key = {} + for j in range(0, number_usage_types): + usage_parameters = _extracted_data.iloc[j] + usage_type = usage_parameters[0] + lighting_data[usage_type] = usage_parameters[1:6].values.tolist() + plug_loads_data[usage_type] = usage_parameters[8:13].values.tolist() + occupancy_data[usage_type] = usage_parameters[17:20].values.tolist() + ventilation_rate[usage_type] = usage_parameters[20:21].item() + water_heating[usage_type] = usage_parameters[23:24].item() + process_data[usage_type] = usage_parameters[24:26].values.tolist() + schedules_key[usage_type] = usage_parameters[27:28].item() + + return {'lighting': lighting_data, + 'plug loads': plug_loads_data, + 'occupancy': occupancy_data, + 'ventilation rate': ventilation_rate, + 'water heating': water_heating, + 'process': process_data, + 'schedules_key': schedules_key + } + + def names(self, category=None): + """ + Get the catalog elements names + :parm: for usage catalog category filter does nothing as there is only one category (usages) + """ + _names = {'usages': []} + for usage in self._content.usages: + _names['usages'].append(usage.name) + return _names + + def entries(self, category=None): + """ + Get the catalog elements + :parm: for usage catalog category filter does nothing as there is only one category (usages) + """ + return self._content + + def get_entry(self, name): + """ + Get one catalog element by names + :parm: entry name + """ + for usage in self._content.usages: + if usage.name.lower() == name.lower(): + return usage + raise IndexError(f"{name} doesn't exists in the catalog") diff --git a/hub/catalog_factories/usage/usage_helper.py b/hub/catalog_factories/usage/usage_helper.py index 26677505..cd761d63 100644 --- a/hub/catalog_factories/usage/usage_helper.py +++ b/hub/catalog_factories/usage/usage_helper.py @@ -90,6 +90,12 @@ class UsageHelper: 'C-14 Gymnasium': 'C-14 Gymnasium' } + _eilat_schedules_key_to_eilat_schedules = { + 'C-12 Residential': 'C-12 Residential', + 'C-15 Dormitory': 'C-15 Dormitory', + 'C-16 Hotel employees': 'C-16 Hotel employees' + } + @property def nrcan_day_type_to_hub_days(self): """ @@ -138,3 +144,10 @@ class UsageHelper: Get the list of days used in comnet """ return self._comnet_days + + @property + def eilat_schedules_key_to_eilat_schedules(self) -> [str]: + """ + Get a dictionary to convert hub schedules to eilat schedules + """ + return self._eilat_schedules_key_to_eilat_schedules diff --git a/hub/catalog_factories/usage_catalog_factory.py b/hub/catalog_factories/usage_catalog_factory.py index 8e826cad..ce015a35 100644 --- a/hub/catalog_factories/usage_catalog_factory.py +++ b/hub/catalog_factories/usage_catalog_factory.py @@ -10,6 +10,7 @@ from typing import TypeVar from hub.catalog_factories.usage.comnet_catalog import ComnetCatalog from hub.catalog_factories.usage.nrcan_catalog import NrcanCatalog +from hub.catalog_factories.usage.eilat_catalog import EilatCatalog from hub.helpers.utils import validate_import_export_type Catalog = TypeVar('Catalog') @@ -41,6 +42,13 @@ class UsageCatalogFactory: # nrcan retrieves the data directly from github return NrcanCatalog(self._path) + @property + def _eilat(self): + """ + Retrieve Eilat catalog + """ + return EilatCatalog(self._path) + @property def catalog(self) -> Catalog: """ diff --git a/hub/data/usage/eilat_archetypes.xlsx b/hub/data/usage/eilat_archetypes.xlsx new file mode 100644 index 00000000..35ad7288 Binary files /dev/null and b/hub/data/usage/eilat_archetypes.xlsx differ diff --git a/hub/data/usage/eilat_schedules_archetypes.xlsx b/hub/data/usage/eilat_schedules_archetypes.xlsx new file mode 100644 index 00000000..2f3a2956 Binary files /dev/null and b/hub/data/usage/eilat_schedules_archetypes.xlsx differ diff --git a/hub/helpers/data/eilat_function_to_hub_function.py b/hub/helpers/data/eilat_function_to_hub_function.py new file mode 100644 index 00000000..71cd0d3f --- /dev/null +++ b/hub/helpers/data/eilat_function_to_hub_function.py @@ -0,0 +1,28 @@ +""" +Dictionaries module for Eilat function to hub function +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2023 Concordia CERC group +Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +""" + +import hub.helpers.constants as cte + + +class EilatFunctionToHubFunction: + """ + Eilat function to hub function class + """ + + def __init__(self): + self._dictionary = {'Residential': cte.RESIDENTIAL, + 'Dormitory': cte.DORMITORY, + 'Hotel employ': cte.HOTEL + } + + @property + def dictionary(self) -> dict: + """ + Get the dictionary + :return: {} + """ + return self._dictionary diff --git a/hub/helpers/data/hub_usage_to_eilat_usage.py b/hub/helpers/data/hub_usage_to_eilat_usage.py new file mode 100644 index 00000000..e4d8a4cc --- /dev/null +++ b/hub/helpers/data/hub_usage_to_eilat_usage.py @@ -0,0 +1,29 @@ +""" +Dictionaries module for hub usage to Eilat usage +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2023 Concordia CERC group +Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +""" + +import hub.helpers.constants as cte + + +class HubUsageToEilatUsage: + """ + Hub usage to Eilat usage class + """ + + def __init__(self): + self._dictionary = { + cte.RESIDENTIAL: 'Residential', + cte.HOTEL: 'Hotel employees', + cte.DORMITORY: 'Dormitory' + } + + @property + def dictionary(self) -> dict: + """ + Get the dictionary + :return: {} + """ + return self._dictionary diff --git a/hub/helpers/dictionaries.py b/hub/helpers/dictionaries.py index 5630c484..c2b766ef 100644 --- a/hub/helpers/dictionaries.py +++ b/hub/helpers/dictionaries.py @@ -7,6 +7,7 @@ Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca from hub.helpers.data.hft_function_to_hub_function import HftFunctionToHubFunction from hub.helpers.data.montreal_function_to_hub_function import MontrealFunctionToHubFunction +from hub.helpers.data.eilat_function_to_hub_function import EilatFunctionToHubFunction from hub.helpers.data.alkis_function_to_hub_function import AlkisFunctionToHubFunction from hub.helpers.data.pluto_function_to_hub_function import PlutoFunctionToHubFunction from hub.helpers.data.hub_function_to_nrel_construction_function import HubFunctionToNrelConstructionFunction @@ -14,6 +15,7 @@ from hub.helpers.data.hub_function_to_nrcan_construction_function import HubFunc from hub.helpers.data.hub_usage_to_comnet_usage import HubUsageToComnetUsage from hub.helpers.data.hub_usage_to_hft_usage import HubUsageToHftUsage from hub.helpers.data.hub_usage_to_nrcan_usage import HubUsageToNrcanUsage +from hub.helpers.data.hub_usage_to_eilat_usage import HubUsageToEilatUsage from hub.helpers.data.montreal_system_to_hub_energy_generation_system import MontrealSystemToHubEnergyGenerationSystem from hub.helpers.data.montreal_demand_type_to_hub_energy_demand_type import MontrealDemandTypeToHubEnergyDemandType from hub.helpers.data.hub_function_to_montreal_custom_costs_function import HubFunctionToMontrealCustomCostsFunction @@ -48,6 +50,14 @@ class Dictionaries: """ return HubUsageToNrcanUsage().dictionary + @property + def hub_usage_to_eilat_usage(self) -> dict: + """ + Hub usage to Eilat usage, transformation dictionary + :return: dict + """ + return HubUsageToEilatUsage().dictionary + @property def hub_function_to_nrcan_construction_function(self) -> dict: """ @@ -115,3 +125,10 @@ class Dictionaries: :return: dict """ return HubFunctionToMontrealCustomCostsFunction().dictionary + + @property + def eilat_function_to_hub_function(self) -> dict: + """ + Get Eilat's function to hub function, transformation dictionary + """ + return EilatFunctionToHubFunction().dictionary diff --git a/hub/imports/usage/eilat_usage_parameters.py b/hub/imports/usage/eilat_usage_parameters.py new file mode 100644 index 00000000..43fd9066 --- /dev/null +++ b/hub/imports/usage/eilat_usage_parameters.py @@ -0,0 +1,232 @@ +""" +EilatUsageParameters extracts the usage properties from Eilat catalog and assigns to each building +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2023 Concordia CERC group +Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +""" +import copy +import logging +import numpy +import hub.helpers.constants as cte +from hub.helpers.dictionaries import Dictionaries +from hub.city_model_structure.building_demand.usage import Usage +from hub.city_model_structure.building_demand.lighting import Lighting +from hub.city_model_structure.building_demand.occupancy import Occupancy +from hub.city_model_structure.building_demand.appliances import Appliances +from hub.city_model_structure.building_demand.thermal_control import ThermalControl +from hub.city_model_structure.building_demand.domestic_hot_water import DomesticHotWater +from hub.city_model_structure.attributes.schedule import Schedule +from hub.city_model_structure.building_demand.internal_gain import InternalGain +from hub.catalog_factories.usage_catalog_factory import UsageCatalogFactory + + +class EilatUsageParameters: + """ + EilatUsageParameters class + """ + def __init__(self, city): + self._city = city + + def enrich_buildings(self): + """ + Returns the city with the usage parameters assigned to the buildings + :return: + """ + city = self._city + eilat_catalog = UsageCatalogFactory('eilat').catalog + for building in city.buildings: + usage_name = Dictionaries().hub_usage_to_eilat_usage[building.function] + try: + archetype_usage = self._search_archetypes(eilat_catalog, usage_name) + except KeyError: + logging.error('Building %s has unknown usage archetype for usage %s', building.name, usage_name) + continue + + for internal_zone in building.internal_zones: + if internal_zone.area is None: + raise TypeError('Internal zone area not defined, ACH cannot be calculated') + if internal_zone.volume is None: + raise TypeError('Internal zone volume not defined, ACH cannot be calculated') + if internal_zone.area <= 0: + raise TypeError('Internal zone area is zero, ACH cannot be calculated') + volume_per_area = internal_zone.volume / internal_zone.area + usage = Usage() + usage.name = usage_name + self._assign_values(usage, archetype_usage, volume_per_area, building.cold_water_temperature) + usage.percentage = 1 + self._calculate_reduced_values_from_extended_library(usage, archetype_usage) + + internal_zone.usages = [usage] + + @staticmethod + def _search_archetypes(eilat_catalog, usage_name): + eilat_archetypes = eilat_catalog.entries('archetypes').usages + for building_archetype in eilat_archetypes: + if str(usage_name) == str(building_archetype.name): + return building_archetype + raise KeyError('archetype not found') + + @staticmethod + def _assign_values(usage, archetype, volume_per_area, cold_water_temperature): + # Due to the fact that python is not a typed language, the wrong object type is assigned to + # usage.occupancy when writing usage.occupancy = archetype.occupancy. + # Same happens for lighting and appliances. Therefore, this walk around has been done. + usage.mechanical_air_change = archetype.ventilation_rate / volume_per_area \ + * cte.HOUR_TO_SECONDS + _occupancy = Occupancy() + _occupancy.occupancy_density = archetype.occupancy.occupancy_density + _occupancy.sensible_radiative_internal_gain = archetype.occupancy.sensible_radiative_internal_gain + _occupancy.latent_internal_gain = archetype.occupancy.latent_internal_gain + _occupancy.sensible_convective_internal_gain = archetype.occupancy.sensible_convective_internal_gain + _occupancy.occupancy_schedules = archetype.occupancy.schedules + usage.occupancy = _occupancy + _lighting = Lighting() + _lighting.density = archetype.lighting.density + _lighting.convective_fraction = archetype.lighting.convective_fraction + _lighting.radiative_fraction = archetype.lighting.radiative_fraction + _lighting.latent_fraction = archetype.lighting.latent_fraction + _lighting.schedules = archetype.lighting.schedules + usage.lighting = _lighting + _appliances = Appliances() + _appliances.density = archetype.appliances.density + _appliances.convective_fraction = archetype.appliances.convective_fraction + _appliances.radiative_fraction = archetype.appliances.radiative_fraction + _appliances.latent_fraction = archetype.appliances.latent_fraction + _appliances.schedules = archetype.appliances.schedules + usage.appliances = _appliances + _control = ThermalControl() + _control.cooling_set_point_schedules = archetype.thermal_control.cooling_set_point_schedules + _control.heating_set_point_schedules = archetype.thermal_control.heating_set_point_schedules + _control.hvac_availability_schedules = archetype.thermal_control.hvac_availability_schedules + usage.thermal_control = _control + _domestic_hot_water = DomesticHotWater() + _domestic_hot_water.density = archetype.domestic_hot_water.density + _domestic_hot_water.service_temperature = archetype.domestic_hot_water.service_temperature + peak_flow = None + if len(cold_water_temperature) > 0: + cold_temperature = cold_water_temperature[cte.YEAR]['epw'] + peak_flow = 0 + if (archetype.domestic_hot_water.service_temperature - cold_temperature) > 0: + peak_flow = archetype.domestic_hot_water.density / cte.WATER_DENSITY / cte.WATER_HEAT_CAPACITY \ + / (archetype.domestic_hot_water.service_temperature - cold_temperature) + _domestic_hot_water.peak_flow = peak_flow + _domestic_hot_water.schedules = archetype.domestic_hot_water.schedules + usage.domestic_hot_water = _domestic_hot_water + + @staticmethod + def _calculate_reduced_values_from_extended_library(usage, archetype): + number_of_days_per_type = {'WD': 231, 'Fri': 52, 'Sat': 82} + total = 0 + for schedule in archetype.thermal_control.hvac_availability_schedules: + if schedule.day_types[0] == cte.SATURDAY: + for value in schedule.values: + total += value * number_of_days_per_type['Fri'] + elif schedule.day_types[0] == cte.SUNDAY: + for value in schedule.values: + total += value * number_of_days_per_type['Sat'] + else: + for value in schedule.values: + total += value * number_of_days_per_type['WD'] + + usage.hours_day = total / 365 + usage.days_year = 365 + + max_heating_setpoint = cte.MIN_FLOAT + min_heating_setpoint = cte.MAX_FLOAT + + for schedule in archetype.thermal_control.heating_set_point_schedules: + if schedule.values is None: + max_heating_setpoint = None + min_heating_setpoint = None + break + if max(schedule.values) > max_heating_setpoint: + max_heating_setpoint = max(schedule.values) + if min(schedule.values) < min_heating_setpoint: + min_heating_setpoint = min(schedule.values) + + min_cooling_setpoint = cte.MAX_FLOAT + for schedule in archetype.thermal_control.cooling_set_point_schedules: + if schedule.values is None: + min_cooling_setpoint = None + break + if min(schedule.values) < min_cooling_setpoint: + min_cooling_setpoint = min(schedule.values) + + usage.thermal_control.mean_heating_set_point = max_heating_setpoint + usage.thermal_control.heating_set_back = min_heating_setpoint + usage.thermal_control.mean_cooling_set_point = min_cooling_setpoint + + @staticmethod + def _calculate_internal_gains(archetype): + + _days = [cte.MONDAY, cte.TUESDAY, cte.WEDNESDAY, cte.THURSDAY, cte.FRIDAY, cte.SATURDAY, cte.SUNDAY, cte.HOLIDAY] + _number_of_days_per_type = [51, 50, 50, 50, 50, 52, 52, 10] + + _mean_internal_gain = InternalGain() + _mean_internal_gain.type = 'mean_value_of_internal_gains' + _base_schedule = Schedule() + _base_schedule.type = cte.INTERNAL_GAINS + _base_schedule.time_range = cte.DAY + _base_schedule.time_step = cte.HOUR + _base_schedule.data_type = cte.FRACTION + + _latent_heat_gain = archetype.occupancy.latent_internal_gain + _convective_heat_gain = archetype.occupancy.sensible_convective_internal_gain + _radiative_heat_gain = archetype.occupancy.sensible_radiative_internal_gain + _total_heat_gain = _latent_heat_gain + _convective_heat_gain + _radiative_heat_gain + + _schedule_values = numpy.zeros([24, 8]) + _sum = 0 + for day, _schedule in enumerate(archetype.occupancy.schedules): + for v_index, value in enumerate(_schedule.values): + _schedule_values[v_index, day] = value * _total_heat_gain + _sum += value * _total_heat_gain * _number_of_days_per_type[day] + + _total_heat_gain += archetype.lighting.density + archetype.appliances.density + _latent_heat_gain += ( + archetype.lighting.latent_fraction * archetype.lighting.density + archetype.appliances.latent_fraction * + archetype.appliances.density + ) + _radiative_heat_gain = ( + archetype.lighting.radiative_fraction * archetype.lighting.density + archetype.appliances.radiative_fraction * + archetype.appliances.density + ) + _convective_heat_gain = ( + archetype.lighting.convective_fraction * archetype.lighting.density + archetype.appliances.convective_fraction * + archetype.appliances.density + ) + + for day, _schedule in enumerate(archetype.lighting.schedules): + for v_index, value in enumerate(_schedule.values): + _schedule_values[v_index, day] += value * archetype.lighting.density + _sum += value * archetype.lighting.density * _number_of_days_per_type[day] + + for day, _schedule in enumerate(archetype.appliances.schedules): + for v_index, value in enumerate(_schedule.values): + _schedule_values[v_index, day] += value * archetype.appliances.density + _sum += value * archetype.appliances.density * _number_of_days_per_type[day] + + _latent_fraction = 0 + _radiative_fraction = 0 + _convective_fraction = 0 + _average_internal_gain = 0 + if _total_heat_gain != 0: + _latent_fraction = _latent_heat_gain / _total_heat_gain + _radiative_fraction = _radiative_heat_gain / _total_heat_gain + _convective_fraction = _convective_heat_gain / _total_heat_gain + _average_internal_gain = _sum / _total_heat_gain + + _schedules = [] + for day, current_day in enumerate(_days): + _schedule = copy.deepcopy(_base_schedule) + _schedule.day_types = [current_day] + _schedule.values = _schedule_values[:day] + _schedules.append(_schedule) + + _mean_internal_gain.average_internal_gain = _average_internal_gain + _mean_internal_gain.latent_fraction = _latent_fraction + _mean_internal_gain.convective_fraction = _convective_fraction + _mean_internal_gain.radiative_fraction = _radiative_fraction + _mean_internal_gain.schedules = _schedules + + return [_mean_internal_gain] diff --git a/hub/imports/usage_factory.py b/hub/imports/usage_factory.py index 138a7e9f..8af57364 100644 --- a/hub/imports/usage_factory.py +++ b/hub/imports/usage_factory.py @@ -9,6 +9,7 @@ Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concord from hub.helpers.utils import validate_import_export_type from hub.imports.usage.comnet_usage_parameters import ComnetUsageParameters from hub.imports.usage.nrcan_usage_parameters import NrcanUsageParameters +from hub.imports.usage.eilat_usage_parameters import EilatUsageParameters class UsageFactory: @@ -38,9 +39,20 @@ class UsageFactory: for building in self._city.buildings: building.level_of_detail.usage = 2 + def _eilat(self): + """ + Enrich the city with Eilat usage library + """ + EilatUsageParameters(self._city).enrich_buildings() + self._city.level_of_detail.usage = 2 + for building in self._city.buildings: + building.level_of_detail.usage = 2 + def enrich(self): """ Enrich the city given to the class using the usage factory given handler :return: None """ getattr(self, self._handler, lambda: None)() + +