- Akku mit Verlusten + Bug in der test.py Gesamtlast kein update

modules/class_akku.py

@@ -1,12 +1,15 @@
 import numpy as np
 class PVAkku:
-    def __init__(self, kapazitaet_wh, hours):
+    def __init__(self, kapazitaet_wh, hours, lade_effizienz=0.9, entlade_effizienz=0.9):
         # Kapazität des Akkus in Wh
         self.kapazitaet_wh = kapazitaet_wh
         # Initialer Ladezustand des Akkus in Wh
         self.soc_wh = 0
         self.hours = hours
         self.discharge_array = np.full(self.hours, 1)
+        # Lade- und Entladeeffizienz
+        self.lade_effizienz = lade_effizienz
+        self.entlade_effizienz = entlade_effizienz        
 
     def reset(self):
         self.soc_wh = 0
@@ -22,19 +25,27 @@ class PVAkku:
     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
-        else:
-            abgegebene_energie = self.soc_wh
-            self.soc_wh = 0
-            return abgegebene_energie
+        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:
+            # self.soc_wh -= wh
+            # return wh
+        # else:
+            # abgegebene_energie = self.soc_wh
+            # self.soc_wh = 0
+            # return abgegebene_energie
 
     def energie_laden(self, wh):
-        if self.soc_wh + wh <= self.kapazitaet_wh:
-            self.soc_wh += wh
-        else:
-            self.soc_wh = self.kapazitaet_wh
+        # Berechnung der tatsächlichen Lademenge unter Berücksichtigung der Ladeeffizienz
+        effektive_lademenge = wh * self.lade_effizienz
+        # Aktualisierung des Ladezustands ohne die Kapazität zu überschreiten
+        self.soc_wh = min(self.soc_wh + effektive_lademenge, self.kapazitaet_wh)
+
 
 
 

modules/class_eauto.py

@@ -6,6 +6,7 @@ from pprint import pprint
 class EAuto:
     def __init__(self, soc=None, capacity = None, power_charge = None, load_allowed = None):
         self.soc = soc
+        self.init_soc = soc
         self.akku_kapazitaet = capacity
         self.ladegeschwindigkeit = power_charge
         self.laden_moeglich = None
@@ -14,9 +15,13 @@ class EAuto:
         self.laden_moeglich = load_allowed
         self.berechne_ladevorgang()
 
+    def reset(self):
+        self.soc = self.init_soc
+        self.stuendlicher_soc = []
+        
     def set_laden_moeglich(self, laden_moeglich):
         self.laden_moeglich = laden_moeglich
-        self.stuendlicher_soc = [self.soc]  # Beginnt mit dem aktuellen SoC
+        self.stuendlicher_soc = []  # Beginnt mit dem aktuellen SoC
         self.stuendliche_last = []  # Zurücksetzen der stündlichen Last
 
     def berechne_ladevorgang(self):

modules/class_ems.py

@@ -10,6 +10,8 @@ class EnergieManagementSystem:
         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
     
     def set_akku_discharge_hours(self, ds):
         self.akku.set_discharge_per_hour(ds)

modules/class_load.py

@@ -66,11 +66,13 @@ class LoadForecast:
         end_day_of_year = end_date.timetuple().tm_yday
 
         # Beachten, dass bei Schaltjahren der Tag des Jahres angepasst werden muss
-        stats_for_range = self.data_year_energy[start_day_of_year-1:end_day_of_year]  # -1 da die Indizierung bei 0 beginnt
-        
+        stats_for_range = self.data_year_energy[start_day_of_year:end_day_of_year]  # -1 da die Indizierung bei 0 beginnt
+        # print()
+        # print(stats_for_range)
+        # print(start_day_of_year, " ",end_day_of_year)
         # Hier kannst du entscheiden, wie du die Daten über den Zeitraum aggregieren möchtest
         # Zum Beispiel könntest du Mittelwerte, Summen oder andere Statistiken über diesen Zeitraum berechnen
