From 05d88e24616dd14996a104c75a761d1ee8fe5bf7 Mon Sep 17 00:00:00 2001 From: s_ranjbar Date: Mon, 22 Jul 2024 17:37:40 -0400 Subject: [PATCH] fix: small bug is cooling simulation and operational income are fixed fix: simulation models and cop curves modified and finalized fix: all system simulation models are fixed --- energy_system_retrofit.py | 8 +- .../montreal_future_systems.xml | 6 +- hub/imports/geometry/geojson.py | 28 +- input_files/test_geojson1.geojson | 52 +++ main.py | 78 ++-- .../system_simulation_models/archetype1.py | 333 +++++++++++++----- .../system_simulation_models/archetype13.py | 45 ++- .../archetype13_stratified_tes.py | 202 ++++++----- .../archetypes14_15.py | 60 ++-- simulation_result_test.py | 17 +- 10 files changed, 530 insertions(+), 299 deletions(-) create mode 100644 input_files/test_geojson1.geojson diff --git a/energy_system_retrofit.py b/energy_system_retrofit.py index b6b8cd31..e757deb0 100644 --- a/energy_system_retrofit.py +++ b/energy_system_retrofit.py @@ -92,7 +92,9 @@ for building in city.buildings: fuel_tariffs=['Electricity-D', 'Gas-Energir']).life_cycle lcc_dataframe.to_csv(cost_analysis_output_path / f'{building.name}_retrofitted_lcc.csv') retrofitted_life_cycle_cost[f'{building.name}'] = cost_data(building, lcc_dataframe, cost_retrofit_scenario) -(EnergySystemRetrofitReport(city, output_path, 'PV Implementation and System Retrofit', - current_status_energy_consumption, retrofitted_energy_consumption, - current_status_life_cycle_cost, retrofitted_life_cycle_cost).create_report()) +for i in range(12): + dhw_consumption = 0 + for building in city.buildings: + dhw_consumption += building.domestic_hot_water_consumption[cte.MONTH][i] / 3.6e6 + diff --git a/hub/data/energy_systems/montreal_future_systems.xml b/hub/data/energy_systems/montreal_future_systems.xml index b51c9488..3ef396d5 100644 --- a/hub/data/energy_systems/montreal_future_systems.xml +++ b/hub/data/energy_systems/montreal_future_systems.xml @@ -927,7 +927,7 @@ COP source_temperature supply_temperature - + @@ -1052,7 +1052,7 @@ - 3.5 + 3.2 electricity Air @@ -1076,7 +1076,7 @@ COP source_temperature supply_temperature - + diff --git a/hub/imports/geometry/geojson.py b/hub/imports/geometry/geojson.py index 3505c27a..6680b6b6 100644 --- a/hub/imports/geometry/geojson.py +++ b/hub/imports/geometry/geojson.py @@ -129,16 +129,24 @@ class Geojson: function = str(feature['properties'][self._function_field]) if function == 'Mixed use' or function == 'mixed use': function_parts = [] - for key, value in feature['properties'].items(): - if key.startswith("mixed_type_") and not key.endswith("_percentage"): - type_key = key - percentage_key = f"{key}_percentage" - if percentage_key in feature['properties']: - if self._function_to_hub is not None and feature['properties'][type_key] in self._function_to_hub: - usage_function = self._function_to_hub[feature['properties'][type_key]] - function_parts.append(f"{feature['properties'][percentage_key]}-{usage_function}") - else: - function_parts.append(f"{feature['properties'][percentage_key]}-{feature['properties'][type_key]}") + if 'usages' in feature['properties']: + usages = feature['properties']['usages'] + for usage in usages: + if self._function_to_hub is not None and usage['usage'] in self._function_to_hub: + function_parts.append(f"{usage['percentage']}-{self._function_to_hub[usage['usage']]}") + else: + function_parts.append(f"{usage['percentage']}-{usage['usage']}") + else: + for key, value in feature['properties'].items(): + if key.startswith("mixed_type_") and not key.endswith("_percentage"): + type_key = key + percentage_key = f"{key}_percentage" + if percentage_key in feature['properties']: + if self._function_to_hub is not None and feature['properties'][type_key] in self._function_to_hub: + usage_function = self._function_to_hub[feature['properties'][type_key]] + function_parts.append(f"{feature['properties'][percentage_key]}-{usage_function}") + else: + function_parts.append(f"{feature['properties'][percentage_key]}-{feature['properties'][type_key]}") function = "_".join(function_parts) if self._function_to_hub is not None: # use the transformation dictionary to retrieve the proper function diff --git a/input_files/test_geojson1.geojson b/input_files/test_geojson1.geojson new file mode 100644 index 00000000..92307eae --- /dev/null +++ b/input_files/test_geojson1.geojson @@ -0,0 +1,52 @@ +{ + "type": "FeatureCollection", + "features": [ + { + "type": "Feature", + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + -73.58000127109773, + 45.49613461675315 + ], + [ + -73.57962787855432, + 45.496524875557746 + ], + [ + -73.57996357265695, + 45.49668114195629 + ], + [ + -73.57996427397713, + 45.496680342403664 + ], + [ + -73.58034707390021, + 45.49625804233725 + ], + [ + -73.58034697395713, + 45.496257942524835 + ], + [ + -73.58000127109773, + 45.49613461675315 + ] + ] + ] + }, + "id": 179764, + "properties": { + "name": "01119274", + "address": "rue Guy (MTL) 2157", + "function": "Mixed use", + "usages": [{"usage": "commercial", "percentage": 50}, {"usage": "6000", "percentage": 50}], + "height": 62, + "year_of_construction": 1954 + } + } + ] +} \ No newline at end of file diff --git a/main.py b/main.py index edce68d2..431f8e92 100644 --- a/main.py +++ b/main.py @@ -28,7 +28,7 @@ data = {} input_files_path = (Path(__file__).parent / 'input_files') input_files_path.mkdir(parents=True, exist_ok=True) # geojson_file = process_geojson(x=-73.58001358793511, y=45.496445294438715, diff=0.0001) -geojson_file_path = input_files_path / 'test_geojson.geojson' +geojson_file_path = input_files_path / 'test_geojson1.geojson' output_path = (Path(__file__).parent / 'out_files').resolve() output_path.mkdir(parents=True, exist_ok=True) energy_plus_output_path = output_path / 'energy_plus_outputs' @@ -45,42 +45,42 @@ city = GeometryFactory(file_type='geojson', year_of_construction_field='year_of_construction', function_field='function', function_to_hub=Dictionaries().montreal_function_to_hub_function).city -ConstructionFactory('nrcan', city).enrich() -UsageFactory('nrcan', city).enrich() -WeatherFactory('epw', city).enrich() -energy_plus_workflow(city, energy_plus_output_path) -data[f'{city.buildings[0].function}'] = city.buildings[0].heating_demand[cte.YEAR][0] / 3.6e9 -city.buildings[0].function = cte.COMMERCIAL -ConstructionFactory('nrcan', city).enrich() -UsageFactory('nrcan', city).enrich() -energy_plus_workflow(city, energy_plus_output_path) -data[f'{city.buildings[0].function}'] = city.buildings[0].heating_demand[cte.YEAR][0] / 3.6e9 -city.buildings[0].function = cte.MEDIUM_OFFICE -ConstructionFactory('nrcan', city).enrich() -UsageFactory('nrcan', city).enrich() -energy_plus_workflow(city, energy_plus_output_path) -data[f'{city.buildings[0].function}'] = city.buildings[0].heating_demand[cte.YEAR][0] / 3.6e9 -categories = list(data.keys()) -values = list(data.values()) -# Plotting -fig, ax = plt.subplots(figsize=(10, 6), dpi=96) -fig.suptitle('Impact of different usages on yearly heating demand', fontsize=16, weight='bold', alpha=.8) -ax.bar(categories, values, color=['#2196f3', '#ff5a5f', '#4caf50'], width=0.6, zorder=2) -ax.grid(which="major", axis='x', color='#DAD8D7', alpha=0.5, zorder=1) -ax.grid(which="major", axis='y', color='#DAD8D7', alpha=0.5, zorder=1) -ax.set_xlabel('Building Type', fontsize=12, labelpad=10) -ax.set_ylabel('Energy Consumption (MWh)', fontsize=14, labelpad=10) -ax.yaxis.set_major_locator(plt.MaxNLocator(integer=True)) -ax.set_xticks(np.arange(len(categories))) -ax.set_xticklabels(categories, rotation=45, ha='right') -ax.bar_label(ax.containers[0], padding=3, color='black', fontsize=12, rotation=0) -ax.spines[['top', 'left', 'bottom']].set_visible(False) -ax.spines['right'].set_linewidth(1.1) -# Set a white background -fig.patch.set_facecolor('white') -# Adjust the margins around the plot area -plt.subplots_adjust(left=0.1, right=0.9, top=0.85, bottom=0.25) -# Save the plot -plt.savefig('plot_nrcan.png', bbox_inches='tight') -plt.close() +# ConstructionFactory('nrcan', city).enrich() +# UsageFactory('nrcan', city).enrich() +# WeatherFactory('epw', city).enrich() +# energy_plus_workflow(city, energy_plus_output_path) +# data[f'{city.buildings[0].function}'] = city.buildings[0].heating_demand[cte.YEAR][0] / 3.6e9 +# city.buildings[0].function = cte.COMMERCIAL +# ConstructionFactory('nrcan', city).enrich() +# UsageFactory('nrcan', city).enrich() +# energy_plus_workflow(city, energy_plus_output_path) +# data[f'{city.buildings[0].function}'] = city.buildings[0].heating_demand[cte.YEAR][0] / 3.6e9 +# city.buildings[0].function = cte.MEDIUM_OFFICE +# ConstructionFactory('nrcan', city).enrich() +# UsageFactory('nrcan', city).enrich() +# energy_plus_workflow(city, energy_plus_output_path) +# data[f'{city.buildings[0].function}'] = city.buildings[0].heating_demand[cte.YEAR][0] / 3.6e9 +# categories = list(data.keys()) +# values = list(data.values()) +# # Plotting +# fig, ax = plt.subplots(figsize=(10, 6), dpi=96) +# fig.suptitle('Impact of different usages on yearly heating demand', fontsize=16, weight='bold', alpha=.8) +# ax.bar(categories, values, color=['#2196f3', '#ff5a5f', '#4caf50'], width=0.6, zorder=2) +# ax.grid(which="major", axis='x', color='#DAD8D7', alpha=0.5, zorder=1) +# ax.grid(which="major", axis='y', color='#DAD8D7', alpha=0.5, zorder=1) +# ax.set_xlabel('Building Type', fontsize=12, labelpad=10) +# ax.set_ylabel('Energy Consumption (MWh)', fontsize=14, labelpad=10) +# ax.yaxis.set_major_locator(plt.MaxNLocator(integer=True)) +# ax.set_xticks(np.arange(len(categories))) +# ax.set_xticklabels(categories, rotation=45, ha='right') +# ax.bar_label(ax.containers[0], padding=3, color='black', fontsize=12, rotation=0) +# ax.spines[['top', 'left', 'bottom']].set_visible(False) +# ax.spines['right'].set_linewidth(1.1) +# # Set a white background +# fig.patch.set_facecolor('white') +# # Adjust the margins around the plot area +# plt.subplots_adjust(left=0.1, right=0.9, top=0.85, bottom=0.25) +# # Save the plot +# plt.savefig('plot_nrcan.png', bbox_inches='tight') +# plt.close() print('test') \ No newline at end of file diff --git a/scripts/system_simulation_models/archetype1.py b/scripts/system_simulation_models/archetype1.py index 6e8bc4f1..72d91b70 100644 --- a/scripts/system_simulation_models/archetype1.py +++ b/scripts/system_simulation_models/archetype1.py @@ -19,6 +19,8 @@ class Archetype1: self._hourly_dhw_demand = building.domestic_hot_water_heat_demand[cte.HOUR] self._output_path = output_path self._t_out = [0] + building.external_temperature[cte.HOUR] + self.results = {} + self.dt = 900 def hvac_sizing(self): storage_factor = 3 @@ -29,13 +31,26 @@ class Archetype1: heat_pump.nominal_cooling_output = round(self._cooling_peak_load / 3600) boiler.nominal_heat_output = round(0.5 * self._heating_peak_load / 3600) thermal_storage.volume = round( - (self._heating_peak_load * storage_factor) / (cte.WATER_HEAT_CAPACITY * cte.WATER_DENSITY * 30)) + (self._heating_peak_load * storage_factor * cte.WATTS_HOUR_TO_JULES) / + (cte.WATER_HEAT_CAPACITY * cte.WATER_DENSITY * 25)) return heat_pump, boiler, thermal_storage + def dhw_sizing(self): + storage_factor = 3 + dhw_hp = self._dhw_system.generation_systems[0] + dhw_hp.nominal_heat_output = 0.7 * self._domestic_hot_water_peak_load + dhw_hp.source_temperature = self._t_out + dhw_tes = dhw_hp.energy_storage_systems[0] + dhw_tes.volume = round( + (self._domestic_hot_water_peak_load * storage_factor * 3600) / (cte.WATER_HEAT_CAPACITY * cte.WATER_DENSITY * 10)) + return dhw_hp, dhw_tes + def heating_system_simulation(self): hp, boiler, tes = self.hvac_sizing() cop_curve_coefficients = [float(coefficient) for coefficient in hp.heat_efficiency_curve.coefficients] - demand = self._hourly_heating_demand + number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) + demand = [0] + [x for x in self._hourly_heating_demand for _ in range(number_of_ts)] + t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] hp.source_temperature = self._t_out # Heating System Simulation variable_names = ["t_sup_hp", "t_tank", "t_ret", "m_ch", "m_dis", "q_hp", "q_boiler", "hp_cop", @@ -61,7 +76,7 @@ class Archetype1: for i in range(len(demand) - 1): t_tank[i + 1] = (t_tank[i] + ((m_ch[i] * (t_sup_hp[i] - t_tank[i])) + - (ua * (self._t_out[i] - t_tank[i] + 5)) / cte.WATER_HEAT_CAPACITY - + (ua * (t_out[i] - t_tank[i])) / cte.WATER_HEAT_CAPACITY - m_dis[i] * (t_tank[i] - t_ret[i])) * (dt / (cte.WATER_DENSITY * v))) if t_tank[i + 1] < 40: q_hp[i + 1] = hp_heating_cap @@ -77,16 +92,16 @@ class Archetype1: t_sup_hp[i + 1] = (q_hp[i + 1] / (m_ch[i + 1] * cte.WATER_HEAT_CAPACITY)) + t_tank[i + 1] else: q_hp[i + 1], m_ch[i + 1], t_sup_hp[i + 1] = 0, 0, t_tank[i + 1] - t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i + 1] + 32 - t_out_fahrenheit = 1.8 * self._t_out[i + 1] + 32 + t_tank_fahrenheit = 1.8 * t_tank[i + 1] + 32 + t_out_fahrenheit = 1.8 * t_out[i + 1] + 32 if q_hp[i + 1] > 0: - hp_cop[i + 1] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + + hp_cop[i + 1] = (1 / (cop_curve_coefficients[0] + + cop_curve_coefficients[1] * t_tank_fahrenheit + + cop_curve_coefficients[2] * t_tank_fahrenheit ** 2 + cop_curve_coefficients[3] * t_out_fahrenheit + cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) - hp_electricity[i + 1] = q_hp[i + 1] / hp_efficiency + cop_curve_coefficients[5] * t_tank_fahrenheit * t_out_fahrenheit)) * hp_efficiency + hp_electricity[i + 1] = q_hp[i + 1] / hp_cop[i + 1] else: hp_cop[i + 1] = 0 hp_electricity[i + 1] = 0 @@ -110,101 +125,253 @@ class Archetype1: boiler_gas[i + 1] = (q_boiler[i + 1] * dt) / cte.NATURAL_GAS_LHV boiler_consumption[i + 1] = q_boiler[i + 1] / boiler_efficiency heating_consumption[i + 1] = boiler_consumption[i + 1] + hp_electricity[i + 1] - data = list(zip(self._t_out, q_hp, hp_electricity, hp_cop, m_ch, t_sup_hp, t_tank, m_dis, q_boiler, - boiler_gas, t_sup_boiler, t_ret, demand)) - file_name = f'heating_system_simulation_results_{self._name}.csv' - with open(self._output_path / file_name, 'w', newline='') as csvfile: - output_file = csv.writer(csvfile) - # Write header - output_file.writerow(['Outside_air_temperature', 'HP_heat_output(W)', 'HP_heating_electricity_consumption(W)', - 'HP_COP', 'TES_charge_flow_rate(kg/s)', 'TES_supply_temperature(C)', 'TES_temperature(C)', - 'TES_discharge_flow_rate(kg/s)', 'Boiler_heat_output(W)', 'Boiler_gas_consumption(m3)', - 'Boiler_supply_temperature(C)', 'Heating_loop_return_temperature(C)', 'Heating_demand (W)']) - # Write data - output_file.writerows(data) - return heating_consumption, hp_electricity, boiler_consumption, t_sup_hp, t_sup_boiler + tes.temperature = [] + hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] + boiler_consumption_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in boiler_consumption] + hp_hourly = [] + boiler_hourly = [] + boiler_sum = 0 + hp_sum = 0 + for i in range(1, len(demand)): + hp_sum += hp_electricity_j[i] + boiler_sum += boiler_consumption_j[i] + if (i - 1) % number_of_ts == 0: + tes.temperature.append(t_tank[i]) + hp_hourly.append(hp_sum) + boiler_hourly.append(boiler_sum) + hp_sum = 0 + boiler_sum = 0 + hp.energy_consumption[cte.HEATING] = {} + hp.energy_consumption[cte.HEATING][cte.HOUR] = hp_hourly + hp.energy_consumption[cte.HEATING][cte.MONTH] = MonthlyValues.get_total_month( + hp.energy_consumption[cte.HEATING][cte.HOUR]) + hp.energy_consumption[cte.HEATING][cte.YEAR] = [ + sum(hp.energy_consumption[cte.HEATING][cte.MONTH])] + boiler.energy_consumption[cte.HEATING] = {} + boiler.energy_consumption[cte.HEATING][cte.HOUR] = boiler_hourly + boiler.energy_consumption[cte.HEATING][cte.MONTH] = MonthlyValues.get_total_month( + boiler.energy_consumption[cte.HEATING][cte.HOUR]) + boiler.energy_consumption[cte.HEATING][cte.YEAR] = [ + sum(boiler.energy_consumption[cte.HEATING][cte.MONTH])] + self.results['Heating Demand (W)'] = demand + self.results['HP Heat Output (W)'] = q_hp + self.results['HP Source Temperature'] = t_out + self.results['HP Supply Temperature'] = t_sup_hp + self.results['HP COP'] = hp_cop + self.results['HP Electricity Consumption (W)'] = hp_electricity + self.results['Boiler Heat Output (W)'] = q_boiler + self.results['Boiler Supply Temperature'] = t_sup_boiler + self.results['Boiler Gas Consumption'] = boiler_consumption + self.results['TES Temperature'] = t_tank + self.results['TES Charging Flow Rate (kg/s)'] = m_ch + self.results['TES Discharge Flow Rate (kg/s)'] = m_dis + self.results['Heating Loop Return Temperature'] = t_ret + return hp_hourly, boiler_hourly def cooling_system_simulation(self): hp = self.hvac_sizing()[0] eer_curve_coefficients = [float(coefficient) for coefficient in hp.cooling_efficiency_curve.coefficients] cooling_efficiency = float(hp.cooling_efficiency) - demand = self._hourly_cooling_demand + number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) + demand = [0] + [x for x in self._hourly_cooling_demand for _ in range(number_of_ts)] + t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] hp.source_temperature = self._t_out - variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_eer"] + variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_cop"] num_hours = len(demand) variables = {name: [0] * num_hours for name in variable_names} - (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_eer) = [variables[name] for name in variable_names] + (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_cop) = [variables[name] for name in variable_names] t_ret[0] = 13 - dt = 3600 - for i in range(len(demand) - 1): - if demand[i] > 0: - m[i] = self._cooling_peak_load / (cte.WATER_HEAT_CAPACITY * 5 * dt) - if t_ret[i] > 13: - q_hp[i] = hp.nominal_cooling_output - t_sup_hp[i] = t_ret[i] - q_hp[i] / (m[i] * cte.WATER_HEAT_CAPACITY) + + for i in range(1, len(demand)): + if demand[i] > 0.15 * self._cooling_peak_load: + m[i] = hp.nominal_cooling_output / (cte.WATER_HEAT_CAPACITY * 5) + if t_ret[i - 1] >= 13: + if demand[i] < 0.25 * self._cooling_peak_load: + q_hp[i] = 0.25 * hp.nominal_cooling_output + elif demand[i] < 0.5 * self._cooling_peak_load: + q_hp[i] = 0.5 * hp.nominal_cooling_output + else: + q_hp[i] = hp.nominal_cooling_output + t_sup_hp[i] = t_ret[i - 1] - q_hp[i] / (m[i] * cte.WATER_HEAT_CAPACITY) else: q_hp[i] = 0 - t_sup_hp[i] = t_ret[i] - t_ret[i + 1] = t_sup_hp[i] + demand[i] / (m[i] * cte.WATER_HEAT_CAPACITY) + t_sup_hp[i] = t_ret[i - 1] + if m[i] == 0: + t_ret[i] = t_sup_hp[i] + else: + t_ret[i] = t_sup_hp[i] + demand[i] / (m[i] * cte.WATER_HEAT_CAPACITY) else: m[i] = 0 q_hp[i] = 0 - t_sup_hp[i] = t_ret[i] - t_ret[i + 1] = t_ret[i] + t_sup_hp[i] = t_ret[i - 1] + t_ret[i] = t_ret[i - 1] t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i] + 32 - t_out_fahrenheit = 1.8 * self._t_out[i] + 32 + t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: - hp_eer[i] = 1/((eer_curve_coefficients[0] + - eer_curve_coefficients[1] * t_sup_hp_fahrenheit + - eer_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + - eer_curve_coefficients[3] * t_out_fahrenheit + - eer_curve_coefficients[4] * t_out_fahrenheit ** 2 + - eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit)) + hp_cop[i] = (1 / (eer_curve_coefficients[0] + + eer_curve_coefficients[1] * t_sup_hp_fahrenheit + + eer_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + + eer_curve_coefficients[3] * t_out_fahrenheit + + eer_curve_coefficients[4] * t_out_fahrenheit ** 2 + + eer_curve_coefficients[ + 5] * t_sup_hp_fahrenheit * t_out_fahrenheit)) * cooling_efficiency / 3.41 hp_electricity[i] = q_hp[i] / cooling_efficiency else: - hp_eer[i] = 0 + hp_cop[i] = 0 + hp_electricity[i] = 0 + hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] + hp_hourly = [] + hp_sum = 0 + for i in range(1, len(demand)): + hp_sum += hp_electricity_j[i] + if (i - 1) % number_of_ts == 0: + hp_hourly.append(hp_sum) + hp_sum = 0 + hp.energy_consumption[cte.COOLING] = {} + hp.energy_consumption[cte.COOLING][cte.HOUR] = hp_hourly + hp.energy_consumption[cte.COOLING][cte.MONTH] = MonthlyValues.get_total_month( + hp.energy_consumption[cte.COOLING][cte.HOUR]) + hp.energy_consumption[cte.COOLING][cte.YEAR] = [ + sum(hp.energy_consumption[cte.COOLING][cte.MONTH])] + self.results['Cooling Demand (W)'] = demand + self.results['HP Cooling Output (W)'] = q_hp + self.results['HP Cooling Supply Temperature'] = t_sup_hp + self.results['HP Cooling COP'] = hp_cop + self.results['HP Electricity Consumption'] = hp_electricity + self.results['Cooling Loop Flow Rate (kg/s)'] = m + self.results['Cooling Loop Return Temperature'] = t_ret + return hp_hourly + + def dhw_system_simulation(self): + hp, tes = self.dhw_sizing() + cop_curve_coefficients = [float(coefficient) for coefficient in hp.heat_efficiency_curve.coefficients] + number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) + demand = [0] + [x for x in self._hourly_dhw_demand for _ in range(number_of_ts)] + t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] + variable_names = ["t_sup_hp", "t_tank", "m_ch", "m_dis", "q_hp", "q_coil", "hp_cop", + "hp_electricity", "available hot water (m3)", "refill flow rate (kg/s)"] + num_hours = len(demand) + variables = {name: [0] * num_hours for name in variable_names} + (t_sup_hp, t_tank, m_ch, m_dis, m_refill, q_hp, q_coil, hp_cop, hp_electricity, v_dhw) = \ + [variables[name] for name in variable_names] + t_tank[0] = 70 + v_dhw[0] = tes.volume + + hp_heating_cap = hp.nominal_heat_output + hp_delta_t = 8 + v, h = float(tes.volume), float(tes.height) + r_tot = sum(float(layer.thickness) / float(layer.material.conductivity) for layer in + tes.layers) + u_tot = 1 / r_tot + d = math.sqrt((4 * v) / (math.pi * h)) + a_side = math.pi * d * h + a_top = math.pi * d ** 2 / 4 + ua = u_tot * (2 * a_top + a_side) + freshwater_temperature = 18 + for i in range(len(demand) - 1): + delta_t_demand = demand[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) + if t_tank[i] < 62: + q_hp[i] = hp_heating_cap + delta_t_hp = q_hp[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) + if demand[i] > 0: + dhw_needed = (demand[i] * cte.HOUR_TO_SECONDS) / (cte.WATER_HEAT_CAPACITY * t_tank[i] * cte.WATER_DENSITY) + m_dis[i] = dhw_needed * cte.WATER_DENSITY / cte.HOUR_TO_SECONDS + m_refill[i] = m_dis[i] + delta_t_freshwater = m_refill[i] * (t_tank[i] - freshwater_temperature) * (self.dt / (v * cte.WATER_DENSITY)) + if t_tank[i] < 60: + q_coil[i] = float(tes.heating_coil_capacity) + delta_t_coil = q_coil[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) + + if q_hp[i] > 0: + m_ch[i] = q_hp[i] / (cte.WATER_HEAT_CAPACITY * hp_delta_t) + t_sup_hp[i] = (q_hp[i] / (m_ch[i] * cte.WATER_HEAT_CAPACITY)) + t_tank[i] + else: + m_ch[i] = 0 + t_sup_hp[i] = t_tank[i] + t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i] + 32 + t_out_fahrenheit = 1.8 * t_out[i] + 32 + if q_hp[i] > 0: + hp_cop[i] = (cop_curve_coefficients[0] + + cop_curve_coefficients[1] * t_out[i] + + cop_curve_coefficients[2] * t_out[i] ** 2 + + cop_curve_coefficients[3] * t_tank[i] + + cop_curve_coefficients[4] * t_tank[i] ** 2 + + cop_curve_coefficients[5] * t_tank[i] * t_out[i]) * float(hp.heat_efficiency) + hp_electricity[i] = q_hp[i] / hp_cop[i] + else: + hp_cop[i] = 0 hp_electricity[i] = 0 - data = list(zip(q_hp, hp_electricity, hp_eer, m, t_sup_hp, t_ret, demand, self._t_out)) - file_name = f'cooling_system_simulation_results_{self._name}.csv' + t_tank[i + 1] = t_tank[i] + (delta_t_hp - delta_t_freshwater - delta_t_demand + delta_t_coil) + tes.temperature = [] + hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] + heating_coil_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in q_coil] + hp_hourly = [] + coil_hourly = [] + coil_sum = 0 + hp_sum = 0 + for i in range(1, len(demand)): + hp_sum += hp_electricity_j[i] + coil_sum += heating_coil_j[i] + if (i - 1) % number_of_ts == 0: + tes.temperature.append(t_tank[i]) + hp_hourly.append(hp_sum) + coil_hourly.append(coil_sum) + hp_sum = 0 + coil_sum = 0 + + hp.energy_consumption[cte.DOMESTIC_HOT_WATER] = {} + hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.HOUR] = hp_hourly + hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.MONTH] = MonthlyValues.get_total_month( + hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.HOUR]) + hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.YEAR] = [ + sum(hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.MONTH])] + tes.heating_coil_energy_consumption = {} + tes.heating_coil_energy_consumption[cte.HOUR] = coil_hourly + tes.heating_coil_energy_consumption[cte.MONTH] = MonthlyValues.get_total_month( + tes.heating_coil_energy_consumption[cte.HOUR]) + tes.heating_coil_energy_consumption[cte.YEAR] = [ + sum(tes.heating_coil_energy_consumption[cte.MONTH])] + tes.temperature = t_tank + + self.results['DHW Demand (W)'] = demand + self.results['DHW HP Heat Output (W)'] = q_hp + self.results['DHW HP Electricity Consumption (W)'] = hp_electricity + self.results['DHW HP Source Temperature'] = t_out + self.results['DHW HP Supply Temperature'] = t_sup_hp + self.results['DHW HP COP'] = hp_cop + self.results['DHW TES Heating Coil Heat Output (W)'] = q_coil + self.results['DHW TES Temperature'] = t_tank + self.results['DHW TES Charging Flow Rate (kg/s)'] = m_ch + self.results['DHW Flow Rate (kg/s)'] = m_dis + self.results['DHW TES Refill Flow Rate (kg/s)'] = m_refill + self.results['Available Water in Tank (m3)'] = v_dhw + return hp_hourly, coil_hourly + + def enrich_buildings(self): + hp_heating, boiler_consumption = self.heating_system_simulation() + hp_cooling = self.cooling_system_simulation() + hp_dhw, heating_coil = self.dhw_system_simulation() + heating_consumption = [hp_heating[i] + boiler_consumption[i] for i in range(len(hp_heating))] + dhw_consumption = [hp_dhw[i] + heating_coil[i] for i in range(len(hp_dhw))] + self._building.heating_consumption[cte.HOUR] = heating_consumption + self._building.heating_consumption[cte.MONTH] = ( + MonthlyValues.get_total_month(self._building.heating_consumption[cte.HOUR])) + self._building.heating_consumption[cte.YEAR] = [sum(self._building.heating_consumption[cte.MONTH])] + self._building.cooling_consumption[cte.HOUR] = hp_cooling + self._building.cooling_consumption[cte.MONTH] = ( + MonthlyValues.get_total_month(self._building.cooling_consumption[cte.HOUR])) + self._building.cooling_consumption[cte.YEAR] = [sum(self._building.cooling_consumption[cte.MONTH])] + self._building.domestic_hot_water_consumption[cte.HOUR] = dhw_consumption + self._building.domestic_hot_water_consumption[cte.MONTH] = ( + MonthlyValues.get_total_month(self._building.domestic_hot_water_consumption[cte.HOUR])) + self._building.domestic_hot_water_consumption[cte.YEAR] = [ + sum(self._building.domestic_hot_water_consumption[cte.MONTH])] + file_name = f'energy_system_simulation_results_{self._name}.csv' with open(self._output_path / file_name, 'w', newline='') as csvfile: output_file = csv.writer(csvfile) # Write header - output_file.writerow(['HP_cooling_output (W)', 'HP_cooling_electricity_consumption (W)', 'HP_EER', - 'Cooling_loop_flow_rate(kg/s)', 'Cooling_supply_temperature(C)', - 'Cooling_loop_return_temperature(C)', 'Cooling_demand (W)', 'Outside_Air_Temperature']) + output_file.writerow(self.results.keys()) # Write data - output_file.writerows(data) - return hp_electricity, t_sup_hp + output_file.writerows(zip(*self.results.values())) - - def enrich_buildings(self): - (self._building.heating_consumption[cte.HOUR], hp_electricity_heating, - boiler_consumption, t_sup_hp, t_sup_boiler) = self.heating_system_simulation() - hp_electricity_cooling, t_sup_hp_cooling = self.cooling_system_simulation() - self._building.heating_consumption[cte.MONTH] = MonthlyValues.get_total_month( - self._building.heating_consumption[cte.HOUR]) - self._building.heating_consumption[cte.YEAR] = [sum(self._building.heating_consumption[cte.MONTH])] - self._hvac_system.generation_systems[0].energy_consumption[cte.HEATING] = {} - self._hvac_system.generation_systems[1].energy_consumption[cte.HEATING] = {} - self._hvac_system.generation_systems[0].energy_consumption[cte.HEATING][cte.HOUR] = hp_electricity_heating - self._hvac_system.generation_systems[0].energy_consumption[cte.HEATING][cte.MONTH] = MonthlyValues.get_total_month( - self._hvac_system.generation_systems[0].energy_consumption[cte.HEATING][cte.HOUR]) - self._hvac_system.generation_systems[0].energy_consumption[cte.HEATING][cte.YEAR] = \ - [sum(self._hvac_system.generation_systems[0].energy_consumption[cte.HEATING][cte.MONTH])] - self._hvac_system.generation_systems[1].energy_consumption[cte.HEATING][cte.HOUR] = boiler_consumption - self._hvac_system.generation_systems[1].energy_consumption[cte.HEATING][cte.MONTH] = MonthlyValues.get_total_month( - self._hvac_system.generation_systems[1].energy_consumption[cte.HEATING][cte.HOUR]) - self._hvac_system.generation_systems[1].energy_consumption[cte.HEATING][cte.YEAR] = \ - [sum(self._hvac_system.generation_systems[1].energy_consumption[cte.HEATING][cte.MONTH])] - self._hvac_system.generation_systems[0].heat_supply_temperature = t_sup_hp - self._hvac_system.generation_systems[1].heat_supply_temperature = t_sup_boiler - self._hvac_system.generation_systems[0].energy_consumption[cte.COOLING] = {} - self._hvac_system.generation_systems[0].energy_consumption[cte.COOLING][cte.HOUR] = hp_electricity_cooling - self._hvac_system.generation_systems[0].energy_consumption[cte.COOLING][cte.MONTH] = MonthlyValues.get_total_month( - self._hvac_system.generation_systems[0].energy_consumption[cte.COOLING][cte.HOUR]) - self._hvac_system.generation_systems[0].energy_consumption[cte.COOLING][cte.YEAR] = \ - [sum(self._hvac_system.generation_systems[0].energy_consumption[cte.COOLING][cte.MONTH])] - self._hvac_system.generation_systems[0].cooling_supply_temperature = t_sup_hp_cooling - self._dhw_system.generation_systems[0].energy_consumption[cte.DOMESTIC_HOT_WATER] = ( - self._building.domestic_hot_water_consumption) diff --git a/scripts/system_simulation_models/archetype13.py b/scripts/system_simulation_models/archetype13.py index aa9c03bd..642bfca4 100644 --- a/scripts/system_simulation_models/archetype13.py +++ b/scripts/system_simulation_models/archetype13.py @@ -66,6 +66,7 @@ class Archetype13: [variables[name] for name in variable_names] t_tank[0] = 55 hp_heating_cap = hp.nominal_heat_output + hp_efficiency = float(hp.heat_efficiency) boiler_heating_cap = boiler.nominal_heat_output hp_delta_t = 5 boiler_efficiency = float(boiler.heat_efficiency) @@ -98,15 +99,15 @@ class Archetype13: t_sup_hp[i + 1] = (q_hp[i + 1] / (m_ch[i + 1] * cte.WATER_HEAT_CAPACITY)) + t_tank[i + 1] else: q_hp[i + 1], m_ch[i + 1], t_sup_hp[i + 1] = 0, 0, t_tank[i + 1] - t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i + 1] + 32 + t_tank_fahrenheit = 1.8 * t_tank[i + 1] + 32 t_out_fahrenheit = 1.8 * t_out[i + 1] + 32 if q_hp[i + 1] > 0: - hp_cop[i + 1] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + + hp_cop[i + 1] = (1 / (cop_curve_coefficients[0] + + cop_curve_coefficients[1] * t_tank_fahrenheit + + cop_curve_coefficients[2] * t_tank_fahrenheit ** 2 + cop_curve_coefficients[3] * t_out_fahrenheit + cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + cop_curve_coefficients[5] * t_tank_fahrenheit * t_out_fahrenheit)) * hp_efficiency hp_electricity[i + 1] = q_hp[i + 1] / hp_cop[i + 1] else: hp_cop[i + 1] = 0 @@ -183,10 +184,10 @@ class Archetype13: demand = [0] + [x for x in self._hourly_cooling_demand for _ in range(number_of_ts)] t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] hp.source_temperature = self._t_out - variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_eer"] + variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_cop"] num_hours = len(demand) variables = {name: [0] * num_hours for name in variable_names} - (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_eer) = [variables[name] for name in variable_names] + (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_cop) = [variables[name] for name in variable_names] t_ret[0] = 13 for i in range(1, len(demand)): @@ -215,15 +216,15 @@ class Archetype13: t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i] + 32 t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: - hp_eer[i] = (eer_curve_coefficients[0] + + hp_cop[i] = (1 / (eer_curve_coefficients[0] + eer_curve_coefficients[1] * t_sup_hp_fahrenheit + eer_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + eer_curve_coefficients[3] * t_out_fahrenheit + eer_curve_coefficients[4] * t_out_fahrenheit ** 2 + - eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit)) * cooling_efficiency / 3.41 hp_electricity[i] = q_hp[i] / cooling_efficiency else: - hp_eer[i] = 0 + hp_cop[i] = 0 hp_electricity[i] = 0 hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] hp_hourly = [] @@ -242,7 +243,7 @@ class Archetype13: self.results['Cooling Demand (W)'] = demand self.results['HP Cooling Output (W)'] = q_hp self.results['HP Cooling Supply Temperature'] = t_sup_hp - self.results['HP Cooling COP'] = hp_eer + self.results['HP Cooling COP'] = hp_cop self.results['HP Electricity Consumption'] = hp_electricity self.results['Cooling Loop Flow Rate (kg/s)'] = m self.results['Cooling Loop Return Temperature'] = t_ret @@ -276,7 +277,7 @@ class Archetype13: freshwater_temperature = 18 for i in range(len(demand) - 1): delta_t_demand = demand[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) - if t_tank[i] < 65: + if t_tank[i] < 62: q_hp[i] = hp_heating_cap delta_t_hp = q_hp[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) if demand[i] > 0: @@ -284,14 +285,8 @@ class Archetype13: m_dis[i] = dhw_needed * cte.WATER_DENSITY / cte.HOUR_TO_SECONDS m_refill[i] = m_dis[i] delta_t_freshwater = m_refill[i] * (t_tank[i] - freshwater_temperature) * (self.dt / (v * cte.WATER_DENSITY)) - diff = delta_t_freshwater + delta_t_demand - delta_t_hp - if diff > 0: - if diff > 0: - power = diff * (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v) / self.dt - if power <= float(tes.heating_coil_capacity): - q_coil[i] = power - else: - q_coil[i] = float(tes.heating_coil_capacity) + if t_tank[i] < 60: + q_coil[i] = float(tes.heating_coil_capacity) delta_t_coil = q_coil[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) if q_hp[i] > 0: @@ -304,11 +299,11 @@ class Archetype13: t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: hp_cop[i] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + - cop_curve_coefficients[3] * t_out_fahrenheit + - cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + cop_curve_coefficients[1] * t_out[i] + + cop_curve_coefficients[2] * t_out[i] ** 2 + + cop_curve_coefficients[3] * t_tank[i] + + cop_curve_coefficients[4] * t_tank[i] ** 2 + + cop_curve_coefficients[5] * t_tank[i] * t_out[i]) * float(hp.heat_efficiency) hp_electricity[i] = q_hp[i] / hp_cop[i] else: hp_cop[i] = 0 diff --git a/scripts/system_simulation_models/archetype13_stratified_tes.py b/scripts/system_simulation_models/archetype13_stratified_tes.py index c5bdd1e7..632ed304 100644 --- a/scripts/system_simulation_models/archetype13_stratified_tes.py +++ b/scripts/system_simulation_models/archetype13_stratified_tes.py @@ -24,6 +24,7 @@ class Archetype13Stratified: self._output_path = output_path self._t_out = building.external_temperature[cte.HOUR] self.results = {} + self.dt = 300 def hvac_sizing(self): storage_factor = 3 @@ -49,6 +50,7 @@ class Archetype13Stratified: def heating_system_simulation_stratified(self): hp, boiler, tes = self.hvac_sizing() + hp_efficiency = float(hp.heat_efficiency) cop_curve_coefficients = [float(coefficient) for coefficient in hp.heat_efficiency_curve.coefficients] demand = [0] + [x for x in self._hourly_heating_demand for _ in range(12)] hp.source_temperature = self._t_out @@ -114,15 +116,15 @@ class Archetype13Stratified: t_sup_hp[i + 1] = (q_hp[i + 1] / (m_ch[i + 1] * cte.WATER_HEAT_CAPACITY)) + t4[i + 1] else: q_hp[i + 1], m_ch[i + 1], t_sup_hp[i + 1] = 0, 0, t4[i + 1] - t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i + 1] + 32 + t_tank_fahrenheit = 1.8 * t4[i + 1] + 32 t_out_fahrenheit = 1.8 * t_out[i + 1] + 32 if q_hp[i + 1] > 0: - hp_cop[i + 1] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + + hp_cop[i + 1] = (1 / (cop_curve_coefficients[0] + + cop_curve_coefficients[1] * t_tank_fahrenheit + + cop_curve_coefficients[2] * t_tank_fahrenheit ** 2 + cop_curve_coefficients[3] * t_out_fahrenheit + cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + cop_curve_coefficients[5] * t_tank_fahrenheit * t_out_fahrenheit)) * hp_efficiency hp_electricity[i + 1] = q_hp[i + 1] / hp_cop[i + 1] else: hp_cop[i + 1] = 0 @@ -211,66 +213,81 @@ class Archetype13Stratified: hp = self.hvac_sizing()[0] eer_curve_coefficients = [float(coefficient) for coefficient in hp.cooling_efficiency_curve.coefficients] cooling_efficiency = float(hp.cooling_efficiency) - demand = self._hourly_cooling_demand + number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) + demand = [0] + [x for x in self._hourly_cooling_demand for _ in range(number_of_ts)] + t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] hp.source_temperature = self._t_out - variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_eer"] + variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_cop"] num_hours = len(demand) variables = {name: [0] * num_hours for name in variable_names} - (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_eer) = [variables[name] for name in variable_names] + (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_cop) = [variables[name] for name in variable_names] t_ret[0] = 13 - dt = 3600 - for i in range(len(demand) - 1): - if demand[i] > 0: - m[i] = self._cooling_peak_load / (cte.WATER_HEAT_CAPACITY * 5 * dt) - if t_ret[i] > 13: - if demand[i] < 0.25 * self._cooling_peak_load / dt: + + for i in range(1, len(demand)): + if demand[i] > 0.15 * self._cooling_peak_load: + m[i] = hp.nominal_cooling_output / (cte.WATER_HEAT_CAPACITY * 5) + if t_ret[i - 1] >= 13: + if demand[i] < 0.25 * self._cooling_peak_load: q_hp[i] = 0.25 * hp.nominal_cooling_output - elif demand[i] < 0.5 * self._cooling_peak_load / dt: + elif demand[i] < 0.5 * self._cooling_peak_load: q_hp[i] = 0.5 * hp.nominal_cooling_output else: q_hp[i] = hp.nominal_cooling_output - t_sup_hp[i] = t_ret[i] - q_hp[i] / (m[i] * cte.WATER_HEAT_CAPACITY) + t_sup_hp[i] = t_ret[i - 1] - q_hp[i] / (m[i] * cte.WATER_HEAT_CAPACITY) else: q_hp[i] = 0 - t_sup_hp[i] = t_ret[i] - t_ret[i + 1] = t_sup_hp[i] + demand[i] / (m[i] * cte.WATER_HEAT_CAPACITY) + t_sup_hp[i] = t_ret[i - 1] + if m[i] == 0: + t_ret[i] = t_sup_hp[i] + else: + t_ret[i] = t_sup_hp[i] + demand[i] / (m[i] * cte.WATER_HEAT_CAPACITY) else: m[i] = 0 q_hp[i] = 0 - t_sup_hp[i] = t_ret[i] - t_ret[i + 1] = t_ret[i] + t_sup_hp[i] = t_ret[i - 1] + t_ret[i] = t_ret[i - 1] t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i] + 32 - t_out_fahrenheit = 1.8 * self._t_out[i] + 32 + t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: - hp_eer[i] = (eer_curve_coefficients[0] + + hp_cop[i] = (1 / (eer_curve_coefficients[0] + eer_curve_coefficients[1] * t_sup_hp_fahrenheit + eer_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + eer_curve_coefficients[3] * t_out_fahrenheit + eer_curve_coefficients[4] * t_out_fahrenheit ** 2 + - eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit)) * cooling_efficiency / 3.41 hp_electricity[i] = q_hp[i] / cooling_efficiency else: - hp_eer[i] = 0 + hp_cop[i] = 0 hp_electricity[i] = 0 + hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] + hp_hourly = [] + hp_sum = 0 + for i in range(1, len(demand)): + hp_sum += hp_electricity_j[i] + if (i - 1) % number_of_ts == 0: + hp_hourly.append(hp_sum) + hp_sum = 0 hp.energy_consumption[cte.COOLING] = {} - hp.energy_consumption[cte.COOLING][cte.HOUR] = hp_electricity + hp.energy_consumption[cte.COOLING][cte.HOUR] = hp_hourly hp.energy_consumption[cte.COOLING][cte.MONTH] = MonthlyValues.get_total_month( hp.energy_consumption[cte.COOLING][cte.HOUR]) hp.energy_consumption[cte.COOLING][cte.YEAR] = [ sum(hp.energy_consumption[cte.COOLING][cte.MONTH])] - # self.results['Cooling Demand (W)'] = demand - # self.results['HP Cooling Output (W)'] = q_hp - # self.results['HP Cooling Supply Temperature'] = t_sup_hp - # self.results['HP Cooling COP'] = hp_eer - # self.results['HP Electricity Consumption'] = hp_electricity - # self.results['Cooling Loop Flow Rate (kg/s)'] = m - # self.results['Cooling Loop Return Temperature'] = t_ret - return hp_electricity + self.results['Cooling Demand (W)'] = demand + self.results['HP Cooling Output (W)'] = q_hp + self.results['HP Cooling Supply Temperature'] = t_sup_hp + self.results['HP Cooling COP'] = hp_cop + self.results['HP Electricity Consumption'] = hp_electricity + self.results['Cooling Loop Flow Rate (kg/s)'] = m + self.results['Cooling Loop Return Temperature'] = t_ret + return hp_hourly def dhw_system_simulation(self): hp, tes = self.dhw_sizing() cop_curve_coefficients = [float(coefficient) for coefficient in hp.heat_efficiency_curve.coefficients] - demand = self._hourly_dhw_demand + number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) + demand = [0] + [x for x in self._hourly_dhw_demand for _ in range(number_of_ts)] + t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] variable_names = ["t_sup_hp", "t_tank", "m_ch", "m_dis", "q_hp", "q_coil", "hp_cop", "hp_electricity", "available hot water (m3)", "refill flow rate (kg/s)"] num_hours = len(demand) @@ -279,7 +296,7 @@ class Archetype13Stratified: [variables[name] for name in variable_names] t_tank[0] = 70 v_dhw[0] = tes.volume - dt = 3600 + hp_heating_cap = hp.nominal_heat_output hp_delta_t = 8 v, h = float(tes.volume), float(tes.height) @@ -292,26 +309,18 @@ class Archetype13Stratified: ua = u_tot * (2 * a_top + a_side) freshwater_temperature = 18 for i in range(len(demand) - 1): - delta_t_demand = demand[i] * (dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) - if t_tank[i] < 65: + delta_t_demand = demand[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) + if t_tank[i] < 62: q_hp[i] = hp_heating_cap - delta_t_hp = q_hp[i] * (dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) + delta_t_hp = q_hp[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) if demand[i] > 0: dhw_needed = (demand[i] * cte.HOUR_TO_SECONDS) / (cte.WATER_HEAT_CAPACITY * t_tank[i] * cte.WATER_DENSITY) m_dis[i] = dhw_needed * cte.WATER_DENSITY / cte.HOUR_TO_SECONDS m_refill[i] = m_dis[i] - delta_t_freshwater = m_refill[i] * (t_tank[i] - freshwater_temperature) * (dt / (v * cte.WATER_DENSITY)) - diff = delta_t_freshwater + delta_t_demand - delta_t_hp - if diff > 0: - if diff > 0: - power = diff * (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v) / dt - if power <= float(tes.heating_coil_capacity): - q_coil[i] = power - else: - q_coil[i] = float(tes.heating_coil_capacity) - elif t_tank[i] < 65: - q_coil[i] = float(tes.heating_coil_capacity) - delta_t_coil = q_coil[i] * (dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) + delta_t_freshwater = m_refill[i] * (t_tank[i] - freshwater_temperature) * (self.dt / (v * cte.WATER_DENSITY)) + if t_tank[i] < 60: + q_coil[i] = float(tes.heating_coil_capacity) + delta_t_coil = q_coil[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) if q_hp[i] > 0: m_ch[i] = q_hp[i] / (cte.WATER_HEAT_CAPACITY * hp_delta_t) @@ -320,69 +329,84 @@ class Archetype13Stratified: m_ch[i] = 0 t_sup_hp[i] = t_tank[i] t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i] + 32 - t_out_fahrenheit = 1.8 * self._t_out[i] + 32 + t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: hp_cop[i] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + - cop_curve_coefficients[3] * t_out_fahrenheit + - cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) - hp_electricity[i] = q_hp[i] / 3.5 + cop_curve_coefficients[1] * t_out[i] + + cop_curve_coefficients[2] * t_out[i] ** 2 + + cop_curve_coefficients[3] * t_tank[i] + + cop_curve_coefficients[4] * t_tank[i] ** 2 + + cop_curve_coefficients[5] * t_tank[i] * t_out[i]) * float(hp.heat_efficiency) + hp_electricity[i] = q_hp[i] / hp_cop[i] else: hp_cop[i] = 0 hp_electricity[i] = 0 t_tank[i + 1] = t_tank[i] + (delta_t_hp - delta_t_freshwater - delta_t_demand + delta_t_coil) + tes.temperature = [] + hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] + heating_coil_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in q_coil] + hp_hourly = [] + coil_hourly = [] + coil_sum = 0 + hp_sum = 0 + for i in range(1, len(demand)): + hp_sum += hp_electricity_j[i] + coil_sum += heating_coil_j[i] + if (i - 1) % number_of_ts == 0: + tes.temperature.append(t_tank[i]) + hp_hourly.append(hp_sum) + coil_hourly.append(coil_sum) + hp_sum = 0 + coil_sum = 0 hp.energy_consumption[cte.DOMESTIC_HOT_WATER] = {} - hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.HOUR] = hp_electricity + hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.HOUR] = hp_hourly hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.MONTH] = MonthlyValues.get_total_month( hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.HOUR]) hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.YEAR] = [ sum(hp.energy_consumption[cte.DOMESTIC_HOT_WATER][cte.MONTH])] tes.heating_coil_energy_consumption = {} - tes.heating_coil_energy_consumption[cte.HOUR] = q_coil + tes.heating_coil_energy_consumption[cte.HOUR] = coil_hourly tes.heating_coil_energy_consumption[cte.MONTH] = MonthlyValues.get_total_month( tes.heating_coil_energy_consumption[cte.HOUR]) tes.heating_coil_energy_consumption[cte.YEAR] = [ sum(tes.heating_coil_energy_consumption[cte.MONTH])] tes.temperature = t_tank - - # self.results['DHW Demand (W)'] = demand - # self.results['DHW HP Heat Output (W)'] = q_hp - # self.results['DHW HP Electricity Consumption (W)'] = hp_electricity - # self.results['DHW HP Source Temperature'] = self._t_out - # self.results['DHW HP Supply Temperature'] = t_sup_hp - # self.results['DHW HP COP'] = hp_cop - # self.results['DHW TES Heating Coil Heat Output (W)'] = q_coil - # self.results['DHW TES Temperature'] = t_tank - # self.results['DHW TES Charging Flow Rate (kg/s)'] = m_ch - # self.results['DHW Flow Rate (kg/s)'] = m_dis - # self.results['DHW TES Refill Flow Rate (kg/s)'] = m_refill - # self.results['Available Water in Tank (m3)'] = v_dhw - return hp_electricity, q_coil + self.results['DHW Demand (W)'] = demand + self.results['DHW HP Heat Output (W)'] = q_hp + self.results['DHW HP Electricity Consumption (W)'] = hp_electricity + self.results['DHW HP Source Temperature'] = t_out + self.results['DHW HP Supply Temperature'] = t_sup_hp + self.results['DHW HP COP'] = hp_cop + self.results['DHW TES Heating Coil Heat Output (W)'] = q_coil + self.results['DHW TES Temperature'] = t_tank + self.results['DHW TES Charging Flow Rate (kg/s)'] = m_ch + self.results['DHW Flow Rate (kg/s)'] = m_dis + self.results['DHW TES Refill Flow Rate (kg/s)'] = m_refill + self.results['Available Water in Tank (m3)'] = v_dhw + return hp_hourly, coil_hourly def enrich_buildings(self): hp_heating, boiler_consumption = self.heating_system_simulation_stratified() - # hp_cooling = self.cooling_system_simulation() - # hp_dhw, heating_coil = self.dhw_system_simulation() + hp_cooling = self.cooling_system_simulation() + hp_dhw, heating_coil = self.dhw_system_simulation() heating_consumption = [hp_heating[i] + boiler_consumption[i] for i in range(len(hp_heating))] - # dhw_consumption = [hp_dhw[i] + heating_coil[i] for i in range(len(hp_dhw))] - # self._building.heating_consumption[cte.HOUR] = heating_consumption - # self._building.heating_consumption[cte.MONTH] = ( - # MonthlyValues.get_total_month(self._building.heating_consumption[cte.HOUR])) - # self._building.heating_consumption[cte.YEAR] = sum(self._building.heating_consumption[cte.MONTH]) - # self._building.cooling_consumption[cte.HOUR] = hp_cooling - # self._building.cooling_consumption[cte.MONTH] = ( - # MonthlyValues.get_total_month(self._building.cooling_consumption[cte.HOUR])) - # self._building.cooling_consumption[cte.YEAR] = sum(self._building.cooling_consumption[cte.MONTH]) - # self._building.domestic_hot_water_consumption[cte.HOUR] = dhw_consumption - # self._building.domestic_hot_water_consumption[cte.MONTH] = ( - # MonthlyValues.get_total_month(self._building.domestic_hot_water_consumption[cte.HOUR])) - # self._building.domestic_hot_water_consumption[cte.YEAR] = ( - # sum(self._building.domestic_hot_water_consumption[cte.MONTH])) + dhw_consumption = [hp_dhw[i] + heating_coil[i] for i in range(len(hp_dhw))] + self._building.heating_consumption[cte.HOUR] = heating_consumption + self._building.heating_consumption[cte.MONTH] = ( + MonthlyValues.get_total_month(self._building.heating_consumption[cte.HOUR])) + self._building.heating_consumption[cte.YEAR] = sum(self._building.heating_consumption[cte.MONTH]) + self._building.cooling_consumption[cte.HOUR] = hp_cooling + self._building.cooling_consumption[cte.MONTH] = ( + MonthlyValues.get_total_month(self._building.cooling_consumption[cte.HOUR])) + self._building.cooling_consumption[cte.YEAR] = sum(self._building.cooling_consumption[cte.MONTH]) + self._building.domestic_hot_water_consumption[cte.HOUR] = dhw_consumption + self._building.domestic_hot_water_consumption[cte.MONTH] = ( + MonthlyValues.get_total_month(self._building.domestic_hot_water_consumption[cte.HOUR])) + self._building.domestic_hot_water_consumption[cte.YEAR] = ( + sum(self._building.domestic_hot_water_consumption[cte.MONTH])) file_name = f'energy_system_simulation_results_{self._name}.csv' with open(self._output_path / file_name, 'w', newline='') as csvfile: output_file = csv.writer(csvfile) diff --git a/scripts/system_simulation_models/archetypes14_15.py b/scripts/system_simulation_models/archetypes14_15.py index e3cf52d1..cc5f8d6a 100644 --- a/scripts/system_simulation_models/archetypes14_15.py +++ b/scripts/system_simulation_models/archetypes14_15.py @@ -64,6 +64,7 @@ class Archetype14_15: def heating_system_simulation(self): hp, boiler, tes = self.heating_system_sizing() + hp_efficiency = float(hp.heat_efficiency) cop_curve_coefficients = [float(coefficient) for coefficient in hp.heat_efficiency_curve.coefficients] number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) demand = [0] + [x for x in self._hourly_heating_demand for _ in range(number_of_ts)] @@ -111,15 +112,15 @@ class Archetype14_15: t_sup_hp[i + 1] = (q_hp[i + 1] / (m_ch[i + 1] * cte.WATER_HEAT_CAPACITY)) + t_tank[i + 1] else: q_hp[i + 1], m_ch[i + 1], t_sup_hp[i + 1] = 0, 0, t_tank[i + 1] - t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i + 1] + 32 + t_tank_fahrenheit = 1.8 * t_tank[i + 1] + 32 t_out_fahrenheit = 1.8 * t_out[i + 1] + 32 if q_hp[i + 1] > 0: - hp_cop[i + 1] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + + hp_cop[i + 1] = (1 / (cop_curve_coefficients[0] + + cop_curve_coefficients[1] * t_tank_fahrenheit + + cop_curve_coefficients[2] * t_tank_fahrenheit ** 2 + cop_curve_coefficients[3] * t_out_fahrenheit + cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + cop_curve_coefficients[5] * t_tank_fahrenheit * t_out_fahrenheit)) * hp_efficiency hp_electricity[i + 1] = q_hp[i + 1] / hp_cop[i + 1] else: hp_cop[i + 1] = 0 @@ -189,26 +190,26 @@ class Archetype14_15: return hp_hourly, boiler_hourly def cooling_system_simulation(self): - hp = self.cooling_system_sizing() + hp = self.cooling_system_sizing()[0] eer_curve_coefficients = [float(coefficient) for coefficient in hp.cooling_efficiency_curve.coefficients] cooling_efficiency = float(hp.cooling_efficiency) number_of_ts = int(cte.HOUR_TO_SECONDS / self.dt) demand = [0] + [x for x in self._hourly_cooling_demand for _ in range(number_of_ts)] t_out = [0] + [x for x in self._t_out for _ in range(number_of_ts)] hp.source_temperature = self._t_out - variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_eer"] + variable_names = ["t_sup_hp", "t_ret", "m", "q_hp", "hp_electricity", "hp_cop"] num_hours = len(demand) variables = {name: [0] * num_hours for name in variable_names} - (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_eer) = [variables[name] for name in variable_names] + (t_sup_hp, t_ret, m, q_hp, hp_electricity, hp_cop) = [variables[name] for name in variable_names] t_ret[0] = 13 for i in range(1, len(demand)): - if demand[i] > 0: - m[i] = self._cooling_peak_load / (cte.WATER_HEAT_CAPACITY * 5 * cte.HOUR_TO_SECONDS) + if demand[i] > 0.15 * self._cooling_peak_load: + m[i] = hp.nominal_cooling_output / (cte.WATER_HEAT_CAPACITY * 5) if t_ret[i - 1] >= 13: - if demand[i] < 0.25 * self._cooling_peak_load / cte.HOUR_TO_SECONDS: + if demand[i] < 0.25 * self._cooling_peak_load: q_hp[i] = 0.25 * hp.nominal_cooling_output - elif demand[i] < 0.5 * self._cooling_peak_load / cte.HOUR_TO_SECONDS: + elif demand[i] < 0.5 * self._cooling_peak_load: q_hp[i] = 0.5 * hp.nominal_cooling_output else: q_hp[i] = hp.nominal_cooling_output @@ -223,20 +224,20 @@ class Archetype14_15: else: m[i] = 0 q_hp[i] = 0 - t_sup_hp[i] = t_ret[i -1] + t_sup_hp[i] = t_ret[i - 1] t_ret[i] = t_ret[i - 1] t_sup_hp_fahrenheit = 1.8 * t_sup_hp[i] + 32 t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: - hp_eer[i] = (eer_curve_coefficients[0] + + hp_cop[i] = (1 / (eer_curve_coefficients[0] + eer_curve_coefficients[1] * t_sup_hp_fahrenheit + eer_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + eer_curve_coefficients[3] * t_out_fahrenheit + eer_curve_coefficients[4] * t_out_fahrenheit ** 2 + - eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) - hp_electricity[i] = q_hp[i] / hp_eer[i] + eer_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit)) * cooling_efficiency / 3.41 + hp_electricity[i] = q_hp[i] / cooling_efficiency else: - hp_eer[i] = 0 + hp_cop[i] = 0 hp_electricity[i] = 0 hp_electricity_j = [(x * cte.WATTS_HOUR_TO_JULES) / number_of_ts for x in hp_electricity] hp_hourly = [] @@ -255,7 +256,7 @@ class Archetype14_15: self.results['Cooling Demand (W)'] = demand self.results['HP Cooling Output (W)'] = q_hp self.results['HP Cooling Supply Temperature'] = t_sup_hp - self.results['HP Cooling COP'] = hp_eer + self.results['HP Cooling COP'] = hp_cop self.results['HP Electricity Consumption'] = hp_electricity self.results['Cooling Loop Flow Rate (kg/s)'] = m self.results['Cooling Loop Return Temperature'] = t_ret @@ -289,7 +290,7 @@ class Archetype14_15: freshwater_temperature = 18 for i in range(len(demand) - 1): delta_t_demand = demand[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) - if t_tank[i] < 65: + if t_tank[i] < 62: q_hp[i] = hp_heating_cap delta_t_hp = q_hp[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) if demand[i] > 0: @@ -297,14 +298,8 @@ class Archetype14_15: m_dis[i] = dhw_needed * cte.WATER_DENSITY / cte.HOUR_TO_SECONDS m_refill[i] = m_dis[i] delta_t_freshwater = m_refill[i] * (t_tank[i] - freshwater_temperature) * (self.dt / (v * cte.WATER_DENSITY)) - diff = delta_t_freshwater + delta_t_demand - delta_t_hp - if diff > 0: - if diff > 0: - power = diff * (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v) / self.dt - if power <= float(tes.heating_coil_capacity): - q_coil[i] = power - else: - q_coil[i] = float(tes.heating_coil_capacity) + if t_tank[i] < 60: + q_coil[i] = float(tes.heating_coil_capacity) delta_t_coil = q_coil[i] * (self.dt / (cte.WATER_DENSITY * cte.WATER_HEAT_CAPACITY * v)) if q_hp[i] > 0: @@ -317,11 +312,11 @@ class Archetype14_15: t_out_fahrenheit = 1.8 * t_out[i] + 32 if q_hp[i] > 0: hp_cop[i] = (cop_curve_coefficients[0] + - cop_curve_coefficients[1] * t_sup_hp_fahrenheit + - cop_curve_coefficients[2] * t_sup_hp_fahrenheit ** 2 + - cop_curve_coefficients[3] * t_out_fahrenheit + - cop_curve_coefficients[4] * t_out_fahrenheit ** 2 + - cop_curve_coefficients[5] * t_sup_hp_fahrenheit * t_out_fahrenheit) + cop_curve_coefficients[1] * t_out[i] + + cop_curve_coefficients[2] * t_out[i] ** 2 + + cop_curve_coefficients[3] * t_tank[i] + + cop_curve_coefficients[4] * t_tank[i] ** 2 + + cop_curve_coefficients[5] * t_tank[i] * t_out[i]) * float(hp.heat_efficiency) hp_electricity[i] = q_hp[i] / hp_cop[i] else: hp_cop[i] = 0 @@ -374,6 +369,7 @@ class Archetype14_15: return hp_hourly, coil_hourly + def enrich_buildings(self): hp_heating, boiler_consumption = self.heating_system_simulation() hp_cooling = self.cooling_system_simulation() diff --git a/simulation_result_test.py b/simulation_result_test.py index a54477b4..3d72ad8b 100644 --- a/simulation_result_test.py +++ b/simulation_result_test.py @@ -47,21 +47,8 @@ ConstructionFactory('nrcan', city).enrich() UsageFactory('nrcan', city).enrich() WeatherFactory('epw', city).enrich() energy_plus_workflow(city, energy_plus_output_path) -random_assignation.call_random(city.buildings, random_assignation.residential_systems_percentage) -EnergySystemsFactory('montreal_custom', city).enrich() -SystemSizing(city.buildings).montreal_custom() -for i in range(12): - monthly_cooling = 0 - for building in city.buildings: - monthly_cooling += building.cooling_consumption[cte.MONTH][i] / (cte.WATTS_HOUR_TO_JULES * 1000) - print(monthly_cooling) random_assignation.call_random(city.buildings, random_assignation.residential_new_systems_percentage) EnergySystemsFactory('montreal_future', city).enrich() for building in city.buildings: - if building.energy_systems_archetype_name == 'PV+4Pipe+DHW': - EnergySystemsSimulationFactory('archetype13', building=building, output_path=simulation_results_path).enrich() -for i in range(12): - monthly_cooling = 0 - for building in city.buildings: - monthly_cooling += building.cooling_consumption[cte.MONTH][i] / (cte.WATTS_HOUR_TO_JULES * 1000) - print(monthly_cooling) + EnergySystemsSimulationFactory('archetype1', building=building, output_path=simulation_results_path).enrich() +