Merge branch 'main' into feature/lifecycle_emission_calculation

.gitignore

@@ -10,3 +10,8 @@
 **/__pycache__/
 **/.idea/
 cerc_hub.egg-info
+
+ali_*.py
+mreza_*.json
+*_cap_3.json
+

hub/catalog_factories/data_models/construction/material.py

@@ -3,6 +3,8 @@ Construction catalog material
 SPDX - License - Identifier: LGPL - 3.0 - or -later
 Copyright © 2022 Concordia CERC group
 Project Coder Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
+Code contributors: Alireza Adli alireza.adli@concordia.ca
+Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
 """
 
 
@@ -15,6 +17,13 @@ class Material:
                solar_absorptance,
                thermal_absorptance,
                visible_absorptance,
+               density_unit,
+               embodied_carbon,
+               embodied_carbon_unit,
+               recycling_ratio,
+               company_recycling_ratio,
+               onsite_recycling_ratio,
+               landfilling_ratio,
                no_mass=False,
                thermal_resistance=None,
                conductivity=None,
@@ -29,7 +38,14 @@ class Material:
     self._thermal_resistance = thermal_resistance
     self._conductivity = conductivity
     self._density = density
+    self._density_unit = density_unit
     self._specific_heat = specific_heat
+    self._recycling_ratio = recycling_ratio
+    self._onsite_recycling_ratio = onsite_recycling_ratio
+    self._company_recycling_ratio = company_recycling_ratio
+    self._landfilling_ratio = landfilling_ratio
+    self._embodied_carbon = embodied_carbon
+    self._embodied_carbon_unit = embodied_carbon_unit
 
   @property
   def id(self):
@@ -71,6 +87,14 @@ class Material:
     """
     return self._density
 
+  @property
+  def density_unit(self):
+    """
+    Get material density unit in kg/m3
+    :return: str
+    """
+    return self._density_unit
+
   @property
   def solar_absorptance(self):
     """
@@ -111,18 +135,73 @@ class Material:
     """
     return self._thermal_resistance
 
+  @property
+  def recycling_ratio(self):
+    """
+    Get recycling ratio in %
+    :return: float
+    """
+    return self._recycling_ratio
+
+  @property
+  def onsite_recycling_ratio(self):
+    """
+    Get onsite recycling ratio in %
+    :return: float
+    """
+    return self._onsite_recycling_ratio
+
+  @property
+  def company_recycling_ratio(self):
+    """
+    Get company recycling ratio in %
+    :return: float
+    """
+    return self._company_recycling_ratio
+
+  @property
+  def landfilling_ratio(self):
+    """
+    Get landfilling ratio in %
+    :return: float
+    """
+    return self._landfilling_ratio
+
+  @property
+  def embodied_carbon(self):
+    """
+    Get embodied carbon in kg
+    :return: float
+    """
+    return self._embodied_carbon
+
+  @property
+  def embodied_carbon_unit(self):
+    """
+    Get embodied carbon unit in kg_co2_eq/kg_material
+    :return: str
+    """
+    return self._embodied_carbon_unit
+
   def to_dictionary(self):
     """Class content to dictionary"""
     content = {'Material': {'id': self.id,
                             'name': self.name,
                             'is no-mass': self.no_mass,
                             'density [kg/m3]': self.density,
+                            'density unit [kg/m3]': self.density_unit,
                             'specific heat [J/kgK]': self.specific_heat,
                             'conductivity [W/mK]': self.conductivity,
                             'thermal resistance [m2K/W]': self.thermal_resistance,
                             'solar absorptance': self.solar_absorptance,
                             'thermal absorptance': self.thermal_absorptance,
-                            'visible absorptance': self.visible_absorptance
+                            'visible absorptance': self.visible_absorptance,
+                            'recycling ratio': self.recycling_ratio,
+                            'onsite recycling ratio': self.onsite_recycling_ratio,
+                            'company recycling ratio': self.company_recycling_ratio,
+                            'landfilling ratio': self.landfilling_ratio,
+                            'embodied carbon': self.embodied_carbon,
+                            'embodied carbon unit': self.embodied_carbon_unit
                             }
                }
     return content

hub/city_model_structure/life_cycle_assessment/access_nrcan_catalogue.py

