hub/main.py

import subprocess
from pathlib import Path
import geopandas as gpd
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import Normalize
from shapely.geometry import Polygon
from hub.imports.energy_systems_factory import EnergySystemsFactory
from hub.imports.geometry_factory import GeometryFactory
from hub.helpers.dictionaries import Dictionaries
from hub.imports.construction_factory import ConstructionFactory
from hub.imports.results_factory import ResultFactory
from hub.exports.exports_factory import ExportsFactory
from hub.imports.weather_factory import WeatherFactory
from pv_assessment.solar_calculator import SolarCalculator
from pv_assessment.pv_system_assessment_with_lcoe import PvSystemAssessment
from scripts import random_assignation

input_file_1 = "./data/updated_geojson_layers/output_layer_6.geojson"
# input_file_2 = "./data/updated_geojson_layers/output_layer_20.geojson"
# input_file_3 = "./data/updated_geojson_layers/output_layer_38.geojson"
# input_file_4 = "./data/updated_geojson_layers/output_layer_53.geojson"
demand_file = "data/energy_demand_data.csv"

output_path = (Path(__file__).parent.parent / 'hub/out_files').resolve()
output_path.mkdir(parents=True, exist_ok=True)
sra_output_path = output_path / 'sra_outputs'
sra_output_path.mkdir(parents=True, exist_ok=True)
pv_assessment_path = output_path / 'pv_outputs'
pv_assessment_path.mkdir(parents=True, exist_ok=True)

figures_path = (Path(__file__).parent.parent / 'hub/figures').resolve()
figures_path.mkdir(parents=True, exist_ok=True)

def process_city(input_file, name_suffix):
  city_obj = GeometryFactory(
    "geojson",
    input_file,
    height_field="height",
    year_of_construction_field="contr_year",
    function_field="function_c",
    adjacency_field="adjacency",
    lot_area_field='lot_area',
    build_area_field='build_area',
    function_to_hub=Dictionaries().montreal_function_to_hub_function
  ).city

  ConstructionFactory('nrcan', city_obj).enrich()
  WeatherFactory('epw', city_obj).enrich()

  ResultFactory('archetypes', city_obj, demand_file).enrich()

  ExportsFactory('sra', city_obj, sra_output_path).export()
  sra_path = (sra_output_path / f'{city_obj.name}_sra.xml').resolve()
  subprocess.run(['sra', str(sra_path)])
  ResultFactory('sra', city_obj, sra_output_path).enrich()

  tilt_angle = 37
  solar_parameters = SolarCalculator(city=city_obj,
                                     surface_azimuth_angle=180,
                                     tilt_angle=tilt_angle,
                                     standard_meridian=-75)
  solar_angles = solar_parameters.solar_angles
  solar_parameters.tilted_irradiance_calculator()

  random_assignation.call_random(city_obj.buildings, random_assignation.residential_systems_percentage)
  EnergySystemsFactory('montreal_future', city_obj).enrich()

  for building in city_obj.buildings:
    PvSystemAssessment(building=building,
                       pv_system=None,
                       battery=None,
                       electricity_demand=None,
                       tilt_angle=tilt_angle,
                       solar_angles=solar_angles,
                       pv_installation_type='rooftop',
                       simulation_model_type='explicit',
                       module_model_name=None,
                       inverter_efficiency=0.95,
                       system_catalogue_handler=None,
                       roof_percentage_coverage=0.75,
                       facade_coverage_percentage=0,
                       csv_output=False,
                       output_path=pv_assessment_path,
                       run_lcoe=True).enrich()

  return city_obj


city1 = process_city(input_file_1, "_city1")
# city2 = process_city(input_file_2, "_city2")
# city3 = process_city(input_file_3, "_city3")
# city4 = process_city(input_file_4, "_city4")

print("All cities processed.")


def city_to_gdf(city_obj):
  buildings_data = []
  for b in city_obj.buildings:
    yearly_pv = b.pv_generation['year']
    if isinstance(yearly_pv, list):
      yearly_pv = sum(yearly_pv)
    lcoe_val = b.pv_generation['LCOE_PV']

    yearly_self_sufficiency = b.self_sufficiency['year']/1000.0 if 'year' in b.self_sufficiency else np.nan

    if not b.surfaces:
      continue

    ground_surface = b.surfaces[0]
    coords_3d = ground_surface.solid_polygon.coordinates
    coords_2d = [(c[0], c[1]) for c in coords_3d]
    footprint_poly = Polygon(coords_2d)

    buildings_data.append({
      "geometry": footprint_poly,
      "yearly_pv": yearly_pv,
      "LCOE": lcoe_val,
      "self_sufficiency": yearly_self_sufficiency
    })

  gdf = gpd.GeoDataFrame(buildings_data, crs="EPSG:26911")
  return gdf

