diff --git a/post_hpc_sensitivity_test_analysis.py b/post_hpc_sensitivity_test_analysis.py index c51b007..79a7e19 100644 --- a/post_hpc_sensitivity_test_analysis.py +++ b/post_hpc_sensitivity_test_analysis.py @@ -2,6 +2,7 @@ import json import matplotlib.colors as mcolors +import matplotlib.patches as mpatches import matplotlib.pyplot as plt import numpy as np import os @@ -9,14 +10,17 @@ import re import seaborn as sns -from matplotlib import rc +from matplotlib import rc, rcParams from pycirclize import Circos from tqdm import tqdm -COMBINED_CSV_FILENAME: str = "combined_post_hpc_sensitivity_test" +COMBINED_CSV_FILENAME: str = "combined_25_apr_post_hpc_sensitivity_test" TOTEX_HEADER: str = "Other TOTEX" rc("font", **{"family": "sans-serif", "sans-serif": ["Arial"]}) +rc("figure", **{"figsize": (48 / 5, 32 / 5)}) +rcParams["pdf.fonttype"] = 42 +rcParams["ps.fonttype"] = 42 sns.set_context("paper") sns.set_style("whitegrid") @@ -122,8 +126,8 @@ ( reduced_temperature_plot_filename := os.path.join( "output_files", - "22_feb_24", - "autotherm_sensitivity_of_absorber_absorptivity_with_value_0.81.json", + "25_apr_24", + "autotherm_sensitivity_of_glass_thermal_conductivity_with_value_0.58.json", ) ) ) as f: @@ -140,13 +144,17 @@ ) frame_to_plot["marker"] = [ - "h" if row[1]["wind_speed"] == 1 else "H" for row in frame_to_plot.iterrows() + "h" if row[1]["wind_speed"] == 1 else "H" if row[1]["wind_speed"] == 5 else "D" + for row in frame_to_plot.iterrows() ] fig = plt.figure(figsize=(48 / 5, 32 / 5)) for marker, sub_frame in frame_to_plot.groupby("marker"): plt.scatter( - [], [], alpha=0, label=f"Wind speed = {'1' if marker == 'h' else '10'} m/s" + [], + [], + alpha=0, + label=f"Wind speed = {'1' if marker == 'h' else '5' if marker == 'H' else '10'} m/s", ) sns.scatterplot( sub_frame, @@ -156,28 +164,30 @@ marker=marker, alpha=0.5, s=200, - palette=sns.color_palette("RdBu_r" if marker == "h" else "PiYG_r", 4), - linewidth=0, - ) - sub_reduced_temperature_fit = np.poly1d( - np.polyfit( - sub_frame["reduced_collector_temperature"], - sub_frame["thermal_efficiency"], - 2, - ) - ) - sns.lineplot( - x=( - x_linspace := np.linspace( - min(sub_frame["reduced_collector_temperature"]), - max(sub_frame["reduced_collector_temperature"]), - ) + palette=sns.color_palette( + "RdBu_r" if marker == "h" else "PiYG_r" if marker == "H" else "PRGn", 4 ), - y=sub_reduced_temperature_fit(x_linspace), - color="C4", - dashes=(2, 2), - label="Quadratic fit", + linewidth=0, ) + # sub_reduced_temperature_fit = np.poly1d( + # np.polyfit( + # sub_frame["reduced_collector_temperature"], + # sub_frame["thermal_efficiency"], + # 2, + # ) + # ) + # sns.lineplot( + # x=( + # x_linspace := np.linspace( + # min(sub_frame["reduced_collector_temperature"]), + # max(sub_frame["reduced_collector_temperature"]), + # ) + # ), + # y=sub_reduced_temperature_fit(x_linspace), + # color="C4", + # dashes=(2, 2), + # label="Quadratic fit", + # ) plt.xlabel("Reduced collector temperature / Km$^2$/W") plt.ylabel("Thermal efficiency") @@ -188,7 +198,9 @@ ) plt.savefig( - reduced_temperature_plot_filename.split("autotherm_sensitivity_of_")[1] + ".png", + "25_apr_" + + reduced_temperature_plot_filename.split("autotherm_sensitivity_of_")[1] + + ".png", transparent=True, bbox_inches="tight", dpi=400, @@ -204,18 +216,19 @@ # various parameters that were explored. filename_regex = re.compile( - r"autotherm_sensitivity_of_(?Pabsorber|adhesive|bond|eva|glass|insulation|pipe|pv|pvt|tedlar)_(?P.*)_with_value_(?P.*)\.json" + r"autotherm_sensitivity_of_(?Pabsorber|adhesive|air_gap|bond|eva|glass|insulation|pipe|pv|pvt|tedlar)_(?P.*)_with_value_(?P.*)\.json" ) run_number_regex = re.compile(r"run_(?P\d*)_T.*") -with open((benchmark_filename := "15_mar_benchmark.json")) as benchmark_file: +# with open((benchmark_filename := "15_mar_benchmark.json")) as benchmark_file: +with open((benchmark_filename := "30_apr_benchmark.json")) as benchmark_file: benchmark_data = json.load(benchmark_file) if not os.path.isfile(COMBINED_CSV_FILENAME): un_concatenated_dataframes: list[pd.DataFrame] = [] for filename in tqdm( os.listdir( - (output_directory_name := os.path.join("output_files", "22_feb_24")) + (output_directory_name := os.path.join("output_files", "25_apr_24")) ), desc="processing files", unit="files", @@ -287,6 +300,15 @@ ) / _this_benchmark_value except KeyError: continue + except TypeError: + combined_output_frame.at[index, "fractional_thermal_efficiency_change"] = ( + None + ) + combined_output_frame.at[index, "percentage_thermal_efficiency_change"] = ( + None + ) + combined_output_frame.at[index, "squared_thermal_efficiency_change"] = None + continue _percentage_thermal_efficiency_change = ( 100 * _fractional_thermal_efficiency_change ) @@ -316,6 +338,106 @@ with open(COMBINED_CSV_FILENAME, "r") as combined_outputfile: combined_output_frame = pd.read_csv(combined_outputfile, index_col=0) +############################################### +# Plot a marginal abatement curve--style plot # +############################################### + +blue_first_thesis_palette_20 = sns.color_palette( + colourmap(np.linspace(0, 1, 20)).tolist() +) +sns.set_palette(blue_first_thesis_palette_20) + +combined_output_frame["combined_name"] = ( + combined_output_frame["component_name"] + + " " + + combined_output_frame["parameter_name"] +) + +for G in tqdm([200, 400, 600, 800, 1000]): + parameter_median_squared_fractional_changes: dict[tuple[str, str], float] = {} + parameter_mean_squared_fractional_changes: dict[tuple[str, str], float] = {} + frame_to_plot = combined_output_frame[ + combined_output_frame["solar_irradiance"] == G + ] + for component_name, sub_frame in tqdm( + frame_to_plot.groupby("component_name"), leave=True + ): + for parameter_name, sub_sub_frame in tqdm( + sub_frame.groupby("parameter_name"), leave=False + ): + parameter_median_squared_fractional_changes[ + component_name, parameter_name + ] = float(sub_sub_frame["squared_thermal_efficiency_change"].median()) + parameter_mean_squared_fractional_changes[ + component_name, parameter_name + ] = float(sub_sub_frame["squared_thermal_efficiency_change"].median()) + sorted_medians = sorted( + parameter_median_squared_fractional_changes.items(), key=lambda item: item[1] + ) + sorted_means = sorted( + parameter_mean_squared_fractional_changes.items(), key=lambda item: item[1] + ) + # g = sns.catplot(x=["_".join(entry[0]) for entry in sorted_medians], y=[entry[1] for entry in sorted_medians], hue=[entry[0][0] for entry in sorted_medians], kind="bar") + gng = sns.catplot( + frame_to_plot, + x="combined_name", + y="squared_thermal_efficiency_change", + hue="component_name", + kind="box", + log_scale=True, + order=[" ".join(entry[0]) for entry in sorted_medians], + whis=(1, 99), + flierprops={"marker": "D", "alpha": 0.7}, + ) + ax = plt.gca() + ax.tick_params(axis="x", rotation=90) + ax.set_xlabel("") + ax.set_ylabel("Squared fractional change in thermal efficiency") + gng.legend.set_title("Component") + # rect = mpatches.Rectangle( + # [ax.get_position().x0, ax.get_position().y0], + # ax.get_position().x1 - ax.get_position().x0, + # 0.5, + # ec="k", + # fc="grey", + # alpha=0.1, + # clip_on=False, + # transform=fig.transFigure, + # linewidth=0, + # ) + # ax.add_patch(rect) + plt.savefig( + f"squared_box_sensitivity_autotherm_G_{G}.pdf", + transparent=True, + format="pdf", + dpi=300, + bbox_inches="tight", + ) + gng = sns.catplot( + frame_to_plot, + x="combined_name", + y="squared_thermal_efficiency_change", + hue="component_name", + kind="boxen", + log_scale=True, + order=[" ".join(entry[0]) for entry in sorted_medians], + ) + ax = plt.gca() + ax.tick_params(axis="x", rotation=90) + ax.set_xlabel("") + ax.set_ylabel("Squared fractional change in thermal efficiency") + gng.legend.set_title("Component") + plt.savefig( + f"squared_boxen_sensitivity_autotherm_G_{G}.pdf", + transparent=True, + format="pdf", + dpi=300, + bbox_inches="tight", + ) + + +plt.show() + ##################################################################### # Plot a single variable with the parameter value dictating the hue # ##################################################################### @@ -331,7 +453,7 @@ "Heat capacity": "J/kgK", "Reference efficiency": None, "Thermal coefficient": "K$^-1$", - "Thermal conductivity": "W/Km", + "Thermal conductivity": "W/m K", "Thickness": "m", "Transmissivity": None, "Width": "m", @@ -340,35 +462,153 @@ start = 0 end = 8 + def _size_from_component_and_parameter(component: str, parameter: str) -> int: """Determine the size of the points based on the component and parameter.""" - if component == "Absorber": - if parameter in ("Thickness"): - return 1 - if component in ("Adhesive", "Eva", "Tedlar"): - if parameter in ("Thermal conductivity"): - return 1 - if component == "Bond": - if parameter in ("Thermal conductivity", "Width"): - return 1 - if component == "Glass": - if parameter in ("Diffuse reflection coefficient", "Emissivity", "Thermal conductivity", "Thickenss"): - return 1 - if component == "Insulation": - if parameter in ("Thermal conductivity", "Thickness"): - return 1 - if component == "PV": - if parameter in ("Emissivity", "Reference efficiency", "Thermal coefficienct", "Transmissivity"): - return 1 - if component == "Pvt": - return 1 - return 3 + # if component == "Absorber": + # if parameter in ("Thickness"): + # return 0.5 + # if component in ("Adhesive", "Eva", "Tedlar", "Air gap",): + # if parameter in ("Thermal conductivity"): + # return 0.5 + # if component == "Bond": + # if parameter in ("Thermal conductivity", "Width"): + # return 0.5 + # if component == "Glass": + # if parameter in ("Diffuse reflection coefficient", "Emissivity", "Thermal conductivity", "Thickenss"): + # return 0.5 + # if component == "Insulation": + # if parameter in ("Thermal conductivity", "Thickness"): + # return 0.5 + # if component == "PV": + # if parameter in ("Emissivity", "Reference efficiency", "Thermal coefficienct", "Transmissivity"): + # return 0.5 + # if component == "Pvt": + # return 0.5 + return 0.25 + + +for irradiance in [0, 200, 400, 600, 800, 1000]: + plotting_frame = combined_output_frame[ + combined_output_frame["solar_irradiance"] == irradiance + ] + for _component_name, start_hue in zip( + [ + # "Absorber", + "Adhesive", + "Air gap", + # "Bond", + "Eva", + "Glass", + "Insulation", + "Pv", + "Pvt", + "Tedlar", + ][start:end], + [0.2, 0.0, -0.2, -0.4, -0.6, -0.8, -1.0, -1.2, -1.4][start:end], + ): + for _parameter_name in set( + plotting_frame[(plotting_frame["component_name"] == _component_name)][ + "parameter_name" + ] + ): + frame_to_plot = plotting_frame[ + (plotting_frame["component_name"] == _component_name) + & (plotting_frame["parameter_name"] == _parameter_name) + & ( + ~plotting_frame["parameter_value"] + .astype(str) + .str.contains("checkpoint") + ) + ] + frame_to_plot.loc[:, "parameter_value"] = frame_to_plot[ + "parameter_value" + ].astype(float) + if _component_name == "Pvt": + frame_to_plot.loc[:, "parameter_value"] = [ + int(0.86 / entry) + for entry in frame_to_plot["parameter_value"].astype(float) + ] + _unit: str | None = parameter_name_to_unit_map[_parameter_name] + fig = plt.figure(figsize=(48 / 5, 32 / 5)) + # sns.swarmplot( + # frame_to_plot, + # x="percentage_thermal_efficiency_change", + # y="parameter_name", + # hue="parameter_value", + # palette=( + # this_palette := sns.cubehelix_palette( + # start=start_hue, + # rot=-0.2, + # dark=0.1, + # n_colors=len(set(frame_to_plot["parameter_value"])), + # ) + # ), + # marker="D", + # size=_size_from_component_and_parameter(_component_name, _parameter_name), + # ) + sns.stripplot( + frame_to_plot, + x="percentage_thermal_efficiency_change", + y="parameter_name", + hue="parameter_value", + palette=( + this_palette := sns.cubehelix_palette( + start=start_hue, + rot=-0.6, + dark=0.15, + light=0.9, + n_colors=len(set(frame_to_plot["parameter_value"])), + ) + ), + marker="D", + alpha=0.3, + size=10, + ) + axis = plt.gca() + norm = plt.Normalize( + frame_to_plot["parameter_value"].min(), + frame_to_plot["parameter_value"].max(), + ) + scalar_mappable = plt.cm.ScalarMappable( + cmap=mcolors.LinearSegmentedColormap.from_list( + "Custom", + this_palette.as_hex(), + len(set(frame_to_plot["parameter_value"])), + ), + norm=norm, + ) + colorbar = axis.figure.colorbar( + scalar_mappable, + ax=axis, + label=( + ( + f"{_component_name} {_parameter_name}" + if _component_name != "Pvt" + else "Number of pipes" + ) + + (f" / {_unit}" if _unit is not None else "") + ), + ) + axis = plt.gca() + axis.get_legend().remove() + axis.set_xlabel("Percentage change in thermal efficiency / %") + axis.set(ylabel=None, yticklabels=[]) + axis.axvline(x=0, linestyle="--", color="grey", linewidth=1) + plt.savefig( + f"(Strip) G_{irradiance} Sensitivity of {_component_name} {_parameter_name}.png", + transparent=True, + dpi=400, + bbox_inches="tight", + pad_inches=0, + ) for _component_name, start_hue in zip( [ - "Absorber", + # "Absorber", "Adhesive", - "Bond", + "Air gap", + # "Bond", "Eva", "Glass", "Insulation", @@ -411,12 +651,30 @@ def _size_from_component_and_parameter(component: str, parameter: str) -> int: this_palette := sns.cubehelix_palette( start=start_hue, rot=-0.2, + dark=0.1, n_colors=len(set(frame_to_plot["parameter_value"])), ) ), marker="D", size=_size_from_component_and_parameter(_component_name, _parameter_name), ) + # sns.stripplot( + # frame_to_plot, + # x="percentage_thermal_efficiency_change", + # y="parameter_name", + # hue="parameter_value", + # palette=( + # this_palette := sns.cubehelix_palette( + # start=start_hue, + # rot=-0.2, + # dark=0.1, + # n_colors=len(set(frame_to_plot["parameter_value"])), + # ) + # ), + # marker="D", + # alpha=0.1, + # size=5, + # ) axis = plt.gca() norm = plt.Normalize( frame_to_plot["parameter_value"].min(), @@ -434,9 +692,12 @@ def _size_from_component_and_parameter(component: str, parameter: str) -> int: scalar_mappable, ax=axis, label=( - f"{_component_name} {_parameter_name}" - if _component_name != "Pvt" - else "Number of pipes" + (f" / {_unit}" if _unit is not None else "") + ( + f"{_component_name} {_parameter_name}" + if _component_name != "Pvt" + else "Number of pipes" + ) + + (f" / {_unit}" if _unit is not None else "") ), ) axis = plt.gca() @@ -445,7 +706,7 @@ def _size_from_component_and_parameter(component: str, parameter: str) -> int: axis.set(ylabel=None, yticklabels=[]) axis.axvline(x=0, linestyle="--", color="grey", linewidth=1) plt.savefig( - f"Sensitivity of {_component_name} {_parameter_name}.png", + f"(Swarm) Sensitivity of {_component_name} {_parameter_name}.png", transparent=True, dpi=400, bbox_inches="tight", diff --git a/src/pvt_model/__main__.py b/src/pvt_model/__main__.py index 8fdf673..500db00 100644 --- a/src/pvt_model/__main__.py +++ b/src/pvt_model/__main__.py @@ -397,9 +397,11 @@ def _determine_consistent_conditions( override_ambient_temperature=override_ambient_temperature, override_collector_input_temperature=override_collector_input_temperature, override_irradiance=override_irradiance, - override_mass_flow_rate=override_mass_flow_rate - if override_mass_flow_rate is not None - else parsed_args.mass_flow_rate, + override_mass_flow_rate=( + override_mass_flow_rate + if override_mass_flow_rate is not None + else parsed_args.mass_flow_rate + ), override_wind_speed=override_wind_speed, run_number=run_depth, start_time=parsed_args.start_time, @@ -439,9 +441,11 @@ def _determine_consistent_conditions( override_ambient_temperature=override_ambient_temperature, override_collector_input_temperature=override_collector_input_temperature, override_irradiance=override_irradiance, - override_mass_flow_rate=override_mass_flow_rate - if override_mass_flow_rate is not None - else parsed_args.mass_flow_rate, + override_mass_flow_rate=( + override_mass_flow_rate + if override_mass_flow_rate is not None + else parsed_args.mass_flow_rate + ), override_wind_speed=override_wind_speed, resolution=resolution, run_depth=run_depth + 1, diff --git a/src/pvt_model/analysis/__utils__.py b/src/pvt_model/analysis/__utils__.py index 7473784..83ce146 100644 --- a/src/pvt_model/analysis/__utils__.py +++ b/src/pvt_model/analysis/__utils__.py @@ -661,12 +661,18 @@ def _process_layer_data(key_to_process: str) -> numpy.ndarray: pv_array = _process_layer_data("layer_temperature_map_pv") absorber_array = _process_layer_data("layer_temperature_map_absorber") - vmin = math.floor(min(numpy.min(glass_array), numpy.min(pv_array), numpy.min(absorber_array))) - vmax = math.ceil(max(numpy.max(glass_array), numpy.max(pv_array), numpy.max(absorber_array))) + vmin = math.floor( + min(numpy.min(glass_array), numpy.min(pv_array), numpy.min(absorber_array)) + ) + vmax = math.ceil( + max(numpy.max(glass_array), numpy.max(pv_array), numpy.max(absorber_array)) + ) # Form the data into the right shape for each layer _, axes = plt.subplots(1, 3, figsize=(48 / 5, 32 / 5)) - palette = sns.cubehelix_palette(start=1.5, rot=-0.5, dark=0.05, light=0.95, as_cmap=True) + palette = sns.cubehelix_palette( + start=1.5, rot=-0.5, dark=0.05, light=0.95, as_cmap=True + ) palette = sns.diverging_palette(205, 18, s=100, l=50, n=100) plt.subplots_adjust(hspace=0.3) @@ -675,9 +681,40 @@ def _process_layer_data(key_to_process: str) -> numpy.ndarray: # Plots linewidth: float = 0 - sns.heatmap(glass_array, cmap=palette, ax=axes[0], vmin=vmin, vmax=vmax, cbar=False, square=False, linewidths=linewidth, linecolor="white") - sns.heatmap(pv_array, cmap=palette, ax=axes[1], vmin=vmin, vmax=vmax, cbar=False, square=False, linewidths=linewidth, linecolor="white") - sns.heatmap(absorber_array, cmap=palette, ax=axes[2], vmin=vmin, vmax=vmax, cbar_kws={"pad": 0.02, "label":"Temperature / $^\circ$C"}, cbar=True, square=False, linewidths=linewidth, linecolor="white") + sns.heatmap( + glass_array, + cmap=palette, + ax=axes[0], + vmin=vmin, + vmax=vmax, + cbar=False, + square=False, + linewidths=linewidth, + linecolor="white", + ) + sns.heatmap( + pv_array, + cmap=palette, + ax=axes[1], + vmin=vmin, + vmax=vmax, + cbar=False, + square=False, + linewidths=linewidth, + linecolor="white", + ) + sns.heatmap( + absorber_array, + cmap=palette, + ax=axes[2], + vmin=vmin, + vmax=vmax, + cbar_kws={"pad": 0.02, "label": "Temperature / $^\circ$C"}, + cbar=True, + square=False, + linewidths=linewidth, + linecolor="white", + ) axes[0].set_title("Glass", weight="bold") axes[0].set_xlabel("X-index") @@ -728,12 +765,8 @@ def _process_layer_data(key_to_process: str) -> numpy.ndarray: figname: str = "pvt_temperatures_1.png" - plt.savefig( - figname, - transparent=True, - dpi=300, - bbox_inches="tight" - ) + plt.savefig(figname, transparent=True, dpi=300, bbox_inches="tight") + def plot_two_dimensional_figure( figure_name: str, diff --git a/src/pvt_model/analysis/glazing_analysis.py b/src/pvt_model/analysis/glazing_analysis.py index 003c0fd..16529dd 100644 --- a/src/pvt_model/analysis/glazing_analysis.py +++ b/src/pvt_model/analysis/glazing_analysis.py @@ -273,9 +273,9 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches ] thermal_efficiency_labels.add(f"thermal efficiency p.c.={portion_covered}") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"electrical efficiency p.c.={portion_covered}" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"electrical efficiency p.c.={portion_covered}"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"electrical efficiency p.c.={portion_covered}" ) @@ -317,9 +317,9 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches ] thermal_efficiency_labels.add(f"thermal efficiency p.c.={portion_covered}") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"electrical efficiency p.c.={portion_covered}" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"electrical efficiency p.c.={portion_covered}"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"electrical efficiency p.c.={portion_covered}" ) @@ -361,9 +361,9 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches ] thermal_efficiency_labels.add(f"thermal efficiency p.c.={portion_covered}") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"electrical efficiency p.c.={portion_covered}" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"electrical efficiency p.c.={portion_covered}"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"electrical efficiency p.c.={portion_covered}" ) @@ -405,9 +405,9 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches ] thermal_efficiency_labels.add(f"thermal efficiency p.c.={portion_covered}") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"electrical efficiency p.c.={portion_covered}" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"electrical efficiency p.c.={portion_covered}"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"electrical efficiency p.c.={portion_covered}" ) @@ -449,9 +449,9 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches ] thermal_efficiency_labels.add(f"thermal efficiency p.c.={portion_covered}") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"electrical efficiency p.c.={portion_covered}" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"electrical efficiency p.c.={portion_covered}"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"electrical efficiency p.c.={portion_covered}" ) @@ -493,9 +493,9 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches ] thermal_efficiency_labels.add(f"thermal efficiency p.c.={portion_covered}") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"electrical efficiency p.c.={portion_covered}" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"electrical efficiency p.c.={portion_covered}"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"electrical efficiency p.c.={portion_covered}" ) @@ -871,14 +871,14 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches # continue # Only include important mass-flow rates. for sub_key, value in sub_dict.items(): - reduced_data[sub_key][ - f"{glazing} thermal efficiency {pipes} pipes" - ] = value["thermal_efficiency"] + reduced_data[sub_key][f"{glazing} thermal efficiency {pipes} pipes"] = ( + value["thermal_efficiency"] + ) thermal_efficiency_labels.add(f"{glazing} thermal efficiency {pipes} pipes") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"{glazing} electrical efficiency {pipes} pipes" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"{glazing} electrical efficiency {pipes} pipes"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"{glazing} electrical efficiency {pipes} pipes" ) @@ -913,14 +913,14 @@ def analyse_decoupled_steady_state_data( # pylint: disable=too-many-branches continue # Only include important mass-flow rates. for sub_key, value in sub_dict.items(): - reduced_data[sub_key][ - f"{glazing} thermal efficiency {pipes} pipes" - ] = value["thermal_efficiency"] + reduced_data[sub_key][f"{glazing} thermal efficiency {pipes} pipes"] = ( + value["thermal_efficiency"] + ) thermal_efficiency_labels.add(f"{glazing} thermal efficiency {pipes} pipes") # Store the specific electrical efficiency. - reduced_data[sub_key][ - f"{glazing} electrical efficiency {pipes} pipes" - ] = value["electrical_efficiency"] + reduced_data[sub_key][f"{glazing} electrical efficiency {pipes} pipes"] = ( + value["electrical_efficiency"] + ) electrical_efficiency_labels.add( f"{glazing} electrical efficiency {pipes} pipes" ) diff --git a/src/pvt_model/analysis/machine_learning_fit.py b/src/pvt_model/analysis/machine_learning_fit.py index 68ad42e..c6cfb40 100644 --- a/src/pvt_model/analysis/machine_learning_fit.py +++ b/src/pvt_model/analysis/machine_learning_fit.py @@ -170,7 +170,7 @@ def _parse_args(args) -> argparse.Namespace: "-cv", help="Carry out a CV grid search of the available hyperparameter space.", default=False, - action="store_true" + action="store_true", ) parser.add_argument( "--data-file-name", "-df", help="Path to the data file to parse." @@ -180,7 +180,7 @@ def _parse_args(args) -> argparse.Namespace: "-f", help="Fit a random forest regressor in addition to the base decision tree fit.", default=False, - action="store_true" + action="store_true", ) parser.add_argument( "--num-pipes-correction", @@ -233,7 +233,6 @@ def _train_trees_and_forest( """ - if use_existing_fits: with open(f"{data_name}_electric_tree.sav", "rb") as f: electric_tree = pickle.load(f) @@ -274,12 +273,16 @@ def _train_trees_and_forest( pickle.dump(thermal_tree, f) with open( - os.path.join("..", "CLOVER", "src", "clover", "src", f"{data_name}_electric_tree.sav"), + os.path.join( + "..", "CLOVER", "src", "clover", "src", f"{data_name}_electric_tree.sav" + ), "wb", ) as f: pickle.dump(electric_tree, f) with open( - os.path.join("..", "CLOVER", "src", "clover", "src", f"{data_name}_thermal_tree.sav"), + os.path.join( + "..", "CLOVER", "src", "clover", "src", f"{data_name}_thermal_tree.sav" + ), "wb", ) as f: pickle.dump(thermal_tree, f) @@ -319,12 +322,26 @@ def _train_trees_and_forest( pickle.dump(thermal_forest, f) with open( - os.path.join("..", "CLOVER", "src", "clover", "src", f"{data_name}_electric_forest.sav"), + os.path.join( + "..", + "CLOVER", + "src", + "clover", + "src", + f"{data_name}_electric_forest.sav", + ), "wb", ) as f: pickle.dump(electric_forest, f) with open( - os.path.join("..", "CLOVER", "src", "clover", "src", f"{data_name}_thermal_forest.sav"), + os.path.join( + "..", + "CLOVER", + "src", + "clover", + "src", + f"{data_name}_thermal_forest.sav", + ), "wb", ) as f: pickle.dump(thermal_forest, f) @@ -363,8 +380,12 @@ def _train_trees_and_forest( thermal_forest_search.fit(x_train_therm, y_train_therm) print("[ DONE ]") - print(f"Best {data_name} electric forest params: {electric_forest_search.best_params_}") - print(f"Best {data_name} thermal forest params: {thermal_forest_search.best_params_}") + print( + f"Best {data_name} electric forest params: {electric_forest_search.best_params_}" + ) + print( + f"Best {data_name} thermal forest params: {thermal_forest_search.best_params_}" + ) best_electric_forest = electric_forest_search.best_estimator_ best_thermal_forest = thermal_forest_search.best_estimator_ @@ -376,19 +397,37 @@ def _train_trees_and_forest( pickle.dump(best_thermal_forest, f) with open( - os.path.join("..", "CLOVER", "src", "clover", "src", f"{data_name}_best_electric_forest.sav"), + os.path.join( + "..", + "CLOVER", + "src", + "clover", + "src", + f"{data_name}_best_electric_forest.sav", + ), "wb", ) as f: pickle.dump(best_electric_forest, f) with open( - os.path.join("..", "CLOVER", "src", "clover", "src", f"{data_name}_best_thermal_forest.sav"), + os.path.join( + "..", + "CLOVER", + "src", + "clover", + "src", + f"{data_name}_best_thermal_forest.sav", + ), "wb", ) as f: pickle.dump(best_thermal_forest, f) def analyse( - cv_search: bool, data_file_name: str, forest: bool, num_pipes_correction: int, use_existing_fits: bool + cv_search: bool, + data_file_name: str, + forest: bool, + num_pipes_correction: int, + use_existing_fits: bool, ) -> None: """ Analysis function for fitting parameters. @@ -552,15 +591,15 @@ def analyse( x_low_irradiance_high_temp_electric = x_low_irradiance_electric[ x_low_irradiance_electric[1] >= LOW_TEMP_THRESHOLD ] - x_low_irradiance_high_temp_electric = x_low_irradiance_high_temp_electric.reset_index( - drop=True + x_low_irradiance_high_temp_electric = ( + x_low_irradiance_high_temp_electric.reset_index(drop=True) ) y_low_irradiance_high_temp_electric = y_low_irradiance_electric[ x_low_irradiance_electric[1] >= LOW_TEMP_THRESHOLD ] - y_low_irradiance_high_temp_electric = y_low_irradiance_high_temp_electric.reset_index( - drop=True + y_low_irradiance_high_temp_electric = ( + y_low_irradiance_high_temp_electric.reset_index(drop=True) ) x_low_irradiance_high_temp_thermal = x_low_irradiance_thermal[ @@ -616,7 +655,7 @@ def analyse( x_low_irradiance_low_temp_electric, x_low_irradiance_low_temp_thermal, y_low_irradiance_low_temp_electric, - y_low_irradiance_low_temp_thermal + y_low_irradiance_low_temp_thermal, ) _train_trees_and_forest( @@ -627,7 +666,7 @@ def analyse( x_low_irradiance_high_temp_electric, x_low_irradiance_high_temp_thermal, y_low_irradiance_high_temp_electric, - y_low_irradiance_high_temp_thermal + y_low_irradiance_high_temp_thermal, ) _train_trees_and_forest( diff --git a/src/pvt_model/pvt_system/__main__.py b/src/pvt_model/pvt_system/__main__.py index 10d2942..162991c 100644 --- a/src/pvt_model/pvt_system/__main__.py +++ b/src/pvt_model/pvt_system/__main__.py @@ -356,15 +356,15 @@ def main( # pylint: disable=too-many-branches # Instantiate the rest of the PVT system if relevant. if operating_mode.coupled: # Set up the heat exchanger. - heat_exchanger: Optional[ - exchanger.Exchanger - ] = process_pvt_system_data.heat_exchanger_from_path(exchanger_data_file) + heat_exchanger: Optional[exchanger.Exchanger] = ( + process_pvt_system_data.heat_exchanger_from_path(exchanger_data_file) + ) logger.info("Heat exchanger successfully instantiated: %s", heat_exchanger) # Set up the hot-water tank. - hot_water_tank: Optional[ - tank.Tank - ] = process_pvt_system_data.hot_water_tank_from_path(tank_data_file) + hot_water_tank: Optional[tank.Tank] = ( + process_pvt_system_data.hot_water_tank_from_path(tank_data_file) + ) logger.info("Hot-water tank successfully instantiated: %s", hot_water_tank) # Set up the mains supply system. @@ -502,7 +502,10 @@ def main( # pylint: disable=too-many-branches BColours.FAIL, BColours.ENDC ) ) - (final_run_temperature_vector, system_data,) = decoupled.decoupled_dynamic_run( + ( + final_run_temperature_vector, + system_data, + ) = decoupled.decoupled_dynamic_run( cloud_efficacy_factor, override_collector_input_temperature, days, diff --git a/src/pvt_model/pvt_system/convergent_solver.py b/src/pvt_model/pvt_system/convergent_solver.py index 291e190..2465e66 100644 --- a/src/pvt_model/pvt_system/convergent_solver.py +++ b/src/pvt_model/pvt_system/convergent_solver.py @@ -181,9 +181,11 @@ def solve_temperature_vector_convergence_method( logger.info( "Date and time: %s; Run number: %s: Beginning convergent calculation.", - next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") - if next_date_and_time is not None - else "[time-independent]", + ( + next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") + if next_date_and_time is not None + else "[time-independent]" + ), convergence_run_number, ) @@ -259,9 +261,11 @@ def solve_temperature_vector_convergence_method( logger.debug( "Date and time: %s; Run number: %s: " "Temperatures successfully computed. Temperature vector: T = %s", - next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") - if next_date_and_time is not None - else "[time-independent]", + ( + next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") + if next_date_and_time is not None + else "[time-independent]" + ), convergence_run_number, run_two_temperature_vector, ) @@ -275,9 +279,11 @@ def solve_temperature_vector_convergence_method( logger.debug( "Date and time: %s; Run number: %s: Convergent solution found. " "Convergent difference: %s", - next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") - if next_date_and_time is not None - else "[time-independent]", + ( + next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") + if next_date_and_time is not None + else "[time-independent]" + ), convergence_run_number, run_two_temperature_difference, ) @@ -286,9 +292,11 @@ def solve_temperature_vector_convergence_method( logger.debug( "Date and time: %s; Run number: %s: Solution not convergent. " "Convergent difference: %s", - next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") - if next_date_and_time is not None - else "[time-independent]", + ( + next_date_and_time.strftime("%d/%m/%Y %H:%M:%S") + if next_date_and_time is not None + else "[time-independent]" + ), convergence_run_number, run_two_temperature_difference, ) diff --git a/src/pvt_model/pvt_system/load.py b/src/pvt_model/pvt_system/load.py index 73d75bd..f07ef56 100644 --- a/src/pvt_model/pvt_system/load.py +++ b/src/pvt_model/pvt_system/load.py @@ -219,9 +219,9 @@ def _process_csv( # @@@ -coded in. Ideally, there would be some regex matching here. profile_type = ProfileType.ELECTRICITY - electrical_load_profile: Dict[ - _MonthAndDayType, LoadProfile - ] = collections.defaultdict(LoadProfile) + electrical_load_profile: Dict[_MonthAndDayType, LoadProfile] = ( + collections.defaultdict(LoadProfile) + ) # Open the csv file, and cycle through the rows, processing them. with open(csv_file_path, "r") as csv_file: diff --git a/src/pvt_model/pvt_system/matrix/matrix.py b/src/pvt_model/pvt_system/matrix/matrix.py index 3ee7d58..b0e29f3 100644 --- a/src/pvt_model/pvt_system/matrix/matrix.py +++ b/src/pvt_model/pvt_system/matrix/matrix.py @@ -872,9 +872,11 @@ def calculate_matrix_equation( # pylint: disable=too-many-branches " Heat exchanger missing." if heat_exchanger is None else "", " Hot water load missing." if hot_water_load is None else "", " Hot-water tank missing." if hot_water_tank is None else "", - " Previous temperature vector is missing." - if previous_temperature_vector is None - else "", + ( + " Previous temperature vector is missing." + if previous_temperature_vector is None + else "" + ), BColours.FAIL, BColours.ENDC, ) diff --git a/src/pvt_model/pvt_system/matrix/pv.py b/src/pvt_model/pvt_system/matrix/pv.py index 7544c7b..d2c40d3 100644 --- a/src/pvt_model/pvt_system/matrix/pv.py +++ b/src/pvt_model/pvt_system/matrix/pv.py @@ -95,7 +95,10 @@ def calculate_pv_equation( # pylint: disable=too-many-branches # Compute the upward environmental losses. if not element.glass: - (pv_to_air_conduction, pv_to_sky_radiation,) = physics_utils.upward_loss_terms( + ( + pv_to_air_conduction, + pv_to_sky_radiation, + ) = physics_utils.upward_loss_terms( best_guess_temperature_vector, pvt_collector, element, diff --git a/src/pvt_model/pvt_system/process_pvt_system_data.py b/src/pvt_model/pvt_system/process_pvt_system_data.py index 79dab13..0f0b87b 100644 --- a/src/pvt_model/pvt_system/process_pvt_system_data.py +++ b/src/pvt_model/pvt_system/process_pvt_system_data.py @@ -201,20 +201,26 @@ def _absorber_params_from_data( try: return CollectorParameters( absorptivity=absorber_data["absorptivity"], # [unitless] - conductivity=absorber_data["thermal_conductivity"] - if "thermal_conductivity" in absorber_data - else None, + conductivity=( + absorber_data["thermal_conductivity"] + if "thermal_conductivity" in absorber_data + else None + ), density=absorber_data["density"] if "density" in absorber_data else None, emissivity=absorber_data["emissivity"], # [unitless] heat_capacity=absorber_data["heat_capacity"], # [J/kg*K] - htf_heat_capacity=absorber_data["htf_heat_capacity"] # [J/kg*K] - if "htf_heat_capacity" in absorber_data - else HEAT_CAPACITY_OF_WATER, # [J/kg*K] + htf_heat_capacity=( + absorber_data["htf_heat_capacity"] # [J/kg*K] + if "htf_heat_capacity" in absorber_data + else HEAT_CAPACITY_OF_WATER + ), # [J/kg*K] inner_pipe_diameter=absorber_data["inner_pipe_diameter"], # [m] length=length, # [m] - mass_flow_rate=override_mass_flow_rate - if override_mass_flow_rate is not None - else absorber_data["mass_flow_rate"], # [Litres/hour] + mass_flow_rate=( + override_mass_flow_rate + if override_mass_flow_rate is not None + else absorber_data["mass_flow_rate"] + ), # [Litres/hour] number_of_pipes=absorber_data["number_of_pipes"], # [pipes] outer_pipe_diameter=absorber_data["outer_pipe_diameter"], # [m] pipe_density=absorber_data["pipe_density"], # [kg/m^3] @@ -248,9 +254,11 @@ def _glass_params_from_data(glass_data: Dict[str, Any]) -> OpticalLayerParameter try: return OpticalLayerParameters( absorptivity=glass_data["absorptivity"], # [unitless] - conductivity=glass_data["thermal_conductivity"] - if "thermal_conductivity" in glass_data - else None, + conductivity=( + glass_data["thermal_conductivity"] + if "thermal_conductivity" in glass_data + else None + ), density=glass_data["density"], # [kg/m^3] emissivity=glass_data["emissivity"], # [unitless] heat_capacity=glass_data["heat_capacity"], # [J/kg*K] @@ -289,9 +297,11 @@ def _pv_params_from_data(pv_data: Optional[Dict[str, Any]]) -> PVParameters: try: return PVParameters( - conductivity=pv_data["thermal_conductivity"] - if "thermal_conductivity" in pv_data - else None, + conductivity=( + pv_data["thermal_conductivity"] + if "thermal_conductivity" in pv_data + else None + ), density=pv_data["density"] if "density" in pv_data else None, # [kg/m^3] heat_capacity=pv_data["heat_capacity"], # [J/kg*K] thickness=pv_data["thickness"], # [m] @@ -449,31 +459,43 @@ def _elements_from_data( ): element.Element( absorber=TemperatureName.absorber in layers, glass=TemperatureName.glass in layers, - length=edge_length - if y_coordinate(element_number, x_resolution) in {0, y_resolution - 1} - else nominal_element_length, - pipe=x_coordinate(element_number, x_resolution) in pipe_positions - if TemperatureName.pipe in layers - else False, - pv=y_coordinate(element_number, x_resolution) <= pv_coordinate_cutoff - if TemperatureName.pv in layers - else False, + length=( + edge_length + if y_coordinate(element_number, x_resolution) + in {0, y_resolution - 1} + else nominal_element_length + ), + pipe=( + x_coordinate(element_number, x_resolution) in pipe_positions + if TemperatureName.pipe in layers + else False + ), + pv=( + y_coordinate(element_number, x_resolution) <= pv_coordinate_cutoff + if TemperatureName.pv in layers + else False + ), upper_glass=TemperatureName.upper_glass in layers, # Use the edge with if the element is an edge element. - width=edge_width - if x_coordinate(element_number, x_resolution) in {0, x_resolution - 1} - # Otherwise, use the bond width if the element is a pipe element. - else bond_width - if x_coordinate(element_number, x_resolution) in pipe_positions - # Otherwise, use the nominal element width. - else nominal_element_width, + width=( + edge_width + if x_coordinate(element_number, x_resolution) + in {0, x_resolution - 1} + # Otherwise, use the bond width if the element is a pipe element. + else ( + bond_width + if x_coordinate(element_number, x_resolution) in pipe_positions + # Otherwise, use the nominal element width. + else nominal_element_width + ) + ), x_index=x_coordinate(element_number, x_resolution), y_index=y_coordinate(element_number, x_resolution), - pipe_index=pipe_positions.index( - x_coordinate(element_number, x_resolution) - ) - if x_coordinate(element_number, x_resolution) in pipe_positions - else None, + pipe_index=( + pipe_positions.index(x_coordinate(element_number, x_resolution)) + if x_coordinate(element_number, x_resolution) in pipe_positions + else None + ), ) for element_number in range(x_resolution * y_resolution) } @@ -529,9 +551,9 @@ def pvt_collector_from_path( # If there is upper-glass data present, process this accordingly. if "upper_glass" in pvt_data and TemperatureName.upper_glass in layers: - upper_glass_parameters: Optional[ - OpticalLayerParameters - ] = _glass_params_from_data(pvt_data["upper_glass"]) + upper_glass_parameters: Optional[OpticalLayerParameters] = ( + _glass_params_from_data(pvt_data["upper_glass"]) + ) elif "glass" in pvt_data and TemperatureName.upper_glass in layers: upper_glass_parameters = _glass_params_from_data(pvt_data["glass"]) elif TemperatureName.upper_glass in layers: @@ -589,10 +611,12 @@ def pvt_collector_from_path( pvt_data["adhesive"]["thickness"], ), air_gap_thickness=air_gap_thickness, - area=pvt_data["pvt_collector"]["area"] - if "area" in pvt_data["pvt_collector"] - else pvt_data["pvt_collector"]["width"] - * pvt_data["pvt_collector"]["length"], # [m^2] + area=( + pvt_data["pvt_collector"]["area"] + if "area" in pvt_data["pvt_collector"] + else pvt_data["pvt_collector"]["width"] + * pvt_data["pvt_collector"]["length"] + ), # [m^2] absorber_parameters=absorber_parameters, eva=eva.EVA( pvt_data["eva"]["thermal_conductivity"], pvt_data["eva"]["thickness"] @@ -617,16 +641,18 @@ def pvt_collector_from_path( ), upper_glass_parameters=upper_glass_parameters, width=pvt_data["pvt_collector"]["width"], # [m] - azimuthal_orientation=pvt_data["pvt_collector"][ - "azimuthal_orientation" - ] # [deg] - if "azimuthal_orientation" in pvt_data["pvt_collector"] - else None, + azimuthal_orientation=( + pvt_data["pvt_collector"]["azimuthal_orientation"] # [deg] + if "azimuthal_orientation" in pvt_data["pvt_collector"] + else None + ), horizontal_tracking=pvt_data["pvt_collector"]["horizontal_tracking"], vertical_tracking=pvt_data["pvt_collector"]["vertical_tracking"], - tilt=pvt_data["pvt_collector"]["tilt"] # [deg] - if "tilt" in pvt_data["pvt_collector"] - else None, + tilt=( + pvt_data["pvt_collector"]["tilt"] # [deg] + if "tilt" in pvt_data["pvt_collector"] + else None + ), ) except KeyError as e: raise MissingParametersError( diff --git a/src/pvt_model/pvt_system/runs/__utils__.py b/src/pvt_model/pvt_system/runs/__utils__.py index c145911..200a564 100644 --- a/src/pvt_model/pvt_system/runs/__utils__.py +++ b/src/pvt_model/pvt_system/runs/__utils__.py @@ -213,14 +213,14 @@ def system_data_from_run( TemperatureName.upper_glass, temperature_vector, ) - temperature_map_upper_glass_layer: Optional[ - Dict[str, float] - ] = _layer_temperature_profile( - number_of_pipes, - number_of_x_elements, - pvt_collector, - TemperatureName.upper_glass, - temperature_vector, + temperature_map_upper_glass_layer: Optional[Dict[str, float]] = ( + _layer_temperature_profile( + number_of_pipes, + number_of_x_elements, + pvt_collector, + TemperatureName.upper_glass, + temperature_vector, + ) ) else: average_upper_glass_temperature = None @@ -232,14 +232,14 @@ def system_data_from_run( TemperatureName.glass, temperature_vector, ) - temperature_map_glass_layer: Optional[ - Dict[str, float] - ] = _layer_temperature_profile( - number_of_pipes, - number_of_x_elements, - pvt_collector, - TemperatureName.glass, - temperature_vector, + temperature_map_glass_layer: Optional[Dict[str, float]] = ( + _layer_temperature_profile( + number_of_pipes, + number_of_x_elements, + pvt_collector, + TemperatureName.glass, + temperature_vector, + ) ) else: average_glass_temperature = None @@ -387,12 +387,16 @@ def system_data_from_run( return SystemData( date=date.strftime("%d/%m/%Y"), time=formatted_time, - upper_glass_temperature=average_upper_glass_temperature - ZERO_CELCIUS_OFFSET - if average_upper_glass_temperature is not None - else None, - glass_temperature=average_glass_temperature - ZERO_CELCIUS_OFFSET - if average_glass_temperature is not None - else None, + upper_glass_temperature=( + average_upper_glass_temperature - ZERO_CELCIUS_OFFSET + if average_upper_glass_temperature is not None + else None + ), + glass_temperature=( + average_glass_temperature - ZERO_CELCIUS_OFFSET + if average_glass_temperature is not None + else None + ), pv_temperature=average_pv_temperature - ZERO_CELCIUS_OFFSET, absorber_temperature=average_absorber_temperature - ZERO_CELCIUS_OFFSET, collector_input_temperature=collector_input_temperature - ZERO_CELCIUS_OFFSET, @@ -406,22 +410,22 @@ def system_data_from_run( tank_temperature=tank_temperature, collector_temperature_gain=collector_output_temperature - collector_input_temperature, - layer_temperature_map_bulk_water=temperature_map_bulk_water_layer - if save_2d_output - else None, - layer_temperature_map_absorber=temperature_map_absorber_layer - if save_2d_output - else None, - layer_temperature_map_glass=temperature_map_glass_layer - if save_2d_output - else None, - layer_temperature_map_pipe=temperature_map_pipe_layer - if save_2d_output - else None, + layer_temperature_map_bulk_water=( + temperature_map_bulk_water_layer if save_2d_output else None + ), + layer_temperature_map_absorber=( + temperature_map_absorber_layer if save_2d_output else None + ), + layer_temperature_map_glass=( + temperature_map_glass_layer if save_2d_output else None + ), + layer_temperature_map_pipe=( + temperature_map_pipe_layer if save_2d_output else None + ), layer_temperature_map_pv=temperature_map_pv_layer if save_2d_output else None, - layer_temperature_map_upper_glass=temperature_map_upper_glass_layer - if save_2d_output - else None, + layer_temperature_map_upper_glass=( + temperature_map_upper_glass_layer if save_2d_output else None + ), electrical_efficiency=electrical_efficiency, reduced_collector_temperature=reduced_system_temperature, thermal_efficiency=thermal_efficiency, diff --git a/src/pvt_model/pvt_system/runs/coupled.py b/src/pvt_model/pvt_system/runs/coupled.py index 9d1081f..d27d075 100644 --- a/src/pvt_model/pvt_system/runs/coupled.py +++ b/src/pvt_model/pvt_system/runs/coupled.py @@ -193,9 +193,9 @@ def coupled_dynamic_run( weather_conditions, ) - previous_run_temperature_vector: Union[ - List[float], numpy.ndarray - ] = initial_system_temperature_vector + previous_run_temperature_vector: Union[List[float], numpy.ndarray] = ( + initial_system_temperature_vector + ) for run_number, date_and_time in enumerate( time_iterator( diff --git a/src/pvt_model/pvt_system/runs/decoupled.py b/src/pvt_model/pvt_system/runs/decoupled.py index 25d749d..6f27166 100644 --- a/src/pvt_model/pvt_system/runs/decoupled.py +++ b/src/pvt_model/pvt_system/runs/decoupled.py @@ -195,10 +195,9 @@ def decoupled_dynamic_run( weather_conditions, ) - previous_run_temperature_vector: Union[ - List[float], numpy.ndarray - ] = initial_system_temperature_vector - + previous_run_temperature_vector: Union[List[float], numpy.ndarray] = ( + initial_system_temperature_vector + ) for run_number, date_and_time in enumerate( time_iterator( diff --git a/src/pvt_model/pvt_system/weather.py b/src/pvt_model/pvt_system/weather.py index b2b61bc..442c5c7 100644 --- a/src/pvt_model/pvt_system/weather.py +++ b/src/pvt_model/pvt_system/weather.py @@ -884,9 +884,11 @@ def from_data( # pylint: disable=too-many-branches data, monthly_irradiance_profiles, temperature_profiles, - override_ambient_temperature + ZERO_CELCIUS_OFFSET - if override_ambient_temperature is not None - else None, + ( + override_ambient_temperature + ZERO_CELCIUS_OFFSET + if override_ambient_temperature is not None + else None + ), override_irradiance, override_wind_speed, )