@@ -0,0 +1,179 @@
+"""
+access_nrcan_catalog module
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2024 Concordia CERC group
+Project developer: Alireza Adli alireza.adli@mail.concordia.ca
+"""
+
+import json
+from pathlib import Path
+
+from hub.helpers.data.hub_function_to_nrcan_construction_function \
+  import HubFunctionToNrcanConstructionFunction
+
+
+class AccessNrcanCatalog:
+  def __init__(
+          self, path,
+          archetypes='nrcan_archetypes.json',
+          constructions='nrcan_constructions_cap_3.json',
+          materials='nrcan_materials_dictionaries.json',
+          transparent_surfaces='nrcan_transparent_surfaces_dictionaries.json'):
+    """
+      AccessNrcanCatalog eases accessing the below json files.
+      - It converts year of construction to the period of construction.
+      - It searches a specific material or transparent surface.
+      - The class finds the opaque surface code based on three parameters.
+      :param path: path to the below files
+      :param archetypes: a json file (a list of dictionaries) with building
+      archetypes' data
+      :param constructions: a json file (a list of dictionaries) with
+      building data based on NRCan
+      :param materials: a json file (a dictornaty of
+      dictionares to speed up the search) with construction material info.
+      :param transparent_surfaces: a json file (a dictionary of
+      dictionaries) with windows and skylights data.
+    """
+    self._path = Path(path)
+    self.archetypes = archetypes
+    self.constructions = constructions
+    self.materials = materials
+    self.transparent_surfaces = transparent_surfaces
+    self.hub_to_nrcan_dictionary = \
+        HubFunctionToNrcanConstructionFunction().dictionary
+
+  @property
+  def archetypes(self):
+    return self._archetypes
+
+  @archetypes.setter
+  def archetypes(self, archetypes):
+    archetypes_path = (self._path / archetypes).resolve()
+    self._archetypes = json.loads(archetypes_path.read_text())
+
+  @property
+  def constructions(self):
+    return self._constructions
+
+  @constructions.setter
+  def constructions(self, constructions):
+    constructions_path = (self._path / constructions).resolve()
+    self._constructions = json.loads(constructions_path.read_text())
+
+  @property
+  def materials(self):
+    return self._materials
+
+  @materials.setter
+  def materials(self, materials):
+    materials_path = (self._path / materials).resolve()
+    self._materials = json.loads(materials_path.read_text())
+
+  @property
+  def transparent_surfaces(self):
+    return self._transparent_surfaces
+
+  @transparent_surfaces.setter
+  def transparent_surfaces(self, transparent_surfaces):
+    transparent_surfaces_path = (self._path / transparent_surfaces).resolve()
+    self._transparent_surfaces = json.loads(
+      transparent_surfaces_path.read_text())
+
+  def hub_to_nrcan_function(self, hub_function):
+    return self.hub_to_nrcan_dictionary[hub_function]
+
+  @staticmethod
+  def year_to_period_of_construction(year_of_construction):
+    """
+      Converts year of construction to the period of construction.
+      :param year_of_construction: <class 'int'>
+      :return: <class 'str'>
+    """
+    period_of_construction = None
+    if 1000 <= year_of_construction <= 1900:
+      period_of_construction = '1000_1900'
+    elif 1901 <= year_of_construction <= 1910:
+      period_of_construction = '1901_1910'
+    elif 1911 <= year_of_construction <= 1920:
+      period_of_construction = '1911_1920'
+    elif 1921 <= year_of_construction <= 1930:
+      period_of_construction = '1921_1930'
+    elif 1931 <= year_of_construction <= 1940:
+      period_of_construction = '1931_1940'
+    elif 1941 <= year_of_construction <= 1950:
+      period_of_construction = '1941_1950'
+    elif 1951 <= year_of_construction <= 1960:
+      period_of_construction = '1951_1960'
+    elif 1961 <= year_of_construction <= 1970:
+      period_of_construction = '1961_1970'
+    elif 1971 <= year_of_construction <= 1980:
+      period_of_construction = '1971_1980'
+    elif 1981 <= year_of_construction <= 1990:
+      period_of_construction = '1981_1990'
+    elif 1991 <= year_of_construction <= 2000:
+      period_of_construction = '1991_2000'
+    elif 2001 <= year_of_construction <= 2010:
+      period_of_construction = '2001_2010'
+    elif 2011 <= year_of_construction <= 2016:
+      period_of_construction = '2011_2016'
+    elif 2017 <= year_of_construction <= 2019:
+      period_of_construction = '2017_2019'
+    elif 2020 <= year_of_construction <= 3000:
+      period_of_construction = '2020_3000'
+    return period_of_construction
+
+  def layers(self, opaque_surface_code, component_type):
+    """
+      Returns the corresponding layers of a specific opaque surface
+      and the component type.
+      :param opaque_surface_code: <class 'str'>
+      :param component_type: <class 'str'>
+      :return: <class 'dict'>
+    """
+    for opaque_surface in self.constructions['opaque_surfaces']:
+      opaque_surface_key = list(opaque_surface)[0]
+      if opaque_surface_key != opaque_surface_code:
+        continue
+      elif opaque_surface[opaque_surface_key]['type'] == component_type:
+        return opaque_surface[opaque_surface_key]['layers']
+
+  def search_material(self, material_name):
+    """
+      Search materials and bring up the specific material data
+      based on the material's name
+      :param material_name: <class 'str'>
+      :return: <class 'dict'>
+    """
+    return self.materials[f'{material_name}']
+
+  def search_transparent_surfaces(
+          self, surface_type, opaque_surface_code):
+    """
+      Search transparent surfaces and bring up the specific surface data
+      based on its type and opaque surface code
+      :param surface_type: <class 'str'>
+      :param opaque_surface_code: <class 'str'>
+      :return: <class 'dict'>
+    """
+    return self.transparent_surfaces[
+      f'{surface_type}_{opaque_surface_code}']
+
+  def find_opaque_surface(
+          self, function, period_of_construction, climate_zone):
+    """
+      Returns the opaque_surface_name based on the below parameters.
+      :param function: <class 'str'>
+      :param period_of_construction: <class 'str'>
+      :param climate_zone: <class 'str'>
+      :return: <class 'str'>
+    """
+    for archetype in self.archetypes['archetypes']:
+      if archetype['function'] != function:
+        continue
+      elif archetype['period_of_construction'] != period_of_construction:
+        continue
+      elif archetype['climate_zone'] != climate_zone:
+        continue
+      else:
+        return \
+          archetype['constructions']['OutdoorsWall']['opaque_surface_name']

