kinda simulates

v2/architecture.py

@@ -5,42 +5,68 @@ from enum import IntEnum
 
 # it's really just a network pricing model
 from supplier import Supplier
-from data_processing import read_datasets, add_production_field, interpolate_and_join, Parameters
+from data_processing import read_datasets, add_production_field, interpolate_and_join, SolarParameters
 
 
 STEPS_PER_HOUR = 12
 
 
-# mock model
+# SOC is normalized so that minimal_depth_of_discharge = 0 and maximal_depth_of_discharge = 1.
+# please set capacity_Ah = nominal_capacity_Ah * (max_dod - min_dod)
 class BatteryModel:
-    def __init__(self, capacity, efficiency=0.95):
-        self.soc = 0
-        self.capacity = capacity # kWh
-        self.efficiency = efficiency
-
-    def discharge(self, target):
-        assert 0 <= self.soc <= 1
-        if self.soc >= target:
-            self.soc -= target
-            amount = target
-        else:
-            amount = self.soc
-            self.soc = 0
+    def __init__(self, capacity_Ah, time_interval_h):
+        self.capacity_Ah = capacity_Ah
+        self.efficiency = 0.95 # [dimensionless]
+        self.voltage_V = 600
+        self.charge_kW = 50
+        self.discharge_kW = 60
+        self.time_interval_h = time_interval_h
+
+        # the only non-constant member variable!
+        # ratio of self.current_capacity_kWh and self.maximal_capacity_kWh
+        self.soc = 0.0 
+
+    @property
+    def maximal_capacity_kWh(self):
+        return self.capacity_Ah * self.voltage_V / 1000
+
+    @property
+    def current_capacity_kWh(self):
+        return self.soc * self.maximal_capacity_kWh
+
+    def satisfy_demand(self, demand_kW):
         assert 0 <= self.soc <= 1
-        return amount
-
-    # not very refined, whatevs.
-    def charge(self, target):
-        assert 0 <= self.soc <= 1
-        target_to_add = target * self.efficiency
-        if self.soc <= 1 - target_to_add:
-            self.soc += target_to_add
-            could_take = target
-        else:
-            could_take = (1 - self.soc) / self.efficiency
-            self.soc = 1
+        assert demand_kW >= 0
+        # rate limited:
+        possible_discharge_in_timestep_kWh = self.discharge_kW * self.time_interval_h
+        # limited by current capacity:
+        possible_discharge_in_timestep_kWh = min((possible_discharge_in_timestep_kWh, self.current_capacity_kWh))
+        # limited by need:
+        discharge_in_timestep_kWh = min((possible_discharge_in_timestep_kWh, demand_kW * self.time_interval_h))
+        consumption_from_bess_kW = discharge_in_timestep_kWh / self.time_interval_h
+        unsatisfied_demand_kW = demand_kW - consumption_from_bess_kW
+        cap_of_battery_kWh = self.current_capacity_kWh - discharge_in_timestep_kWh
+        soc = cap_of_battery_kWh / self.maximal_capacity_kWh
+        assert 0 <= soc <= self.soc <= 1
+        self.soc = soc
+        return unsatisfied_demand_kW
+
+    def charge(self, charge_kW):
         assert 0 <= self.soc <= 1
-        return could_take
+        assert charge_kW >= 0
+        # rate limited:
+        possible_charge_in_timestep_kWh = self.charge_kW * self.time_interval_h
+        # limited by current capacity:
+        possible_charge_in_timestep_kWh = min((possible_charge_in_timestep_kWh, self.maximal_capacity_kWh - self.current_capacity_kWh))
+        # limited by supply:
+        charge_in_timestep_kWh = min((possible_charge_in_timestep_kWh, charge_kW * self.time_interval_h))
+        actual_charge_kW = charge_in_timestep_kWh / self.time_interval_h
+        unused_charge_kW = charge_kW - actual_charge_kW
+        cap_of_battery_kWh = self.current_capacity_kWh + charge_in_timestep_kWh
+        soc = cap_of_battery_kWh / self.maximal_capacity_kWh
+        assert 0 <= self.soc <= soc <= 1
+        self.soc = soc
+        return unused_charge_kW
 
 
 class Decision(IntEnum):
@@ -67,7 +93,6 @@ class Decision(IntEnum):
 # output_window_size is not yet used, always decides one timestep.
 class Decider:
     def __init__(self):
-        self.parameters = None
         self.input_window_size = STEPS_PER_HOUR * 24 # day long window.
         self.output_window_size = STEPS_PER_HOUR # only output decisions for the next hour
         self.random_seed = 0
