From 427570ccb2c32d900117b1a168f743497d69af0e Mon Sep 17 00:00:00 2001 From: Bla Bla Date: Sun, 18 Feb 2024 15:53:29 +0100 Subject: [PATCH] Optimierung Entladezustand Akku --- modules/class_akku.py | 14 ++++++++- modules/class_ems.py | 13 +++++++-- modules/visualize.py | 8 ++++- test.py | 68 +++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 96 insertions(+), 7 deletions(-) diff --git a/modules/class_akku.py b/modules/class_akku.py index 91dddea..bad4856 100644 --- a/modules/class_akku.py +++ b/modules/class_akku.py @@ -1,14 +1,26 @@ +import numpy as np class PVAkku: def __init__(self, kapazitaet_wh): # Kapazität des Akkus in Wh self.kapazitaet_wh = kapazitaet_wh # Initialer Ladezustand des Akkus in Wh self.soc_wh = 0 + self.discharge_array = np.full(24, 1) + + def reset(self): + self.soc_wh = 0 + self.discharge_array = np.full(24, 1) + + def set_discharge_per_hour(self, discharge_array): + assert(len(discharge_array) == 24) + self.discharge_array = discharge_array def ladezustand_in_prozent(self): return (self.soc_wh / self.kapazitaet_wh) * 100 - def energie_abgeben(self, wh): + def energie_abgeben(self, wh, hour): + if self.discharge_array[hour] == 0: + return 0.0 if self.soc_wh >= wh: self.soc_wh -= wh return wh diff --git a/modules/class_ems.py b/modules/class_ems.py index 882966e..1964805 100644 --- a/modules/class_ems.py +++ b/modules/class_ems.py @@ -39,6 +39,12 @@ class EnergieManagementSystem: self.pv_prognose_wh = pv_prognose_wh self.strompreis_cent_pro_wh = strompreis_cent_pro_wh # Strompreis in Cent pro Wh self.einspeiseverguetung_cent_pro_wh = einspeiseverguetung_cent_pro_wh # Einspeisevergütung in Cent pro Wh + def set_akku_discharge_hours(self, ds): + self.akku.set_discharge_per_hour(ds) + + def reset(self): + self.akku.reset() + def simuliere(self): eigenverbrauch_wh_pro_stunde = [] netzeinspeisung_wh_pro_stunde = [] @@ -67,7 +73,7 @@ class EnergieManagementSystem: else: netzeinspeisung_wh_pro_stunde.append(0.0) benötigte_energie = verbrauch - erzeugung - aus_akku = self.akku.energie_abgeben(benötigte_energie) + aus_akku = self.akku.energie_abgeben(benötigte_energie, stunde) stündlicher_netzbezug_wh = benötigte_energie - aus_akku netzbezug_wh_pro_stunde.append(stündlicher_netzbezug_wh) eigenverbrauch_wh_pro_stunde.append(erzeugung) @@ -86,7 +92,10 @@ class EnergieManagementSystem: 'Kosten_Euro_pro_Stunde': kosten_euro_pro_stunde, 'akku_soc_pro_stunde': akku_soc_pro_stunde, 'Einnahmen_Euro_pro_Stunde': einnahmen_euro_pro_stunde, - 'Gesamtkosten_Euro': gesamtkosten_euro + 'Gesamtbilanz_Euro': gesamtkosten_euro, + 'Gesamteinnahmen_Euro': sum(einnahmen_euro_pro_stunde), + 'Gesamtkosten_Euro': sum(kosten_euro_pro_stunde) + } # def simuliere(self): diff --git a/modules/visualize.py b/modules/visualize.py index 734f865..090bf93 100644 --- a/modules/visualize.py +++ b/modules/visualize.py @@ -57,7 +57,12 @@ def visualisiere_ergebnisse(last, pv_forecast, strompreise, ergebnisse): # Zusammenfassende Finanzen plt.subplot(3, 2, 3) gesamtkosten = ergebnisse['Gesamtkosten_Euro'] - plt.bar('Gesamtkosten', gesamtkosten, color='red' if gesamtkosten > 0 else 'green') + gesamteinnahmen = ergebnisse['Gesamteinnahmen_Euro'] + gesamtbilanz = ergebnisse['Gesamtbilanz_Euro'] + plt.bar('GesamtKosten', gesamtkosten, color='red' if gesamtkosten > 0 else 'green') + plt.bar('GesamtEinnahmen', gesamteinnahmen, color='red' if gesamtkosten > 0 else 'green') + plt.bar('GesamtBilanz', gesamtbilanz, color='red' if gesamtkosten > 0 else 'green') + plt.title('Gesamtkosten') plt.ylabel('Euro') @@ -67,3 +72,4 @@ def visualisiere_ergebnisse(last, pv_forecast, strompreise, ergebnisse): plt.tight_layout() plt.show() + diff --git a/test.py b/test.py index fecd19e..2b7c111 100644 --- a/test.py +++ b/test.py @@ -9,8 +9,9 @@ from modules.class_strompreis import * from pprint import pprint import matplotlib.pyplot as plt from modules.visualize import * - - +from deap import base, creator, tools, algorithms +import numpy as np +import random date = "2024-02-16" @@ -18,7 +19,17 @@ akku_size = 1000 # Wh year_energy = 2000*1000 #Wh einspeiseverguetung_cent_pro_wh = np.full(24, 7/1000.0) + akku = PVAkku(akku_size) +discharge_array = np.full(24,1) +# discharge_array[12] = 0 +# discharge_array[13] = 0 +# discharge_array[14] = 0 +# discharge_array[15] = 0 +# discharge_array[16] = 0 +# discharge_array[17] = 0 +# discharge_array[18] = 1 +# akku.set_discharge_per_hour(discharge_array) # Load Forecast lf = LoadForecast(filepath=r'load_profiles.npz', year_energy=year_energy) @@ -40,7 +51,58 @@ specific_date_prices = price_forecast.get_prices_for_date(date) # EMS / Stromzähler Bilanz ems = EnergieManagementSystem(akku, specific_date_load, pv_forecast, specific_date_prices, einspeiseverguetung_cent_pro_wh) o = ems.simuliere() -pprint(o) +pprint(o["Gesamtbilanz_Euro"]) + + +# Optimierung + +# Fitness-Funktion (muss Ihre EnergieManagementSystem-Logik integrieren) +def evaluate(individual): + # Hier müssen Sie Ihre Logik einbauen, um die Gesamtbilanz zu berechnen + # basierend auf dem gegebenen `individual` (discharge_array) + #akku.set_discharge_per_hour(individual) + ems.reset() + ems.set_akku_discharge_hours(individual) + o = ems.simuliere() + gesamtbilanz = o["Gesamtbilanz_Euro"] + #print(individual, " ",gesamtbilanz) + return (gesamtbilanz,) + +# Werkzeug-Setup +creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) +creator.create("Individual", list, fitness=creator.FitnessMin) + +toolbox = base.Toolbox() +toolbox.register("attr_bool", random.randint, 0, 1) +toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, 24) +toolbox.register("population", tools.initRepeat, list, toolbox.individual) + +toolbox.register("evaluate", evaluate) +toolbox.register("mate", tools.cxTwoPoint) +toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) +toolbox.register("select", tools.selTournament, tournsize=3) + +# Genetischer Algorithmus +def optimize(): + population = toolbox.population(n=100) + hof = tools.HallOfFame(1) + + stats = tools.Statistics(lambda ind: ind.fitness.values) + stats.register("avg", np.mean) + stats.register("min", np.min) + stats.register("max", np.max) + + algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.2, ngen=100, + stats=stats, halloffame=hof, verbose=True) + return hof[0] + +best_solution = optimize() +print("Beste Lösung:", best_solution) + +ems.set_akku_discharge_hours(best_solution) +o = ems.simuliere() +pprint(o["Gesamtbilanz_Euro"]) + visualisiere_ergebnisse(specific_date_load, pv_forecast, specific_date_prices, o)