Merge remote-tracking branch 'origin/main_branch' into main_branch

.gitignore

@@ -1,14 +1,13 @@
-!.gitignore
-**/venv/
-.idea/
-/development_tests/
-/data/energy_systems/heat_pumps/*.csv
-/data/energy_systems/heat_pumps/*.insel
-.DS_Store
-**/.env
-**/hub/logs/
-**/__pycache__/
-**/.idea/
-cerc_hub.egg-info
-**/out_files/
-/input_files/output_buildings.geojson
+.idea
+*.idf
+*.bnd
+*.eio
+*.end
+*.err
+*.eso
+*.expidf
+*.mtr
+*.rvaudit
+*.shd
+*.csv
+*.htm

MEB_test.py

@@ -1,66 +0,0 @@
-from geojson_creator import process_geojson
-from pathlib import Path
-import subprocess
-from hub.exports.energy_building_exports_factory import EnergyBuildingsExportsFactory
-from hub.helpers.dictionaries import Dictionaries
-from hub.imports.construction_factory import ConstructionFactory
-from hub.imports.geometry_factory import GeometryFactory
-from hub.imports.weather_factory import WeatherFactory
-from hub.imports.results_factory import ResultFactory
-from hub.imports.usage_factory import UsageFactory
-from hub.exports.exports_factory import ExportsFactory
-from scripts.ep_workflow import energy_plus_workflow
-import matplotlib.pyplot as plt
-import random
-import matplotlib.colors as mcolors
-import hub.helpers.constants as cte
-
-# Process geojson
-geojson_file = process_geojson(x=-73.5681295982132, y=45.49218262677643, diff=0.0001)
-months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October',
-          'November', 'December']
-out_path = (Path(__file__).parent / 'out_files')
-file_path = (Path(__file__).parent.parent / 'input_files' / f'{geojson_file}')
-print('[simulation start]')
-city = GeometryFactory('geojson',
-                       path=file_path,
-                       height_field='height',
-                       year_of_construction_field='year_of_construction',
-                       function_field='function',
-                       function_to_hub=Dictionaries().montreal_function_to_hub_function).city
-print(f'city created from {file_path}')
-
-# Enrich city data
-ConstructionFactory('nrcan', city).enrich()
-UsageFactory('nrcan', city).enrich()
-WeatherFactory('epw', city).enrich()
-ExportsFactory('sra', city, out_path).export()
-sra_path = (out_path / f'{city.name}_sra.xml').resolve()
-subprocess.run(['sra', str(sra_path)])
-ResultFactory('sra', city, out_path).enrich()
-EnergyBuildingsExportsFactory('insel_monthly_energy_balance', city, out_path).export_debug()
-
-# Create grid of plots
-fig, axs = plt.subplots(3, 2, figsize=(12, 12))
-
-# Plot monthly heating demands from Monthly Energy Balance
-for i, building in enumerate(city.buildings):
-    monthly_heating_demand = [peak / 3.6e6 for peak in building.heating_peak_load[cte.MONTH]]
-    ax = axs[i, 0]  # Select subplot in the first column
-    ax.plot(months, monthly_heating_demand)
-    ax.set_title(f'Monthly Heating Demand (Building {i+1})')
-    ax.set_xlabel('Month')
-    ax.set_ylabel('Heating Demand')
-
-# Plot monthly heating demands from EnergyPlus
-energy_plus_workflow(city)
-for i, ep in enumerate(city.buildings):
-    monthly_heating_demand = [peak / 3.6e6 for peak in ep.heating_peak_load[cte.MONTH]]
-    ax = axs[i, 1]  # Select subplot in the second column
-    ax.plot(months, monthly_heating_demand)
-    ax.set_title(f'Monthly Heating Demand (Building {i+1})')
-    ax.set_xlabel('Month')
-    ax.set_ylabel('Heating Demand')
-
-plt.tight_layout()
-plt.show()

energy_system_analysis_report.py

