Verluste stündlich / gesamt werden ausgegeben und mit minimiert

Start ab Stunde X jetzt möglich

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
+            return 0.0, 0.0  # Keine Energieabgabe und keine Verluste
-        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
         
-        # if self.soc_wh >= wh:
+        # Berechnung der maximal abgebenden Energiemenge unter Berücksichtigung der Entladeeffizienz
-            # self.soc_wh -= wh
+        max_abgebbar_wh = self.soc_wh * self.entlade_effizienz
-            # return wh
+        
-        # else:
+        # Tatsächlich abgegebene Energie darf nicht mehr sein als angefragt und nicht mehr als maximal abgebbar
-            # abgegebene_energie = self.soc_wh
+        tatsaechlich_abgegeben_wh = min(wh, max_abgebbar_wh)
-            # self.soc_wh = 0
+        
-            # return abgegebene_energie
+        # 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)
 
 
 

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
-   
+        self.eauto = eauto
-    def set_gesamtlast(self,load):
-        self.lastkurve_wh = load
     
     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 = []
+        eauto_soc_pro_stunde = []
+        verluste_wh_pro_stunde = []
+        lastkurve_wh = self.gesamtlast.gesamtlast_berechnen()
         
-        #print(gesamtlast_pro_stunde)
-        #sys.exit()
         
-        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)
+                #geladene_energie = min(überschuss, self.akku.kapazitaet_wh - self.akku.soc_wh)
-                self.akku.energie_laden(geladene_energie)
+                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,22 +88,29 @@ 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']
+        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]
+        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)
+            
             
         }
         

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):
+def visualisiere_ergebnisse(gesamtlast, pv_forecast, strompreise, ergebnisse,  discharge_hours, laden_moeglich, temperature, start_hour, prediction_hours):
-    # Last und PV-Erzeugung
-    plt.figure(figsize=(14, 10))
 
+    #####################
+    # 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)
+    # Strompreise
-    print(len(ergebnisse['Eigenverbrauch_Wh_pro_Stunde']))
+    stundenp = np.arange(1, len(strompreise)+1)
-
-    
-    stunden = np.arange(1, len(ergebnisse['Eigenverbrauch_Wh_pro_Stunde'])+1)
-    # Eigenverbrauch, Netzeinspeisung und Netzbezug
     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, ergebnisse['Verluste_Pro_Stunde'], label='Verluste (Wh)', marker='^')
-    #plt.plot(stunden, last, label='Last (Wh)', marker='o')
     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,14 +93,8 @@ 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')
+    labels = ['GesamtKosten [€]', 'GesamtEinnahmen [€]', 'GesamtBilanz [€]']
-    plt.bar('GesamtEinnahmen', gesamteinnahmen, color='red' if gesamtkosten > 0 else 'green')
+    werte = [gesamtkosten, gesamteinnahmen, gesamtbilanz]
-    plt.bar('GesamtBilanz', gesamtbilanz, color='red' if gesamtkosten > 0 else 'green')
+    colors = ['red' if wert > 0 else 'green' for wert in werte]
 
-    plt.title('Gesamtkosten')
+    ax1.bar(labels, werte, color=colors)
-    plt.ylabel('Euro')
+    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.legend()
+    # plt.title('Gesamtkosten')
-    plt.grid(True)
+    # plt.ylabel('Euro')
 
-    plt.tight_layout()
+
+    # plt.legend()
+    # plt.grid(True)
+
+    # plt.tight_layout()
     plt.show()
 

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)
+eauto = PVAkku(kapazitaet_wh=60000, hours=prediction_hours, lade_effizienz=0.95, entlade_effizienz=1.0, max_ladeleistung_w=10000 ,start_soc_prozent=10)
-min_soc_eauto = 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()
+# leistung_eauto = eauto.get_stuendliche_last()
-soc_eauto = eauto.get_stuendlicher_soc()
+# soc_eauto = eauto.get_stuendlicher_soc()
-gesamtlast.hinzufuegen("eauto", leistung_eauto)
+# 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)
+    ems.set_eauto_charge_hours(eautocharge_hours_float)
     
-    eauto.set_laden_moeglich(eautocharge_hours_float)
+    #eauto.set_laden_moeglich(eautocharge_hours_float)
-    eauto.berechne_ladevorgang()
+    #eauto.berechne_ladevorgang()
-    leistung_eauto = eauto.get_stuendliche_last()
+    #leistung_eauto = eauto.get_stuendliche_last()
-    gesamtlast.hinzufuegen("eauto", leistung_eauto)
+    #gesamtlast.hinzufuegen("eauto", leistung_eauto)
     
-    ems.set_gesamtlast(gesamtlast.gesamtlast_berechnen())
+    #ems.set_gesamtlast(gesamtlast.gesamtlast_berechnen())
     
-    o = ems.simuliere(0)
+    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():