@@ -98,18 +123,25 @@ class DummyPredictor:
         return prediction
 
 
+'''
+    bess_nominal_capacity: float = 330 # [Ah]
+    bess_charge: float = 50 # [kW]
+    bess_discharge: float = 60 # [kW]
+    voltage: float = 600 # [V]
+    maximal_depth_of_discharge: float = 0.75 # [dimensionless]
+    energy_loss: float = 0.1 # [dimensionless]
+    bess_present: bool = True # [boolean]
+'''
+
 # this function does not mutate its inputs.
 # it makes a clone of battery_model and modifies that.
-# TODO even in a first mockup version, parameters should come from a single
-# place, not some from the parameters dataclass and some from the battery_model.
-def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor, decider, parameters):
+def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor, decider):
     battery_model = copy.copy(battery_model)
 
     demand_np = prod_cons['Consumption'].to_numpy()
     production_np = prod_cons['Production'].to_numpy()
     assert len(demand_np) == len(production_np)
     step_in_minutes = prod_cons.index.freq.n
-    print(step_in_minutes)
     assert step_in_minutes == 5
 
     print("Simulating for", len(demand_np), "time steps. Each step is", step_in_minutes, "minutes.")
@@ -124,24 +156,18 @@ def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor
     consumption_from_network_to_bess_series = [] # network used to charge BESS, also included in consumption_from_network.
     # the previous three must sum to demand_series.
 
-    # power taken from solar by BESS.
-    # note: in inital mock version power is never taken from network by BESS.
-    charge_of_bess_series = []
     discarded_production_series = [] # solar power thrown away
 
     # 1 is not nominal but targeted (healthy) maximum charge.
     # we start with an empty battery, but not emptier than what's healthy for the batteries.
 
-    # For the sake of simplicity 0 <= soc <=1
+    # For the sake of simplicity 0 <= soc <= 1
     # soc=0 means battery is emptied till it's 20% and soc=1 means battery is charged till 80% of its capacity
     # soc = 1 - maximal_depth_of_discharge
     # and will use only maximal_depth_of_discharge percent of the real battery capacity
 
-    max_cap_of_battery = parameters.bess_capacity * parameters.maximal_depth_of_discharge
-
     time_interval = step_in_minutes / 60 # amount of time step in hours
     for i, (demand, production) in enumerate(zip(demand_np, production_np)):
-        cap_of_battery = battery_model.soc * max_cap_of_battery
         # these five are modified on the appropriate codepaths:
         consumption_from_solar = 0
         consumption_from_bess = 0
@@ -151,10 +177,6 @@ def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor
 
         unsatisfied_demand = demand
         remaining_production = production
-        
-        assert parameters.bess_present
-        is_battery_charged_enough = battery_model.soc > 0
-        is_battery_chargeable = battery_model.soc < 1.0
 
         prod_prediction = prod_predictor.predict(i, decider.input_window_size)
         cons_prediction = cons_predictor.predict(i, decider.input_window_size)
@@ -162,78 +184,41 @@ def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor
 
         production_used_to_charge = 0
         if unsatisfied_demand >= remaining_production:
-            # all goes to demand
+            # all goes to demand, no rate limit between solar and consumer
             consumption_from_solar = remaining_production
             unsatisfied_demand -= consumption_from_solar
             remaining_production = 0
-            # we try to cover the rest from BESS
-            if unsatisfied_demand > 0:
-                if is_battery_charged_enough and decision == Decision.DISCHARGE:
-                    # battery capacity is limited!
-                    if cap_of_battery >= unsatisfied_demand * time_interval:
-                        consumption_from_bess = unsatisfied_demand
-                        unsatisfied_demand = 0
-                        cap_of_battery -= consumption_from_bess * time_interval
-                        soc = cap_of_battery / max_cap_of_battery
-                    else:
-                        discharge_of_bess = cap_of_battery / time_interval
-                        discharge = min(parameters.bess_discharge, discharge_of_bess)
-                        consumption_from_bess = discharge
-                        unsatisfied_demand -= consumption_from_bess
-                        cap_of_battery -= consumption_from_bess * time_interval
-                        soc = cap_of_battery / max_cap_of_battery
-                        consumption_from_network = unsatisfied_demand
-                        unsatisfied_demand = 0
-                else:
-                    # we cover the rest from network
-                    consumption_from_network = unsatisfied_demand
-                    unsatisfied_demand = 0
+            if decision == Decision.DISCHARGE:
+                # we try to cover the rest from BESS
+                unsatisfied_demand = battery_model.satisfy_demand(unsatisfied_demand)
+            # we cover the rest from network
+            consumption_from_network = unsatisfied_demand
+            unsatisfied_demand = 0
         else:
