Eauto gelöscht,

Resteinspseisung durch Verluste des Akkus

flask_server.py

@@ -76,8 +76,8 @@ toolbox.register("select", tools.selTournament, tournsize=3)
 
 
 # Genetischer Algorithmus
-def optimize():
+def optimize(start_solution=None):
-    population = toolbox.population(n=500)
+    population = toolbox.population(n=100)
     hof = tools.HallOfFame(1)
     
     stats = tools.Statistics(lambda ind: ind.fitness.values)
@@ -85,8 +85,13 @@ def optimize():
     stats.register("min", np.min)
     stats.register("max", np.max)
     
-    algorithms.eaMuPlusLambda(population, toolbox, 100, 200, cxpb=0.3, mutpb=0.3, ngen=500,             stats=stats, halloffame=hof, verbose=True)
+    print("Start:",start_solution)
-    #algorithms.eaSimple(population, toolbox, cxpb=0.2, mutpb=0.2, ngen=1000,             stats=stats, halloffame=hof, verbose=True)
+    
+    if start_solution is not None and start_solution != -1:
+            population.insert(0, creator.Individual(start_solution))     
+    
+    #algorithms.eaMuPlusLambda(population, toolbox, 100, 200, cxpb=0.3, mutpb=0.3, ngen=500,             stats=stats, halloffame=hof, verbose=True)
+    algorithms.eaSimple(population, toolbox, cxpb=0.5, mutpb=0.8, ngen=200,             stats=stats, halloffame=hof, verbose=True)
     return hof[0]
 
 
@@ -104,7 +109,7 @@ def durchfuehre_simulation(parameter):
     ############
     date = (datetime.now().date() + timedelta(hours = prediction_hours)).strftime("%Y-%m-%d")
     date_now = datetime.now().strftime("%Y-%m-%d")
-
+    
     akku_size = parameter['pv_akku_cap'] # Wh
     year_energy = parameter['year_energy'] #2000*1000 #Wh
     
@@ -124,6 +129,7 @@ def durchfuehre_simulation(parameter):
     eauto.set_charge_per_hour(laden_moeglich)
     min_soc_eauto = parameter['eauto_min_soc']
 
+    start_params = parameter['start_solution']
 
     gesamtlast = Gesamtlast()
 
@@ -171,9 +177,10 @@ def durchfuehre_simulation(parameter):
     
     toolbox.register("evaluate", evaluate_wrapper)
 
-    
+    print()
-
+    print("START:",start_params)
-    start_solution = optimize()
+    print()
+    start_solution = optimize(start_params)
     best_solution = start_solution
     o = evaluate_inner(best_solution, ems)
     eauto = ems.eauto.to_dict()
@@ -185,7 +192,7 @@ def durchfuehre_simulation(parameter):
     visualisiere_ergebnisse(gesamtlast, pv_forecast, specific_date_prices, o,best_solution[0::2],best_solution[1::2] , temperature_forecast, start_hour, prediction_hours)
     
     #print(eauto)
-    return {"discharge_hours_bin":discharge_hours_bin, "eautocharge_hours_float":eautocharge_hours_float ,"result":o ,"eauto_obj":eauto}
+    return {"discharge_hours_bin":discharge_hours_bin, "eautocharge_hours_float":eautocharge_hours_float ,"result":o ,"eauto_obj":eauto,"start_solution":best_solution}
 
 
 
@@ -196,7 +203,7 @@ def simulation():
         parameter = request.json
         
         # Erforderliche Parameter prüfen
-        erforderliche_parameter = [ 'pv_akku_cap', 'year_energy',"einspeiseverguetung_euro_pro_wh", 'max_heizleistung', 'pv_forecast_url', 'eauto_min_soc', "eauto_cap","eauto_charge_efficiency","eauto_charge_power","eauto_soc","pv_soc"]
+        erforderliche_parameter = [ 'pv_akku_cap', 'year_energy',"einspeiseverguetung_euro_pro_wh", 'max_heizleistung', 'pv_forecast_url', 'eauto_min_soc', "eauto_cap","eauto_charge_efficiency","eauto_charge_power","eauto_soc","pv_soc","start_solution"]
         for p in erforderliche_parameter:
             if p not in parameter:
                 return jsonify({"error": f"Fehlender Parameter: {p}"}), 400

