m_osman/city_retrofit
1
0
Fork 0
forked from s_ranjbar/city_retrofit
Code Pull Requests Activity

finished generic system and system parts

Browse Source
This commit is contained in:
Pilar Monsalvete 2023-10-11 09:14:38 -04:00
parent 84f5ebe4a0
commit 57ee3e734b
16 changed files with 1106 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hub/catalog_factories/data_models/energy_systems/distribution_system.py
View File

@ -12,6 +12,7 @@ from hub.catalog_factories.data_models.energy_systems.generation_system import G
from hub.catalog_factories.data_models.energy_systems.energy_storage_system import EnergyStorageSystem
from hub.catalog_factories.data_models.energy_systems.emission_system import EmissionSystem
class DistributionSystem:
"""
Distribution system class

2
hub/catalog_factories/data_models/energy_systems/energy_storage_system.py
View File

@ -42,7 +42,7 @@ class EnergyStorageSystem(ABC):
def model_name(self):
"""
Get system model
:return: float
:return: string
"""
return self._model_name

6
hub/catalog_factories/data_models/energy_systems/generation_system.py
View File

@ -6,12 +6,12 @@ Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
Code contributors: Saeed Ranjbar saeed.ranjbar@concordia.ca
"""
from __future__ import annotations
from abc import ABC
from typing import List, Union, TypeVar
from typing import List, Union
from hub.catalog_factories.data_models.energy_systems.energy_storage_system import EnergyStorageSystem
DistributionSystem = TypeVar('DistributionSystem')
from hub.catalog_factories.data_models.energy_systems.distribution_system import DistributionSystem
class GenerationSystem(ABC):

18
hub/catalog_factories/data_models/energy_systems/non_pv_generation_system.py
View File

