diff --git a/hub/catalog_factories/data_models/usages/domestic_hot_water.py b/hub/catalog_factories/data_models/usages/domestic_hot_water.py new file mode 100644 index 00000000..edf4b8ab --- /dev/null +++ b/hub/catalog_factories/data_models/usages/domestic_hot_water.py @@ -0,0 +1,45 @@ +""" +Usage catalog domestic hot water +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2023 Concordia CERC group +Project Coder Pilar Monsalvete Álvarez de Uribarri pilar.monsalvete@concordia.ca +""" + +from typing import Union, List + +from hub.catalog_factories.data_models.usages.schedule import Schedule + + +class DomesticHotWater: + """ + DomesticHotWater class + """ + def __init__(self, density, service_temperature, schedules): + self._density = density + self._service_temperature = service_temperature + self._schedules = schedules + + @property + def density(self) -> Union[None, float]: + """ + Get domestic hot water load density in Watts per m2 + :return: None or float + """ + return self._density + + @property + def service_temperature(self) -> Union[None, float]: + """ + Get service temperature in degrees Celsius + :return: None or float + """ + return self._service_temperature + + @property + def schedules(self) -> Union[None, List[Schedule]]: + """ + Get schedules + dataType = fraction of loads + :return: None or [Schedule] + """ + return self._schedules diff --git a/hub/catalog_factories/data_models/usages/usage.py b/hub/catalog_factories/data_models/usages/usage.py index 95868b21..07ac17bc 100644 --- a/hub/catalog_factories/data_models/usages/usage.py +++ b/hub/catalog_factories/data_models/usages/usage.py @@ -10,6 +10,7 @@ from hub.catalog_factories.data_models.usages.appliances import Appliances from hub.catalog_factories.data_models.usages.lighting import Lighting from hub.catalog_factories.data_models.usages.ocupancy import Occupancy from hub.catalog_factories.data_models.usages.thermal_control import ThermalControl +from hub.catalog_factories.data_models.usages.domestic_hot_water import DomesticHotWater class Usage: @@ -21,7 +22,8 @@ class Usage: occupancy, lighting, appliances, - thermal_control): + thermal_control, + domestic_hot_water): self._name = name self._hours_day = hours_day self._days_year = days_year @@ -32,6 +34,7 @@ class Usage: self._lighting = lighting self._appliances = appliances self._thermal_control = thermal_control + self._domestic_hot_water = domestic_hot_water @property def name(self) -> Union[None, str]: @@ -108,7 +111,15 @@ class Usage: @property def thermal_control(self) -> Union[None, ThermalControl]: """ - Get thermal control of this thermal zone + Get thermal control information :return: None or ThermalControl """ return self._thermal_control + + @property + def domestic_hot_water(self) -> Union[None, DomesticHotWater]: + """ + Get domestic hot water information + :return: None or DomesticHotWater + """ + return self._domestic_hot_water diff --git a/hub/catalog_factories/energy_systems/nrcan_catalog.py b/hub/catalog_factories/energy_systems/nrcan_catalog.py new file mode 100644 index 00000000..baf8a2c2 --- /dev/null +++ b/hub/catalog_factories/energy_systems/nrcan_catalog.py @@ -0,0 +1,189 @@ +""" +NRCAN energy systems 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 json +import urllib.request +import xmltodict + +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.ocupancy import Occupancy +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 + + +class NrcanCatalog(Catalog): + def __init__(self, path): + path = str(path / 'nrcan.xml') + self._content = None + self._schedules = {} + with open(path) as xml: + self._metadata = xmltodict.parse(xml.read()) + self._base_url = self._metadata['nrcan']['@base_url'] + self._load_schedules() + self._content = Content(self._load_archetypes()) + + def _load_archetypes(self): + usages = [] + name = self._metadata['nrcan'] + url = f'{self._base_url}{name["space_types_location"]}' + with urllib.request.urlopen(url) as json_file: + space_types = json.load(json_file)['tables']['space_types']['table'] +# space_types = [st for st in space_types if st['building_type'] == 'Space Function'] + space_types = [st for st in space_types if st['space_type'] == 'WholeBuilding'] + for space_type in space_types: +# usage_type = space_type['space_type'] + usage_type = space_type['building_type'] + occupancy_schedule_name = space_type['occupancy_schedule'] + lighting_schedule_name = space_type['lighting_schedule'] + appliance_schedule_name = space_type['electric_equipment_schedule'] + hvac_schedule_name = space_type['exhaust_schedule'] + if 'FAN' in hvac_schedule_name: + hvac_schedule_name = hvac_schedule_name.replace('FAN', 'Fan') + heating_setpoint_schedule_name = space_type['heating_setpoint_schedule'] + cooling_setpoint_schedule_name = space_type['cooling_setpoint_schedule'] + occupancy_schedule = self._get_schedules(occupancy_schedule_name) + lighting_schedule = self._get_schedules(lighting_schedule_name) + appliance_schedule = self._get_schedules(appliance_schedule_name) + heating_schedule = self._get_schedules(heating_setpoint_schedule_name) + cooling_schedule = self._get_schedules(cooling_setpoint_schedule_name) + hvac_availability = self._get_schedules(hvac_schedule_name) + + occupancy_density = space_type['occupancy_per_area'] + + # ACH + mechanical_air_change = space_type['ventilation_air_changes'] + # cfm/ft2 to m3/m2.s + ventilation_rate = space_type['ventilation_per_area'] / (cte.METERS_TO_FEET * cte.MINUTES_TO_SECONDS) + if ventilation_rate == 0: + # cfm/person to m3/m2.s + ventilation_rate = space_type['ventilation_per_person'] / occupancy_density\ + / (cte.METERS_TO_FEET * cte.MINUTES_TO_SECONDS) + + # W/sqft to W/m2 + lighting_density = space_type['lighting_per_area'] * cte.METERS_TO_FEET * cte.METERS_TO_FEET + lighting_radiative_fraction = space_type['lighting_fraction_radiant'] + lighting_convective_fraction = 0 + if lighting_radiative_fraction is not None: + lighting_convective_fraction = 1 - lighting_radiative_fraction + lighting_latent_fraction = 0 + # W/sqft to W/m2 + appliances_density = space_type['electric_equipment_per_area'] * cte.METERS_TO_FEET * cte.METERS_TO_FEET + appliances_radiative_fraction = space_type['electric_equipment_fraction_radiant'] + appliances_latent_fraction = space_type['electric_equipment_fraction_latent'] + appliances_convective_fraction = 0 + if appliances_radiative_fraction is not None and appliances_latent_fraction is not None: + appliances_convective_fraction = 1 - appliances_radiative_fraction - appliances_latent_fraction + + occupancy = Occupancy(occupancy_density, + None, + None, + None, + occupancy_schedule) + lighting = Lighting(lighting_density, + lighting_convective_fraction, + lighting_radiative_fraction, + lighting_latent_fraction, + lighting_schedule) + appliances = Appliances(appliances_density, + appliances_convective_fraction, + appliances_radiative_fraction, + appliances_latent_fraction, + appliance_schedule) + thermal_control = ThermalControl(None, + None, + None, + hvac_availability, + heating_schedule, + cooling_schedule) + hours_day = None + days_year = None + usages.append(Usage(usage_type, + hours_day, + days_year, + mechanical_air_change, + ventilation_rate, + occupancy, + lighting, + appliances, + thermal_control)) + return usages + + def names(self, category=None): + """ + Get the catalog elements names + :parm: optional category filter + """ + if category is None: + _names = {'archetypes': [], 'constructions': [], 'materials': [], 'windows': []} + for archetype in self._content.archetypes: + _names['archetypes'].append(archetype.name) + for construction in self._content.constructions: + _names['constructions'].append(construction.name) + for material in self._content.materials: + _names['materials'].append(material.name) + for window in self._content.windows: + _names['windows'].append(window.name) + else: + _names = {category: []} + if category.lower() == 'archetypes': + for archetype in self._content.archetypes: + _names[category].append(archetype.name) + elif category.lower() == 'constructions': + for construction in self._content.constructions: + _names[category].append(construction.name) + elif category.lower() == 'materials': + for material in self._content.materials: + _names[category].append(material.name) + elif category.lower() == 'windows': + for window in self._content.windows: + _names[category].append(window.name) + else: + raise ValueError(f'Unknown category [{category}]') + + def entries(self, category=None): + """ + Get the catalog elements + :parm: optional category filter + """ + if category is None: + return self._content + else: + if category.lower() == 'archetypes': + return self._content.archetypes + elif category.lower() == 'constructions': + return self._content.constructions + elif category.lower() == 'materials': + return self._content.materials + elif category.lower() == 'windows': + return self._content.windows + else: + raise ValueError(f'Unknown category [{category}]') + + def get_entry(self, name): + """ + Get one catalog element by names + :parm: entry name + """ + for entry in self._content.archetypes: + if entry.name.lower() == name.lower(): + return entry + for entry in self._content.constructions: + if entry.name.lower() == name.lower(): + return entry + for entry in self._content.materials: + if entry.name.lower() == name.lower(): + return entry + for entry in self._content.windows: + if entry.name.lower() == name.lower(): + return entry + raise IndexError(f"{name} doesn't exists in the catalog") diff --git a/hub/catalog_factories/energy_systems_catalog_factory.py b/hub/catalog_factories/energy_systems_catalog_factory.py new file mode 100644 index 00000000..0bfc9459 --- /dev/null +++ b/hub/catalog_factories/energy_systems_catalog_factory.py @@ -0,0 +1,42 @@ +""" +Usage catalog factory, publish the usage information +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2022 Concordia CERC group +Project Coder Pilar Monsalvete Álvarez de Uribarri pilar.monsalvete@concordia.ca +""" + +from pathlib import Path +from typing import TypeVar +from hub.catalog_factories.energy_systems.nrcan_catalog import NrcanCatalog +from hub.hub_logger import logger +from hub.helpers.utils import validate_import_export_type +Catalog = TypeVar('Catalog') + + +class UsageCatalogFactory: + def __init__(self, file_type, base_path=None): + if base_path is None: + base_path = Path(Path(__file__).parent.parent / 'data/energy_systems') + self._catalog_type = '_' + file_type.lower() + class_funcs = validate_import_export_type(UsageCatalogFactory) + if self._catalog_type not in class_funcs: + err_msg = f"Wrong import type. Valid functions include {class_funcs}" + logger.error(err_msg) + raise Exception(err_msg) + self._path = base_path + + @property + def _nrcan(self): + """ + Retrieve NRCAN catalog + """ + # nrcan retrieves the data directly from github + return NrcanCatalog(self._path) + + @property + def catalog(self) -> Catalog: + """ + Enrich the city given to the class using the class given handler + :return: Catalog + """ + return getattr(self, self._catalog_type, lambda: None) diff --git a/hub/catalog_factories/usage/comnet_catalog.py b/hub/catalog_factories/usage/comnet_catalog.py index 90a54314..2c267477 100644 --- a/hub/catalog_factories/usage/comnet_catalog.py +++ b/hub/catalog_factories/usage/comnet_catalog.py @@ -14,6 +14,7 @@ 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.ocupancy 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 @@ -51,6 +52,7 @@ class ComnetCatalog(Catalog): ventilation_rate = self._archetypes['ventilation rate'][comnet_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'][comnet_usage] # get occupancy occupancy_density = occupancy_archetype[0] / pow(cte.METERS_TO_FEET, 2) @@ -96,6 +98,15 @@ class ComnetCatalog(Catalog): 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, + domestic_hot_water_service_temperature, + self._schedules[schedule_name]['Service Hot Water'] + ) usages.append(Usage(comnet_usage, hours_day, days_year, @@ -104,7 +115,8 @@ class ComnetCatalog(Catalog): occupancy, lighting, appliances, - thermal_control)) + thermal_control, + domestic_hot_water)) self._content = Content(usages) @@ -136,7 +148,7 @@ class ComnetCatalog(Catalog): _schedule_values[day] = _extracted_data.iloc[start:end, 3:27].to_numpy().tolist()[0] _schedule = [] for day in _schedule_values: - if schedule_name == 'ClgSetPt' or schedule_name == 'HtgSetPt': + if schedule_name == 'ClgSetPt' or schedule_name == 'HtgSetPt' or schedule_name == 'WtrHtrSetPt': # to celsius if 'n.a.' in _schedule_values[day]: _schedule_values[day] = None diff --git a/hub/catalog_factories/usage/nrcan_catalog.py b/hub/catalog_factories/usage/nrcan_catalog.py index 6e12b682..a7e8dda9 100644 --- a/hub/catalog_factories/usage/nrcan_catalog.py +++ b/hub/catalog_factories/usage/nrcan_catalog.py @@ -16,6 +16,7 @@ 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.ocupancy 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 @@ -36,7 +37,7 @@ class NrcanCatalog(Catalog): @staticmethod def _extract_schedule(raw): nrcan_schedule_type = raw['category'] - if 'Heating' in raw['name']: + if 'Heating' in raw['name'] and 'Water' not in raw['name']: nrcan_schedule_type = f'{nrcan_schedule_type} Heating' elif 'Cooling' in raw['name']: nrcan_schedule_type = f'{nrcan_schedule_type} Cooling' @@ -45,8 +46,8 @@ class NrcanCatalog(Catalog): hub_type = UsageHelper().nrcan_schedule_type_to_hub_schedule_type[nrcan_schedule_type] data_type = UsageHelper().nrcan_data_type_to_hub_data_type[raw['units']] time_step = UsageHelper().nrcan_time_to_hub_time[raw['type']] - # nrcan only uses yearly range for the schedules - time_range = cte.YEAR + # nrcan only uses daily range for the schedules + time_range = cte.DAY day_types = UsageHelper().nrcan_day_type_to_hub_days[raw['day_types']] return Schedule(hub_type, raw['values'], data_type, time_step, time_range, day_types) @@ -91,12 +92,14 @@ class NrcanCatalog(Catalog): hvac_schedule_name = hvac_schedule_name.replace('FAN', 'Fan') heating_setpoint_schedule_name = space_type['heating_setpoint_schedule'] cooling_setpoint_schedule_name = space_type['cooling_setpoint_schedule'] + domestic_hot_water_schedule_name = space_type['service_water_heating_schedule'] occupancy_schedule = self._get_schedules(occupancy_schedule_name) lighting_schedule = self._get_schedules(lighting_schedule_name) appliance_schedule = self._get_schedules(appliance_schedule_name) heating_schedule = self._get_schedules(heating_setpoint_schedule_name) cooling_schedule = self._get_schedules(cooling_setpoint_schedule_name) hvac_availability = self._get_schedules(hvac_schedule_name) + domestic_hot_water_load_schedule = self._get_schedules(domestic_hot_water_schedule_name) occupancy_density = space_type['occupancy_per_area'] @@ -124,6 +127,15 @@ class NrcanCatalog(Catalog): if appliances_radiative_fraction is not None and appliances_latent_fraction is not None: appliances_convective_fraction = 1 - appliances_radiative_fraction - appliances_latent_fraction + # peak flow in m3/day/m2 + domestic_hot_water_peak_flow = space_type['service_water_heating_peak_flow_per_area'] + domestic_hot_water_service_temperature = space_type['service_water_heating_target_temperature'] + average_domestic_hot_water_inlet_temperature = 16.5 + # result in W/m2 + domestic_hot_water_density = domestic_hot_water_peak_flow / 24 / 3.6 * 4184 \ + * (domestic_hot_water_service_temperature - + average_domestic_hot_water_inlet_temperature) + occupancy = Occupancy(occupancy_density, None, None, @@ -145,6 +157,10 @@ class NrcanCatalog(Catalog): hvac_availability, heating_schedule, cooling_schedule) + domestic_hot_water = DomesticHotWater(domestic_hot_water_density, + domestic_hot_water_service_temperature, + domestic_hot_water_load_schedule) + hours_day = None days_year = None usages.append(Usage(usage_type, @@ -155,7 +171,8 @@ class NrcanCatalog(Catalog): occupancy, lighting, appliances, - thermal_control)) + thermal_control, + domestic_hot_water)) return usages def names(self, category=None): diff --git a/hub/catalog_factories/usage/usage_helper.py b/hub/catalog_factories/usage/usage_helper.py index e2886bc9..57d58d84 100644 --- a/hub/catalog_factories/usage/usage_helper.py +++ b/hub/catalog_factories/usage/usage_helper.py @@ -19,7 +19,8 @@ class UsageHelper: 'Equipment': cte.APPLIANCES, 'Thermostat Setpoint Cooling': cte.COOLING_SET_POINT, # Compose 'Thermostat Setpoint' + 'Cooling' 'Thermostat Setpoint Heating': cte.HEATING_SET_POINT, # Compose 'Thermostat Setpoint' + 'Heating' - 'Fan': cte.HVAC_AVAILABILITY + 'Fan': cte.HVAC_AVAILABILITY, + 'Service Water Heating': cte.DOMESTIC_HOT_WATER } _nrcan_data_type_to_hub_data_type = { 'FRACTION': cte.FRACTION, diff --git a/hub/city_model_structure/building_demand/domestic_hot_water.py b/hub/city_model_structure/building_demand/domestic_hot_water.py new file mode 100644 index 00000000..f48bf68a --- /dev/null +++ b/hub/city_model_structure/building_demand/domestic_hot_water.py @@ -0,0 +1,70 @@ +""" +Domestic Hot Water module +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2023 Concordia CERC group +Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +""" +from typing import Union, List +from hub.city_model_structure.attributes.schedule import Schedule + + +class DomesticHotWater: + """ + DomesticHotWater class + """ + def __init__(self): + self._density = None + self._service_temperature = None + self._schedules = None + + @property + def density(self) -> Union[None, float]: + """ + Get domestic hot water load density in Watts per m2 + :return: None or float + """ + return self._density + + @density.setter + def density(self, value): + """ + Set domestic hot water load density in Watts per m2 + :param value: float + """ + if value is not None: + self._density = float(value) + + @property + def service_temperature(self) -> Union[None, float]: + """ + Get service temperature in degrees Celsius + :return: None or float + """ + return self._service_temperature + + @service_temperature.setter + def service_temperature(self, value): + """ + Set service temperature in degrees Celsius + :param value: float + """ + if value is not None: + self._service_temperature = float(value) + + @property + def schedules(self) -> Union[None, List[Schedule]]: + """ + Get schedules + dataType = fraction + :return: None or [Schedule] + """ + return self._schedules + + @schedules.setter + def schedules(self, value): + """ + Set schedules + dataType = fraction + :param value: [Schedule] + """ + self._schedules = value diff --git a/hub/city_model_structure/building_demand/thermal_zone.py b/hub/city_model_structure/building_demand/thermal_zone.py index beb26045..667c0631 100644 --- a/hub/city_model_structure/building_demand/thermal_zone.py +++ b/hub/city_model_structure/building_demand/thermal_zone.py @@ -15,6 +15,7 @@ from hub.city_model_structure.building_demand.appliances import Appliances from hub.city_model_structure.building_demand.lighting import Lighting from hub.city_model_structure.building_demand.internal_gain import InternalGain 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 import hub.helpers.constants as cte @@ -53,6 +54,7 @@ class ThermalZone: self._appliances = None self._internal_gains = None self._thermal_control = None + self._domestic_hot_water = None self._usages = None @property @@ -590,6 +592,43 @@ class ThermalZone: return self._thermal_control + @property + def domestic_hot_water(self) -> Union[None, DomesticHotWater]: + """ + Get domestic hot water information of this thermal zone + :return: None or DomesticHotWater + """ + self._domestic_hot_water = DomesticHotWater() + _mean_peak_density_load = 0 + _mean_service_temperature = 0 + for usage in self.usages: + _mean_peak_density_load += usage.percentage * usage.domestic_hot_water.density + _mean_service_temperature += usage.percentage * usage.domestic_hot_water.service_temperature + self._domestic_hot_water.density = _mean_peak_density_load + self._domestic_hot_water.service_temperature = _mean_service_temperature + + _domestic_hot_water_reference = self.usages[0].domestic_hot_water + if _domestic_hot_water_reference.schedules is not None: + _schedules = [] + for i_schedule in range(0, len(_domestic_hot_water_reference.schedules)): + schedule = Schedule() + schedule.type = _domestic_hot_water_reference.schedules[i_schedule].type + schedule.day_types = _domestic_hot_water_reference.schedules[i_schedule].day_types + schedule.data_type = _domestic_hot_water_reference.schedules[i_schedule].data_type + schedule.time_step = _domestic_hot_water_reference.schedules[i_schedule].time_step + schedule.time_range = _domestic_hot_water_reference.schedules[i_schedule].time_range + + new_values = [] + for i_value in range(0, len(_domestic_hot_water_reference.schedules[i_schedule].values)): + _new_value = 0 + for usage in self.usages: + _new_value += usage.percentage * usage.domestic_hot_water.schedules[i_schedule].values[i_value] + new_values.append(_new_value) + schedule.values = new_values + _schedules.append(schedule) + self._domestic_hot_water.schedules = _schedules + return self._domestic_hot_water + @property def total_floor_area(self): """ diff --git a/hub/city_model_structure/building_demand/usage.py b/hub/city_model_structure/building_demand/usage.py index 36240038..c3eea9fe 100644 --- a/hub/city_model_structure/building_demand/usage.py +++ b/hub/city_model_structure/building_demand/usage.py @@ -12,6 +12,7 @@ from hub.city_model_structure.building_demand.occupancy import Occupancy from hub.city_model_structure.building_demand.lighting import Lighting 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.building_demand.internal_gain import InternalGain @@ -31,6 +32,7 @@ class Usage: self._lighting = None self._appliances = None self._thermal_control = None + self._domestic_hot_water = None @property def id(self): @@ -236,7 +238,7 @@ class Usage: @property def thermal_control(self) -> Union[None, ThermalControl]: """ - Get thermal control of this thermal zone + Get thermal control information :return: None or ThermalControl """ return self._thermal_control @@ -244,7 +246,23 @@ class Usage: @thermal_control.setter def thermal_control(self, value): """ - Set thermal control for this thermal zone + Set thermal control information :param value: ThermalControl """ self._thermal_control = value + + @property + def domestic_hot_water(self) -> Union[None, DomesticHotWater]: + """ + Get domestic hot water information + :return: None or ThermalControl + """ + return self._domestic_hot_water + + @domestic_hot_water.setter + def domestic_hot_water(self, value): + """ + Set domestic hot water information + :return: None or ThermalControl + """ + self._domestic_hot_water = value diff --git a/hub/data/energy_systems/nrcan.xml b/hub/data/energy_systems/nrcan.xml new file mode 100644 index 00000000..d9843ae5 --- /dev/null +++ b/hub/data/energy_systems/nrcan.xml @@ -0,0 +1,11 @@ + + + boiler_set.json + chiller_set.json + curves.json + furnace_set.json + heat_pumps.json + shw_set.json + pv.json + unitary_acs.json + diff --git a/hub/helpers/constants.py b/hub/helpers/constants.py index 4792130f..8c601f5c 100644 --- a/hub/helpers/constants.py +++ b/hub/helpers/constants.py @@ -137,6 +137,7 @@ HEATING_SET_POINT = 'HtgSetPt' EQUIPMENT = 'Equipment' ACTIVITY = 'Activity' PEOPLE_ACTIVITY_LEVEL = 'People Activity Level' +DOMESTIC_HOT_WATER = 'Domestic Hot Water' # Geometry EPSILON = 0.0000001 diff --git a/hub/imports/usage/comnet_usage_parameters.py b/hub/imports/usage/comnet_usage_parameters.py index 6dcab450..2747c1af 100644 --- a/hub/imports/usage/comnet_usage_parameters.py +++ b/hub/imports/usage/comnet_usage_parameters.py @@ -15,6 +15,7 @@ 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 @@ -101,6 +102,11 @@ class ComnetUsageParameters: _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 + _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): diff --git a/hub/imports/usage/nrcan_usage_parameters.py b/hub/imports/usage/nrcan_usage_parameters.py index 68d8a2bf..bc80487b 100644 --- a/hub/imports/usage/nrcan_usage_parameters.py +++ b/hub/imports/usage/nrcan_usage_parameters.py @@ -14,6 +14,7 @@ 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.catalog_factories.usage_catalog_factory import UsageCatalogFactory @@ -111,6 +112,11 @@ class NrcanUsageParameters: _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 + _domestic_hot_water.schedules = archetype.domestic_hot_water.schedules + usage.domestic_hot_water = _domestic_hot_water @staticmethod def _assign_comnet_extra_values(usage, archetype): diff --git a/hub/unittests/test_usage_factory.py b/hub/unittests/test_usage_factory.py index 4cefef8c..6ff43b60 100644 --- a/hub/unittests/test_usage_factory.py +++ b/hub/unittests/test_usage_factory.py @@ -124,3 +124,7 @@ class TestUsageFactory(TestCase): self.assertIsNotNone(appliances.schedules, 'appliances schedule is none') self.assertIsNotNone(usage.thermal_control.hvac_availability_schedules, 'control hvac availability is none') + self.assertIsNotNone(usage.domestic_hot_water.density, 'domestic hot water density is none') + self.assertIsNotNone(usage.domestic_hot_water.service_temperature, + 'domestic hot water service temperature is none') + self.assertIsNotNone(usage.domestic_hot_water.schedules, 'domestic hot water schedules is none')