-            # demand fully satisfied by production
+            # demand fully satisfied by production, no rate limit between solar and consumer
             consumption_from_solar = unsatisfied_demand
             remaining_production -= unsatisfied_demand
             unsatisfied_demand = 0
             if remaining_production > 0:
                 # exploitable production still remains:
-                if is_battery_chargeable:
-                    # we try to specify the BESS modell
-                    if parameters.bess_charge <= remaining_production :
-                        energy = parameters.bess_charge * time_interval
-                        remaining_production = remaining_production - parameters.bess_charge
-                        production_used_to_charge = parameters.bess_charge
-                    else :
-                        production_used_to_charge = remaining_production
-                        energy = remaining_production * time_interval
-                        remaining_production = 0
-                    cap_of_battery += energy
-                    soc = cap_of_battery / max_cap_of_battery
-
-        discarded_production = remaining_production
+                discarded_production = battery_model.charge(remaining_production) # remaining_production [kW]
 
         if decision == Decision.NETWORK_CHARGE:
-            # there are two things that can limit charging at this point,
-            # one is a distance-like, the other is a velocity-like quantity.
-            # 1. the battery is fully charged
-            # 2. the battery is being charged from solar, no bandwidth left.
-            is_battery_chargeable = battery_model.soc < 1.0
-            remaining_network_charge = parameters.bess_charge - production_used_to_charge
-            if is_battery_chargeable:
-                # we try to specify the BESS modell
-                if parameters.bess_charge <= remaining_network_charge :
-                    energy = parameters.bess_charge * time_interval
-                    remaining_network_charge = remaining_network_charge - parameters.bess_charge
-                    network_used_to_charge = parameters.bess_charge
-                else :
-                    network_used_to_charge = remaining_production
-                    energy = remaining_production * time_interval
-                cap_of_battery += energy
-                soc = cap_of_battery / max_cap_of_battery
-            consumption_from_network += network_used_to_charge
+            # that is some random big number, the actual charge will be
+            # determined by the combination of the BESS rate limit (battery_model.charge_kW)
+            # and the BESS capacity
+            fictional_network_charge_kW = 1000
+            discarded_network_charge_kW = battery_model.charge(fictional_network_charge_kW)
+            actual_network_charge_kW = fictional_network_charge_kW - discarded_network_charge_kW
+            consumption_from_network_to_bess = actual_network_charge_kW # just a renaming.
+            consumption_from_network += actual_network_charge_kW
+        else:
+            consumption_from_network_to_bess = 0
 
         soc_series.append(battery_model.soc)
         consumption_from_solar_series.append(consumption_from_solar)
         consumption_from_network_series.append(consumption_from_network)
-        consumption_from_network_to_bess_series.append(network_used_to_charge)
+        consumption_from_network_to_bess_series.append(consumption_from_network_to_bess)
         consumption_from_bess_series.append(consumption_from_bess)
         discarded_production_series.append(discarded_production)
 
@@ -256,23 +241,30 @@ def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor
 
 
 def main():
-    battery_model = BatteryModel(capacity=200, efficiency=0.95)
 
     supplier = Supplier(price=100) # Ft/kWh
     supplier.set_price_for_interval(9, 17, 150) # nine-to-five increased price.
 
-    parameters = Parameters()
+    parameters = SolarParameters()
 
     met_2021_data, cons_2021_data = read_datasets()
     add_production_field(met_2021_data, parameters)
     all_2021_data = interpolate_and_join(met_2021_data, cons_2021_data)
 
+    time_interval_min = all_2021_data.index.freq.n
+    time_interval_h = time_interval_min / 60
+    battery_model = BatteryModel(capacity_Ah=600, time_interval_h=time_interval_h)
+
     prod_predictor = DummyPredictor(pd.Series(all_2021_data['Production']))
     cons_predictor = DummyPredictor(pd.Series(all_2021_data['Consumption']))
 
     decider = Decider()
 
-    results = simulator(battery_model, supplier, all_2021_data, prod_predictor, cons_predictor, decider, parameters)
+    results = simulator(battery_model, supplier, all_2021_data, prod_predictor, cons_predictor, decider)
+
+    import matplotlib.pyplot as plt
+    results['soc_series'].plot()
+    plt.show()
 
 
 if __name__ == '__main__':

v2/data_processing.py

@@ -1 +0,0 @@
-../data_processing.py

