reproducing previous version

v2/app.py

@@ -4,6 +4,7 @@
 import numpy as np
 import pandas as pd
 import gradio as gr
+from types import SimpleNamespace
 
 # from simulation import *
 from data_processing import *
@@ -24,26 +25,14 @@ met_2021_data, cons_2021_data = read_datasets()
 # TODO move out everything that should not be recalculated.
 # TODO actually use uiParameters. (base_price and peak_price were just to mock up the Accordion gui.)
 # TODO ui_refresh spawns its own Supplier, which is just dumb.
-def recalculate(**uiParameters):
-    fixed_consumption = uiParameters['fixed_consumption']
-    del uiParameters['fixed_consumption']
-
-    parameters = SolarParameters()
-    for k, v in uiParameters.items():
-        setattr(parameters, k, v)
-
+# TODO some gui to upload consumption data.
+#      and maybe solar data? but we don't have a solar data -> production model built in. just scale and switch years from a dropdown?
+def recalculate(ui):
     np.random.seed(1)
 
-    supplier = Supplier(price=100) # Ft/kWh
-    # nine-to-five increased price.
-    supplier.set_price_for_daily_interval(9, 17, 150)
-    # midnight-to-three decreased price, to test network charge.
-    supplier.set_price_for_daily_interval(0, 3, 20)
-    # peak_demand dimension is kWh, but it's interpreted as the full consumption
-    # during a 15 minute timestep.
-    supplier.set_demand_charge(peak_demand=2.5, surcharge_per_kwh=500) # kWh in a 15 minutes interval, Ft/kWh
+    supplier = create_supplier(ui)
 
-    solar_parameters = SolarParameters()
+    solar_parameters = SolarParameters(solar_cell_num=ui.solar_cell_num, panel_power_at_NOCT=ui.solar_cell_nominal_capacity)
 
     add_production_field(met_2021_data, solar_parameters)
     all_data = interpolate_and_join(met_2021_data, cons_2021_data)
@@ -51,14 +40,16 @@ def recalculate(**uiParameters):
     time_interval_min = all_data.index.freq.n
     time_interval_h = time_interval_min / 60
 
+    battery_model = BatteryModel(capacity_Ah=600, time_interval_h=time_interval_h)
+
     # for faster testing:
     DATASET_TRUNCATED_SIZE = None
     if DATASET_TRUNCATED_SIZE is not None:
         print("Truncating dataset to", DATASET_TRUNCATED_SIZE, "datapoints, that is", DATASET_TRUNCATED_SIZE * time_interval_h / 24, "days")
         all_data = all_data.iloc[:DATASET_TRUNCATED_SIZE]
 
-    if fixed_consumption:
-        all_data['Consumption'] = 10
+    if ui.fixed_consumption_kW is not None:
+        all_data['Consumption'] = ui.fixed_consumption_kW
 
     print("Working with", solar_parameters.solar_cell_num, "solar cells, that's a maximum production of", all_data['Production'].max(), "kW.")
 
@@ -69,22 +60,63 @@ def recalculate(**uiParameters):
     # we delete the supplier to avoid accidentally calling it instead of precalculated_supplier
     supplier = None
 
-    all_data_with_predictions['Consumption_fees'] = precalculated_supplier.consumption_fees # [HUF / kWh]
-
-    battery_model = BatteryModel(capacity_Ah=600, time_interval_h=time_interval_h)
-
     # param_1 is prob of choosing PASSIVE
     # param_2 is prob of choosing NETWORK_CHARGE
+    # so this corresponds to constant DISCHARGE mode, where the priorities are:
+    # 1. try solar 2. try bess 3. try network
     decider = RandomDecider(np.array([0.0, 0.0]), precalculated_supplier)
 
+    all_data_with_predictions['Consumption_fees'] = precalculated_supplier.consumption_fees # [HUF / kWh]
+
     results, total_network_fee = simulator(battery_model, all_data_with_predictions, decider)
     print(f"{total_network_fee=}")
     return results
 
 
-def ui_refresh(solar_cell_num, bess_nominal_capacity, fixed_consumption, base_price, peak_price):
-    results = recalculate(solar_cell_num=solar_cell_num, bess_nominal_capacity=bess_nominal_capacity, fixed_consumption=fixed_consumption)
+# that's very error-prone, sorry. must be kept in sync with the gradio button click call.
+# secondarily, with recalculate().
+def list_to_namespace(
+    solar_cell_num, solar_cell_nominal_capacity,
+    bess_capacity_Ah, bess_voltage_V, bess_charge_kW, bess_discharge_kW,
+    fixed_consumption_kW,
+    base_price_HUFpkWh, peak_price_HUFpkWh):
+    return SimpleNamespace(
+        solar_cell_num=solar_cell_num,
+        solar_cell_nominal_capacity=solar_cell_nominal_capacity,
+        bess_capacity_Ah=bess_capacity_Ah,
+        bess_voltage_V=bess_voltage_V,
+        bess_charge_kW=bess_charge_kW,
+        bess_discharge_kW=bess_discharge_kW,
+        fixed_consumption_checkbox=fixed_consumption_checkbox,
+        fixed_consumption_kW=fixed_consumption_kW,
+        base_price_HUFpkWh=base_price_HUFpkWh,
+        peak_price_HUFpkWh=peak_price_HUFpkWh,
+    )
+
+
+def create_supplier(ui):
+    supplier = Supplier(price=ui.base_price_HUFpkWh)
+    supplier.set_price_for_daily_interval_on_workdays(start=6, end=22, price=ui.peak_price_HUFpkWh)
+    return supplier
+
+def ui_refresh(
+        solar_cell_num, solar_cell_nominal_capacity,
+        bess_capacity_Ah, bess_voltage_V, bess_charge_kW, bess_discharge_kW,
+        fixed_consumption_checkbox, fixed_consumption_kW,
+        base_price_HUFpkWh, peak_price_HUFpkWh):
+
+    if not fixed_consumption_checkbox:
+        fixed_consumption_kW = None # None means use dataframe.
+
+    ui = list_to_namespace(
+        solar_cell_num, solar_cell_nominal_capacity,
+        bess_capacity_Ah, bess_voltage_V, bess_charge_kW, bess_discharge_kW,
+        fixed_consumption_kW,
+        base_price_HUFpkWh, peak_price_HUFpkWh)
+
+    results = recalculate(ui)
 