@ -17,7 +17,7 @@ class NonPvGenerationSystem(GenerationSystem):
"""
def __init__(self, system_id, system_type, model_name=None, manufacturer=None, fuel_type=None,
nominal_thermal_output=None, maximum_heat_output=None, minimum_heat_output=None, source_medium=None,
nominal_heat_output=None, maximum_heat_output=None, minimum_heat_output=None, source_medium=None,
supply_medium=None, heat_efficiency=None, nominal_cooling_output=None, maximum_cooling_output=None,
minimum_cooling_output=None, cooling_efficiency=None, electricity_efficiency=None,
source_temperature=None, source_mass_flow=None, nominal_electricity_output=None,
@ -29,7 +29,7 @@ class NonPvGenerationSystem(GenerationSystem):
super().__init__(system_id=system_id, model_name=model_name, manufacturer=manufacturer, fuel_type=fuel_type,
distribution_systems=distribution_systems, energy_storage_systems=energy_storage_systems)
self._system_type = system_type
self._nominal_thermal_output = nominal_thermal_output
self._nominal_heat_output = nominal_heat_output
self._maximum_heat_output = maximum_heat_output
self._minimum_heat_output = minimum_heat_output
self._heat_efficiency = heat_efficiency
@ -63,12 +63,12 @@ class NonPvGenerationSystem(GenerationSystem):
return self._system_type
@property
def nominal_thermal_output(self):
def nominal_heat_output(self):
"""
Get nominal_thermal_output of heat generation devices in kW
Get nominal heat output of heat generation devices in W
:return: float
"""
return self._nominal_thermal_output
return self._nominal_heat_output
@property
def maximum_heat_output(self):
@ -90,7 +90,7 @@ class NonPvGenerationSystem(GenerationSystem):
def source_medium(self):
"""
Get source_type from [air, water, ground, district_heating, grid, on_site_electricity]
:return: [string]
:return: string
"""
return self._source_medium
@ -113,7 +113,7 @@ class NonPvGenerationSystem(GenerationSystem):
@property
def nominal_cooling_output(self):
"""
Get nominal_thermal_output of heat generation devices in kW
Get nominal cooling output of heat generation devices in W
:return: float
"""
return self._nominal_cooling_output
@ -169,7 +169,7 @@ class NonPvGenerationSystem(GenerationSystem):
@property
def nominal_electricity_output(self):
"""
Get nominal_power_output of electricity generation devices or inverters in kW
Get nominal_power_output of electricity generation devices or inverters in W
:return: float
"""
return self._nominal_electricity_output
@ -269,7 +269,7 @@ class NonPvGenerationSystem(GenerationSystem):
'manufacturer': self.manufacturer,
'type': self.system_type,
'fuel type': self.fuel_type,
'nominal thermal output [W]': self.nominal_thermal_output,
'nominal heat output [W]': self.nominal_heat_output,
'maximum heat output [W]': self.maximum_heat_output,
'minimum heat output [W]': self.minimum_heat_output,
'source medium': self.source_medium,

8
hub/catalog_factories/data_models/energy_systems/pv_generation_system.py
View File

@ -45,7 +45,7 @@ class PvGenerationSystem(GenerationSystem):
@property
def nominal_electricity_output(self):
"""
Get nominal_power_output of electricity generation devices or inverters in kW
Get nominal_power_output of electricity generation devices or inverters in W
:return: float
"""
return self._nominal_electricity_output
@ -93,7 +93,7 @@ class PvGenerationSystem(GenerationSystem):
@property
def standard_test_condition_maximum_power(self):
"""
Get standard test condition maximum power of PV panels in kW
Get standard test condition maximum power of PV panels in W
:return: float
"""
return self._standard_test_condition_maximum_power
@ -137,12 +137,12 @@ class PvGenerationSystem(GenerationSystem):
'type': self.system_type,
'fuel type': self.fuel_type,
'electricity efficiency': self.electricity_efficiency,
'nominal power output [kW]': self.nominal_electricity_output,
'nominal power output [W]': 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,
'standard test condition maximum power [W]': self.standard_test_condition_maximum_power,
'cell temperature coefficient': self.cell_temperature_coefficient,
'width': self.width,
'height': self.height,

2
hub/catalog_factories/data_models/energy_systems/system.py
View File

@ -28,8 +28,8 @@ class System:
self._system_id = system_id
self._name = name
self._demand_types = demand_types
self._distribution_systems = distribution_systems
self._generation_systems = generation_systems
self._distribution_systems = distribution_systems
self._configuration_schema = configuration_schema
@property

4
hub/catalog_factories/energy_systems/north_america_energy_system_catalog.py
View File

@ -57,7 +57,7 @@ class NorthAmericaEnergySystemCatalog(Catalog):
model_name=boiler_model_name,
manufacturer=boiler_manufacturer,
fuel_type=boiler_fuel_type,
nominal_thermal_output=boiler_nominal_thermal_output,
nominal_heat_output=boiler_nominal_thermal_output,
maximum_heat_output=boiler_maximum_heat_output,
minimum_heat_output=boiler_minimum_heat_output,
heat_efficiency=boiler_heat_efficiency)
@ -89,7 +89,7 @@ class NorthAmericaEnergySystemCatalog(Catalog):
model_name=heat_pump_model_name,
manufacturer=heat_pump_manufacturer,
fuel_type=heat_pump_fuel_type,
nominal_thermal_output=heat_pump_nominal_thermal_output,
nominal_heat_output=heat_pump_nominal_thermal_output,
maximum_heat_output=heat_pump_maximum_heat_output,
minimum_heat_output=heat_pump_minimum_heat_output,
source_medium=heat_pump_source_medium,

74
hub/city_model_structure/energy_systems/generic_distribution_system.py
View File

@ -5,17 +5,43 @@ 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.energy_systems.generic_generation_system import GenericGenerationSystem
from hub.city_model_structure.energy_systems.generic_emission_system import GenericEmissionSystem
from hub.city_model_structure.energy_systems.generic_storage_system import GenericStorageSystem
class GenericDistributionSystem:
"""
GenericDistributionSystem class
"""
def __init__(self):
self._model_name = None
self._type = None
self._supply_temperature = None
self._distribution_consumption_fix_flow = None
self._distribution_consumption_variable_flow = None
self._heat_losses = None
self._generic_generation_systems = None
self._generic_storage_systems = None
self._generic_emission_systems = None
@property
def model_name(self):
"""
Get model name
:return: string
"""
return self._model_name
@model_name.setter
def model_name(self, value):
"""
Set model name
:param value: string
"""
self._model_name = value
@property
def type(self):
@ -98,3 +124,51 @@ class GenericDistributionSystem:
:param value: float
"""
self._heat_losses = value
@property
def generic_generation_systems(self) -> Union[None, List[GenericGenerationSystem]]:
"""
Get generation systems connected to the distribution system
:return: [generic_generation_systems]
"""
return self._generic_generation_systems
@generic_generation_systems.setter
def generic_generation_systems(self, value):
"""
Set generation systems connected to the distribution system
:param value: [generic_generation_systems]
"""
self._generic_generation_systems = value
@property
def generic_storage_systems(self) -> Union[None, List[GenericStorageSystem]]:
"""
Get energy storage systems connected to this distribution system
:return: [GenericStorageSystem]
"""
return self._generic_storage_systems
@generic_storage_systems.setter
def generic_storage_systems(self, value):
"""
Set energy storage systems connected to this distribution system
:param value: [GenericStorageSystem]
"""
self._generic_storage_systems = value
@property
def generic_emission_systems(self) -> Union[None, List[GenericEmissionSystem]]:
"""
Get energy emission systems connected to this distribution system
:return: [GenericEmissionSystem]
"""
return self._generic_emission_systems
@generic_emission_systems.setter
def generic_emission_systems(self, value):
"""
Set energy emission systems connected to this distribution system
:param value: [GenericEmissionSystem]
"""
self._generic_emission_systems = value

104
hub/city_model_structure/energy_systems/generic_electrical_storage_system.py Normal file
View File