-        return stats_for_range
+        return stats_for_range[0]
 
 
 

modules/visualize.py

@@ -1,19 +1,13 @@
 import numpy as np
-import matplotlib.pyplot as plt
-import numpy as np
-import matplotlib.pyplot as plt
 from modules.class_load_container import Gesamtlast  # Stellen Sie sicher, dass dies dem tatsächlichen Importpfad entspricht
+import matplotlib.pyplot as plt
 
 
-
-
-def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecast, strompreise, ergebnisse):
-   
-
+def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecast, strompreise, ergebnisse, soc_eauto, discharge_hours, laden_moeglich):
     # Last und PV-Erzeugung
     plt.figure(figsize=(14, 10))
     
-    plt.subplot(3, 1, 1)
+    plt.subplot(3, 2, 1)
     stunden = np.arange(1, len(next(iter(gesamtlast.lasten.values()))) + 1)
     
     
@@ -31,9 +25,13 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas
     plt.grid(True)
     plt.legend()
 
+
+
+
+
     # Strompreise
     stundenp = np.arange(1, len(strompreise)+1)
-    plt.subplot(3, 1, 2)
+    plt.subplot(3, 2, 2)
     plt.plot(stundenp, strompreise, label='Strompreis (€/Wh)', color='purple', marker='s')
     plt.title('Strompreise')
     plt.xlabel('Stunde des Tages')
@@ -41,26 +39,44 @@ 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']))
 
-    plt.figure(figsize=(18, 12))
+    
     stunden = np.arange(1, len(ergebnisse['Eigenverbrauch_Wh_pro_Stunde'])+1)
     # Eigenverbrauch, Netzeinspeisung und Netzbezug
-    plt.subplot(3, 2, 1)
+    plt.subplot(3, 2, 3)
     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['akku_soc_pro_stunde'], label='Akku (%)', 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, pv_forecast, label='PV-Erzeugung (Wh)', marker='x')
     #plt.plot(stunden, last, label='Last (Wh)', marker='o')
-    
     plt.title('Energiefluss pro Stunde')
     plt.xlabel('Stunde')
     plt.ylabel('Energie (Wh)')
     plt.legend()
-    plt.grid(True)
+    
+    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.legend(loc='upper left')
 
+    ax1 = plt.subplot(3, 2, 5)
+    for hour, value in enumerate(discharge_hours):
+        if value == 1:
+            ax1.axvspan(hour, hour+1, color='red', alpha=0.3, label='Entlademöglichkeit' if hour == 0 else "")
+    for hour, value in enumerate(laden_moeglich):
+        if value == 1:
+            ax1.axvspan(hour, hour+1, color='green', alpha=0.3, label='Lademöglichkeit' if hour == 0 else "")
+    ax1.legend(loc='upper left')
+
+
+    
+    
+    plt.grid(True)
+    plt.figure(figsize=(14, 10))
     # Kosten und Einnahmen pro Stunde
-    plt.subplot(3, 2, 2)
+    plt.subplot(1, 2, 1)
     plt.plot(stunden, ergebnisse['Kosten_Euro_pro_Stunde'], label='Kosten (Euro)', marker='o', color='red')
     plt.plot(stunden, ergebnisse['Einnahmen_Euro_pro_Stunde'], label='Einnahmen (Euro)', marker='x', color='green')
     plt.title('Finanzielle Bilanz pro Stunde')
@@ -70,7 +86,7 @@ def visualisiere_ergebnisse(gesamtlast,leistung_haushalt,leistung_wp, pv_forecas
     plt.grid(True)
 
     # Zusammenfassende Finanzen
-    plt.subplot(3, 2, 3)
+    plt.subplot(1, 2, 2)
     gesamtkosten = ergebnisse['Gesamtkosten_Euro']
     gesamteinnahmen = ergebnisse['Gesamteinnahmen_Euro']
     gesamtbilanz = ergebnisse['Gesamtbilanz_Euro']