@@ -1,340 +0,0 @@
-import os
-import hub.helpers.constants as cte
-import matplotlib.pyplot as plt
-import random
-import matplotlib.colors as mcolors
-from matplotlib import cm
-from report_creation import LatexReport
-
-class EnergySystemAnalysisReport:
-  def __init__(self, city, output_path):
-    self.city = city
-    self.output_path = output_path
-    self.content = []
-    self.report = LatexReport('energy_system_analysis_report.tex')
-
-  def building_energy_info(self):
-
-    table_data = [
-      ["Building Name", "Year of Construction", "function", "Yearly Heating Demand (MWh)",
-       "Yearly Cooling Demand (MWh)", "Yearly DHW Demand (MWh)", "Yearly Electricity Demand (MWh)"]
-    ]
-    intensity_table_data = [["Building Name", "Total Floor Area m2", "Heating Demand Intensity kWh/m2",
-                      "Cooling Demand Intensity kWh/m2", "Electricity Intensity kWh/m2"]]
-
-    for building in self.city.buildings:
-      total_floor_area = 0
-      for zone in building.thermal_zones_from_internal_zones:
-        total_floor_area += zone.total_floor_area
-      building_data = [
-        building.name,
-        str(building.year_of_construction),
-        building.function,
-        str(format(building.heating_demand[cte.YEAR][0] / 1e6, '.2f')),
-        str(format(building.cooling_demand[cte.YEAR][0] / 1e6, '.2f')),
-        str(format(building.domestic_hot_water_heat_demand[cte.YEAR][0] / 1e6, '.2f')),
-        str(format((building.lighting_electrical_demand[cte.YEAR][0] + building.appliances_electrical_demand[cte.YEAR][0]) / 1e6, '.2f')),
-      ]
-      intensity_data = [
-        building.name,
-        str(format(total_floor_area, '.2f')),
-        str(format(building.heating_demand[cte.YEAR][0] / (1e3 * total_floor_area), '.2f')),
-        str(format(building.cooling_demand[cte.YEAR][0] / (1e3 * total_floor_area), '.2f')),
-        str(format(
-          (building.lighting_electrical_demand[cte.YEAR][0] + building.appliances_electrical_demand[cte.YEAR][0]) /
-          (1e3 * total_floor_area), '.2f'))
-      ]
-      table_data.append(building_data)
-      intensity_table_data.append(intensity_data)
-
-    self.report.add_table(table_data, caption='City Buildings Energy Demands')
-    self.report.add_table(intensity_table_data, caption='Energy Intensity Information')
-
-  def base_case_charts(self):
-    save_directory = self.output_path
-
-    def autolabel(bars, ax):
-      for bar in bars:
-        height = bar.get_height()
-        ax.annotate('{:.1f}'.format(height),
-                    xy=(bar.get_x() + bar.get_width() / 2, height),
-                    xytext=(0, 3),  # 3 points vertical offset
-                    textcoords="offset points",
-                    ha='center', va='bottom')
-
-    def create_hvac_demand_chart(building_names, yearly_heating_demand, yearly_cooling_demand):
-      fig, ax = plt.subplots()
-      bar_width = 0.35
-      index = range(len(building_names))
-
-      bars1 = ax.bar(index, yearly_heating_demand, bar_width, label='Yearly Heating Demand (MWh)')
-      bars2 = ax.bar([i + bar_width for i in index], yearly_cooling_demand, bar_width,
-                     label='Yearly Cooling Demand (MWh)')
-
-      ax.set_xlabel('Building Name')
-      ax.set_ylabel('Energy Demand (MWh)')
-      ax.set_title('Yearly HVAC Demands')
-      ax.set_xticks([i + bar_width / 2 for i in index])
-      ax.set_xticklabels(building_names, rotation=45, ha='right')
-      ax.legend()
-      autolabel(bars1, ax)
-      autolabel(bars2, ax)
-      fig.tight_layout()
-      plt.savefig(save_directory / 'hvac_demand_chart.jpg')
-      plt.close()
-
-    def create_bar_chart(title, ylabel, data, filename, bar_color=None):
-      fig, ax = plt.subplots()
-      bar_width = 0.35
-      index = range(len(building_names))
-
-      if bar_color is None:
-        # Generate a random color
-        bar_color = random.choice(list(mcolors.CSS4_COLORS.values()))
-
-      bars = ax.bar(index, data, bar_width, label=ylabel, color=bar_color)
-
-      ax.set_xlabel('Building Name')
-      ax.set_ylabel('Energy Demand (MWh)')
-      ax.set_title(title)
-      ax.set_xticks([i + bar_width / 2 for i in index])
-      ax.set_xticklabels(building_names, rotation=45, ha='right')
-      ax.legend()
-      autolabel(bars, ax)
-      fig.tight_layout()
-      plt.savefig(save_directory / filename)
-      plt.close()
-
-    building_names = [building.name for building in self.city.buildings]
-    yearly_heating_demand = [building.heating_demand[cte.YEAR][0] / 1e6 for building in self.city.buildings]
-    yearly_cooling_demand = [building.cooling_demand[cte.YEAR][0] / 1e6 for building in self.city.buildings]
-    yearly_dhw_demand = [building.domestic_hot_water_heat_demand[cte.YEAR][0] / 1e6 for building in
-                         self.city.buildings]
-    yearly_electricity_demand = [(building.lighting_electrical_demand[cte.YEAR][0] +
-                                  building.appliances_electrical_demand[cte.YEAR][0]) / 1e6 for building in
-                                 self.city.buildings]
-
-    create_hvac_demand_chart(building_names, yearly_heating_demand, yearly_cooling_demand)
-    create_bar_chart('Yearly DHW Demands', 'Energy Demand (MWh)', yearly_dhw_demand, 'dhw_demand_chart.jpg', )
-    create_bar_chart('Yearly Electricity Demands', 'Energy Demand (MWh)', yearly_electricity_demand,
-                     'electricity_demand_chart.jpg')
-
-  def maximum_monthly_hvac_chart(self):
-    save_directory = self.output_path
-    months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October',
-              'November', 'December']
-    for building in self.city.buildings:
-      maximum_monthly_heating_load = []
-      maximum_monthly_cooling_load = []
-      fig, axs = plt.subplots(1, 2, figsize=(12, 6))  # Create a figure with 2 subplots side by side
-      for demand in building.heating_peak_load[cte.MONTH]:
-          maximum_monthly_heating_load.append(demand / 3.6e6)
-      for demand in building.cooling_peak_load[cte.MONTH]:
-          maximum_monthly_cooling_load.append(demand / 3.6e6)
-
-    # Plot maximum monthly heating load
-      axs[0].bar(months, maximum_monthly_heating_load, color='red')  # Plot on the first subplot
-      axs[0].set_title('Maximum Monthly Heating Load')
-      axs[0].set_xlabel('Month')
-      axs[0].set_ylabel('Load (kW)')
-      axs[0].tick_params(axis='x', rotation=45)
-
-      # Plot maximum monthly cooling load
-      axs[1].bar(months, maximum_monthly_cooling_load, color='blue')  # Plot on the second subplot
-      axs[1].set_title('Maximum Monthly Cooling Load')
-      axs[1].set_xlabel('Month')
-      axs[1].set_ylabel('Load (kW)')
-      axs[1].tick_params(axis='x', rotation=45)
-
-      plt.tight_layout()  # Adjust layout to prevent overlapping
-      plt.savefig(save_directory / f'{building.name}_monthly_maximum_hvac_loads.jpg')
-      plt.close()
-
-  def load_duration_curves(self):
-    save_directory = self.output_path
-    for building in self.city.buildings:
-      heating_demand = [demand / 1000 for demand in building.heating_demand[cte.HOUR]]
-      cooling_demand = [demand / 1000 for demand in building.cooling_demand[cte.HOUR]]
-      heating_demand_sorted = sorted(heating_demand, reverse=True)
-      cooling_demand_sorted = sorted(cooling_demand, reverse=True)
-
-      plt.style.use('ggplot')
-
-      # Create figure and axis objects with 1 row and 2 columns
-      fig, axs = plt.subplots(1, 2, figsize=(12, 6))
-
-      # Plot sorted heating demand
-      axs[0].plot(heating_demand_sorted, color='red', linewidth=2, label='Heating Demand')
-      axs[0].set_xlabel('Hour', fontsize=14)
-      axs[0].set_ylabel('Heating Demand', fontsize=14)
-      axs[0].set_title('Heating Load Duration Curve', fontsize=16)
-      axs[0].grid(True)
-      axs[0].legend(loc='upper right', fontsize=12)
-
-      # Plot sorted cooling demand
-      axs[1].plot(cooling_demand_sorted, color='blue', linewidth=2, label='Cooling Demand')
-      axs[1].set_xlabel('Hour', fontsize=14)
-      axs[1].set_ylabel('Cooling Demand', fontsize=14)
-      axs[1].set_title('Cooling Load Duration Curve', fontsize=16)
-      axs[1].grid(True)
-      axs[1].legend(loc='upper right', fontsize=12)
-
-      # Adjust layout
-      plt.tight_layout()
-
-      # Save the plot
-      plt.savefig(save_directory / f'{building.name}_load_duration_curve.jpg')
-
-      # Close the plot to release memory
-      plt.close()
-
-  def individual_building_info(self, building):
-    table_data = [
-      ["Maximum Monthly HVAC Demands",
-       f"\\includegraphics[width=1\\linewidth]{{{building.name}_monthly_maximum_hvac_loads.jpg}}"],
-      ["Load Duration Curve", f"\\includegraphics[width=1\\linewidth]{{{building.name}_load_duration_curve.jpg}}"],
-    ]
-
-    self.report.add_table(table_data, caption=f'{building.name} Information', first_column_width=1.5)
-
-  def building_existing_system_info(self, building):
-    existing_archetype = building.energy_systems_archetype_name
-    fuels = []
-    system_schematic = "-"
-    heating_system = "-"
-    cooling_system = "-"
-    dhw = "-"
-    electricity = "Grid"
-    hvac_ec = format((building.heating_consumption[cte.YEAR][0] + building.cooling_consumption[cte.YEAR][0])/1e6, '.2f')
-    dhw_ec = format(building.domestic_hot_water_consumption[cte.YEAR][0]/1e6, '.2f')
-    on_site_generation = "-"
-    yearly_operational_cost = "-"
-    life_cycle_cost = "-"
-    for energy_system in building.energy_systems:
-      if cte.HEATING and cte.DOMESTIC_HOT_WATER in energy_system.demand_types:
-        heating_system = energy_system.name
-        dhw = energy_system.name
-      elif cte.DOMESTIC_HOT_WATER in energy_system.demand_types:
-        dhw = energy_system.name
-      elif cte.HEATING in energy_system.demand_types:
-        heating_system = energy_system.name
-      elif cte.COOLING in energy_system.demand_types:
-        cooling_system = energy_system.name
-      for generation_system in energy_system.generation_systems:
-        fuels.append(generation_system.fuel_type)
-        if generation_system.system_type == cte.PHOTOVOLTAIC:
-          electricity = "Grid-tied PV"
-
-    energy_system_table_data = [
-      ["Detail", "Existing System", "Proposed System"],
-      ["Energy System Archetype", existing_archetype, "-"],
-      ["System Schematic", system_schematic, system_schematic],
-      ["Heating System", heating_system, "-"],
-      ["Cooling System", cooling_system, "-"],
-      ["DHW System", dhw, "-"],
-      ["Electricity", electricity, "-"],
-      ["Fuel(s)", str(fuels), "-"],
-      ["HVAC Energy Consumption (MWh)", hvac_ec, "-"],
-      ["DHW Energy Consumption (MWH)", dhw_ec, "-"],
-      ["Yearly Operational Cost (CAD)", yearly_operational_cost, "-"],
-      ["Life Cycle Cost (CAD)", life_cycle_cost, "-"]
-    ]
-    self.report.add_table(energy_system_table_data, caption= f'Building {building.name} Energy System Characteristics')
-
-  def building_fuel_consumption_breakdown(self, building):
-    save_directory = self.output_path
-    # Initialize variables to store fuel consumption breakdown
-    fuel_breakdown = {
-      "Heating": {"Gas": 0, "Electricity": 0},
-      "Domestic Hot Water": {"Gas": 0, "Electricity": 0},
-      "Cooling": {"Electricity": 0},
-      "Appliance": building.appliances_electrical_demand[cte.YEAR][0] / 1e6,
-      "Lighting": building.lighting_electrical_demand[cte.YEAR][0] / 1e6
-    }
-
-    # Iterate through energy systems of the building
-    for energy_system in building.energy_systems:
-      for demand_type in energy_system.demand_types:
-        for generation_system in energy_system.generation_systems:
-          consumption = 0
-          if demand_type == cte.HEATING:
-            consumption = building.heating_consumption[cte.YEAR][0] / 1e6
-          elif demand_type == cte.DOMESTIC_HOT_WATER:
-            consumption = building.domestic_hot_water_consumption[cte.YEAR][0] / 1e6
-          elif demand_type == cte.COOLING:
-            consumption = building.cooling_consumption[cte.YEAR][0] / 1e6
-
-          if generation_system.fuel_type == cte.ELECTRICITY:
-            fuel_breakdown[demand_type]["Electricity"] += consumption
-          else:
-            fuel_breakdown[demand_type]["Gas"] += consumption
-
-    electricity_labels = ['Appliance', 'Lighting']
-    electricity_sizes = [fuel_breakdown['Appliance'], fuel_breakdown['Lighting']]
-    if fuel_breakdown['Heating']['Electricity'] > 0:
-      electricity_labels.append('Heating')
-      electricity_sizes.append(fuel_breakdown['Heating']['Electricity'])
-    if fuel_breakdown['Cooling']['Electricity'] > 0:
-      electricity_labels.append('Cooling')
-      electricity_sizes.append(fuel_breakdown['Cooling']['Electricity'])
-    if fuel_breakdown['Domestic Hot Water']['Electricity'] > 0:
-      electricity_labels.append('Domestic Hot Water')
-      electricity_sizes.append(fuel_breakdown['Domestic Hot Water']['Electricity'])
-
-    # Data for bar chart
-    gas_labels = ['Heating', 'Domestic Hot Water']
-    gas_sizes = [fuel_breakdown['Heating']['Gas'], fuel_breakdown['Domestic Hot Water']['Gas']]
-
-    # Set the style
-    plt.style.use('ggplot')
-
-    # Create plot grid
-    fig, axs = plt.subplots(1, 2, figsize=(12, 6))
-
-    # Plot pie chart for electricity consumption breakdown
-    colors = cm.get_cmap('tab20c', len(electricity_labels))
-    axs[0].pie(electricity_sizes, labels=electricity_labels,
-               autopct=lambda pct: f"{pct:.1f}%\n({pct / 100 * sum(electricity_sizes):.2f})",
-               startangle=90, colors=[colors(i) for i in range(len(electricity_labels))])
-    axs[0].set_title('Electricity Consumption Breakdown')
-
-    # Plot bar chart for natural gas consumption breakdown
-    colors = cm.get_cmap('Paired', len(gas_labels))
-    axs[1].bar(gas_labels, gas_sizes, color=[colors(i) for i in range(len(gas_labels))])
-    axs[1].set_ylabel('Consumption (MWh)')
-    axs[1].set_title('Natural Gas Consumption Breakdown')
-
-    # Add grid to bar chart
-    axs[1].grid(axis='y', linestyle='--', alpha=0.7)
-
-    # Add a title to the entire figure
-    plt.suptitle('Building Energy Consumption Breakdown', fontsize=16, fontweight='bold')
-
-    # Adjust layout
-    plt.tight_layout()
-
-    # Save the plot as a high-quality image
-    plt.savefig(save_directory / f'{building.name}_energy_consumption_breakdown.png', dpi=300)
-    plt.close()
-
-  def create_report(self):
-    os.chdir(self.output_path)
-    self.report.add_section('Current Status')
-    self.building_energy_info()
-    self.base_case_charts()
-    self.report.add_image('hvac_demand_chart.jpg', caption='Yearly HVAC Demands')
-    self.report.add_image('dhw_demand_chart.jpg', caption='Yearly DHW Demands')
-    self.report.add_image('electricity_demand_chart.jpg', caption='Yearly Electricity Demands')
-    self.maximum_monthly_hvac_chart()
-    self.load_duration_curves()
-    for building in self.city.buildings:
-      self.individual_building_info(building)
-      self.building_existing_system_info(building)
-      self.building_fuel_consumption_breakdown(building)
-      self.report.add_image(f'{building.name}_energy_consumption_breakdown.png',
-                       caption=f'Building {building.name} Consumption by source and sector breakdown')
-    self.report.save_report()
-    self.report.compile_to_pdf()
-
-
-