@ -0,0 +1,104 @@
"""
Generic electrical storage 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.city_model_structure.energy_systems.generic_storage_system import GenericStorageSystem
class GenericElectricalStorageSystem(GenericStorageSystem):
""""
Generic Electrical Storage System Class
"""
def __init__(self):
super().__init__()
self._rated_output_power = None
self._nominal_efficiency = None
self._battery_voltage = None
self._depth_of_discharge = None
self._self_discharge_rate = None
@property
def rated_output_power(self):
"""
Get the rated output power of storage system in Watts
:return: float
"""
return self._rated_output_power
@rated_output_power.setter
def rated_output_power(self, value):
"""
Set the rated output power of storage system in Watts
:param value: float
"""
self._rated_output_power = value
@property
def nominal_efficiency(self):
"""
Get the nominal efficiency of the storage system
:return: float
"""
return self._nominal_efficiency
@nominal_efficiency.setter
def nominal_efficiency(self, value):
"""
Set the nominal efficiency of the storage system
:param value: float
"""
self._nominal_efficiency = value
@property
def battery_voltage(self):
"""
Get the battery voltage in Volts
:return: float
"""
return self._battery_voltage
@battery_voltage.setter
def battery_voltage(self, value):
"""
Set the battery voltage in Volts
:param value: float
"""
self._battery_voltage = value
@property
def depth_of_discharge(self):
"""
Get the depth of discharge as a percentage
:return: float
"""
return self._depth_of_discharge
@depth_of_discharge.setter
def depth_of_discharge(self, value):
"""
Set the depth of discharge as a percentage
:param value: float
"""
self._depth_of_discharge = value
@property
def self_discharge_rate(self):
"""
Get the self discharge rate of battery as a percentage
:return: float
"""
return self._self_discharge_rate
@self_discharge_rate.setter
def self_discharge_rate(self, value):
"""
Set the self discharge rate of battery as a percentage
:param value: float
"""
self._self_discharge_rate = value

34
hub/city_model_structure/energy_systems/generic_emission_system.py
View File

@ -11,8 +11,42 @@ class GenericEmissionSystem:
GenericEmissionSystem class
"""
def __init__(self):
self._model_name = None
self._type = None
self._parasitic_energy_consumption = None
@property
def model_name(self):
"""
Get model name
:return: string
"""
return self._model_name
@model_name.setter
def model_name(self, value):
"""
Set model name
:param value: string
"""
self._model_name = value
@property
def type(self):
"""
Get type
:return: string
"""
return self._type
@type.setter
def type(self, value):
"""
Set type
:param value: string
"""
self._type = value
@property
def parasitic_energy_consumption(self):
"""

105
hub/city_model_structure/energy_systems/generic_energy_system.py
View File

@ -6,41 +6,22 @@ Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
"""
from typing import Union, List
from pathlib import Path
from hub.city_model_structure.energy_systems.generic_distribution_system import GenericDistributionSystem
from hub.city_model_structure.energy_systems.generic_emission_system import GenericEmissionSystem
from hub.city_model_structure.energy_systems.generic_generation_system import GenericGenerationSystem
from hub.city_model_structure.energy_systems.generic_storage_system import GenericStorageSystem
class GenericEnergySystem:
"""
GenericEnergySystem class
"""
def __init__(self):
self._name = None
self._demand_types = None
self._generation_system = None
self._distribution_system = None
self._emission_system = None
self._connected_city_objects = None
self._energy_storage_system = None
@property
def name(self):
"""
Get energy system name
:return: str
"""
return self._name
@name.setter
def name(self, value):
"""
Set energy system name
:param value:
"""
self._name = value
self._name = None
self._generation_systems = None
self._distribution_systems = None
self._configuration_schema = None
@property
def demand_types(self):
@ -58,66 +39,66 @@ class GenericEnergySystem:
"""
self._demand_types = value
@property
def name(self):
"""
Get energy system name
:return: str
"""
return self._name
@name.setter
def name(self, value):
"""
Set energy system name
:param value:
"""
self._name = value
@property
def generation_systems(self) -> List[GenericGenerationSystem]:
"""
Get generation system
:return: GenerationSystem
Get generation systems
:return: [GenerationSystem]
"""
return self._generation_system
return self._generation_systems
@generation_systems.setter
def generation_systems(self, value):
"""
Set generation system
:return: GenerationSystem
Set generation systems
:return: [GenerationSystem]
"""
self._generation_system = value
self._generation_systems = value
@property
def distribution_systems(self) -> Union[None, List[GenericDistributionSystem]]:
"""
Get distribution system
:return: DistributionSystem
Get distribution systems
:return: [DistributionSystem]
"""
return self._distribution_system
return self._distribution_systems
@distribution_systems.setter
def distribution_systems(self, value):
"""
Set distribution system
:param value: DistributionSystem
Set distribution systems
:param value: [DistributionSystem]
"""
self._distribution_system = value
self._distribution_systems = value
@property
def emission_systems(self) -> Union[None, List[GenericEmissionSystem]]:
def configuration_schema(self) -> Path:
"""
Get emission system
:return: EmissionSystem
Get the schema of the system configuration
:return: Path
"""
return self._emission_system
return self._configuration_schema
@emission_systems.setter
def emission_systems(self, value):
@configuration_schema.setter
def configuration_schema(self, value):
"""
Set emission system
:param value: EmissionSystem
Set the schema of the system configuration
:param value: Path
"""
self._emission_system = value
@property
def energy_storage_systems(self) -> Union[None, List[GenericStorageSystem]]:
"""
Get storage system
:return: EnergyStorageSystem
"""
return self._energy_storage_system
@energy_storage_systems.setter
def energy_storage_systems(self, value):
"""
Set storage system
:return: EnergyStorageSystem
"""
self._energy_storage_system = value
self._configuration_schema = value

394
hub/city_model_structure/energy_systems/generic_generation_system.py
View File

@ -1,58 +1,78 @@
"""
Energy System catalog heat generation system
Generic energy generation system (abstract class)
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2023 Concordia CERC group
Project Coder Saeed Ranjbar saeed.ranjbar@concordia.ca
Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
Code contributors: Saeed Ranjbar saeed.ranjbar@concordia.ca
"""
from __future__ import annotations
from typing import Union
from hub.city_model_structure.energy_systems.performance_curve import PerformanceCurves
from abc import ABC
from typing import Union, List
from hub.city_model_structure.energy_systems.generic_distribution_system import GenericDistributionSystem
from hub.city_model_structure.energy_systems.generic_storage_system import GenericStorageSystem
class GenericGenerationSystem:
class GenericGenerationSystem(ABC):
"""
GenericGenerationSystem class
"""
def __init__(self):
self._type = None
self._system_type = None
self._model_name = None
self._manufacturer = None
self._fuel_type = None
self._source_types = None
self._heat_efficiency = None
self._cooling_efficiency = None
self._electricity_efficiency = None
self._source_temperature = None
self._source_mass_flow = None
self._storage = None
self._auxiliary_equipment = None
self._supply_medium = None
self._maximum_heat_supply_temperature = None
self._minimum_heat_supply_temperature = None
self._maximum_cooling_supply_temperature = None
self._minimum_cooling_supply_temperature = None
self._heat_output_curve = None
self._heat_fuel_consumption_curve = None
self._heat_efficiency_curve = None
self._cooling_output_curve = None
self._cooling_fuel_consumption_curve = None
self._cooling_efficiency_curve = None
self._generic_distribution_systems = None
self._generic_storage_systems = None
@property
def type(self):
def system_type(self):
"""
Get system type
Get type
:return: string
"""
return self._type
return self._system_type
@type.setter
def type(self, value):
@system_type.setter
def system_type(self, value):
"""
Set system type
Set type
:param value: string
"""
self._type = value
self._system_type = value
@property
def model_name(self):
"""
Get model name
:return: string
"""
return self._model_name
@model_name.setter
def model_name(self, value):
"""
Set model name
:param value: string
"""
self._model_name = value
@property
def manufacturer(self):
"""
Get manufacturer's name
:return: string
"""
return self._manufacturer
@manufacturer.setter
def manufacturer(self, value):
"""
Set manufacturer's name
:param value: string
"""
self._manufacturer = value
@property
def fuel_type(self):
@ -71,305 +91,33 @@ class GenericGenerationSystem:
self._fuel_type = value
@property
def source_types(self):
def generic_distribution_systems(self) -> Union[None, List[GenericDistributionSystem]]:
"""
Get source_type from [Air, Water, Geothermal, District Heating, Grid, Onsite Electricity]
:return: [string]
Get distributions systems connected to this generation system
:return: [GenericDistributionSystem]
"""
return self._source_types
return self._generic_distribution_systems
@source_types.setter
def source_types(self, value):
@generic_distribution_systems.setter
def generic_distribution_systems(self, value):
"""
Set source_type from [Air, Water, Geothermal, District Heating, Grid, Onsite Electricity]
:param value: [string]
Set distributions systems connected to this generation system
:param value: [GenericDistributionSystem]
"""
self._source_types = value
self._generic_distribution_systems = value
@property
def heat_efficiency(self):
def generic_storage_systems(self) -> Union[None, List[GenericStorageSystem]]:
"""
Get heat_efficiency
:return: float
Get energy storage systems connected to this generation system
:return: [GenericStorageSystem]
"""
return self._heat_efficiency
return self._generic_storage_systems
@heat_efficiency.setter
def heat_efficiency(self, value):
@generic_storage_systems.setter
def generic_storage_systems(self, value):
"""
Set heat_efficiency
:param value: float
Set energy storage systems connected to this generation system
:param value: [GenericStorageSystem]
"""
self._heat_efficiency = value
@property
def cooling_efficiency(self):
"""
Get cooling_efficiency
:return: float
"""
return self._cooling_efficiency
@cooling_efficiency.setter
def cooling_efficiency(self, value):
"""
Set cooling_efficiency
:param value: float
"""
self._cooling_efficiency = value
@property
def electricity_efficiency(self):
"""
Get electricity_efficiency
:return: float
"""
return self._electricity_efficiency
@electricity_efficiency.setter
def electricity_efficiency(self, value):
"""
Set electricity_efficiency
:param value: float
"""
self._electricity_efficiency = value
@property
def source_temperature(self):
"""
Get source_temperature in degree Celsius
:return: float
"""
return self._source_temperature
@source_temperature.setter
def source_temperature(self, value):
"""
Set source_temperature in degree Celsius
:param value: float
"""
self._source_temperature = value
@property
def source_mass_flow(self):
"""
Get source_mass_flow in kg/s
:return: float
"""
return self._source_mass_flow
@source_mass_flow.setter
def source_mass_flow(self, value):
"""
Set source_mass_flow in kg/s
:param value: float
"""
self._source_mass_flow = value
@property
def storage(self):
"""
Get boolean storage exists
:return: bool
"""
return self._storage
@storage.setter
def storage(self, value):
"""
Set boolean storage exists
:return: bool
"""
self._storage = value
@property
def auxiliary_equipment(self) -> Union[None, GenericGenerationSystem]:
"""
Get auxiliary_equipment
:return: GenerationSystem
"""
return self._auxiliary_equipment
@auxiliary_equipment.setter
def auxiliary_equipment(self, value):
"""
Set auxiliary_equipment
:return: GenerationSystem
"""
self._auxiliary_equipment = value
@property
def supply_medium(self):
"""
Get the supply medium from ['air', 'water']
:return: string
"""
return self._supply_medium
@supply_medium.setter
def supply_medium(self, value):
"""
Set the supply medium from ['air', 'water']
:param value: string
"""
self._supply_medium = value
@property
def maximum_heat_supply_temperature(self):
"""
Get maximum heating supply temperature in degree Celsius
:return: float
"""
return self._maximum_heat_supply_temperature
@maximum_heat_supply_temperature.setter
def maximum_heat_supply_temperature(self, value):
"""
Set maximum heating supply temperature in degree Celsius
:param value: float
"""
self._maximum_heat_supply_temperature = value
@property
def minimum_heat_supply_temperature(self):
"""
Get minimum heating supply temperature in degree Celsius
:return: float
"""
return self._minimum_heat_supply_temperature
@minimum_heat_supply_temperature.setter
def minimum_heat_supply_temperature(self, value):
"""
Set minimum heating supply temperature in degree Celsius
:param value: float
"""
self._minimum_heat_supply_temperature = value
@property
def maximum_cooling_supply_temperature(self):
"""
Get maximum cooling supply temperature in degree Celsius
:return: float
"""
return self._maximum_cooling_supply_temperature
@maximum_cooling_supply_temperature.setter
def maximum_cooling_supply_temperature(self, value):
"""
Set maximum cooling supply temperature in degree Celsius
:param value: float
"""
self._maximum_cooling_supply_temperature = value
@property
def minimum_cooling_supply_temperature(self):
"""
Get minimum cooling supply temperature in degree Celsius
:return: float
"""
return self._minimum_cooling_supply_temperature
@minimum_cooling_supply_temperature.setter
def minimum_cooling_supply_temperature(self, value):
"""
Set minimum cooling supply temperature in degree Celsius
:param value: float
"""
self._minimum_cooling_supply_temperature = value
@property
def heat_output_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heat output curve of the heat generation device
:return: PerformanceCurve
"""
return self._heat_output_curve
@heat_output_curve.setter
def heat_output_curve(self, value):
"""
Set the heat output curve of the heat generation device
:return: PerformanceCurve
"""
self._heat_output_curve = value
@property
def heat_fuel_consumption_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
return self._heat_fuel_consumption_curve
@heat_fuel_consumption_curve.setter
def heat_fuel_consumption_curve(self, value):
"""
Set the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
self._heat_fuel_consumption_curve = value
@property
def heat_efficiency_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
return self._heat_efficiency_curve
@heat_efficiency_curve.setter
def heat_efficiency_curve(self, value):
"""
Set the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
self._heat_efficiency_curve = value
@property
def cooling_output_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the cooling output curve of the heat generation device
:return: PerformanceCurve
"""
return self._cooling_output_curve
@cooling_output_curve.setter
def cooling_output_curve(self, value):
"""
Set the cooling output curve of the heat generation device
:return: PerformanceCurve
"""
self._cooling_output_curve = value
@property
def cooling_fuel_consumption_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
return self._cooling_fuel_consumption_curve
@cooling_fuel_consumption_curve.setter
def cooling_fuel_consumption_curve(self, value):
"""
Set the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
self._cooling_fuel_consumption_curve = value
@property
def cooling_efficiency_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
return self._cooling_efficiency_curve
@cooling_efficiency_curve.setter
def cooling_efficiency_curve(self, value):
"""
Set the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
self._cooling_efficiency_curve = value
self._generic_storage_systems = value

428
hub/city_model_structure/energy_systems/generic_non_pv_generation_system.py Normal file
View File

@ -0,0 +1,428 @@
"""
Generic non PV energy 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 hub.city_model_structure.energy_systems.generic_generation_system import GenericGenerationSystem
from hub.city_model_structure.energy_systems.performance_curve import PerformanceCurves
class GenericNonPvGenerationSystem(GenericGenerationSystem):
"""
GenericNonPvGenerationSystem class
"""
def __init__(self):
super().__init__()
self._nominal_heat_output = None
self._maximum_heat_output = None
self._minimum_heat_output = None
self._heat_efficiency = None
self._nominal_cooling_output = None
self._maximum_cooling_output = None
self._minimum_cooling_output = None
self._cooling_efficiency = None
self._electricity_efficiency = None
self._nominal_electricity_output = None
self._source_medium = None
self._source_temperature = None
self._source_mass_flow = None
self._supply_medium = None
self._maximum_heat_supply_temperature = None
self._minimum_heat_supply_temperature = None
self._maximum_cooling_supply_temperature = None
self._minimum_cooling_supply_temperature = None
self._heat_output_curve = None
self._heat_fuel_consumption_curve = None
self._heat_efficiency_curve = None
self._cooling_output_curve = None
self._cooling_fuel_consumption_curve = None
self._cooling_efficiency_curve = None
@property
def nominal_heat_output(self):
"""
Get nominal heat output of heat generation devices in W
:return: float
"""
return self._nominal_heat_output
@nominal_heat_output.setter
def nominal_heat_output(self, value):
"""
Set nominal heat output of heat generation devices in W
:param value: float
"""
self._nominal_heat_output = value
@property
def maximum_heat_output(self):
"""
Get maximum heat output of heat generation devices in W
:return: float
"""
return self._maximum_heat_output
@maximum_heat_output.setter
def maximum_heat_output(self, value):
"""
Set maximum heat output of heat generation devices in W
:param value: float
"""
self._maximum_heat_output = value
@property
def minimum_heat_output(self):
"""
Get minimum heat output of heat generation devices in W
:return: float
"""
return self._minimum_heat_output
@minimum_heat_output.setter
def minimum_heat_output(self, value):
"""
Set minimum heat output of heat generation devices in W
:param value: float
"""
self._minimum_heat_output = value
@property
def source_medium(self):
"""
Get source_type from [air, water, ground, district_heating, grid, on_site_electricity]
:return: string
"""
return self._source_medium
@source_medium.setter
def source_medium(self, value):
"""
Set source medium from [Air, Water, Geothermal, District Heating, Grid, Onsite Electricity]
:param value: [string]
"""
self._source_medium = value
@property
def supply_medium(self):
"""
Get the supply medium from ['air', 'water']
:return: string
"""
return self._supply_medium
@supply_medium.setter
def supply_medium(self, value):
"""
Set the supply medium from ['air', 'water']
:param value: string
"""
self._supply_medium = value
@property
def heat_efficiency(self):
"""
Get heat_efficiency
:return: float
"""
return self._heat_efficiency
@heat_efficiency.setter
def heat_efficiency(self, value):
"""
Set heat_efficiency
:param value: float
"""
self._heat_efficiency = value
@property
def nominal_cooling_output(self):
"""
Get nominal cooling output of heat generation devices in W
:return: float
"""
return self._nominal_cooling_output
@nominal_cooling_output.setter
def nominal_cooling_output(self, value):
"""
Set nominal cooling output of heat generation devices in W
:param value: float
"""
self._nominal_cooling_output = value
@property
def maximum_cooling_output(self):
"""
Get maximum heat output of heat generation devices in W
:return: float
"""
return self._maximum_cooling_output
@maximum_cooling_output.setter
def maximum_cooling_output(self, value):
"""
Set maximum heat output of heat generation devices in W
:param value: float
"""
self._maximum_cooling_output = value
@property
def minimum_cooling_output(self):
"""
Get minimum heat output of heat generation devices in W
:return: float
"""
return self._minimum_cooling_output
@minimum_cooling_output.setter
def minimum_cooling_output(self, value):
"""
Set minimum heat output of heat generation devices in W
:param value: float
"""
self._minimum_cooling_output = value
@property
def cooling_efficiency(self):
"""
Get cooling_efficiency
:return: float
"""
return self._cooling_efficiency
@cooling_efficiency.setter
def cooling_efficiency(self, value):
"""
Set cooling_efficiency
:param value: float
"""
self._cooling_efficiency = value
@property
def electricity_efficiency(self):
"""
Get electricity_efficiency
:return: float
"""
return self._electricity_efficiency
@electricity_efficiency.setter
def electricity_efficiency(self, value):
"""
Set electricity_efficiency
:param value: float
"""
self._electricity_efficiency = value
@property
def source_temperature(self):
"""
Get source_temperature in degree Celsius
:return: float
"""
return self._source_temperature
@source_temperature.setter
def source_temperature(self, value):
"""
Set source_temperature in degree Celsius
:param value: float
"""
self._source_temperature = value
@property
def source_mass_flow(self):
"""
Get source_mass_flow in kg/s
:return: float
"""
return self._source_mass_flow
@source_mass_flow.setter
def source_mass_flow(self, value):
"""
Set source_mass_flow in kg/s
:param value: float
"""
self._source_mass_flow = value
@property
def nominal_electricity_output(self):
"""
Get nominal_power_output of electricity generation devices or inverters in W
:return: float
"""
return self._nominal_electricity_output
@nominal_electricity_output.setter
def nominal_electricity_output(self, value):
"""
Get nominal_power_output of electricity generation devices or inverters in W
:param value: float
"""
self._nominal_electricity_output = value
@property
def maximum_heat_supply_temperature(self):
"""
Get the maximum heat supply temperature in degree Celsius
:return: float
"""
return self._minimum_heat_supply_temperature
@maximum_heat_supply_temperature.setter
def maximum_heat_supply_temperature(self, value):
"""
Set maximum heating supply temperature in degree Celsius
:param value: float
"""
self._maximum_heat_supply_temperature = value
@property
def minimum_heat_supply_temperature(self):
"""
Get the minimum heat supply temperature in degree Celsius
:return: float
"""
return self._minimum_heat_supply_temperature
@minimum_heat_supply_temperature.setter
def minimum_heat_supply_temperature(self, value):
"""
Set minimum heating supply temperature in degree Celsius
:param value: float
"""
self._minimum_heat_supply_temperature = value
@property
def maximum_cooling_supply_temperature(self):
"""
Get the maximum cooling supply temperature in degree Celsius
:return: float
"""
return self._maximum_cooling_supply_temperature
@maximum_cooling_supply_temperature.setter
def maximum_cooling_supply_temperature(self, value):
"""
Set maximum cooling supply temperature in degree Celsius
:param value: float
"""
self._maximum_cooling_supply_temperature = value
@property
def minimum_cooling_supply_temperature(self):
"""
Get the minimum cooling supply temperature in degree Celsius
:return: float
"""
return self._minimum_cooling_supply_temperature
@minimum_cooling_supply_temperature.setter
def minimum_cooling_supply_temperature(self, value):
"""
Set minimum cooling supply temperature in degree Celsius
:param value: float
"""
self._minimum_cooling_supply_temperature = value
@property
def heat_output_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heat output curve of the heat generation device
:return: PerformanceCurve
"""
return self._heat_output_curve
@heat_output_curve.setter
def heat_output_curve(self, value):
"""
Set the heat output curve of the heat generation device
:return: PerformanceCurve
"""
self._heat_output_curve = value
@property
def heat_fuel_consumption_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
return self._heat_fuel_consumption_curve
@heat_fuel_consumption_curve.setter
def heat_fuel_consumption_curve(self, value):
"""
Set the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
self._heat_fuel_consumption_curve = value
@property
def heat_efficiency_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
return self._heat_efficiency_curve
@heat_efficiency_curve.setter
def heat_efficiency_curve(self, value):
"""
Set the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
self._heat_efficiency_curve = value
@property
def cooling_output_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heat output curve of the heat generation device
:return: PerformanceCurve
"""
return self._cooling_output_curve
@cooling_output_curve.setter
def cooling_output_curve(self, value):
"""
Set the cooling output curve of the heat generation device
:return: PerformanceCurve
"""
self._cooling_output_curve = value
@property
def cooling_fuel_consumption_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
return self._cooling_fuel_consumption_curve
@cooling_fuel_consumption_curve.setter
def cooling_fuel_consumption_curve(self, value):
"""
Set the heating fuel consumption curve of the heat generation device
:return: PerformanceCurve
"""
self._cooling_fuel_consumption_curve = value
@property
def cooling_efficiency_curve(self) -> Union[None, PerformanceCurves]:
"""
Get the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
return self._cooling_efficiency_curve
@cooling_efficiency_curve.setter
def cooling_efficiency_curve(self, value):
"""
Set the heating efficiency curve of the heat generation device
:return: PerformanceCurve
"""
self._cooling_efficiency_curve = value

187
hub/city_model_structure/energy_systems/generic_pv_generation_system.py Normal file
View File

@ -0,0 +1,187 @@
"""
Generic PV energy 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 hub.city_model_structure.energy_systems.generic_generation_system import GenericGenerationSystem
class GenericPvGenerationSystem(GenericGenerationSystem):
"""
GenericPvGenerationSystem class
"""
def __init__(self):
super().__init__()
self._electricity_efficiency = None
self._nominal_electricity_output = None
self._nominal_ambient_temperature = None
self._nominal_cell_temperature = None
self._nominal_radiation = None
self._standard_test_condition_cell_temperature = None
self._standard_test_condition_maximum_power = None
self._cell_temperature_coefficient = None
self._width = None
self._height = None
@property
def nominal_electricity_output(self):
"""
Get nominal_power_output of electricity generation devices or inverters in W
:return: float
"""
return self._nominal_electricity_output
@nominal_electricity_output.setter
def nominal_electricity_output(self, value):
"""
Set nominal_power_output of electricity generation devices or inverters in W
:param value: float
"""
self._nominal_electricity_output = value
@property
def electricity_efficiency(self):
"""
Get electricity_efficiency
:return: float
"""
return self._electricity_efficiency
@electricity_efficiency.setter
def electricity_efficiency(self, value):
"""
Set electricity_efficiency
:param value: float
"""
self._electricity_efficiency = value
@property
def nominal_ambient_temperature(self):
"""
Get nominal ambient temperature of PV panels in degree Celsius
:return: float
"""
return self._nominal_ambient_temperature
@nominal_ambient_temperature.setter
def nominal_ambient_temperature(self, value):
"""
Set nominal ambient temperature of PV panels in degree Celsius
:param value: float
"""
self._nominal_ambient_temperature = value
@property
def nominal_cell_temperature(self):
"""
Get nominal cell temperature of PV panels in degree Celsius
:return: float
"""
return self._nominal_cell_temperature
@nominal_cell_temperature.setter
def nominal_cell_temperature(self, value):
"""
Set nominal cell temperature of PV panels in degree Celsius
:param value: float
"""
self._nominal_cell_temperature = value
@property
def nominal_radiation(self):
"""
Get nominal radiation of PV panels
:return: float
"""
return self._nominal_radiation
@nominal_radiation.setter
def nominal_radiation(self, value):
"""
Set nominal radiation of PV panels
:param value: float
"""
self._nominal_radiation = value
@property
def standard_test_condition_cell_temperature(self):
"""
Get standard test condition cell temperature of PV panels in degree Celsius
:return: float
"""
return self._standard_test_condition_cell_temperature
@standard_test_condition_cell_temperature.setter
def standard_test_condition_cell_temperature(self, value):
"""
Set standard test condition cell temperature of PV panels in degree Celsius
:param value: float
"""
self._standard_test_condition_cell_temperature = value
@property
def standard_test_condition_maximum_power(self):
"""
Get standard test condition maximum power of PV panels in W
:return: float
"""
return self._standard_test_condition_maximum_power
@standard_test_condition_maximum_power.setter
def standard_test_condition_maximum_power(self, value):
"""
Set standard test condition maximum power of PV panels in W
:param value: float
"""
self._standard_test_condition_maximum_power = value
@property
def cell_temperature_coefficient(self):
"""
Get cell temperature coefficient of PV module
:return: float
"""
return self._cell_temperature_coefficient
@cell_temperature_coefficient.setter
def cell_temperature_coefficient(self, value):
"""
Set cell temperature coefficient of PV module
:param value: float
"""
self._cell_temperature_coefficient = value
@property
def width(self):
"""
Get PV module width in m
:return: float
"""
return self._width
@width.setter
def width(self, value):
"""
Set PV module width in m
:param value: float
"""
self._width = value
@property
def height(self):
"""
Get PV module height in m
:return: float
"""
return self._height
@height.setter
def height(self, value):
"""
Set PV module height in m
:param value: float
"""
self._height = value

