lca_carbon_workflow.py

@@ -18,8 +18,6 @@ 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:
@@ -58,15 +56,15 @@ class LCACarbonWorkflow:
     self.building_envelope_emission = []
     self.building_opening_emission = []
     self.building_component_emission = []
-    self.building_envelope_end_of_life_emission = []
-    self.building_opening_end_of_life_emission = []
-    self.building_component_end_of_life_emission = []
+    self.building_envelope_workload = []
+    self.building_opening_workload = []
+    self.building_component_workload = []
 
   def calculate_building_component_emission(self, building):
     surface_envelope_emission = []
     surface_opening_emission = []
-    surface_envelope_end_of_life_emission = []
-    surface_opening_end_of_life_emission = []
+    surface_envelope_workload = []
+    surface_opening_workload = []
     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(
@@ -76,35 +74,33 @@ class LCACarbonWorkflow:
     for surface in building.surfaces:
       boundary_envelope_emission = []
       boundary_opening_emission = []
-      boundary_envelope_end_of_life_emission = []
-      boundary_opening_end_of_life_emission = []
+      boundary_envelope_workload =[]
+      boundary_opening_workload = []
 
       for boundary in surface.associated_thermal_boundaries:
         opening_emission = None
-        opening_end_of_life_emission = None
-        layer_emission, layer_end_of_life_emission = \
+        opening_workload = None
+        layer_emission, boundary_work_load = \
             self._calculate_envelope_emission(boundary)
         boundary_envelope_emission += layer_emission
-        boundary_envelope_end_of_life_emission += layer_end_of_life_emission
+        boundary_envelope_workload += boundary_work_load
 
         if boundary.window_ratio:
-          opening_emission, opening_end_of_life_emission = \
+          opening_emission, opening_workload = \
             self._calculate_opening_emission(
               building, surface, boundary, opaque_surface_code)
         if opening_emission:
           boundary_opening_emission += opening_emission
-          boundary_opening_end_of_life_emission += opening_end_of_life_emission
+          boundary_opening_workload += opening_workload
       if boundary_opening_emission:
         surface_opening_emission += boundary_opening_emission
-        surface_opening_end_of_life_emission += \
-            boundary_opening_end_of_life_emission
+        surface_opening_workload += boundary_opening_workload
       surface_envelope_emission += boundary_envelope_emission
-      surface_envelope_end_of_life_emission += \
-          boundary_envelope_end_of_life_emission
+      surface_envelope_workload += boundary_envelope_workload
     building_envelope_emission = sum(surface_envelope_emission)
-    building_envelope_workload = sum(surface_envelope_end_of_life_emission)
+    building_envelope_workload = sum(surface_envelope_workload)
     building_opening_emission = sum(surface_opening_emission)
-    building_opening_workload = sum(surface_opening_end_of_life_emission)
+    building_opening_workload = sum(surface_opening_workload)
     building_component_emission = \
         building_envelope_emission + building_opening_emission
     building_component_workload = \
@@ -115,7 +111,7 @@ class LCACarbonWorkflow:
 
   def _calculate_envelope_emission(self, boundary):
     layer_emission = []
-    layer_end_of_life_emission = []
+    boundary_workload = []
     for layer in boundary.layers:
       if not layer.no_mass:
         layer_material = \
@@ -124,18 +120,9 @@ class LCACarbonWorkflow:
           layer_material['embodied_carbon'],
           boundary.opaque_area,
           layer.thickness, layer.density).calculate_envelope_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
+        boundary_workload.append(
+          boundary.opaque_area * layer.thickness * layer.density)
+    return layer_emission, boundary_workload
 
   def _calculate_opening_emission(
           self,
@@ -146,40 +133,27 @@ class LCACarbonWorkflow:
        These two values are being used to calculate window's workload
        for End of Life emission evaluation."""
     opening_emission = []
-    opening_end_of_life_emission = []
+    window_workload = []
     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_material = self.nrcan_catalogs.search_transparent_surfaces(
-          transparent_surface_type, opaque_surface_code)
-      opening_emission.append(
-        OpeningEmission(opening_material['embodied_carbon'],
+      opening_emission.append(OpeningEmission(
+        self.nrcan_catalogs.search_transparent_surfaces(
+          transparent_surface_type, opaque_surface_code)['embodied_carbon'],
         opening.area).calculate_opening_emission())
-
-      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
+      window_workload.append(opening.area * boundary.thickness * density)
+    return opening_emission, window_workload
 
   def calculate_emission(self):
     for building in self.city.buildings:
       envelope_emission, opening_emission, component_emission, \
-       envelope_end_of_life_emission, \
-       opening_end_of_life_emission, \
-       component_end_of_life_emission = \
+       envelope_workload, opening_workload, component_workload = \
        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_end_of_life_emission.append(
-        envelope_end_of_life_emission)
-      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)
+      self.building_envelope_workload.append(envelope_workload)
+      self.building_opening_workload.append(opening_workload)
+      self.building_component_workload.append(component_workload)