Refining of outputs and prepared outputs for the inclusion of system results.

life_cycle_costs.py

@@ -15,8 +15,7 @@ import hub.helpers.constants as cte
 
 class LifeCycleCosts:
   def __init__(self, building, archetype, number_of_years, consumer_price_index, discount_rate,
-               retrofitting_scenario, heating_scop, cooling_seer, peak_electricity_demand,
+               retrofitting_scenario):
-               factor_pv, factor_peak_lights):
     self._building = building
     self._number_of_years = number_of_years
     self._consumer_price_index = consumer_price_index
@@ -33,13 +32,8 @@ class LifeCycleCosts:
         for thermal_zone in internal_zone.thermal_zones:
           self._total_floor_area += thermal_zone.total_floor_area
 
-    self._heating_scop = heating_scop
-    self._cooling_seer = cooling_seer
-    self._peak_electricity_demand = peak_electricity_demand
-    self._factor_pv = factor_pv
-    self._peak_lights = factor_peak_lights
     #todo: revise if it works
-    rng = range(40)
+    rng = range(number_of_years)
     self._yearly_capital_costs = pd.DataFrame(index=rng, columns=['B2010_opaque_walls', 'B2020_transparent',
                                                          'B3010_opaque_roof','B10_superstructure',
                                                          'D301010_photovoltaic_system','D3020_heat_generating_systems',
@@ -51,7 +45,6 @@ class LifeCycleCosts:
   def calculate_capital_costs(self):
     building = self._building
     archetype = self._archetype
-    factor_pv = self._factor_pv
 
     surface_opaque = 0
     surface_transparent = 0
@@ -68,15 +61,17 @@ class LifeCycleCosts:
               surface_roof += thermal_boundary.opaque_area
             elif thermal_boundary.type == 'Wall':
               surface_opaque += thermal_boundary.opaque_area * (1-thermal_boundary.window_ratio)
-            surface_transparent += thermal_boundary.opaque_area * thermal_boundary.window_ratio
+              surface_transparent += thermal_boundary.opaque_area * thermal_boundary.window_ratio
 
     chapters = archetype.capital_cost
     capital_cost_skin = 0
     capital_cost_services = 0
     reposition_cost_pv = 0
 
-    peak_heating = 0.1*self._total_floor_area
+    peak_heating = building.heating_peak_load[cte.YEAR].values[0]
-    peak_cooling = 0.1*self._total_floor_area
+    peak_cooling = building.cooling_peak_load[cte.YEAR].values[0]
+    #todo: put the value of area_pv when it exists
+    surface_pv = 10 #building.area_pv
 
     if self._retrofitting_scenario == 1 or self._retrofitting_scenario == 3:
       chapter = chapters.chapter('B_shell')
@@ -89,17 +84,18 @@ class LifeCycleCosts:
         self._yearly_capital_costs.loc[0]['B3010_opaque_roof'],self._yearly_capital_costs.loc[0]['B10_superstructure'],\
         self._yearly_capital_costs.loc[0]['B_Shell']\
         =[capital_cost_opaque , capital_cost_transparent , capital_cost_roof , capital_cost_ground , capital_cost_skin]
+
     if self._retrofitting_scenario == 2 or self._retrofitting_scenario == 3:
       chapter = chapters.chapter('D_services')
-      capital_cost_pv = surface_roof * factor_pv * chapter.item('D301010_photovoltaic_system').initial_investment[0]
+      capital_cost_pv = surface_pv * chapter.item('D301010_photovoltaic_system').initial_investment[0]
-      self._yearly_capital_costs.loc[0]['D301010_photovoltaic_system']=capital_cost_pv
+      self._yearly_capital_costs.loc[0]['D301010_photovoltaic_system'] = capital_cost_pv
       for year in range(1, self._number_of_years + 1):
         costs_increase = math.pow(1 + self._consumer_price_index, year) / math.pow(1 + self._discount_rate, year)
         if (year % chapter.item('D301010_photovoltaic_system').lifetime) == 0:
-          reposition_cost_pv += surface_roof * factor_pv * chapter.item('D301010_photovoltaic_system').reposition[
+          reposition_cost_pv += surface_pv * chapter.item('D301010_photovoltaic_system').reposition[
             0] * costs_increase
-          self._yearly_capital_costs.loc[year]['D301010_photovoltaic_system'] = surface_roof * \
+          self._yearly_capital_costs.loc[year]['D301010_photovoltaic_system'] = surface_pv\
-                                                                           factor_pv * chapter.item('D301010_photovoltaic_system').reposition[0] * costs_increase
+                                                                                * chapter.item('D301010_photovoltaic_system').reposition[0] * costs_increase
       capital_cost_heating_equipment = peak_heating \
                                        * chapter.item('D3020_heat_generating_systems').initial_investment[0]
       capital_cost_cooling_equipment = peak_cooling \
@@ -107,12 +103,14 @@ class LifeCycleCosts:
       capital_cost_distribution_equipment = peak_cooling \
                                             * chapter.item('D3040_distribution_systems').initial_investment[0]
       capital_cost_other_hvac_ahu = peak_cooling * chapter.item('D3080_other_hvac_ahu').initial_investment[0]
+
       capital_cost_lighting = total_floor_area * self._peak_lights \
                               * chapter.item('D5020_lighting_and_branch_wiring').initial_investment[0]
 
       capital_cost_services = capital_cost_pv + capital_cost_heating_equipment + capital_cost_cooling_equipment\
                               + capital_cost_distribution_equipment + capital_cost_other_hvac_ahu \
                               + capital_cost_lighting
+
       self._yearly_capital_costs.loc[0]['D3020_heat_generating_systems'], self._yearly_capital_costs.loc[0]['D3030_cooling_generation_systems'], \
         self._yearly_capital_costs.loc[0]['D3040_distribution_systems'], self._yearly_capital_costs.loc[0]['D3080_other_hvac_ahu'], \
         self._yearly_capital_costs.loc[0]['D5020_lighting_and_branch_wiring'], self._yearly_capital_costs.loc[0]['D_services'] \
@@ -127,22 +125,27 @@ class LifeCycleCosts:
     for year in range(1, self._number_of_years + 1):
       chapter = chapters.chapter('D_services')
       costs_increase = math.pow(1 + self._consumer_price_index, year) / math.pow(1 + self._discount_rate, year)
+
       if (year % chapter.item('D3020_heat_generating_systems').lifetime) == 0:
         reposition_cost_heating_equipment = peak_heating * chapter.item('D3020_heat_generating_systems').reposition[0] \
                                             * costs_increase
         self._yearly_capital_costs.loc[year]['D3020_heat_generating_systems'] = reposition_cost_heating_equipment
+
       if (year % chapter.item('D3030_cooling_generation_systems').lifetime) == 0:
         reposition_cost_cooling_equipment = peak_cooling \
                                             * chapter.item('D3030_cooling_generation_systems').reposition[0] \
                                             * costs_increase
         self._yearly_capital_costs.loc[year]['D3030_cooling_generation_systems'] = reposition_cost_cooling_equipment
+
       if (year % chapter.item('D3080_other_hvac_ahu').lifetime) == 0:
         reposition_cost_hvac_ahu = peak_cooling * chapter.item('D3080_other_hvac_ahu').reposition[0] * costs_increase
         self._yearly_capital_costs.loc[year]['D3080_other_hvac_ahu'] = reposition_cost_hvac_ahu
+
       if (year % chapter.item('D5020_lighting_and_branch_wiring').lifetime) == 0:
         reposition_cost_lighting = total_floor_area * chapter.item('D5020_lighting_and_branch_wiring').reposition[0] \
                                    * costs_increase
         self._yearly_capital_costs.loc[year]['D5020_lighting_and_branch_wiring'] = reposition_cost_lighting
+
     capital_cost_subtotal = capital_cost_skin + capital_cost_services
 
     capital_cost_total = capital_cost_subtotal * (1+chapters.design_allowance) * (1+chapters.overhead_and_profit)
@@ -172,31 +175,34 @@ class LifeCycleCosts:
   def calculate_total_operational_costs(self):
     building = self._building
     archetype = self._archetype
-
     total_operational_costs = 0
     peak_cost = 0
     monthly_cost = 0
     variable_cost = 0
+    variable_incomes = 0
     total_floor_area = self._total_floor_area
-
+    #todo: split the heating between fuels
-    electricity_heating = building.heating[cte.YEAR]['insel meb'] / (self._heating_scop*1000)
+    electricity_heating = building.heating_consumption[cte.YEAR][0] / (1000)
-    electricity_cooling = building.cooling[cte.YEAR]['insel meb'] / (self._cooling_seer*1000)
+    electricity_cooling = building.cooling_consumption[cte.YEAR][0] / (1000)
-    electricity_lighting = building.lighting_electrical_demand['month']['insel meb'].sum()/1000
+    electricity_lighting = building.lighting_electrical_demand[cte.YEAR]['insel meb']/1000
-    domestic_hot_water_demand = building.domestic_hot_water_heat_demand['month']['insel meb'].sum()/1000
+    domestic_hot_water_demand = building.domestic_hot_water_consumption[cte.YEAR][0]/1000
-    electricity_plug_loads = building.appliances_electrical_demand['month']['insel meb'].sum()/1000
+    electricity_plug_loads = building.appliances_electrical_demand[cte.YEAR]['insel meb']/1000
-    total_electricity_consumption = electricity_cooling[0] + electricity_heating[0] + electricity_lighting \
+    if (building.onsite_electrical_production[cte.YEAR][0] is None):
+      onsite_electricity_production = 0
+    else:
+      onsite_electricity_production= building.onsite_electrical_production[cte.YEAR][0]/1000
+    total_electricity_consumption = electricity_cooling + electricity_heating + electricity_lighting \
                                     + domestic_hot_water_demand + electricity_plug_loads
 
     print(f'total electricity consumption: {total_electricity_consumption}')
+    print(f'total electricity production: {onsite_electricity_production}')
 
-    peak_electricity_demand = self._peak_electricity_demand
+    #todo: change when peak electricity demand is coded
-
+    peak_electricity_demand = 100 #self._peak_electricity_demand
     operational_cost_year_0 = total_electricity_consumption * archetype.operational_cost.fuels[0].variable[0]
     peak_cost_year_0 = peak_electricity_demand * archetype.operational_cost.fuels[0].fixed_power * 12
     monthly_cost_year_0 = archetype.operational_cost.fuels[0].fixed_monthly * 12 * (total_floor_area/100)
-    print(f'operational_cost_year_0 {operational_cost_year_0}')
+    incomes_year_0 = onsite_electricity_production * archetype.operational_cost.fuels[0].variable[0]
-    print(f'peak_cost_year_0 {peak_cost_year_0}')
-    print(f'monthly_cost_year_0 {monthly_cost_year_0}')
 
     for year in range(1, self._number_of_years + 1):
       peak_cost += operational_cost_year_0 \
@@ -205,27 +211,23 @@ class LifeCycleCosts:
                       * math.pow(1 + self._consumer_price_index, year) / math.pow(1 + self._discount_rate, year)
       variable_cost += monthly_cost_year_0 \
                        * math.pow(1 + self._consumer_price_index, year) / math.pow(1 + self._discount_rate, year)
-      total_operational_costs = peak_cost + monthly_cost + variable_cost
+      variable_incomes += incomes_year_0 \
+                   * math.pow(1 + self._consumer_price_index, year) / math.pow(1 + self._discount_rate, year)
+      total_operational_costs = peak_cost + monthly_cost + variable_cost - variable_incomes
 
     return total_operational_costs
 
   def calculate_total_maintenance_costs(self):
     building = self._building
     archetype = self._archetype
-    factor_pv = self._factor_pv
+    #todo: change area pv when the variable exists
-    surface_roof = 0
+    surface_pv = 10 #building.area_pv
     maintenance_pv = 0
     maintenance_heating = 0
     maintenance_cooling = 0
-    peak_heating = 0.1 * self._total_floor_area
+    peak_heating = building.heating_peak_load
-    peak_cooling = 0.1 * self._total_floor_area
+    peak_cooling = building.cooling_peak_load
 
-    for internal_zone in building.internal_zones:
-        for thermal_zone in internal_zone.thermal_zones:
-          for thermal_boundary in thermal_zone.thermal_boundaries:
-            if thermal_boundary.type == 'Roof':
-              surface_roof += thermal_boundary.opaque_area
-    surface_pv = surface_roof * factor_pv
     maintenance_pv_0 = surface_pv * archetype.operational_cost.maintenance_pv
     maintenance_heating_0 = peak_heating * archetype.operational_cost.maintenance_heating
     maintenance_cooling_0 = peak_cooling * archetype.operational_cost.maintenance_cooling

main.py

@@ -21,10 +21,11 @@ from hub.catalog_factories.costs_catalog_factory import CostCatalogFactory
 import hub.helpers.constants as cte
 from monthly_energy_balance_engine import MonthlyEnergyBalanceEngine
 from sra_engine import SraEngine
+from hub.imports.energy_systems_factory import EnergySystemsFactory
+from energy_systems_sizing import EnergySystemsSizing
 
 from life_cycle_costs import LifeCycleCosts
 
-
 def _search_archetype(costs_catalog, building_function):
   costs_archetypes = costs_catalog.entries('archetypes').archetypes
   for building_archetype in costs_archetypes:
@@ -32,19 +33,18 @@ def _search_archetype(costs_catalog, building_function):
       return building_archetype
   raise KeyError('archetype not found')
 
-
 file_path = (Path(__file__).parent.parent/'costs_workflow'/'input_files'/'selected_building_2864.geojson')
 climate_reference_city = 'Montreal'
 weather_file = 'CAN_PQ_Montreal.Intl.AP.716270_CWEC.epw'
 weather_format = 'epw'
 construction_format = 'nrcan'
-usage_format = 'nrcan'
+usage_format = 'comnet'
+energy_systems_format = 'montreal_custom'
 attic_heated_case = 0
 basement_heated_case = 1
 tmp_folder = (Path(__file__).parent.parent/'monthly_energy_balance_workflow'/'tmp')
 out_path = (Path(__file__).parent.parent / 'costs_workflow' / 'out_files')
 files = glob.glob(f'{out_path}/*')
-retrofitting_year_of_construction = 2015
 
 for file in files:
   if file != '.gitignore':
@@ -53,86 +53,89 @@ for file in files:
 number_of_years = 30
 consumer_price_index = 0.04
 discount_rate = 0.03
-
+retrofitting_year_of_construction =2020
-peak_electricity_demand = 33
-factor_pv = 0.5
-factor_peak_lights = 0.07
 
 retrofitting_scenarios = [0, 1, 2, 3]
 life_cycle_results = pd.DataFrame()
+print('[city creation start]')
+city = GeometryFactory('geojson',
+                       path=file_path,
+                       height_field='heightmax',
+                       name_field='OBJECTID_12',
+                       year_of_construction_field='ANNEE_CONS',
+                       function_field='CODE_UTILI',
+                       function_to_hub=Dictionaries().montreal_function_to_hub_function).city
+print(f'city created from {file_path}')
+city.climate_reference_city = climate_reference_city
+city.climate_file = (tmp_folder / f'{climate_reference_city}.cli').resolve()
+print(f'city created from {file_path}')
+WeatherFactory(weather_format, city, file_name=weather_file).enrich()
+print('enrich weather... done')
+ConstructionFactory(construction_format, city).enrich()
+print('enrich constructions... done')
+UsageFactory(usage_format, city).enrich()
+print('enrich usage... done')
+for building in city.buildings:
+  building.energy_systems_archetype_name = 'system 1 gas'
+EnergySystemsFactory(energy_systems_format, city).enrich()
+print('enrich systems... done')
+print('exporting:')
+catalog = CostCatalogFactory('montreal_custom').catalog
+print('costs catalog access... done')
+sra_file = (tmp_folder / f'{city.name}_sra.xml').resolve()
+SraEngine(city, sra_file, tmp_folder, weather_file)
+print('    sra processed...')
+
+for building in city.buildings:
+  building.attic_heated = attic_heated_case
+  building.basement_heated = basement_heated_case
+
 for retrofitting_scenario in retrofitting_scenarios:
-    if retrofitting_scenario == 2 or retrofitting_scenario == 3:
-        heating_scop = 3
-        cooling_seer = 4.5
-    else:
-        heating_scop = 1
-        cooling_seer = 2.8
 
-    print('[simulation start]')
+  if retrofitting_scenario == 1 or retrofitting_scenario==3:
-    city = GeometryFactory('geojson',
+      for building in city.buildings:
-                           path=file_path,
+        building.year_of_construction=2020
-                           height_field='heightmax',
+      ConstructionFactory(construction_format, city).enrich()
-                           name_field='OBJECTID_12',
+      print('enrich retrofitted constructions... done')
-                           year_of_construction_field='ANNEE_CONS',
-                           function_field='CODE_UTILI',
-                           function_to_hub=Dictionaries().montreal_function_to_hub_function).city
-    print(f'city created from {file_path}')
-
-    city.climate_reference_city = climate_reference_city
-
-    city.climate_file = (tmp_folder / f'{climate_reference_city}.cli').resolve()
-    print(f'city created from {file_path}')
-    WeatherFactory(weather_format, city, file_name=weather_file).enrich()
-    print('enrich weather... done')
-    UsageFactory(usage_format, city).enrich()
-    print('enrich usage... done')
-    catalog = CostCatalogFactory('montreal_custom').catalog
-    print('costs catalog access... done')
-
-    if retrofitting_scenario == 0 or retrofitting_scenario == 2:
-        for building in city.buildings:
-            building.year_of_construction = retrofitting_year_of_construction
-
-    ConstructionFactory(construction_format, city).enrich()
-    print('enrich constructions... done')
-
-    # sra + monthly running
-
-    print('exporting:')
-    sra_file = (tmp_folder / f'{city.name}_sra.xml').resolve()
-    SraEngine(city, sra_file, tmp_folder, weather_file)
-    # Assign radiation to the city
-    print('    sra processed...')
 
+  if retrofitting_scenario==2 or retrofitting_scenario==3:
     for building in city.buildings:
-        building.attic_heated = attic_heated_case
+      building.energy_systems_archetype_name = 'system 6 electricity pv'
-        building.basement_heated = basement_heated_case
+    EnergySystemsFactory(energy_systems_format, city).enrich()
+    print('enrich systems... done')
 
-    MonthlyEnergyBalanceEngine(city, tmp_folder)
+  MonthlyEnergyBalanceEngine(city, tmp_folder)
 
-    for building in city.buildings:
+  EnergySystemsSizing(city).enrich()
-        try:
-            function = Dictionaries().hub_function_to_montreal_custom_costs_function[building.function]
-            archetype = _search_archetype(catalog, function)
-        except KeyError:
-            logger.error(f'Building {building.name} has unknown costs archetype for building function: '
-                         f'{building.function}\n')
-            sys.stderr.write(f'Building {building.name} has unknown costs archetype for building function: '
-                             f'{building.function}\n')
-            continue
-        lcc = LifeCycleCosts(building, archetype, number_of_years, consumer_price_index,
-                             discount_rate, retrofitting_scenario, heating_scop, cooling_seer,
-                             peak_electricity_demand, factor_pv,factor_peak_lights)
 
+  print(f'beginning costing scenario {retrofitting_scenario} systems... done')
+
+  for building in city.buildings:
+    #try:
+    function = Dictionaries().hub_function_to_montreal_custom_costs_function[building.function]
+    archetype = _search_archetype(catalog, function)
+    #except KeyError:
+    #  logger.error(f'Building {building.name} has unknown costs archetype for building function: '
+    #               f'{building.function}\n')
+    #  sys.stderr.write(f'Building {building.name} has unknown costs archetype for building function: '
+    #                   f'{building.function}\n')
+    #continue
+    print('lcc for first building started')
+    lcc = LifeCycleCosts(building, archetype, number_of_years, consumer_price_index,
+                       discount_rate, retrofitting_scenario)
+
+    total_capital_costs = lcc.calculate_capital_costs()
+    print(f'total capital costs {total_capital_costs}')
+    end_of_life_costs = lcc.calculate_end_of_life_costs()
+    total_operational_costs = lcc.calculate_total_operational_costs()
+    total_maintenance_costs = lcc.calculate_total_maintenance_costs()
+    life_cycle_costs = total_capital_costs + end_of_life_costs + total_operational_costs + total_maintenance_costs
+    life_cycle_results[f'Scenario {retrofitting_scenario}'] = [total_capital_costs, end_of_life_costs,
+                                                               total_operational_costs, total_maintenance_costs,
+                                                               life_cycle_costs]
+
+life_cycle_results.index = ['total_capital_costs','end_of_life_costs', 'total_operational_costs',
+                            'total_maintenance_costs','life_cycle_costs']
+
+life_cycle_results.to_excel(Path(__file__).parent/'out_files'/'Results.xlsx', index=True)
 
-        total_capital_costs, yearly_capital_costs = lcc.calculate_capital_costs()
-        end_of_life_costs = lcc.calculate_end_of_life_costs()
-        total_operational_costs = lcc.calculate_total_operational_costs()
-        total_maintenance_costs = lcc.calculate_total_maintenance_costs()
-        life_cycle_costs = total_capital_costs + end_of_life_costs + total_operational_costs + total_maintenance_costs
-        life_cycle_results[f'Scenario {retrofitting_scenario}'] = [total_capital_costs, end_of_life_costs,
-                                                                   total_operational_costs, total_maintenance_costs,
-                                                                   life_cycle_costs]
-        life_cycle_results.index = ['total_capital_costs', 'end_of_life_costs', 'total_operational_costs',
-                                    'total_maintenance_costs', 'life_cycle_costs']
-        life_cycle_results.to_excel(Path(__file__).parent/'out_files'/'Results.xlsx', index=True)