finished generic system and system parts

hub/catalog_factories/data_models/energy_systems/distribution_system.py

@@ -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

hub/catalog_factories/data_models/energy_systems/energy_storage_system.py

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

hub/catalog_factories/data_models/energy_systems/generation_system.py

@@ -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
-
+from hub.catalog_factories.data_models.energy_systems.distribution_system import DistributionSystem
-DistributionSystem = TypeVar('DistributionSystem')
 
 
 class GenerationSystem(ABC):

hub/catalog_factories/data_models/energy_systems/non_pv_generation_system.py

@@ -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,

hub/catalog_factories/data_models/energy_systems/pv_generation_system.py

@@ -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,

hub/catalog_factories/data_models/energy_systems/system.py

@@ -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

hub/catalog_factories/energy_systems/north_america_energy_system_catalog.py

@@ -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,

hub/city_model_structure/energy_systems/generic_distribution_system.py

@@ -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

hub/city_model_structure/energy_systems/generic_electrical_storage_system.py

@@ -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

hub/city_model_structure/energy_systems/generic_emission_system.py

@@ -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):
     """

hub/city_model_structure/energy_systems/generic_energy_system.py

@@ -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._name = None
-    self._distribution_system = None
+    self._generation_systems = None
-    self._emission_system = None
+    self._distribution_systems = None
-    self._connected_city_objects = None
+    self._configuration_schema = 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
 
   @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
+    Get generation systems
-    :return: GenerationSystem
+    :return: [GenerationSystem]
     """
-    return self._generation_system
+    return self._generation_systems
 
   @generation_systems.setter
   def generation_systems(self, value):
     """
-    Set generation system
+    Set generation systems
-    :return: GenerationSystem
+    :return: [GenerationSystem]
     """
-    self._generation_system = value
+    self._generation_systems = value
 
   @property
   def distribution_systems(self) -> Union[None, List[GenericDistributionSystem]]:
     """
-    Get distribution system
+    Get distribution systems
-    :return: DistributionSystem
+    :return: [DistributionSystem]
     """
-    return self._distribution_system
+    return self._distribution_systems
 
   @distribution_systems.setter
   def distribution_systems(self, value):
     """
-    Set distribution system
+    Set distribution systems
-    :param value: DistributionSystem
+    :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
+    Get the schema of the system configuration
-    :return: EmissionSystem
+    :return: Path
     """
-    return self._emission_system
+    return self._configuration_schema
 
-  @emission_systems.setter
+  @configuration_schema.setter
-  def emission_systems(self, value):
+  def configuration_schema(self, value):
     """
-    Set emission system
+    Set the schema of the system configuration
-    :param value: EmissionSystem
+    :param value: Path
     """
-    self._emission_system = value
+    self._configuration_schema = 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

hub/city_model_structure/energy_systems/generic_generation_system.py

@@ -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
+Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
-Code contributors: 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 abc import ABC
-from hub.city_model_structure.energy_systems.performance_curve import PerformanceCurves
+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._generic_distribution_systems = None
-    self._heat_efficiency = None
+    self._generic_storage_systems = 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
 
   @property
-  def type(self):
+  def system_type(self):
     """
-    Get system type
+    Get type
     :return: string
     """
-    return self._type
+    return self._system_type
 
-  @type.setter
+  @system_type.setter
-  def type(self, value):
+  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]
+    Get distributions systems connected to this generation system
-    :return: [string]
+    :return: [GenericDistributionSystem]
     """
-    return self._source_types
+    return self._generic_distribution_systems
 
-  @source_types.setter
+  @generic_distribution_systems.setter
-  def source_types(self, value):
+  def generic_distribution_systems(self, value):
     """
-    Set source_type from [Air, Water, Geothermal, District Heating, Grid, Onsite Electricity]
+    Set distributions systems connected to this generation system
-    :param value: [string]
+    :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
+    Get energy storage systems connected to this generation system
-    :return: float
+    :return: [GenericStorageSystem]
     """
-    return self._heat_efficiency
+    return self._generic_storage_systems
 
-  @heat_efficiency.setter
+  @generic_storage_systems.setter
-  def heat_efficiency(self, value):
+  def generic_storage_systems(self, value):
     """
-    Set heat_efficiency
+    Set energy storage systems connected to this generation system
-    :param value: float
+    :param value: [GenericStorageSystem]
     """
-    self._heat_efficiency = value
+    self._generic_storage_systems = 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

hub/city_model_structure/energy_systems/generic_non_pv_generation_system.py

@@ -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

hub/city_model_structure/energy_systems/generic_pv_generation_system.py

@@ -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

hub/city_model_structure/energy_systems/generic_storage_system.py

@@ -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]
+    Get storage type
-    :return: string
+    :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):
     """

hub/city_model_structure/energy_systems/generic_thermal_storage_system.py

@@ -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