159 lines
7.5 KiB
Python
159 lines
7.5 KiB
Python
from pathlib import Path
|
|
from scripts.ep_workflow import energy_plus_workflow
|
|
from hub.imports.geometry_factory import GeometryFactory
|
|
from hub.helpers.dictionaries import Dictionaries
|
|
from hub.imports.construction_factory import ConstructionFactory
|
|
from hub.imports.usage_factory import UsageFactory
|
|
from hub.imports.weather_factory import WeatherFactory
|
|
import hub.helpers.constants as cte
|
|
from hub.imports.energy_systems_factory import EnergySystemsFactory
|
|
import geopandas as gpd
|
|
# Specify the GeoJSON file path
|
|
input_files_path = (Path(__file__).parent / 'input_files')
|
|
|
|
building_type_2_modelling=2
|
|
#'Lachine_New_Developments.geojson'
|
|
geojson_file_path = input_files_path / 'Lachine_moved_2024_type.geojson'
|
|
if building_type_2_modelling==1:
|
|
gdf = gpd.read_file(geojson_file_path)
|
|
# Filter gdf when 'building_type_2' is not null
|
|
filtered_gdf = gdf[gdf['building_type_2'].notnull()]
|
|
output_geojson =input_files_path /'Lachine_moved_2024_type_2.geojson'
|
|
geojson_file_path =output_geojson
|
|
filtered_gdf.to_file(output_geojson, driver='GeoJSON')
|
|
print(f"New GeoJSON saved in: {output_geojson}")
|
|
if building_type_2_modelling==2:
|
|
gdf = gpd.read_file(geojson_file_path)
|
|
# Filter gdf when 'building_type_3' is not null
|
|
filtered_gdf = gdf[gdf['building_type_3'].notnull()]
|
|
output_geojson =input_files_path /'Lachine_moved_2024_type_3.geojson'
|
|
geojson_file_path = output_geojson
|
|
filtered_gdf.to_file(output_geojson, driver='GeoJSON')
|
|
print(f"New GeoJSON saved in: {output_geojson}")
|
|
|
|
|
|
output_path = (Path(__file__).parent / 'out_files').resolve()
|
|
output_path.mkdir(parents=True, exist_ok=True)
|
|
# Create city object from GeoJSON file
|
|
city = GeometryFactory('geojson',
|
|
path=geojson_file_path,
|
|
height_field='maximum_roof_height',
|
|
year_of_construction_field='year_built',
|
|
function_field='building_type',
|
|
function_to_hub=Dictionaries().montreal_function_to_hub_function).city
|
|
# Enrich city data
|
|
ConstructionFactory('nrcan', city).enrich()
|
|
UsageFactory('nrcan', city).enrich()
|
|
WeatherFactory('epw', city).enrich()
|
|
energy_plus_workflow(city)
|
|
def to_dict(building, total_floor_area):
|
|
return {
|
|
'roof_area': building.floor_area,
|
|
'total_floor_area': total_floor_area,
|
|
'year_of_construction' : building.year_of_construction,
|
|
'type_function':building.function,
|
|
'beam_kWh_per_m2': sum(building.beam[cte.HOUR])/ (3.6e6),
|
|
'diffuse_kWh_per_m2': sum(building.diffuse[cte.HOUR])/ (3.6e6),
|
|
'direct_normal_kWh_per_m2': sum(building.direct_normal[cte.HOUR])/ (3.6e6),
|
|
'average_storey_height_meters': building.average_storey_height,
|
|
'max_height_meters_meters': building.max_height,
|
|
'global_horizontal_kWh_per_m2': sum(building.global_horizontal[cte.HOUR])/ (3.6e6),
|
|
'appliances_peak_load_kW':building.appliances_peak_load[cte.YEAR][0]/ (1e3),
|
|
'domestic_hot_water_peak_load_kW': building.domestic_hot_water_peak_load[cte.YEAR][0]/ (1e3),
|
|
'heating_peak_load_kW': building.heating_peak_load[cte.YEAR][0]/ (1e3),
|
|
'cooling_peak_load_kW': building.cooling_peak_load[cte.YEAR][0]/ (1e3),
|
|
'lighting_peak_load_kW': building.lighting_peak_load[cte.YEAR][0]/ (1e3),
|
|
'heating_demand_kWh_per_m2' : sum(building.heating_demand[cte.HOUR])/ (3.6e6 * total_floor_area),
|
|
'cooling_demand_kWh_per_m2' : sum(building.cooling_demand[cte.HOUR])/ (3.6e6 * total_floor_area),
|
|
'domestic_hot_water_heat_demand_kWh_per_m2': sum(building.domestic_hot_water_heat_demand[cte.HOUR])/ (3.6e6 * total_floor_area),
|
|
'appliances_electrical_demand_kWh_per_m2':sum(building.appliances_electrical_demand[cte.HOUR])/ (3.6e6 * total_floor_area),
|
|
'lighting_electrical_demand_kWh_per_m2': sum(building.lighting_electrical_demand[cte.HOUR])/ (3.6e6 * total_floor_area),
|
|
'heating_demand_kWh': [x / (cte.WATTS_HOUR_TO_JULES * 1000) for x in building.heating_demand[cte.HOUR]],
|
|
'cooling_demand_kWh':[x / (cte.WATTS_HOUR_TO_JULES * 1000) for x in building.cooling_demand[cte.HOUR]],
|
|
'domestic_hot_water_heat_demand_kWh': [x / (cte.WATTS_HOUR_TO_JULES * 1000) for x in building.domestic_hot_water_heat_demand[cte.HOUR]],
|
|
'appliances_electrical_demand_kWh':[x / (cte.WATTS_HOUR_TO_JULES * 1000) for x in building.appliances_electrical_demand[cte.HOUR]],
|
|
'lighting_electrical_demand_kWh': [x / (cte.WATTS_HOUR_TO_JULES * 1000) for x in building.lighting_electrical_demand[cte.HOUR]]
|
|
}
|
|
buildings_dic={}
|
|
|
|
|
|
for building in city.buildings:
|
|
|
|
total_floor_area = 0
|
|
for thermal_zone in building.thermal_zones_from_internal_zones:
|
|
total_floor_area += thermal_zone.total_floor_area
|
|
print(building.heating_demand[cte.YEAR][0] / (3.6e6 * total_floor_area))
|
|
building.energy_systems_archetype_name = 'system 1 gas'
|
|
buildings_dic[building.name] = to_dict(building,total_floor_area)
|
|
print('test')
|
|
|
|
""""EXPORTERS"""
|
|
import pandas as pd
|
|
# Convert the dictionary to a DataFrame
|
|
df = pd.DataFrame.from_dict(buildings_dic, orient='index')
|
|
|
|
# Export the DataFrame to an Excel file
|
|
excel_file_path = r'C:\Users\a_gabald\PycharmProjects\summer_course_2024\out_files\buildings.xlsx'
|
|
df.to_excel(excel_file_path, index=True, index_label='Building')
|
|
|
|
import json
|
|
|
|
|
|
def make_json_serializable(data):
|
|
if isinstance(data, (str, int, float, bool, type(None))):
|
|
return data
|
|
elif isinstance(data, dict):
|
|
return {k: make_json_serializable(v) for k, v in data.items()}
|
|
elif isinstance(data, list):
|
|
return [make_json_serializable(item) for item in data]
|
|
else:
|
|
return str(data) # Convert any other type to a string
|
|
|
|
# Load the existing GeoJSON file
|
|
|
|
with open(geojson_file_path, 'r') as f:
|
|
geojson_data = json.load(f)
|
|
|
|
# Update the properties of each feature
|
|
for feature in geojson_data['features']:
|
|
# Attempt to retrieve the building_id from 'id' or 'properties'
|
|
building_id = feature.get('id') or feature['properties'].get('id')
|
|
|
|
if building_id in buildings_dic:
|
|
serializable_properties = make_json_serializable(buildings_dic[building_id])
|
|
feature['properties'].update(serializable_properties)
|
|
|
|
# Save the updated GeoJSON to a new file
|
|
updated_geojson_file_path = r'C:\Users\a_gabald\PycharmProjects\summer_course_2024\out_files\updated_buildings.geojson' # Replace with your actual path
|
|
with open(updated_geojson_file_path, 'w') as f:
|
|
json.dump(geojson_data, f, indent=4)
|
|
|
|
|
|
# EnergySystemsFactory('montreal_custom', city).enrich()
|
|
# print('test')
|
|
# for building in city.buildings:
|
|
# energy_systems = building.energy_systems
|
|
# for energy_system in energy_systems:
|
|
# generation_units = energy_system.generation_systems
|
|
# if cte.HEATING in energy_system.demand_types:
|
|
# for generation_unit in generation_units:
|
|
# generation_unit.heat_efficiency = 0.96
|
|
# # for building in city.buildings:
|
|
# # building.function = cte.COMMERCIAL
|
|
# #
|
|
# # ConstructionFactory('nrcan', city).enrich()
|
|
# # UsageFactory('nrcan', city).enrich()
|
|
# # energy_plus_workflow(city)
|
|
# # for building in city.buildings:
|
|
# # print(building.heating_demand[cte.YEAR][0] / 3.6e6)
|
|
# # print(building.name)
|
|
# # total_floor_area = 0
|
|
# # for thermal_zone in building.thermal_zones_from_internal_zones:
|
|
# # total_floor_area += thermal_zone.total_floor_area
|
|
# # print(building.heating_demand[cte.YEAR][0] / (3.6e6 * total_floor_area))
|
|
|
|
|
|
# for building in city.buildings:
|
|
# print(building.name)
|
|
# print(building.year_of_construction)
|
|
# print(building.usages_percentage) |