hub/city_model_structure/life_cycle_assessment/energy_systems_material_emission.py

@@ -0,0 +1,13 @@
+"""
+energy_systems_material_emission module
+Returns the summarize of emission of energy systems material.
+The returned value will be used to calculate the building component emission.
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class EnergySystemsMaterialEmission:
+  pass

hub/city_model_structure/life_cycle_assessment/envelope_emission.py

@@ -0,0 +1,43 @@
+"""
+envelope_emission module
+Returns the summarize of envelope's surfaces emissions
+The returned value will be used to calculate the building component emission.
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class EnvelopeEmission:
+  def __init__(self,
+               envelope_material_emission,
+               envelope_thickness,
+               envelope_surface,
+               density):
+    self._envelope_material_emission = envelope_material_emission
+    self._envelope_thickness = envelope_thickness
+    self._envelope_surface = envelope_surface
+    self._density = density
+
+  @property
+  def envelope_material_emission(self):
+    return self._envelope_material_emission
+
+  @property
+  def envelope_thickness(self):
+    return self._envelope_thickness
+
+  @property
+  def envelope_surface(self):
+    return self._envelope_surface
+
+  @property
+  def density(self):
+    return self._density
+
+  def calculate_envelope_emission(self):
+    return self._envelope_material_emission * \
+           self._envelope_thickness * \
+           self._envelope_surface * \
+           self._density

hub/city_model_structure/life_cycle_assessment/lca_embodied_carbon.py

@@ -0,0 +1,11 @@
+"""
+lca_embodied_carbon module
+SPDX - License - Identifier: LGPL - 3.0
+Copyright © 2022 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class Embodied:
+  pass

hub/city_model_structure/life_cycle_assessment/lca_end_of_life_carbon.py

@@ -0,0 +1,61 @@
+"""
+lca_end_of_life_carbon module
+Machine emission of different methods can be a default argument, because,
+at this phase we use the average emission of different machines emission
+for each part (demolition, onsite, recycling and landfilling).
+If we are to use data for different processes, setters will be develop for
+the machines of each process to replace the default arguments. In that sense,
+a conditional will decide to use which value. The conditional will be defined
+in the setters.
+For next phases, we can use a Machine object to find the corresponding
+emission.
+SPDX - License - Identifier: LGPL - 3.0
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class EndOfLifeEmission:
+  def __init__(
+          self, recycling_ratio, onsite_recycling_ratio,
+          company_recycling_ratio, landfilling_ratio,
+          material_workload,
+          demolition_machine_emission=4.3577325,
+          onsite_machine_emission=2.0576313,
+          companies_recycling_machine_emission=0.6189555,
+          landfilling_machine_emission=15.7364044):
+    self.recycling_ratio = recycling_ratio
+    self.onsite_recycling_ratio = onsite_recycling_ratio
+    self.company_recycling_ratio = company_recycling_ratio
+    self.landfilling_ratio = landfilling_ratio
+    self.material_workload = material_workload
+    self.demolition_machine_emission = demolition_machine_emission
+    self.onsite_machine_emission = onsite_machine_emission
+    self.companies_recycling_machine_emission = \
+        companies_recycling_machine_emission
+    self.landfilling_machine_emission = landfilling_machine_emission
+
+  def demolition(self):
+    return self.demolition_machine_emission * self.material_workload
+
+  def onsite_recycling(self):
+    return self.recycling_ratio * (self.onsite_recycling_ratio *
+                                   self.onsite_machine_emission *
+                                   self.material_workload)
+
+  def companies_recycling(self):
+   return self.recycling_ratio * (self.company_recycling_ratio *
+                                  self.companies_recycling_machine_emission *
+                                  self.material_workload)
+
+  def landfilling(self):
+    return self.landfilling_ratio * \
+           self.landfilling_machine_emission * \
+           self.material_workload
+
+  def calculate_end_of_life_emission(self):
+    return self.demolition() + \
+           self.onsite_recycling() + \
+           self.companies_recycling() + \
+           self.landfilling()

