Replace the building workload with end of life emission

lca_carbon_workflow.py

@@ -18,6 +18,8 @@ from city_model_structure.life_cycle_assessment.opening_emission \
   import OpeningEmission
 from city_model_structure.life_cycle_assessment.envelope_emission \
   import EnvelopeEmission
+from city_model_structure.life_cycle_assessment.lca_end_of_life_carbon \
+  import EndOfLifeEmission
 
 
 class LCACarbonWorkflow:
@@ -56,15 +58,15 @@ class LCACarbonWorkflow:
     self.building_envelope_emission = []
     self.building_opening_emission = []
     self.building_component_emission = []
-    self.building_envelope_workload = []
+    self.building_envelope_end_of_life_emission = []
-    self.building_opening_workload = []
+    self.building_opening_end_of_life_emission = []
-    self.building_component_workload = []
+    self.building_component_end_of_life_emission = []
 
   def calculate_building_component_emission(self, building):
     surface_envelope_emission = []
     surface_opening_emission = []
-    surface_envelope_workload = []
+    surface_envelope_end_of_life_emission = []
-    surface_opening_workload = []
+    surface_opening_end_of_life_emission = []
     opaque_surface_code = self.nrcan_catalogs.find_opaque_surface(
       self.nrcan_catalogs.hub_to_nrcan_function(building.function),
       self.nrcan_catalogs.year_to_period_of_construction(
@@ -74,33 +76,35 @@ class LCACarbonWorkflow:
     for surface in building.surfaces:
       boundary_envelope_emission = []
       boundary_opening_emission = []
-      boundary_envelope_workload =[]
+      boundary_envelope_end_of_life_emission = []
-      boundary_opening_workload = []
+      boundary_opening_end_of_life_emission = []
 
       for boundary in surface.associated_thermal_boundaries:
         opening_emission = None
-        opening_workload = None
+        opening_end_of_life_emission = None
-        layer_emission, boundary_work_load = \
+        layer_emission, layer_end_of_life_emission = \
             self._calculate_envelope_emission(boundary)
         boundary_envelope_emission += layer_emission
-        boundary_envelope_workload += boundary_work_load
+        boundary_envelope_end_of_life_emission += layer_end_of_life_emission
 
         if boundary.window_ratio:
-          opening_emission, opening_workload = \
+          opening_emission, opening_end_of_life_emission = \
             self._calculate_opening_emission(
               building, surface, boundary, opaque_surface_code)
         if opening_emission:
           boundary_opening_emission += opening_emission
-          boundary_opening_workload += opening_workload
+          boundary_opening_end_of_life_emission += opening_end_of_life_emission
       if boundary_opening_emission:
         surface_opening_emission += boundary_opening_emission
-        surface_opening_workload += boundary_opening_workload
+        surface_opening_end_of_life_emission += \
+            boundary_opening_end_of_life_emission
       surface_envelope_emission += boundary_envelope_emission
-      surface_envelope_workload += boundary_envelope_workload
+      surface_envelope_end_of_life_emission += \
+          boundary_envelope_end_of_life_emission
     building_envelope_emission = sum(surface_envelope_emission)
-    building_envelope_workload = sum(surface_envelope_workload)
+    building_envelope_workload = sum(surface_envelope_end_of_life_emission)
     building_opening_emission = sum(surface_opening_emission)
-    building_opening_workload = sum(surface_opening_workload)
+    building_opening_workload = sum(surface_opening_end_of_life_emission)
     building_component_emission = \
         building_envelope_emission + building_opening_emission
     building_component_workload = \
@@ -111,7 +115,7 @@ class LCACarbonWorkflow:
 
   def _calculate_envelope_emission(self, boundary):
     layer_emission = []
-    boundary_workload = []
+    layer_end_of_life_emission = []
     for layer in boundary.layers:
       if not layer.no_mass:
         layer_material = \
@@ -120,9 +124,18 @@ class LCACarbonWorkflow:
           layer_material['embodied_carbon'],
           boundary.opaque_area,
           layer.thickness, layer.density).calculate_envelope_emission())
-        boundary_workload.append(
+
-          boundary.opaque_area * layer.thickness * layer.density)
+        boundary_workload = \
-    return layer_emission, boundary_workload
+            boundary.opaque_area * \
+            layer.thickness * \
+            layer.density
+        layer_end_of_life_emission.append(EndOfLifeEmission(
+          layer_material['recycling_ratio'],
+          layer_material['onsite_recycling_ratio'],
+          layer_material['company_recycling_ratio'],
+          layer_material['landfilling_ratio'],
+          boundary_workload).calculate_end_of_life_emission())
+    return layer_emission, layer_end_of_life_emission
 
   def _calculate_opening_emission(
           self,
@@ -133,27 +146,40 @@ class LCACarbonWorkflow:
        These two values are being used to calculate window's workload
        for End of Life emission evaluation."""
     opening_emission = []
-    window_workload = []
+    opening_end_of_life_emission = []
     for opening in boundary.thermal_openings:
       transparent_surface_type = 'Window'
       if building.year_of_construction >= 2020 and \
               surface.type == 'Roof':
         transparent_surface_type = 'Skylight'
-      opening_emission.append(OpeningEmission(
+      opening_material = self.nrcan_catalogs.search_transparent_surfaces(
-        self.nrcan_catalogs.search_transparent_surfaces(
+          transparent_surface_type, opaque_surface_code)
-          transparent_surface_type, opaque_surface_code)['embodied_carbon'],
+      opening_emission.append(
-        opening.area).calculate_opening_emission())
+        OpeningEmission(opening_material['embodied_carbon'],
-      window_workload.append(opening.area * boundary.thickness * density)
+                        opening.area).calculate_opening_emission())
-    return opening_emission, window_workload
+
+      window_workload = opening.area * boundary.thickness * density
+      opening_end_of_life_emission.append(EndOfLifeEmission(
+          opening_material['recycling_ratio'],
+          opening_material['onsite_recycling_ratio'],
+          opening_material['company_recycling_ratio'],
+          opening_material['landfilling_ratio'],
+          window_workload).calculate_end_of_life_emission())
+    return opening_emission, opening_end_of_life_emission
 
   def calculate_emission(self):
     for building in self.city.buildings:
       envelope_emission, opening_emission, component_emission, \
-       envelope_workload, opening_workload, component_workload = \
+       envelope_end_of_life_emission, \
+       opening_end_of_life_emission, \
+       component_end_of_life_emission = \
        self.calculate_building_component_emission(building)
       self.building_envelope_emission.append(envelope_emission)
       self.building_opening_emission.append(opening_emission)
       self.building_component_emission.append(component_emission)
-      self.building_envelope_workload.append(envelope_workload)
+      self.building_envelope_end_of_life_emission.append(
-      self.building_opening_workload.append(opening_workload)
+        envelope_end_of_life_emission)
-      self.building_component_workload.append(component_workload)
+      self.building_opening_end_of_life_emission.append(
+        opening_end_of_life_emission)
+      self.building_component_end_of_life_emission.append(
+        component_end_of_life_emission)