modules/class_eauto.py

@@ -1,146 +0,0 @@
-import json
-from datetime import datetime, timedelta, timezone
-import numpy as np
-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
-        self.stuendlicher_soc = []
-        self.stuendliche_last = []  # Hinzugefügt für die Speicherung der stündlichen Last
-        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 = []  # Beginnt mit dem aktuellen SoC
-        self.stuendliche_last = []  # Zurücksetzen der stündlichen Last
-
-    def berechne_ladevorgang(self):
-        if self.laden_moeglich is None:
-            print("Lademöglichkeit wurde nicht gesetzt.")
-            return
-        
-        for moeglich in self.laden_moeglich:
-            if moeglich > 0.0 and self.soc < 100:
-                # Berechnung der geladenen Energie basierend auf dem Anteil der Lademöglichkeit
-                geladene_energie = min(self.ladegeschwindigkeit * moeglich, (100 - self.soc) / 100 * self.akku_kapazitaet)
-                self.soc += geladene_energie / self.akku_kapazitaet * 100
-                self.soc = min(100, self.soc)
-                self.stuendliche_last.append(geladene_energie)
-            else:
-                self.stuendliche_last.append(0)  # Keine Ladung in dieser Stunde
-            self.stuendlicher_soc.append(self.soc)
-            
-        # Umwandlung der stündlichen Last in ein NumPy-Array
-        self.stuendliche_last = np.array(self.stuendliche_last)
-
-    # def berechne_ladevorgang(self):
-        # if self.laden_moeglich is None:
-            # print("Lademöglichkeit wurde nicht gesetzt.")
-            # return
-        
-        # for moeglich in self.laden_moeglich:
-            # if moeglich > 1 and self.soc < 100:
-                # geladene_energie = min(self.ladegeschwindigkeit, (100 - self.soc) / 100 * self.akku_kapazitaet)
-                # self.soc += geladene_energie / self.akku_kapazitaet * 100
-                # self.soc = min(100, self.soc)
-                # self.stuendliche_last.append(geladene_energie)
-            # else:
-                # self.stuendliche_last.append(0)  # Keine Ladung in dieser Stunde
-            # self.stuendlicher_soc.append(self.soc)
-            
-        # # Umwandlung der stündlichen Last in ein NumPy-Array
-        # self.stuendliche_last = np.array(self.stuendliche_last)
-
-    def get_stuendliche_last(self):
-        """Gibt das NumPy-Array mit der stündlichen Last zurück."""
-        return self.stuendliche_last
-
-    def get_stuendlicher_soc(self):
-        """Gibt den stündlichen SoC als Liste zurück."""
-        return self.stuendlicher_soc
-
-
-# class EAuto:
-    # def __init__(self, soc, akku_kapazitaet, ladegeschwindigkeit):
-        # self.soc = soc
-        # self.akku_kapazitaet = akku_kapazitaet
-        # self.ladegeschwindigkeit = ladegeschwindigkeit
-        # self.laden_moeglich = None
-        # # Initialisieren des Arrays für den stündlichen SoC
-        # self.stuendlicher_soc = []
-
-    # def set_laden_moeglich(self, laden_moeglich):
-        # """
-        # Setzt das Array, das angibt, wann das Laden möglich ist.
-        # :param laden_moeglich: Ein Array von 0 und 1, das die Lademöglichkeit angibt
-        # """
-        # self.laden_moeglich = laden_moeglich
-        # # Zurücksetzen des stündlichen SoC Arrays bei jeder neuen Lademöglichkeit
-        # self.stuendlicher_soc = [self.soc]  # Start-SoC hinzufügen
-
-    # def berechne_ladevorgang(self):
-        # """
-        # Berechnet den Ladevorgang basierend auf der Ladegeschwindigkeit und der Lademöglichkeit.
-        # Aktualisiert den SoC entsprechend und speichert den stündlichen SoC.
-        # """
-        # if self.laden_moeglich is None:
-            # print("Lademöglichkeit wurde nicht gesetzt.")
-            # return
-        
-        # for i, moeglich in enumerate(self.laden_moeglich):
-            # if moeglich == 1:
-                # # Berechnen, wie viel Energie in einer Stunde geladen werden kann
-                # geladene_energie = min(self.ladegeschwindigkeit, (100 - self.soc) / 100 * self.akku_kapazitaet)
-                # # Aktualisieren des SoC
-                # self.soc += geladene_energie / self.akku_kapazitaet * 100
-                # # Sicherstellen, dass der SoC nicht über 100% geht
-                # self.soc = min(100, self.soc)
-                # print(f"Stunde {i}: Geladen {geladene_energie} kWh, neuer SoC: {self.soc}%")
-            # else:
-                # # Wenn nicht geladen wird, bleibt der SoC gleich
-                # print(f"Stunde {i}: Nicht geladen, SoC bleibt bei {self.soc}%")
-            # self.stuendlicher_soc.append(self.soc)  # Aktuellen SoC zum Array hinzufügen
-            # if self.soc >= 100:
-                # print("Akku vollständig geladen.")
-                # break
-
-    # def berechne_benoetigte_energie(self):
-        # """
-        # Berechnet die Gesamtenergie, die benötigt wird, um den Akku vollständig zu laden.
-        # """
-        # return (100 - self.soc) / 100 * self.akku_kapazitaet
-
-    # def get_stuendlicher_soc(self):
-        # """
-        # Gibt den stündlichen Ladezustand (SoC) als Array zurück.
-        # """
-        # return self.stuendlicher_soc
-
-
-if __name__ == "__main__":
-    # Initialisierung des Elektroauto-Ladens
-    mein_eauto = EAuto(soc=50, akku_kapazitaet=60, ladegeschwindigkeit=11)
-    
-    # Festlegen, wann das Laden möglich ist (1 = Laden erlaubt, 0 = Laden nicht erlaubt)
-    # Beispiel: Laden ist nur während der Nachtstunden und frühen Morgenstunden erlaubt
-    laden_moeglich = [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1]
-    mein_eauto.set_laden_moeglich(laden_moeglich)
-    
-    # Durchführen des Ladevorgangs
-    mein_eauto.berechne_ladevorgang()
-    
-    # Abrufen und Ausgeben des stündlichen Ladezustands
-    stuendlicher_soc = mein_eauto.get_stuendlicher_soc()
-    print("\nStündlicher SoC während des Ladevorgangs:")
-    for stunde, soc in enumerate(stuendlicher_soc):
-        print(f"Stunde {stunde}: SoC = {soc}%")

modules/class_ems.py

@@ -81,9 +81,10 @@ class EnergieManagementSystem:
                 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)
+                netzeinspeisung_wh_pro_stunde.append(überschuss - geladene_energie-verluste_laden_akku)
                 eigenverbrauch_wh_pro_stunde.append(verbrauch)
-                stündliche_einnahmen_euro = (überschuss - geladene_energie) * self.einspeiseverguetung_cent_pro_wh[stunde] 
+                stündliche_einnahmen_euro = (überschuss - geladene_energie-verluste_laden_akku) * self.einspeiseverguetung_cent_pro_wh[stunde] 
+                #print(überschuss," ", geladene_energie," ",verluste_laden_akku)
                 netzbezug_wh_pro_stunde.append(0.0)
             else:
                 netzeinspeisung_wh_pro_stunde.append(0.0)