v2/data_processing.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+import numpy as np
+import pandas as pd
+from scipy.interpolate import interp1d   
+
+
+PATH_PREFIX = "./"
+
+START = f"2021-01-01"
+END = f"2022-01-01"
+
+
+def read_datasets(mini=False):
+    if mini:
+        met_filename = 'PL_44527.2101.csv.gz'
+        cons_filename = 'pq_terheles_202101_adatok.tsv'
+    else:
+        met_filename = 'PL_44527.19-21.csv.gz'
+        cons_filename = 'pq_terheles_2021_adatok.tsv'
+
+    #@title ### Preprocessing meteorologic data
+    met_data = pd.read_csv(PATH_PREFIX + met_filename, compression='gzip', sep=';', skipinitialspace=True, na_values='n/a', skiprows=[0, 1, 2, 3, 4])
+    met_data['Time'] = met_data['Time'].astype(str)
+    date_time = met_data['Time'] = pd.to_datetime(met_data['Time'], format='%Y%m%d%H%M')
+    met_data = met_data.set_index('Time')
+
+
+    #@title ### Preprocessing consumption data
+    cons_data = pd.read_csv(PATH_PREFIX + cons_filename, sep='\t', skipinitialspace=True, na_values='n/a', decimal=',')
+    cons_data['Time'] = pd.to_datetime(cons_data['Korrigált időpont'], format='%m/%d/%y %H:%M')
+    cons_data = cons_data.set_index('Time')
+    cons_data['Consumption'] = cons_data['Hatásos teljesítmény [kW]']
+
+    # consumption data is at 14 29 44 59 minutes, we move it by 1 minute
+    # to sync it with production data:
+    cons_data.index = cons_data.index + pd.DateOffset(minutes=1)
+
+    met_2021_data = met_data[(met_data.index >= START) & (met_data.index < END)]
+    cons_2021_data = cons_data[(cons_data.index >= START) & (cons_data.index < END)]
+
+    return met_2021_data, cons_2021_data
+
+
+# BESS parameters are now in BatteryModel
+@dataclass
+class SolarParameters:
+    solar_cell_num: float = 114 # units
+    solar_efficiency: float = 0.93 * 0.96 # [dimensionless]
+    NOCT: float = 280 # [W]
+    NOCT_irradiation: float = 800 # [W/m^2]
+
+
+# mutates met_2021_data
+def add_production_field(met_2021_data, parameters):
+    sr = met_2021_data['sr']
+
+    nop_total = sr * parameters.solar_cell_num * parameters.solar_efficiency * parameters.NOCT / parameters.NOCT_irradiation / 1e3
+    nop_total = nop_total.clip(0)
+    met_2021_data['Production'] = nop_total
+
+
+def interpolate_and_join(met_2021_data, cons_2021_data):
+    applicable = 24*60*365 - 15 + 5
+
+    demand_f = interp1d(range(0, 365*24*60, 15), cons_2021_data['Consumption'])
+    #demand_f = interp1d(range(0, 6*24*60, 15), cons_2021_data['Consumption'])
+    demand_interp = demand_f(range(0, applicable, 5))
+
+    production_f = interp1d(range(0, 365*24*60, 10), met_2021_data['Production'])
+    #production_f = interp1d(range(0, 6*24*60, 10), met_2021_data['Production'])
+    production_interp = production_f(range(0, applicable, 5))
+
+    all_2021_datetimeindex = pd.date_range(start=START, end=END, freq='5min')[:len(production_interp)]
+
+    all_2021_data = pd.DataFrame({'Consumption': demand_interp, 'Production': production_interp})
+    all_2021_data = all_2021_data.set_index(all_2021_datetimeindex)
+    return all_2021_data
+
+
+# TODO build a dataframe instead
+def monthly_analysis(results):
+    consumptions = []
+    for month in range(1, 13):
+        start = f"2021-{month:02}-01"
+        end = f"2021-{month+1:02}-01"
+        if month == 12:
+            end = "2022-01-01"
+        results_in_month = results[(results.index >= start) & (results.index < end)]
+
+        total = results_in_month['Consumption'].sum()
+        network = results_in_month['consumption_from_network'].sum()
+        solar = results_in_month['consumption_from_solar'].sum()
+        bess = results_in_month['consumption_from_bess'].sum()
+        consumptions.append([network, solar, bess])
+
+    consumptions = np.array(consumptions)
+    step_in_minutes = results.index.freq.n
+    # consumption is given in kW. each tick is step_in_minutes long (5mins, in fact)
+    # we get consumption in kWh if we multiply sum by step_in_minutes/60
+    consumptions_in_mwh = consumptions * (step_in_minutes / 60) / 1000
+    return consumptions_in_mwh