diff --git a/hub/catalog_factories/data_models/energy_systems/distribution_system.py b/hub/catalog_factories/data_models/energy_systems/distribution_system.py index 8c1146fd..defdad4f 100644 --- a/hub/catalog_factories/data_models/energy_systems/distribution_system.py +++ b/hub/catalog_factories/data_models/energy_systems/distribution_system.py @@ -13,38 +13,36 @@ class DistributionSystem: Distribution system class """ - def __init__(self, model, manufacturer, system_type, supply_temperature, distribution_consumption_fix_flow, - distribution_consumption_variable_flow, heat_losses, nominal_heat_output, medium): - self._model = model - self._manufacturer = manufacturer + def __init__(self, system_id, name, system_type, supply_temperature, distribution_consumption_fix_flow, + distribution_consumption_variable_flow, heat_losses): + self._system_id = system_id + self._name = name self._type = system_type self._supply_temperature = supply_temperature self._distribution_consumption_fix_flow = distribution_consumption_fix_flow self._distribution_consumption_variable_flow = distribution_consumption_variable_flow self._heat_losses = heat_losses - self._nominal_heat_output = nominal_heat_output - self._medium = medium @property - def model(self): + def id(self): """ - Get system model - :return: string + Get system id + :return: float """ - return self._model + return self._system_id @property - def manufacturer(self): + def name(self): """ Get name :return: string """ - return self._manufacturer + return self._name @property def type(self): """ - Get type from ['radiator', 'forced air convection', 'radiant floor heating'] + Get type from [air, water, refrigerant] :return: string """ return self._type @@ -82,35 +80,17 @@ class DistributionSystem: """ return self._heat_losses - @property - def nominal_heat_output(self): - """ - Get the nominal heat output of the heat distribution system in kW - :return: float - """ - return self._nominal_heat_output - - @property - def medium(self) -> Material: - """ - Get the heat transfer medium characteristics - :return: Material - """ - return self._medium - def to_dictionary(self): """Class content to dictionary""" content = { 'Layer': { - 'model': self.model, - 'manufacturer': self.manufacturer, + 'id': self.id, + 'name': self.name, 'type': self.type, 'supply temperature [Celsius]': self.supply_temperature, 'distribution consumption if fix flow over peak power [W/W]': self.distribution_consumption_fix_flow, 'distribution consumption if variable flow over peak power [J/J]': self.distribution_consumption_variable_flow, - 'heat losses per energy produced [J/J]': self.heat_losses, - 'nominal_heat_output': self.nominal_heat_output, - 'heat transfer medium': self.medium + 'heat losses per energy produced [J/J]': self.heat_losses } } return content diff --git a/hub/catalog_factories/data_models/energy_systems/emission_system.py b/hub/catalog_factories/data_models/energy_systems/emission_system.py deleted file mode 100644 index 5e9d2865..00000000 --- a/hub/catalog_factories/data_models/energy_systems/emission_system.py +++ /dev/null @@ -1,60 +0,0 @@ -""" -Energy System catalog emission system -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2023 Concordia CERC group -Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca -""" - - -class EmissionSystem: - """ - Emission system class - """ - def __init__(self, system_id, name, system_type, parasitic_energy_consumption): - - self._system_id = system_id - self._name = name - self._type = system_type - self._parasitic_energy_consumption = parasitic_energy_consumption - - @property - def id(self): - """ - Get system id - :return: float - """ - return self._system_id - - @property - def name(self): - """ - Get name - :return: string - """ - return self._name - - @property - def type(self): - """ - Get type - :return: string - """ - return self._type - - @property - def parasitic_energy_consumption(self): - """ - Get parasitic_energy_consumption in ratio (J/J) - :return: float - """ - return self._parasitic_energy_consumption - - def to_dictionary(self): - """Class content to dictionary""" - content = {'Layer': {'id': self.id, - 'name': self.name, - 'type': self.type, - 'parasitic energy consumption per energy produced [J/J]': self.parasitic_energy_consumption - } - } - return content diff --git a/hub/catalog_factories/data_models/energy_systems/energy_emission_system.py b/hub/catalog_factories/data_models/energy_systems/energy_emission_system.py new file mode 100644 index 00000000..171a8fda --- /dev/null +++ b/hub/catalog_factories/data_models/energy_systems/energy_emission_system.py @@ -0,0 +1,94 @@ +""" +Energy System catalog emission system +SPDX - License - Identifier: LGPL - 3.0 - or -later +Copyright © 2023 Concordia CERC group +Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +Code contributors: Saeed Ranjbar saeed.ranjbar@concordia.ca +""" + +from hub.catalog_factories.data_models.construction.material import Material + + +class EnergyEmissionSystem: + """ + Emission system class + """ + def __init__(self, model_name, manufacturer, system_type, parasitic_energy_consumption, nominal_heat_output, + nominal_efficiency, medium): + + self._system_id = model_name + self._name = manufacturer + self._type = system_type + self._parasitic_energy_consumption = parasitic_energy_consumption + self._nominal_heat_output = nominal_heat_output + self._nominal_efficiency = nominal_efficiency + self._medium = medium + + @property + def model_name(self): + """ + Get system id + :return: float + """ + return self._system_id + + @property + def manufacturer(self): + """ + Get name + :return: string + """ + return self._name + + @property + def type(self): + """ + Get type + :return: string + """ + return self._type + + @property + def parasitic_energy_consumption(self): + """ + Get parasitic_energy_consumption in ratio (J/J) + :return: float + """ + return self._parasitic_energy_consumption + + @property + def nominal_heat_output(self): + """ + Get the nominal heat output of the emission system in kW + :return: float + """ + return self._nominal_heat_output + + @property + def nominal_efficiency(self): + """ + Get the nominal efficiency of the emission system + :return: float + """ + return self._nominal_efficiency + + @property + def medium(self) -> Material: + """ + Get the heat transfer characteristics of the heat transfer medium + :return: Material + """ + return self._medium + + def to_dictionary(self): + """Class content to dictionary""" + content = {'Layer': {'id': self.model_name, + 'name': self.manufacturer, + 'type': self.type, + 'parasitic energy consumption per energy produced [J/J]': self.parasitic_energy_consumption, + 'nominal heat output [kW]': self.nominal_heat_output, + 'nominal efficiency': self.nominal_efficiency, + 'heat transfer medium': self.medium + } + } + return content diff --git a/hub/catalog_factories/data_models/energy_systems/generation_system.py b/hub/catalog_factories/data_models/energy_systems/generation_system.py index 5179eb8d..f0ce35ab 100644 --- a/hub/catalog_factories/data_models/energy_systems/generation_system.py +++ b/hub/catalog_factories/data_models/energy_systems/generation_system.py @@ -17,7 +17,7 @@ class GenerationSystem: def __init__(self, model_name, manufacturer, system_type, fuel_type, nominal_thermal_output, modulation_range, source_types, heat_efficiency, cooling_efficiency, electricity_efficiency, source_temperature, - source_mass_flow, nominal_electricity_output, cogeneration_ratio): + source_mass_flow, nominal_electricity_output): self._model_name = model_name self._manufacturer = manufacturer self._system_type = system_type @@ -31,7 +31,6 @@ class GenerationSystem: self._source_temperature = source_temperature self._source_mass_flow = source_mass_flow self._nominal_electricity_output = nominal_electricity_output - self._cogeneration_ratio = cogeneration_ratio @property def model_name(self): @@ -137,30 +136,21 @@ class GenerationSystem: """ return self._nominal_electricity_output - @property - def cogeneration_ratio(self): - """ - Get the ratio between the heat output and electricity output of CHP units - :return: float - """ - return self._cogeneration_ratio - def to_dictionary(self): """Class content to dictionary""" - content = {'Heat Generation component': {'model name': self.model_name, - 'manufacturer': self.manufacturer, - 'type': self.system_type, - 'fuel type': self.fuel_type, - 'nominal thermal output': self.nominal_thermal_output, - 'modulation_range': self.modulation_range, - 'source types': self.source_types, - 'source temperature [Celsius]': self.source_temperature, - 'source mass flow [kg/s]': self.source_mass_flow, - 'heat efficiency': self.heat_efficiency, - 'cooling efficiency': self.cooling_efficiency, - 'electricity efficiency': self.electricity_efficiency, - 'nominal power output [kW]': self.nominal_electricity_output, - 'cogeneration ratio': self.cogeneration_ratio, - } + content = {'Energy Generation component': {'model name': self.model_name, + 'manufacturer': self.manufacturer, + 'type': self.system_type, + 'fuel type': self.fuel_type, + 'nominal thermal output': self.nominal_thermal_output, + 'modulation_range': self.modulation_range, + 'source types': self.source_types, + 'source temperature [Celsius]': self.source_temperature, + 'source mass flow [kg/s]': self.source_mass_flow, + 'heat efficiency': self.heat_efficiency, + 'cooling efficiency': self.cooling_efficiency, + 'electricity efficiency': self.electricity_efficiency, + 'nominal power output [kW]': self.nominal_electricity_output, + } } return content diff --git a/hub/catalog_factories/data_models/energy_systems/pv_generation_system.py b/hub/catalog_factories/data_models/energy_systems/pv_generation_system.py index 78bd2bd6..a258b4b9 100644 --- a/hub/catalog_factories/data_models/energy_systems/pv_generation_system.py +++ b/hub/catalog_factories/data_models/energy_systems/pv_generation_system.py @@ -8,15 +8,22 @@ Code contributors: Saeed Ranjbar saeed.ranjbar@concordia.ca from __future__ import annotations from typing import Union +from hub.catalog_factories.data_models.energy_systems.generation_system import GenerationSystem -class PvGenerationSystem: +class PvGenerationSystem(GenerationSystem): """ Electricity Generation system class """ def __init__(self, nominal_ambient_temperature, nominal_cell_temperature, nominal_radiation, - standard_test_condition_cell_temperature, standard_test_condition_maximum_power, width, height): + standard_test_condition_cell_temperature, standard_test_condition_maximum_power, width, height, + model_name, manufacturer, electricity_efficiency, nominal_electricity_output): + super(GenerationSystem, self).__init__(model_name=model_name, manufacturer=manufacturer, system_type='pv', + fuel_type='renewable', nominal_thermal_output=None, modulation_range=None, + source_types=None, heat_efficiency=None, cooling_efficiency=None, + electricity_efficiency=electricity_efficiency, source_temperature=None, + source_mass_flow=None, nominal_electricity_output=nominal_electricity_output) self._nominal_ambient_temperature = nominal_ambient_temperature self._nominal_cell_temperature = nominal_cell_temperature self._nominal_radiation = nominal_radiation @@ -83,16 +90,20 @@ class PvGenerationSystem: def to_dictionary(self): """Class content to dictionary""" - content = {'Electricity Generation component': { - 'nominal ambient temperature [Celsius]': self.nominal_ambient_temperature, - 'nominal cell temperature [Celsius]': self.nominal_cell_temperature, - 'nominal radiation [W/m2]': self.nominal_radiation, - 'standard test condition cell temperature [Celsius]': - self.standard_test_condition_cell_temperature, - 'standard test condition maximum power [kW]': - self.standard_test_condition_maximum_power, - 'width': self.width, - 'height': self.height, - } - } + content = {'Photovoltaic Module': { + 'model name': self.model_name, + 'manufacturer': self.manufacturer, + 'type': self.system_type, + 'fuel type': self.fuel_type, + 'electricity efficiency': self.electricity_efficiency, + 'nominal power output [kW]': self.nominal_electricity_output, + 'nominal ambient temperature [Celsius]': self.nominal_ambient_temperature, + 'nominal cell temperature [Celsius]': self.nominal_cell_temperature, + 'nominal radiation [W/m2]': self.nominal_radiation, + 'standard test condition cell temperature [Celsius]': self.standard_test_condition_cell_temperature, + 'standard test condition maximum power [kW]': self.standard_test_condition_maximum_power, + 'width': self.width, + 'height': self.height, + } + } return content diff --git a/hub/catalog_factories/data_models/energy_systems/system.py b/hub/catalog_factories/data_models/energy_systems/system.py index 5dc59ddb..b22251f8 100644 --- a/hub/catalog_factories/data_models/energy_systems/system.py +++ b/hub/catalog_factories/data_models/energy_systems/system.py @@ -1,41 +1,47 @@ """ -Energy System catalog equipment +Energy System catalog heat generation system SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2023 Concordia CERC group Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca +Code contributors: Saeed Ranjbar saeed.ranjbar@concordia.ca """ -from typing import Union +from typing import Union, List from hub.catalog_factories.data_models.energy_systems.generation_system import GenerationSystem from hub.catalog_factories.data_models.energy_systems.pv_generation_system import PvGenerationSystem from hub.catalog_factories.data_models.energy_systems.energy_storage_system import EnergyStorageSystem from hub.catalog_factories.data_models.energy_systems.distribution_system import DistributionSystem -from hub.catalog_factories.data_models.energy_systems.emission_system import EmissionSystem +from hub.catalog_factories.data_models.energy_systems.performance_curves import PerformanceCurves +from hub.catalog_factories.data_models.energy_systems.energy_emission_system import EnergyEmissionSystem class System: """ System class """ + def __init__(self, lod, system_id, - name, + system_configuration, demand_types, - heat_generation_system, - electricity_generation_system, + generation_systems, + pv_generation_system, distribution_system, - emission_system): - + emission_system, + energy_storage_systems, + performance_curves): self._lod = lod self._system_id = system_id - self._name = name + self._system_configuration = system_configuration self._demand_types = demand_types - self._heat_generation_system = heat_generation_system - self._electricity_generation_system = electricity_generation_system self._distribution_system = distribution_system self._emission_system = emission_system + self._generation_systems = generation_systems + self._pv_generation_system = pv_generation_system + self._energy_storage_systems = energy_storage_systems + self._performance_curves = performance_curves @property def lod(self): @@ -54,36 +60,37 @@ class System: return self._system_id @property - def name(self): + def system_configuration(self): """ - Get name + Get the system configuration from ['hp_tes', 'hp_boiler_tes', 'pv_hp', 'pv_battery', 'pv', 'pv_hp_tes', + 'pv_hp_battery_tes'] :return: string """ - return self._name + return self._system_configuration @property def demand_types(self): """ - Get demand able to cover from [heating, cooling, domestic_hot_water, electricity] + Get demand able to cover from ['heating', 'cooling', 'domestic_hot_water', 'electricity'] :return: [string] """ return self._demand_types @property - def heat_generation_system(self) -> GenerationSystem: + def generation_systems(self) -> List[GenerationSystem]: """ - Get heat generation system - :return: HeatGenerationSystem + Get generation system + :return: GenerationSystem """ - return self._heat_generation_system + return self._generation_systems @property - def electricity_generation_system(self) -> PvGenerationSystem: + def pv_generation_system(self) -> Union[None, PvGenerationSystem]: """ - Get electricity generation system + Get pv generation system :return: ElectricityGenerationSystem """ - return self._electricity_generation_system + return self._pv_generation_system @property def distribution_system(self) -> Union[None, DistributionSystem]: @@ -94,29 +101,58 @@ class System: return self._distribution_system @property - def emission_system(self) -> Union[None, EmissionSystem]: + def emission_system(self) -> Union[None, EnergyEmissionSystem]: """ Get emission system :return: EmissionSystem """ return self._emission_system + @property + def energy_storage_system(self) -> Union[None, List[EnergyStorageSystem]]: + """ + Get energy storage system + :return: EnergyStorageSystem + """ + return self._energy_storage_systems + + @property + def performance_curves(self) -> Union[None, List[PerformanceCurves]]: + """ + Get the list of all performance curves associated with components + :return: PerformanceCurves + """ + return self._performance_curves + def to_dictionary(self): """Class content to dictionary""" + _generation_systems = [] + for _generation in self.generation_systems: + _generation_systems.append(_generation.to_dictionary()) + _pv_system = None + if self.pv_generation_system is not None: + _pv_system = self.pv_generation_system.to_dictionary() _distribution_system = None if self.distribution_system is not None: _distribution_system = self.distribution_system.to_dictionary() _emission_system = None if self.emission_system is not None: _emission_system = self.emission_system.to_dictionary() + _storage_system = [_storage.to_dictionary() for _storage in + self.energy_storage_system] if self.energy_storage_system is not None else None + _performance_curves = [_curve.to_dictionary() for _curve in + self.performance_curves] if self.performance_curves is not None else None + content = {'Layer': {'id': self.id, - 'name': self.name, + 'name': self.system_configuration, 'level of detail': self.lod, 'demand types': self.demand_types, - 'heat generation system': self.heat_generation_system.to_dictionary(), - 'electricity generation system': self.electricity_generation_system.to_dictionary(), + 'Generation system(s)': _generation_systems, + 'electricity generation system': _pv_system, 'distribution system': _distribution_system, - 'emission system': _emission_system + 'emission system': _emission_system, + 'energy storage system': _storage_system, + 'performance curves': _performance_curves } } return content diff --git a/hub/catalog_factories/energy_systems/montreal_custom_catalog.py b/hub/catalog_factories/energy_systems/montreal_custom_catalog.py index 91c8d4e4..bea78b0d 100644 --- a/hub/catalog_factories/energy_systems/montreal_custom_catalog.py +++ b/hub/catalog_factories/energy_systems/montreal_custom_catalog.py @@ -12,7 +12,7 @@ from hub.catalog_factories.data_models.energy_systems.system import System from hub.catalog_factories.data_models.energy_systems.content import Content from hub.catalog_factories.data_models.energy_systems.generation_system import GenerationSystem from hub.catalog_factories.data_models.energy_systems.distribution_system import DistributionSystem -from hub.catalog_factories.data_models.energy_systems.emission_system import EmissionSystem +from hub.catalog_factories.data_models.energy_systems.energy_emission_system import EnergyEmissionSystem from hub.catalog_factories.data_models.energy_systems.archetype import Archetype @@ -114,10 +114,10 @@ class MontrealCustomCatalog(Catalog): if 'parasitic_consumption' in equipment: parasitic_consumption = float(equipment['parasitic_consumption']['#text']) / 100 - emission_system = EmissionSystem(equipment_id, - name, - equipment_type, - parasitic_consumption) + emission_system = EnergyEmissionSystem(equipment_id, + name, + equipment_type, + parasitic_consumption) _equipments.append(emission_system) return _equipments @@ -177,32 +177,32 @@ class MontrealCustomCatalog(Catalog): _names = {'archetypes': [], 'systems': [], 'generation_equipments': [], 'distribution_equipments': [], 'emission_equipments':[]} for archetype in self._content.archetypes: - _names['archetypes'].append(archetype.name) + _names['archetypes'].append(archetype.manufacturer) for system in self._content.systems: - _names['systems'].append(system.name) + _names['systems'].append(system.manufacturer) for equipment in self._content.generation_equipments: - _names['generation_equipments'].append(equipment.name) + _names['generation_equipments'].append(equipment.manufacturer) for equipment in self._content.distribution_equipments: - _names['distribution_equipments'].append(equipment.name) + _names['distribution_equipments'].append(equipment.manufacturer) for equipment in self._content.emission_equipments: - _names['emission_equipments'].append(equipment.name) + _names['emission_equipments'].append(equipment.manufacturer) else: _names = {category: []} if category.lower() == 'archetypes': for archetype in self._content.archetypes: - _names[category].append(archetype.name) + _names[category].append(archetype.manufacturer) elif category.lower() == 'systems': for system in self._content.systems: - _names[category].append(system.name) + _names[category].append(system.manufacturer) elif category.lower() == 'generation_equipments': for system in self._content.generation_equipments: - _names[category].append(system.name) + _names[category].append(system.manufacturer) elif category.lower() == 'distribution_equipments': for system in self._content.distribution_equipments: - _names[category].append(system.name) + _names[category].append(system.manufacturer) elif category.lower() == 'emission_equipments': for system in self._content.emission_equipments: - _names[category].append(system.name) + _names[category].append(system.manufacturer) else: raise ValueError(f'Unknown category [{category}]') return _names @@ -232,18 +232,18 @@ class MontrealCustomCatalog(Catalog): :parm: entry name """ for entry in self._content.archetypes: - if entry.name.lower() == name.lower(): + if entry.manufacturer.lower() == name.lower(): return entry for entry in self._content.systems: - if entry.name.lower() == name.lower(): + if entry.manufacturer.lower() == name.lower(): return entry for entry in self._content.generation_equipments: - if entry.name.lower() == name.lower(): + if entry.manufacturer.lower() == name.lower(): return entry for entry in self._content.distribution_equipments: - if entry.name.lower() == name.lower(): + if entry.manufacturer.lower() == name.lower(): return entry for entry in self._content.emission_equipments: - if entry.name.lower() == name.lower(): + if entry.manufacturer.lower() == name.lower(): return entry raise IndexError(f"{name} doesn't exists in the catalog")