hub/catalog_factories/cost/montreal_complete_cost_catalog.py

@@ -1,196 +0,0 @@
-"""
-Cost catalog
-SPDX - License - Identifier: LGPL - 3.0 - or -later
-Copyright © 2023 Concordia CERC group
-Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
-"""
-
-import xmltodict
-from hub.catalog_factories.catalog import Catalog
-from hub.catalog_factories.data_models.cost.archetype import Archetype
-from hub.catalog_factories.data_models.cost.content import Content
-from hub.catalog_factories.data_models.cost.capital_cost import CapitalCost
-from hub.catalog_factories.data_models.cost.chapter import Chapter
-from hub.catalog_factories.data_models.cost.item_description import ItemDescription
-from hub.catalog_factories.data_models.cost.operational_cost import OperationalCost
-from hub.catalog_factories.data_models.cost.fuel import Fuel
-from hub.catalog_factories.data_models.cost.income import Income
-
-
-class MontrealNewCatalog(Catalog):
-  """
-  Montreal custom catalog class
-  """
-
-  def __init__(self, path):
-    path = (path / 'montreal_costs_completed.xml').resolve()
-    with open(path, 'r', encoding='utf-8') as xml:
-      self._archetypes = xmltodict.parse(xml.read(), force_list='archetype')
-
-    # store the full catalog data model in self._content
-    self._content = Content(self._load_archetypes())
-
-  def _load_archetypes(self):
-    _catalog_archetypes = []
-    archetypes = self._archetypes['archetypes']['archetype']
-    for archetype in archetypes:
-      lod = float(archetype['@lod'])
-      function = archetype['@function']
-      municipality = archetype['@municipality']
-      country = archetype['@country']
-      currency = archetype['currency']
-      capital_cost = self.load_capital_costs(archetype)
-      operational_cost = self._get_operational_costs(archetype['operational_cost'])
-      end_of_life_cost = float(archetype['end_of_life_cost']['#text'])
-      construction = float(archetype['incomes']['subsidies']['construction']['#text'])
-      hvac = float(archetype['incomes']['subsidies']['hvac']['#text'])
-      photovoltaic_system = float(archetype['incomes']['subsidies']['photovoltaic']['#text'])
-      electricity_exports = float(archetype['incomes']['electricity_export']['#text']) / 1000 / 3600
-      reduction_tax = float(archetype['incomes']['tax_reduction']['#text']) / 100
-      income = Income(construction_subsidy=construction,
-                      hvac_subsidy=hvac,
-                      photovoltaic_subsidy=photovoltaic_system,
-                      electricity_export=electricity_exports,
-                      reductions_tax=reduction_tax)
-      _catalog_archetypes.append(Archetype(lod,
-                                           function,
-                                           municipality,
-                                           country,
-                                           currency,
-                                           capital_cost,
-                                           operational_cost,
-                                           end_of_life_cost,
-                                           income))
-    return _catalog_archetypes
-
-  @staticmethod
-  def item_description(item_type, item):
-    if 'refurbishment_cost' in item.keys():
-      _refurbishment = float(item['refurbishment_cost']['#text'])
-      _refurbishment_unit = item['refurbishment_cost']['@cost_unit']
-      _item_description = ItemDescription(item_type,
-                                          initial_investment=None,
-                                          initial_investment_unit=None,
-                                          refurbishment=_refurbishment,
-                                          refurbishment_unit=_refurbishment_unit,
-                                          reposition=None,
-                                          reposition_unit=None,
-                                          lifetime=None)
-    else:
-      _reposition = float(item['reposition']['#text'])
-      _reposition_unit = item['reposition']['@cost_unit']
-      _investment = float(item['investment_cost']['#text'])
-      _investment_unit = item['investment_cost']['@cost_unit']
-      _lifetime = float(item['lifetime_equipment']['#text'])
-      _item_description = ItemDescription(item_type,
-                                          initial_investment=_investment,
-                                          initial_investment_unit=_investment_unit,
-                                          refurbishment=None,
-                                          refurbishment_unit=None,
-                                          reposition=_reposition,
-                                          reposition_unit=_reposition_unit,
-                                          lifetime=_lifetime)
-
-    return _item_description
-
-  def load_capital_costs(self, archetype):
-    archetype_capital_costs = archetype['capital_cost']
-    design_allowance = float(
-      archetype_capital_costs['Z_allowances_overhead_profit']['Z10_design_allowance']['#text']) / 100
-    overhead_and_profit = float(
-      archetype_capital_costs['Z_allowances_overhead_profit']['Z20_overhead_profit']['#text']) / 100
-    general_chapters = []
-    shell_items = []
-    service_items = []
-    for category in archetype_capital_costs:
-      if category == 'B_shell':
-        items = archetype_capital_costs[category]
-        for item in items:
-          components = items[item]
-          for component in components:
-            building_item = components[component]
-            shell_items.append(self.item_description(component, building_item))
-        general_chapters.append(Chapter(chapter_type=category, items=shell_items))
-      elif category == 'D_services':
-        services = archetype_capital_costs[category]
-        for service in services:
-          components = services[service]
-          if len(components.keys()) == 1:
-            for component in components:
-              service_item = components[component]
-              service_items.append(self.item_description(component, service_item))
-          else:
-            for component in components:
-              items = components[component]
-              if 'investment_cost' in items.keys():
-                service_item = components[component]
-                service_items.append(self.item_description(component, service_item))
-              else:
-                for item in items:
-                  service_item = items[item]
-                  service_items.append(self.item_description(item, service_item))
-
-        general_chapters.append(Chapter(chapter_type=category, items=service_items))
-    capital_costs = CapitalCost(general_chapters=general_chapters,
-                                design_allowance=design_allowance,
-                                overhead_and_profit=overhead_and_profit)
-
-    return capital_costs
-
-  @staticmethod
-  def _get_operational_costs(entry):
-    fuels = []
-    for item in entry['fuels']['fuel']:
-      fuel_type = item['@fuel_type']
-      fuel_variable = float(item['variable']['#text'])
-      fuel_variable_units = item['variable']['@cost_unit']
-      fuel_fixed_monthly = None
-      fuel_fixed_peak = None
-      if fuel_type == 'electricity':
-        fuel_fixed_monthly = float(item['fixed_monthly']['#text'])
-        fuel_fixed_peak = float(item['fixed_power']['#text']) / 1000
-      elif fuel_type == 'gas':
-        fuel_fixed_monthly = float(item['fixed_monthly']['#text'])
-      fuel = Fuel(fuel_type,
-                  fixed_monthly=fuel_fixed_monthly,
-                  fixed_power=fuel_fixed_peak,
-                  variable=fuel_variable,
-                  variable_units=fuel_variable_units)
-      fuels.append(fuel)
-    heating_equipment_maintenance = float(entry['maintenance']['heating_equipment']['#text']) / 1000
-    cooling_equipment_maintenance = float(entry['maintenance']['cooling_equipment']['#text']) / 1000
-    photovoltaic_system_maintenance = float(entry['maintenance']['photovoltaic_system']['#text'])
-    co2_emissions = float(entry['co2_cost']['#text'])
-    _operational_cost = OperationalCost(fuels,
-                                        heating_equipment_maintenance,
-                                        cooling_equipment_maintenance,
-                                        photovoltaic_system_maintenance,
-                                        co2_emissions)
-    return _operational_cost
-
-  def names(self, category=None):
-    """
-    Get the catalog elements names
-    :parm: for costs catalog category filter does nothing as there is only one category (archetypes)
-    """
-    _names = {'archetypes': []}
-    for archetype in self._content.archetypes:
-      _names['archetypes'].append(archetype.name)
-    return _names
-
-  def entries(self, category=None):
-    """
-    Get the catalog elements
-    :parm: for costs catalog category filter does nothing as there is only one category (archetypes)
-    """
-    return self._content
-
-  def get_entry(self, name):
-    """
-    Get one catalog element by names
-    :parm: entry name
-    """
-    for entry in self._content.archetypes:
-      if entry.name.lower() == name.lower():
-        return entry
-    raise IndexError(f"{name} doesn't exists in the catalog")

hub/catalog_factories/costs_catalog_factory.py

@@ -9,7 +9,6 @@ Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concord
 from pathlib import Path
 from typing import TypeVar
 from hub.catalog_factories.cost.montreal_custom_catalog import MontrealCustomCatalog
-from hub.catalog_factories.cost.montreal_complete_cost_catalog import MontrealNewCatalog
 
 Catalog = TypeVar('Catalog')
 
@@ -31,14 +30,6 @@ class CostsCatalogFactory:
     """
     return MontrealCustomCatalog(self._path)
 
-  @property
-  def _montreal_new(self):
-    """
-    Retrieve Montreal Custom catalog
-    """
-    return MontrealNewCatalog(self._path)
-
-
   @property
   def catalog(self) -> Catalog:
     """
@@ -46,7 +37,3 @@ class CostsCatalogFactory:
     :return: CostCatalog
     """
     return getattr(self, self._catalog_type, lambda: None)
-
-  @property
-  def catalog_debug(self):
-    return MontrealNewCatalog(self._path)