gdf_city1 = city_to_gdf(city1)
# gdf_city2 = city_to_gdf(city2)
# gdf_city3 = city_to_gdf(city3)
# gdf_city4 = city_to_gdf(city4)

all_buildings_gdf = gpd.GeoDataFrame(pd.concat([gdf_city1], ignore_index=True),
                                     crs=gdf_city1.crs)

print("Dataframe for all cities created, now plotting and saving figures")

layers_file = "data/cmm_limites_avec_mtl.geojson"
layers_gdf = gpd.read_file(layers_file)
if layers_gdf.crs is None:
  layers_gdf.set_crs(epsg=32188, inplace=True)

all_buildings_gdf = all_buildings_gdf.to_crs(layers_gdf.crs)

if 'self_sufficiency' in all_buildings_gdf.columns and not all_buildings_gdf['self_sufficiency'].isna().all():
  vmin = min(0, all_buildings_gdf['self_sufficiency'].min())
  vmax = max(0, all_buildings_gdf['self_sufficiency'].max())
  fig, ax = plt.subplots(1, 1, figsize=(14, 10))
  cmap = plt.cm.viridis
  norm = Normalize(vmin=vmin, vmax=vmax)

  all_buildings_gdf.plot(column='self_sufficiency',
                         cmap=cmap,
                         linewidth=0.8,
                         edgecolor='grey',
                         legend=False,
                         ax=ax)

  sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
  sm._A = []
  cbar = fig.colorbar(sm, ax=ax, fraction=0.03, pad=0.04)
  cbar.set_label('Self-Sufficiency (kWh/year)', fontsize=12)

  ax.grid(color='lightgrey', linestyle='--', linewidth=0.5, alpha=0.7)
  ax.set_title('Building Self-Sufficiency Levels (All 4 Cities)', fontsize=16, fontweight='bold', pad=20)
  ax.set_xlabel('Longitude', fontsize=12)
  ax.set_ylabel('Latitude', fontsize=12)

  plt.tight_layout()
  plt.savefig(figures_path / "self_sufficiency.png", dpi=300)
  plt.close(fig)
else:
  print("No self_sufficiency data available.")

if 'yearly_pv' in all_buildings_gdf.columns and not all_buildings_gdf['yearly_pv'].isna().all():
  fig2, ax2 = plt.subplots(1, 1, figsize=(14, 10))
  vmin_pv = all_buildings_gdf['yearly_pv'].min()
  vmax_pv = all_buildings_gdf['yearly_pv'].max()

  all_buildings_gdf.plot(column='yearly_pv',
                         cmap="plasma",
                         edgecolor="white",
                         linewidth=0.5,
                         legend=True,
                         legend_kwds={'label': "Yearly PV Generation (kWh)", 'orientation': "vertical"},
                         vmin=vmin_pv, vmax=vmax_pv,
                         ax=ax2)

  ax2.set_title("Yearly PV Generation (All 4 Cities)", fontsize=16, fontweight='bold')
  ax2.set_aspect('equal', 'box')
  plt.tight_layout()
  plt.savefig(figures_path / "yearly_pv_generation.png", dpi=300)
  plt.close(fig2)
else:
  print("No yearly_pv data available.")

lcoe_gdf = all_buildings_gdf.dropna(subset=['LCOE'])
if not lcoe_gdf.empty:
  vmin_lcoe = lcoe_gdf['LCOE'].min()
  vmax_lcoe = lcoe_gdf['LCOE'].max()
  cmap_lcoe = plt.cm.viridis
  norm_lcoe = Normalize(vmin=vmin_lcoe, vmax=vmax_lcoe)

  fig3, ax3 = plt.subplots(1, 1, figsize=(14, 10))
  lcoe_gdf.plot(column='LCOE',
                cmap=cmap_lcoe,
                linewidth=0.8,
                edgecolor='grey',
                legend=False,
                ax=ax3)

  sm_lcoe = plt.cm.ScalarMappable(cmap=cmap_lcoe, norm=norm_lcoe)
  sm_lcoe._A = []
  cbar_lcoe = fig3.colorbar(sm_lcoe, ax=ax3, fraction=0.03, pad=0.04)
  cbar_lcoe.set_label('LCOE (currency/kWh)', fontsize=12)

  ax3.grid(color='lightgrey', linestyle='--', linewidth=0.5, alpha=0.7)
  ax3.set_title('LCOE Values for Buildings (All 4 Cities)', fontsize=16, fontweight='bold', pad=20)
  ax3.set_xlabel('Longitude', fontsize=12)
  ax3.set_ylabel('Latitude', fontsize=12)

  plt.tight_layout()
  plt.savefig(figures_path / "lcoe_values.png", dpi=300)
  plt.close(fig3)
