From a1f7d683d48ba351be30641b425792e23134766e Mon Sep 17 00:00:00 2001 From: Bla Bla Date: Mon, 25 Mar 2024 14:40:48 +0100 Subject: [PATCH] =?UTF-8?q?Verluste=20st=C3=BCndlich=20/=20gesamt=20werden?= =?UTF-8?q?=20ausgegeben=20und=20mit=20minimiert=20Start=20ab=20Stunde=20X?= =?UTF-8?q?=20jetzt=20m=C3=B6glich?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- modules/class_akku.py | 69 +++++++++++++++++++-------- modules/class_ems.py | 71 ++++++++++++++++++++-------- modules/visualize.py | 105 +++++++++++++++++++++++++++--------------- test.py | 99 +++++++++++---------------------------- 4 files changed, 194 insertions(+), 150 deletions(-) diff --git a/modules/class_akku.py b/modules/class_akku.py index d801a52..ca59170 100644 --- a/modules/class_akku.py +++ b/modules/class_akku.py @@ -1,50 +1,79 @@ import numpy as np class PVAkku: - def __init__(self, kapazitaet_wh, hours, lade_effizienz=0.9, entlade_effizienz=0.9): + def __init__(self, kapazitaet_wh=None, hours=None, lade_effizienz=0.9, entlade_effizienz=0.9,max_ladeleistung_w=None,start_soc_prozent=0): # Kapazität des Akkus in Wh self.kapazitaet_wh = kapazitaet_wh # Initialer Ladezustand des Akkus in Wh - self.soc_wh = 0 + self.start_soc_prozent = start_soc_prozent + self.soc_wh = (start_soc_prozent / 100) * kapazitaet_wh self.hours = hours self.discharge_array = np.full(self.hours, 1) + self.charge_array = np.full(self.hours, 1) # Lade- und Entladeeffizienz self.lade_effizienz = lade_effizienz self.entlade_effizienz = entlade_effizienz + self.max_ladeleistung_w = max_ladeleistung_w if max_ladeleistung_w else self.kapazitaet_wh + def reset(self): - self.soc_wh = 0 + self.soc_wh = (self.start_soc_prozent / 100) * self.kapazitaet_wh self.discharge_array = np.full(self.hours, 1) + self.charge_array = np.full(self.hours, 1) def set_discharge_per_hour(self, discharge_array): assert(len(discharge_array) == self.hours) self.discharge_array = discharge_array + def set_charge_per_hour(self, charge_array): + assert(len(charge_array) == self.hours) + self.charge_array = charge_array + def ladezustand_in_prozent(self): return (self.soc_wh / self.kapazitaet_wh) * 100 def energie_abgeben(self, wh, hour): if self.discharge_array[hour] == 0: - return 0.0 - soc_tmp = self.soc_wh - # Berechnung der tatsächlichen Entlademenge unter Berücksichtigung der Entladeeffizienz - effektive_entlademenge = wh / self.entlade_effizienz - # Aktualisierung des Ladezustands ohne negativ zu werden - self.soc_wh = max(self.soc_wh - effektive_entlademenge, 0) - return soc_tmp-self.soc_wh + return 0.0, 0.0 # Keine Energieabgabe und keine Verluste - # if self.soc_wh >= wh: - # self.soc_wh -= wh - # return wh - # else: - # abgegebene_energie = self.soc_wh - # self.soc_wh = 0 - # return abgegebene_energie + # Berechnung der maximal abgebenden Energiemenge unter Berücksichtigung der Entladeeffizienz + max_abgebbar_wh = self.soc_wh * self.entlade_effizienz + + # Tatsächlich abgegebene Energie darf nicht mehr sein als angefragt und nicht mehr als maximal abgebbar + tatsaechlich_abgegeben_wh = min(wh, max_abgebbar_wh) + + # Berechnung der tatsächlichen Entnahmemenge aus dem Akku (vor Effizienzverlust) + tatsaechliche_entnahme_wh = tatsaechlich_abgegeben_wh / self.entlade_effizienz + + # Aktualisierung des Ladezustands unter Berücksichtigung der tatsächlichen Entnahmemenge + self.soc_wh -= tatsaechliche_entnahme_wh + + # Berechnung der Verluste durch die Effizienz + verluste_wh = tatsaechliche_entnahme_wh - tatsaechlich_abgegeben_wh + + # Rückgabe der tatsächlich abgegebenen Energiemenge und der Verluste + return tatsaechlich_abgegeben_wh, verluste_wh + + # return soc_tmp-self.soc_wh + + def energie_laden(self, wh, hour): + if hour is not None and self.charge_array[hour] == 0: + return 0,0 # Ladevorgang in dieser Stunde nicht erlaubt + + # Wenn kein Wert für wh angegeben wurde, verwende die maximale Ladeleistung + wh = wh if wh is not None else self.max_ladeleistung_w - def energie_laden(self, wh): # Berechnung der tatsächlichen Lademenge unter Berücksichtigung der Ladeeffizienz - effektive_lademenge = wh * self.lade_effizienz + effektive_lademenge = min(wh, self.max_ladeleistung_w) * self.lade_effizienz + # Aktualisierung des Ladezustands ohne die Kapazität zu überschreiten - self.soc_wh = min(self.soc_wh + effektive_lademenge, self.kapazitaet_wh) + geladene_menge = min(self.kapazitaet_wh - self.soc_wh, effektive_lademenge) + self.soc_wh += geladene_menge + + verluste_wh = geladene_menge* (1.0-self.lade_effizienz) + + return geladene_menge, verluste_wh + # effektive_lademenge = wh * self.lade_effizienz + # self.soc_wh = min(self.soc_wh + effektive_lademenge, self.kapazitaet_wh) diff --git a/modules/class_ems.py b/modules/class_ems.py index 8cd9f00..14446ba 100644 --- a/modules/class_ems.py +++ b/modules/class_ems.py @@ -3,20 +3,23 @@ from pprint import pprint class EnergieManagementSystem: - def __init__(self, akku, lastkurve_wh, pv_prognose_wh, strompreis_cent_pro_wh, einspeiseverguetung_cent_pro_wh): + def __init__(self, akku=None, pv_prognose_wh=None, strompreis_cent_pro_wh=None, einspeiseverguetung_cent_pro_wh=None, eauto=None, gesamtlast=None): self.akku = akku - self.lastkurve_wh = lastkurve_wh + #self.lastkurve_wh = lastkurve_wh + self.gesamtlast = gesamtlast 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_gesamtlast(self,load): - self.lastkurve_wh = load + self.eauto = eauto def set_akku_discharge_hours(self, ds): self.akku.set_discharge_per_hour(ds) + + def set_eauto_charge_hours(self, ds): + self.eauto.set_charge_per_hour(ds) def reset(self): + self.eauto.reset() self.akku.reset() def simuliere_ab_jetzt(self): @@ -38,29 +41,46 @@ class EnergieManagementSystem: kosten_euro_pro_stunde = [] einnahmen_euro_pro_stunde = [] akku_soc_pro_stunde = [] - - #print(gesamtlast_pro_stunde) - #sys.exit() + eauto_soc_pro_stunde = [] + verluste_wh_pro_stunde = [] + lastkurve_wh = self.gesamtlast.gesamtlast_berechnen() - ende = min( len(self.lastkurve_wh),len(self.pv_prognose_wh), len(self.strompreis_cent_pro_wh)) + + ende = min( len(lastkurve_wh),len(self.pv_prognose_wh), len(self.strompreis_cent_pro_wh)) #print(ende) # Berechnet das Ende basierend auf der Länge der Lastkurve for stunde in range(start_stunde, ende): # Anpassung, um sicherzustellen, dass Indizes korrekt sind - verbrauch = self.lastkurve_wh[stunde] + verbrauch = lastkurve_wh[stunde] erzeugung = self.pv_prognose_wh[stunde] strompreis = self.strompreis_cent_pro_wh[stunde] if stunde < len(self.strompreis_cent_pro_wh) else self.strompreis_cent_pro_wh[-1] - #print(verbrauch," ",erzeugung," ",strompreis) + verluste_wh_pro_stunde.append(0.0) + #eauto_soc = self.eauto.get_stuendlicher_soc()[stunde] + + + # Logik für die E-Auto-Ladung bzw. Entladung + if self.eauto: # Falls ein E-Auto vorhanden ist + geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden(None,stunde) + verbrauch = verbrauch + geladene_menge_eauto + verluste_wh_pro_stunde[-1] += verluste_eauto + #print("verluste_eauto:",verluste_eauto) + #eauto_soc_pro_stunde.append(eauto_soc) + # Fügen Sie hier zusätzliche Logik für E-Auto ein, z.B. Ladung über Nacht + + stündlicher_netzbezug_wh = 0 stündliche_kosten_euro = 0 stündliche_einnahmen_euro = 0 + eauto_soc = self.eauto.ladezustand_in_prozent() if erzeugung > verbrauch: überschuss = erzeugung - verbrauch - geladene_energie = min(überschuss, self.akku.kapazitaet_wh - self.akku.soc_wh) - self.akku.energie_laden(geladene_energie) + #geladene_energie = min(überschuss, self.akku.kapazitaet_wh - self.akku.soc_wh) + geladene_energie, verluste_laden_akku = self.akku.energie_laden(überschuss, stunde) + verluste_wh_pro_stunde[-1] += verluste_laden_akku + #print("verluste_laden_akku:",verluste_laden_akku) netzeinspeisung_wh_pro_stunde.append(überschuss - geladene_energie) eigenverbrauch_wh_pro_stunde.append(verbrauch) stündliche_einnahmen_euro = (überschuss - geladene_energie) * self.einspeiseverguetung_cent_pro_wh[stunde] @@ -68,23 +88,30 @@ class EnergieManagementSystem: else: netzeinspeisung_wh_pro_stunde.append(0.0) benötigte_energie = verbrauch - erzeugung - aus_akku = self.akku.energie_abgeben(benötigte_energie, stunde) + aus_akku, akku_entladeverluste = self.akku.energie_abgeben(benötigte_energie, stunde) + verluste_wh_pro_stunde[-1] += akku_entladeverluste + #print("akku_entladeverluste:",akku_entladeverluste) + stündlicher_netzbezug_wh = benötigte_energie - aus_akku netzbezug_wh_pro_stunde.append(stündlicher_netzbezug_wh) - eigenverbrauch_wh_pro_stunde.append(erzeugung) + eigenverbrauch_wh_pro_stunde.append(erzeugung+aus_akku) stündliche_kosten_euro = stündlicher_netzbezug_wh * strompreis + + #print(self.akku.ladezustand_in_prozent()) + eauto_soc_pro_stunde.append(eauto_soc) akku_soc_pro_stunde.append(self.akku.ladezustand_in_prozent()) kosten_euro_pro_stunde.append(stündliche_kosten_euro) einnahmen_euro_pro_stunde.append(stündliche_einnahmen_euro) - # Berechnung der Gesamtbilanzen + gesamtkosten_euro = sum(kosten_euro_pro_stunde) - sum(einnahmen_euro_pro_stunde) expected_length = ende - start_stunde - array_names = ['Eigenverbrauch_Wh_pro_Stunde', 'Netzeinspeisung_Wh_pro_Stunde', 'Netzbezug_Wh_pro_Stunde', 'Kosten_Euro_pro_Stunde', 'akku_soc_pro_stunde', 'Einnahmen_Euro_pro_Stunde'] - all_arrays = [eigenverbrauch_wh_pro_stunde, netzeinspeisung_wh_pro_stunde, netzbezug_wh_pro_stunde, kosten_euro_pro_stunde, akku_soc_pro_stunde, einnahmen_euro_pro_stunde] + array_names = ['Eigenverbrauch_Wh_pro_Stunde', 'Netzeinspeisung_Wh_pro_Stunde', 'Netzbezug_Wh_pro_Stunde', 'Kosten_Euro_pro_Stunde', 'akku_soc_pro_stunde', 'Einnahmen_Euro_pro_Stunde','E-Auto_SoC_pro_Stunde', "Verluste_Pro_Stunde"] + all_arrays = [eigenverbrauch_wh_pro_stunde, netzeinspeisung_wh_pro_stunde, netzbezug_wh_pro_stunde, kosten_euro_pro_stunde, akku_soc_pro_stunde, einnahmen_euro_pro_stunde,eauto_soc_pro_stunde,verluste_wh_pro_stunde] inconsistent_arrays = [name for name, arr in zip(array_names, all_arrays) if len(arr) != expected_length] - + #print(inconsistent_arrays) + if inconsistent_arrays: raise ValueError(f"Inkonsistente Längen bei den Arrays: {', '.join(inconsistent_arrays)}. Erwartete Länge: {expected_length}, gefunden: {[len(all_arrays[array_names.index(name)]) for name in inconsistent_arrays]}") @@ -96,8 +123,12 @@ class EnergieManagementSystem: 'akku_soc_pro_stunde': akku_soc_pro_stunde, 'Einnahmen_Euro_pro_Stunde': einnahmen_euro_pro_stunde, 'Gesamtbilanz_Euro': gesamtkosten_euro, + 'E-Auto_SoC_pro_Stunde':eauto_soc_pro_stunde, 'Gesamteinnahmen_Euro': sum(einnahmen_euro_pro_stunde), - 'Gesamtkosten_Euro': sum(kosten_euro_pro_stunde) + 'Gesamtkosten_Euro': sum(kosten_euro_pro_stunde), + "Verluste_Pro_Stunde":verluste_wh_pro_stunde, + "Gesamt_Verluste":sum(verluste_wh_pro_stunde) + } diff --git a/modules/visualize.py b/modules/visualize.py index 8d06402..af89491 100644 --- a/modules/visualize.py +++ b/modules/visualize.py @@ -3,12 +3,16 @@ from modules.class_load_container import Gesamtlast # Stellen Sie sicher, dass import matplotlib.pyplot as plt -def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecast, strompreise, ergebnisse, soc_eauto, discharge_hours, laden_moeglich, temperature): - # Last und PV-Erzeugung - plt.figure(figsize=(14, 10)) +def visualisiere_ergebnisse(gesamtlast, pv_forecast, strompreise, ergebnisse, discharge_hours, laden_moeglich, temperature, start_hour, prediction_hours): + + ##################### + # 24h + ##################### + # Last und PV-Erzeugung + plt.figure(figsize=(14, 14)) plt.subplot(3, 2, 1) - stunden = np.arange(1, len(next(iter(gesamtlast.lasten.values()))) + 1) + stunden = np.arange(0, prediction_hours) # Einzellasten plotten @@ -18,7 +22,6 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas # Gesamtlast berechnen und plotten gesamtlast_array = gesamtlast.gesamtlast_berechnen() plt.plot(stunden, gesamtlast_array, label='Gesamtlast (Wh)', marker='o', linewidth=2, linestyle='--') - plt.xlabel('Stunde') plt.ylabel('Last (Wh)') plt.title('Lastprofile') @@ -26,9 +29,6 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas plt.legend() - - - # Strompreise stundenp = np.arange(1, len(strompreise)+1) plt.subplot(3, 2, 2) @@ -39,29 +39,52 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas plt.legend() plt.grid(True) - print(pv_forecast.shape) - print(len(ergebnisse['Eigenverbrauch_Wh_pro_Stunde'])) - - - stunden = np.arange(1, len(ergebnisse['Eigenverbrauch_Wh_pro_Stunde'])+1) - # Eigenverbrauch, Netzeinspeisung und Netzbezug + # Strompreise + stundenp = np.arange(1, len(strompreise)+1) plt.subplot(3, 2, 3) + plt.plot(stunden, pv_forecast, label='PV-Erzeugung (Wh)', marker='x') + plt.title('PV Forecast') + plt.xlabel('Stunde des Tages') + plt.ylabel('Wh') + plt.legend() + plt.grid(True) + + # Temperatur Forecast + plt.subplot(3, 2, 4) + plt.title('Temperatur Forecast °C') + plt.plot(stunden, temperature, label='Temperatur °C', marker='x') + plt.xlabel('Stunde des Tages') + plt.ylabel('°C') + plt.legend() + plt.grid(True) + + + ##################### + # Start_Hour + ##################### + + plt.figure(figsize=(14, 10)) + stunden = np.arange(start_hour, prediction_hours) + # Eigenverbrauch, Netzeinspeisung und Netzbezug + plt.subplot(3, 2, 1) plt.plot(stunden, ergebnisse['Eigenverbrauch_Wh_pro_Stunde'], label='Eigenverbrauch (Wh)', marker='o') plt.plot(stunden, ergebnisse['Netzeinspeisung_Wh_pro_Stunde'], label='Netzeinspeisung (Wh)', marker='x') plt.plot(stunden, ergebnisse['Netzbezug_Wh_pro_Stunde'], label='Netzbezug (Wh)', marker='^') - plt.plot(stunden, pv_forecast, label='PV-Erzeugung (Wh)', marker='x') - #plt.plot(stunden, last, label='Last (Wh)', marker='o') + plt.plot(stunden, ergebnisse['Verluste_Pro_Stunde'], label='Verluste (Wh)', marker='^') plt.title('Energiefluss pro Stunde') plt.xlabel('Stunde') plt.ylabel('Energie (Wh)') plt.legend() - plt.subplot(3, 2, 4) - plt.plot(stunden, ergebnisse['akku_soc_pro_stunde'], label='Akku (%)', marker='x') - plt.plot(stunden, soc_eauto, label='Eauto Akku (%)', marker='x') + + + + plt.subplot(3, 2, 2) + plt.plot(stunden, ergebnisse['akku_soc_pro_stunde'], label='PV Akku (%)', marker='x') + plt.plot(stunden, ergebnisse['E-Auto_SoC_pro_Stunde'], label='E-Auto Akku (%)', marker='x') plt.legend(loc='upper left') - ax1 = plt.subplot(3, 2, 5) + ax1 = plt.subplot(3, 2, 3) for hour, value in enumerate(discharge_hours): #if value == 1: ax1.axvspan(hour, hour+1, color='red',ymax=value, alpha=0.3, label='Entlademöglichkeit' if hour == 0 else "") @@ -70,13 +93,7 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas ax1.axvspan(hour, hour+1, color='green',ymax=value, alpha=0.3, label='Lademöglichkeit' if hour == 0 else "") ax1.legend(loc='upper left') - ax1 = plt.subplot(3, 2, 6) - ax1.plot(stunden, temperature, label='Temperatur °C', marker='x') - - - ax2 = ax1.twinx() - ax2.plot(stunden, leistung_wp, label='Wärmepumpe W', marker='x') - plt.legend(loc='upper left') + @@ -93,24 +110,38 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas plt.xlabel('Stunde') plt.ylabel('Euro') plt.legend() - plt.grid(True) + # Zusammenfassende Finanzen - plt.subplot(1, 2, 2) + fig, ax1 = plt.subplots() gesamtkosten = ergebnisse['Gesamtkosten_Euro'] 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') + labels = ['GesamtKosten [€]', 'GesamtEinnahmen [€]', 'GesamtBilanz [€]'] + werte = [gesamtkosten, gesamteinnahmen, gesamtbilanz] + colors = ['red' if wert > 0 else 'green' for wert in werte] + + ax1.bar(labels, werte, color=colors) + ax1.set_ylabel('Euro') + ax1.set_title('Finanzübersicht') + + # Zweite Achse (ax2) für die Verluste, geteilt mit ax1 + ax2 = ax1.twinx() + verluste = ergebnisse['Gesamt_Verluste'] + ax2.bar('GesamtVerluste', verluste, color='blue') + ax2.set_ylabel('Verluste [Wh]', color='blue') + + # Stellt sicher, dass die Achsenbeschriftungen der zweiten Achse in der gleichen Farbe angezeigt werden + ax2.tick_params(axis='y', labelcolor='blue') + - plt.title('Gesamtkosten') - plt.ylabel('Euro') + # plt.title('Gesamtkosten') + # plt.ylabel('Euro') - plt.legend() - plt.grid(True) + # plt.legend() + # plt.grid(True) - plt.tight_layout() + # plt.tight_layout() plt.show() diff --git a/test.py b/test.py index ead6618..9836928 100644 --- a/test.py +++ b/test.py @@ -19,7 +19,7 @@ import random import os - +start_hour = 11 prediction_hours = 24 date = (datetime.now().date() + timedelta(hours = prediction_hours)).strftime("%Y-%m-%d") date_now = datetime.now().strftime("%Y-%m-%d") @@ -36,8 +36,9 @@ discharge_array = np.full(prediction_hours,1) #np.array([1, 0, 1, 0, 1, 1, 1, 1, laden_moeglich = np.full(prediction_hours,1) # np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0]) #np.full(prediction_hours,1) -eauto = EAuto(soc=10, capacity = 60000, power_charge = 7000, load_allowed = laden_moeglich) -min_soc_eauto = 10 +eauto = PVAkku(kapazitaet_wh=60000, hours=prediction_hours, lade_effizienz=0.95, entlade_effizienz=1.0, max_ladeleistung_w=10000 ,start_soc_prozent=10) +eauto.set_charge_per_hour(laden_moeglich) +min_soc_eauto = 80 hohe_strafe = 10.0 @@ -82,24 +83,25 @@ gesamtlast.hinzufuegen("Heatpump", leistung_wp) # EAuto ###################### -leistung_eauto = eauto.get_stuendliche_last() -soc_eauto = eauto.get_stuendlicher_soc() -gesamtlast.hinzufuegen("eauto", leistung_eauto) +# leistung_eauto = eauto.get_stuendliche_last() +# soc_eauto = eauto.get_stuendlicher_soc() +# gesamtlast.hinzufuegen("eauto", leistung_eauto) # print(gesamtlast.gesamtlast_berechnen()) # EMS / Stromzähler Bilanz -ems = EnergieManagementSystem(akku, gesamtlast.gesamtlast_berechnen(), pv_forecast, specific_date_prices, einspeiseverguetung_cent_pro_wh) +#akku=None, pv_prognose_wh=None, strompreis_cent_pro_wh=None, einspeiseverguetung_cent_pro_wh=None, eauto=None, gesamtlast=None + +ems = EnergieManagementSystem(akku=akku, gesamtlast = gesamtlast, pv_prognose_wh=pv_forecast, strompreis_cent_pro_wh=specific_date_prices, einspeiseverguetung_cent_pro_wh=einspeiseverguetung_cent_pro_wh, eauto=eauto) -o = ems.simuliere(0)#ems.simuliere_ab_jetzt() +o = ems.simuliere(start_hour)#ems.simuliere_ab_jetzt() #pprint(o) #pprint(o["Gesamtbilanz_Euro"]) -#visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecast, specific_date_prices, o, soc_eauto) +#visualisiere_ergebnisse(gesamtlast, pv_forecast, specific_date_prices, o,discharge_array,laden_moeglich, temperature_forecast, start_hour, prediction_hours) -#sys.exit() # Optimierung @@ -111,17 +113,18 @@ def evaluate_inner(individual): #print(discharge_hours_bin) #print(len(eautocharge_hours_float)) ems.reset() - eauto.reset() + #eauto.reset() ems.set_akku_discharge_hours(discharge_hours_bin) - - eauto.set_laden_moeglich(eautocharge_hours_float) - eauto.berechne_ladevorgang() - leistung_eauto = eauto.get_stuendliche_last() - gesamtlast.hinzufuegen("eauto", leistung_eauto) + ems.set_eauto_charge_hours(eautocharge_hours_float) - ems.set_gesamtlast(gesamtlast.gesamtlast_berechnen()) + #eauto.set_laden_moeglich(eautocharge_hours_float) + #eauto.berechne_ladevorgang() + #leistung_eauto = eauto.get_stuendliche_last() + #gesamtlast.hinzufuegen("eauto", leistung_eauto) - o = ems.simuliere(0) + #ems.set_gesamtlast(gesamtlast.gesamtlast_berechnen()) + + o = ems.simuliere(start_hour) return o, eauto # Fitness-Funktion (muss Ihre EnergieManagementSystem-Logik integrieren) @@ -130,12 +133,13 @@ def evaluate(individual): gesamtbilanz = o["Gesamtbilanz_Euro"] # Überprüfung, ob der Mindest-SoC erreicht wird - final_soc = eauto.get_stuendlicher_soc()[-1] # Nimmt den SoC am Ende des Optimierungszeitraums + final_soc = eauto.ladezustand_in_prozent() # Nimmt den SoC am Ende des Optimierungszeitraums strafe = 0.0 #if final_soc < min_soc_eauto: # Fügt eine Strafe hinzu, wenn der Mindest-SoC nicht erreicht wird strafe = max(0,(min_soc_eauto - final_soc) * hohe_strafe ) # `hohe_strafe` ist ein vorher festgelegter Strafwert gesamtbilanz += strafe + gesamtbilanz += o["Gesamt_Verluste"]/1000.0 return (gesamtbilanz,) @@ -229,65 +233,14 @@ print("Beste Lösung:", best_solution) #ems.set_akku_discharge_hours(best_solution) o,eauto = evaluate_inner(best_solution) -soc_eauto = eauto.get_stuendlicher_soc() -print(soc_eauto) -pprint(o) -pprint(eauto.get_stuendlicher_soc()) - - - - - -# # 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("attr_float", random.uniform, 0.0, 1.0) -# toolbox.register("individual", tools.initCycle, creator.Individual, (toolbox.attr_bool,toolbox.attr_float), n=prediction_hours) - -# start_individual = toolbox.individual() -# start_individual[:] = start_solution - -# 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=1000) - # population[0] = start_individual - # 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.eaMuPlusLambda(population, toolbox, 100, 200, cxpb=0.5, mutpb=0.2, ngen=1000, stats=stats, halloffame=hof, verbose=True) - # #algorithms.eaSimple(population, toolbox, cxpb=0.2, mutpb=0.2, ngen=1000, 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,eauto = evaluate_inner(best_solution) - # soc_eauto = eauto.get_stuendlicher_soc() # print(soc_eauto) # pprint(o) # pprint(eauto.get_stuendlicher_soc()) -visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecast, specific_date_prices, o,soc_eauto,best_solution[0::2],best_solution[1::2] , temperature_forecast) + +#visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecast, specific_date_prices, o,soc_eauto,best_solution[0::2],best_solution[1::2] , temperature_forecast) +visualisiere_ergebnisse(gesamtlast, pv_forecast, specific_date_prices, o,best_solution[0::2],best_solution[1::2] , temperature_forecast, start_hour, prediction_hours) # for data in forecast.get_forecast_data():