+    # TODO generalize to other input ranges
     fig1 = plotly_visualize_simulation(results, date_range=("2021-02-01", "2021-02-07"))
     fig2 = plotly_visualize_simulation(results, date_range=("2021-08-02", "2021-08-08"))
 
@@ -98,11 +130,7 @@ def ui_refresh(solar_cell_num, bess_nominal_capacity, fixed_consumption, base_pr
     for column, column_name in zip((network, solar, bess), ("Network", "Solar directly", "Solar via BESS")):
         html += f"<tr><td>Yearly consumption served by {column_name}:&nbsp;&nbsp;&nbsp;</td><td>{column:0.2f} MWh</td></tr>\n"
 
-    supplier = Supplier(price=70) # HUF/kWh
-    supplier.set_price_for_daily_interval_on_workdays(start=6, end=22, price=100)
-
-    # not realistic, just for testing the effect
-    # supplier.set_demand_charge(peak_demand=100, surcharge_per_kw=1000)
+    supplier = create_supplier(ui)
 
     fee = supplier.fee(results["consumption_from_network"])
     html += f"<tr><td>{fee/1e6:.3f} million HUF billed by energy supplier</td></tr>\n"
@@ -116,13 +144,22 @@ with gr.Blocks() as ui:
     with gr.Row():
         # LEFT: Input controls
         with gr.Column(scale=1):  # narrower column
-            solar_slider = gr.Slider(0, 2000, 114, label="Solar cell number")
-            bess_slider = gr.Slider(0, 2000, 330, label="BESS nominal capacity in [Ah]")
-            fixed_consumption = gr.Checkbox(value=False, label="Use fixed consumption (10 kW)")
+            solar_cell_num = gr.Slider(0, 3000, 1140, label="number of installed solar cells")
+            solar_cell_nominal_capacity = gr.Slider(0, 1000, 280, label="solar cell nominal capacity at NOCT [W]")
+
+            bess_capacity_Ah = gr.Slider(0, 2000, 330, label="BESS nominal capacity [Ah]")
+
+            fixed_consumption_checkbox = gr.Checkbox(value=False, label="Use fixed consumption")
+            fixed_consumption_kW = gr.Slider(0, 100, 10, label="Amount of fixed consumption [kW]")
 
-            with gr.Accordion("Advanced Pricing Settings", open=False):
-                base_price = gr.Number(value=0.1, label="Base energy price [€/kWh]")
-                peak_price = gr.Number(value=0.3, label="Peak energy price [€/kWh]")
+            with gr.Accordion("Extra BESS settings", open=False):
+                bess_voltage_V    = gr.Number(value=600, label="BESS voltage [V]")
+                bess_charge_kW    = gr.Number(value=50, label="BESS charge [kW]")
+                bess_discharge_kW = gr.Number(value=60, label="BESS discharge [kW]")
+
+            with gr.Accordion("Pricing settings", open=False):
+                peak_price_HUFpkWh = gr.Number(value=60, label="Peak energy price [HUF/kWh]")
+                base_price_HUFpkWh = gr.Number(value=60, label="Base energy price [HUF/kWh]")
 
             run_btn = gr.Button("Run Simulation")
 
@@ -133,9 +170,17 @@ with gr.Blocks() as ui:
             plot2 = gr.Plot()
             plot3 = gr.Plot()
 
+    inputs = [
+        solar_cell_num, solar_cell_nominal_capacity,
+        bess_capacity_Ah, bess_voltage_V, bess_charge_kW, bess_discharge_kW,
+        fixed_consumption_checkbox, fixed_consumption_kW,
+        base_price_HUFpkWh, peak_price_HUFpkWh
+    ]
+
     run_btn.click(
         ui_refresh,
-        inputs=[solar_slider, bess_slider, fixed_consumption, base_price, peak_price],
+        inputs=inputs,
+        # [solar_cell_num_slider, bess_slider, fixed_consumption_slider, base_price, peak_price],
         outputs=[html_out, plot1, plot2, plot3],
     )
 

v2/data_processing.py

@@ -46,15 +46,18 @@ def read_datasets(mini=False):
 class SolarParameters:
     solar_cell_num: float = 1140 # units
     solar_efficiency: float = 0.93 * 0.96 # [dimensionless]
-    NOCT: float = 280 # [W]
+    panel_power_at_NOCT: float = 280 # [W]
+    # this is the SR (solar radiation) level where panel_power_at_NOCT is produced:
     NOCT_irradiation: float = 800 # [W/m^2]
 
 
 # mutates met_2021_data
 def add_production_field(met_2021_data, parameters):
+    # sr has dimension W/m^2.
     sr = met_2021_data['sr']
 
-    nop_total = sr * parameters.solar_cell_num * parameters.solar_efficiency * parameters.NOCT / parameters.NOCT_irradiation / 1e3
+    # TODO use something a bit more fancy nonlinear if we have the temperature anyway.
+    nop_total = sr * parameters.solar_cell_num * parameters.solar_efficiency * parameters.panel_power_at_NOCT / parameters.NOCT_irradiation / 1e3
     nop_total = nop_total.clip(0)
     met_2021_data['Production'] = nop_total