else:
  print("No buildings have LCOE values computed.")

layers_of_interest = [f"layer_{i}" for i in range(6, 21)]

for layer_name in layers_of_interest:
  layer_poly = layers_gdf[layers_gdf["region"] == layer_name]
  if layer_poly.empty:
    continue
  layer_union = layer_poly.unary_union
  if layer_union.is_empty:
    continue
  buildings_in_layer = all_buildings_gdf[all_buildings_gdf.geometry.within(layer_union)]
  if buildings_in_layer.empty:
    continue
  fig, ax = plt.subplots(figsize=(20, 20), dpi=600)
  layer_poly.plot(ax=ax, facecolor="none", edgecolor="black", linewidth=1)
  vmin = buildings_in_layer["yearly_pv"].min()
  vmax = buildings_in_layer["yearly_pv"].max()

  buildings_in_layer.plot(column="yearly_pv", ax=ax,
                          cmap="viridis",
                          edgecolor="white",
                          linewidth=0.5,
                          legend=True,
                          legend_kwds={'label': "Yearly PV Generation (kWh)", 'orientation': "vertical"},
                          vmin=vmin, vmax=vmax)

  ax.set_title(f"Yearly PV Generation - {layer_name}", fontsize=14)
  ax.set_aspect('equal', 'box')
  plt.tight_layout()
  plt.savefig(figures_path / f"{layer_name}_pv_generation_multi_city.pdf", dpi=300)
  plt.close(fig)

fig, ax = plt.subplots(figsize=(20, 20), dpi=1200)
layers_gdf.plot(ax=ax, facecolor="none", edgecolor="grey", linewidth=0.5)

vmin = all_buildings_gdf["yearly_pv"].min()
vmax = all_buildings_gdf["yearly_pv"].max()

all_buildings_gdf.plot(column="yearly_pv", ax=ax,
                       cmap="plasma",
                       edgecolor="none",
                       legend=True,
                       legend_kwds={'label': "Yearly PV Generation (kWh)", 'orientation': "vertical"},
                       vmin=vmin, vmax=vmax)

ax.set_title("Yearly PV Generation - All Layers (All 4 Cities)", fontsize=14)
ax.set_aspect('equal', 'box')
plt.tight_layout()
plt.savefig(figures_path / "all_layers_pv_generation_all_4_cities.png", dpi=1200)
plt.close(fig)

layer_sums = []
for idx, row in layers_gdf.iterrows():
  region_name = row["region"]
  poly_geom = row["geometry"]
  b_in_poly = all_buildings_gdf[all_buildings_gdf.geometry.within(poly_geom)]
  total_pv = b_in_poly["yearly_pv"].sum()
  layer_sums.append({
    "region": region_name,
    "total_pv": total_pv,
    "geometry": poly_geom
  })

layers_pv_gdf = gpd.GeoDataFrame(layer_sums, crs=layers_gdf.crs)

fig, ax = plt.subplots(figsize=(10, 10), dpi=300)
vmin = layers_pv_gdf["total_pv"].min()
vmax = layers_pv_gdf["total_pv"].max()

layers_pv_gdf.plot(column="total_pv", ax=ax,
                   cmap="YlOrRd",
                   edgecolor="black",
                   legend=True,
                   legend_kwds={'label': "Total PV Generation per Layer (kWh)", 'orientation': "vertical"},
                   vmin=vmin, vmax=vmax)

ax.set_title("Total PV Generation by Layer (All 4 Cities)", fontsize=14)
ax.set_aspect('equal', 'box')
plt.tight_layout()
plt.savefig(figures_path / "layers_total_pv_all_4_cities.png", dpi=300)
plt.close(fig)

print("All plots generated successfully for the 4 cities and saved in the 'figures' folder.")