hub/city_model_structure/life_cycle_assessment/lca_operational_carbon.py

@@ -0,0 +1,11 @@
+"""
+lca_operational_carbon module
+SPDX - License - Identifier: LGPL - 3.0
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class Operational:
+  pass

hub/city_model_structure/life_cycle_assessment/machine.py

@@ -0,0 +1,59 @@
+"""
+machine module
+SPDX - License - Identifier: LGPL - 3.0
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class Machine:
+  def __init__(self, machine_id, name, work_efficiency_rate,
+               work_efficiency_unit, energy_consumption_rate,
+               energy_consumption_unit, emission_factor,
+               emission_unit):
+    self._machine_id = machine_id
+    self._name = name
+    self._work_efficiency_rate = work_efficiency_rate
+    self._work_efficiency_unit = work_efficiency_unit
+    self._energy_consumption_rate = energy_consumption_rate
+    self._energy_consumption_unit = energy_consumption_unit
+    self._emission_factor = emission_factor
+    self._emission_unit = emission_unit
+
+  @property
+  def id(self) -> int:
+    return self._machine_id
+
+  @property
+  def name(self):
+    return self._name
+
+  @property
+  def work_efficiency(self):
+    return self._work_efficiency_rate
+
+  @property
+  def work_efficiency_unit(self):
+    return self._work_efficiency_unit
+
+  @property
+  def energy_consumption_rate(self):
+    return self._energy_consumption_rate
+
+  @property
+  def energy_consumption_unit(self):
+    return self._energy_consumption_unit
+
+  @property
+  def emission_factor(self):
+    return self._emission_factor
+
+  @property
+  def emission_unit(self):
+    return self._emission_unit
+
+  def total_machine_emssion(self):
+    return self._work_efficiency_rate * \
+        self._energy_consumption_rate * \
+        self._emission_factor

hub/city_model_structure/life_cycle_assessment/opening_emission.py

@@ -0,0 +1,26 @@
+"""
+opening_emission module
+Returns the summarize of all surfaces openings' emissions
+The returned value will be used to calculate the building component emission.
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class OpeningEmission:
+  def __init__(self, opening_material_emission, opening_surface):
+    self._opening_material_emission = opening_material_emission
+    self._opening_surface = opening_surface
+
+  @property
+  def opening_material_emission(self):
+    return self._opening_material_emission
+
+  @property
+  def opening_surface(self):
+    return self._opening_surface
+
+  def calculate_opening_emission(self):
+    return self._opening_material_emission * self._opening_surface

hub/city_model_structure/life_cycle_assessment/vehicle.py

@@ -0,0 +1,46 @@
+"""
+vehicle module
+SPDX - License - Identifier: LGPL - 3.0
+Copyright © 2024 Concordia CERC group
+Project Developer: Alireza Adli alireza.adli@mail.concordia.ca
+Theoritical Support: Mohammad Reza Seyedabadi mohammad.seyedabadi@mail.concordia.ca
+"""
+
+
+class Vehicle:
+  def __init__(self, vehicle_id, name, fuel_consumption_rate,
+               fuel_consumption_unit, carbon_emission_factor,
+               carbon_emission_unit):
+    self._vehicle_id = vehicle_id
+    self._name = name
+    self._fuel_consumption_rate = fuel_consumption_rate
+    self._fuel_consumption_unit = fuel_consumption_unit
+    self._carbon_emission_factor = carbon_emission_factor
+    self._carbon_emission_unit = carbon_emission_unit
+
+  @property
+  def id(self):
+    return self._vehicle_id
+
+  @property
+  def name(self):
+    return self._name
+
+  @property
+  def fuel_consumption_rate(self):
+    return self._fuel_consumption_rate
+
+  @property
+  def fuel_consumption_unit(self):
+    return self._fuel_consumption_unit
+
+  @property
+  def carbon_emission_factor(self):
+    return self._carbon_emission_factor
+
+  @property
+  def carbon_emission_unit(self):
+    return self._carbon_emission_unit
+
+  def total_vehicle_emission(self):
+    return self._fuel_consumption_rate * self._carbon_emission_factor