60
hub/city_model_structure/energy_systems/generic_storage_system.py
View File

@ -7,21 +7,41 @@ Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concord
"""
from __future__ import annotations
from abc import ABC
class GenericStorageSystem:
class GenericStorageSystem(ABC):
"""
Generic storage System class
"""
def __init__(self):
self._type_energy_stored = None
self._storage_type = None
self._model_name = None
self._manufacturer = None
self._nominal_capacity = None
self._losses_ratio = None
@property
def type_energy_stored(self):
"""
Get type of energy stored from ['electrical', 'thermal']
:return: string
"""
return self._type_energy_stored
@type_energy_stored.setter
def type_energy_stored(self, value):
"""
Set type of energy stored from ['electrical', 'thermal']
:return: string
"""
self._type_energy_stored = value
@property
def storage_type(self):
"""
Get the type of storage system from [sensible, latent, lithium_ion, NiCd, lead_acid]
Get storage type
:return: string
"""
return self._storage_type
@ -29,11 +49,43 @@ class GenericStorageSystem:
@storage_type.setter
def storage_type(self, value):
"""
Set the type of storage system from [sensible, latent, lithium_ion, NiCd, lead_acid]
:return: string
Get storage type
:param value: string
"""
self._storage_type = value
@property
def model_name(self):
"""
Get system model
:return: string
"""
return self._model_name
@model_name.setter
def model_name(self, value):
"""
Set system model
:param value: string
"""
self._model_name = value
@property
def manufacturer(self):
"""
Get name of manufacturer
:return: string
"""
return self._manufacturer
@manufacturer.setter
def manufacturer(self, value):
"""
Set name of manufacturer
:param value: string
"""
self._manufacturer = value
@property
def nominal_capacity(self):
"""

88
hub/city_model_structure/energy_systems/generic_thermal_storage_system.py Normal file
View File

@ -0,0 +1,88 @@
"""
Generic thermal storage 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.city_model_structure.energy_systems.generic_storage_system import GenericStorageSystem
from hub.city_model_structure.building_demand.layer import Layer
class GenericThermalStorageSystem(GenericStorageSystem):
""""
Generic Thermal Storage System Class
"""
def __init__(self):
super().__init__()
self._volume = None
self._height = None
self._layers = None
self._maximum_operating_temperature = None
@property
def volume(self):
"""
Get the physical volume of the storage system in cubic meters
:return: float
"""
return self._volume
@volume.setter
def volume(self, value):
"""
Set the physical volume of the storage system in cubic meters
:param value: float
"""
self._volume = value
@property
def height(self):
"""
Get the diameter of the storage system in meters
:return: float
"""
return self._height
@height.setter
def height(self, value):
"""
Set the diameter of the storage system in meters
:param value: float
"""
self._height = value
@property
def layers(self) -> [Layer]:
"""
Get construction layers
:return: [layer]
"""
return self._layers
@layers.setter
def layers(self, value):
"""
Set construction layers
:param value: [layer]
"""
self._layers = value
@property
def maximum_operating_temperature(self):
"""
Get maximum operating temperature of the storage system in degree Celsius
:return: float
"""
return self._maximum_operating_temperature
@maximum_operating_temperature.setter
def maximum_operating_temperature(self, value):
"""
Set maximum operating temperature of the storage system in degree Celsius
:param value: float
"""
self._maximum_operating_temperature = value