Haushaltsgeräte wie z.B. Spülmaschine

flask / Optimierung besser getrennt
Optimierung Bug, bei mehrfahcen neustart

modules/class_ems.py

@@ -3,7 +3,7 @@ from pprint import pprint
 
 
 class EnergieManagementSystem:
-    def __init__(self, akku=None,  pv_prognose_wh=None, strompreis_euro_pro_wh=None, einspeiseverguetung_euro_pro_wh=None, eauto=None, gesamtlast=None):
+    def __init__(self, akku=None,  pv_prognose_wh=None, strompreis_euro_pro_wh=None, einspeiseverguetung_euro_pro_wh=None, eauto=None, gesamtlast=None, haushaltsgeraet=None):
         self.akku = akku
         #self.lastkurve_wh = lastkurve_wh
         self.gesamtlast = gesamtlast
@@ -11,12 +11,17 @@ class EnergieManagementSystem:
         self.strompreis_euro_pro_wh = strompreis_euro_pro_wh  # Strompreis in Cent pro Wh
         self.einspeiseverguetung_euro_pro_wh = einspeiseverguetung_euro_pro_wh  # Einspeisevergütung in Cent pro Wh
         self.eauto = eauto
+        self.haushaltsgeraet = haushaltsgeraet
+        
     
     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 set_haushaltsgeraet_start(self, ds, global_start_hour=0):
+        self.haushaltsgeraet.set_startzeitpunkt(ds,global_start_hour=global_start_hour)
         
     def reset(self):
         self.eauto.reset()
@@ -43,24 +48,27 @@ class EnergieManagementSystem:
         akku_soc_pro_stunde = []
         eauto_soc_pro_stunde = []
         verluste_wh_pro_stunde = []
+        haushaltsgeraet_wh_pro_stunde = []
         lastkurve_wh = self.gesamtlast.gesamtlast_berechnen()
         
         
         assert len(lastkurve_wh) == len(self.pv_prognose_wh) == len(self.strompreis_euro_pro_wh), f"Arraygrößen stimmen nicht überein: Lastkurve = {len(lastkurve_wh)}, PV-Prognose = {len(self.pv_prognose_wh)}, Strompreis = {len(self.strompreis_euro_pro_wh)}"
 
         ende = min( len(lastkurve_wh),len(self.pv_prognose_wh), len(self.strompreis_euro_pro_wh))
-#        print(len(lastkurve_wh), " ",len(self.pv_prognose_wh)," ", len(self.strompreis_euro_pro_wh))
-        
-        # sys.exit()
+
         # 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 = lastkurve_wh[stunde]
+            verbrauch = lastkurve_wh[stunde] 
+            if self.haushaltsgeraet != None:
+                verbrauch = verbrauch + self.haushaltsgeraet.get_last_fuer_stunde(stunde)
+                haushaltsgeraet_wh_pro_stunde.append(self.haushaltsgeraet.get_last_fuer_stunde(stunde))
+            else: 
+                haushaltsgeraet_wh_pro_stunde.append(0)
             erzeugung = self.pv_prognose_wh[stunde]
             strompreis = self.strompreis_euro_pro_wh[stunde] if stunde < len(self.strompreis_euro_pro_wh) else self.strompreis_euro_pro_wh[-1]
             verluste_wh_pro_stunde.append(0.0)
-            #eauto_soc = self.eauto.get_stuendlicher_soc()[stunde]
             
 
             # Logik für die E-Auto-Ladung bzw. Entladung
@@ -68,16 +76,14 @@ class EnergieManagementSystem:
                 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
+                eauto_soc = self.eauto.ladezustand_in_prozent()
 
 
             
             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
@@ -102,8 +108,9 @@ class EnergieManagementSystem:
                 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)
+            if self.eauto:
+                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)
@@ -132,7 +139,8 @@ class EnergieManagementSystem:
             'Gesamteinnahmen_Euro': sum(einnahmen_euro_pro_stunde),
             'Gesamtkosten_Euro': sum(kosten_euro_pro_stunde),
             "Verluste_Pro_Stunde":verluste_wh_pro_stunde,
-            "Gesamt_Verluste":sum(verluste_wh_pro_stunde)
+            "Gesamt_Verluste":sum(verluste_wh_pro_stunde),
+            "Haushaltsgeraet_wh_pro_stunde":haushaltsgeraet_wh_pro_stunde
         }
         
         return out

modules/class_haushaltsgeraet.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+class Haushaltsgeraet:
+    def __init__(self, hours=None, verbrauch_kwh=None, dauer_h=None):
+        self.hours = hours  # Gesamtzeitraum, für den die Planung erfolgt
+        self.verbrauch_kwh = verbrauch_kwh  # Gesamtenergieverbrauch des Geräts in kWh
+        self.dauer_h = dauer_h  # Dauer der Nutzung in Stunden
+        self.lastkurve = np.zeros(self.hours)  # Initialisiere die Lastkurve mit Nullen
+
+    def set_startzeitpunkt(self, start_hour,global_start_hour=0):
+        """
+        Setzt den Startzeitpunkt des Geräts und generiert eine entsprechende Lastkurve.
+        :param start_hour: Die Stunde, zu der das Gerät starten soll.
+        """
+        self.reset()
+        # Überprüfe, ob die Dauer der Nutzung innerhalb des verfügbaren Zeitraums liegt
+        if start_hour + self.dauer_h > self.hours:
+            raise ValueError("Die Nutzungsdauer überschreitet den verfügbaren Zeitraum.")
+        if start_hour < global_start_hour:
+            raise ValueError("Die Nutzungsdauer unterschreitet den verfügbaren Zeitraum.")
+        
+        # Berechne die Leistung pro Stunde basierend auf dem Gesamtverbrauch und der Dauer
+        leistung_pro_stunde = (self.verbrauch_kwh / self.dauer_h) # Umwandlung in Wattstunde
+        #print(start_hour," ",leistung_pro_stunde)
+        # Setze die Leistung für die Dauer der Nutzung im Lastkurven-Array
+        self.lastkurve[start_hour:start_hour + self.dauer_h] = leistung_pro_stunde
+
+    def reset(self):
+        """
+        Setzt die Lastkurve zurück.
+        """
+        self.lastkurve = np.zeros(self.hours)
+
+    def get_lastkurve(self):
+        """
+        Gibt die aktuelle Lastkurve zurück.
+        """
+        return self.lastkurve
+
+    def get_last_fuer_stunde(self, hour):
+        """
+        Gibt die Last für eine spezifische Stunde zurück.
+        :param hour: Die Stunde, für die die Last abgefragt wird.
+        :return: Die Last in Watt für die angegebene Stunde.
+        """
+        if hour < 0 or hour >= self.hours:
+            raise ValueError("Angegebene Stunde liegt außerhalb des verfügbaren Zeitraums.")
+        
+        return self.lastkurve[hour]
+
+    def spaetestmoeglicher_startzeitpunkt(self):
+        """
+        Gibt den spätestmöglichen Startzeitpunkt zurück, an dem das Gerät noch vollständig laufen kann.
+        """
+        return self.hours - self.dauer_h
+
+

modules/class_optimizable_load.py

@@ -1,61 +0,0 @@
-import numpy as np
-class OptimizableLoad:
-    def __init__(self, name=None, power=0, duration=0, schedule=None):
-        """
-        Initialisiert eine neue optimierbare Last.
-
-        :param name: Eindeutiger Name der Last
-        :param power: Leistung der Last in kW
-        :param duration: Dauer, für die die Last aktiv ist, in Stunden
-        :param schedule: Ein 24-Stunden-Array (0/1), das angibt, wann die Last gestartet werden kann
-        """
-        self.name = name
-        self.power = power
-        self.duration = duration
-        self.optimal_start_time = None
-        if schedule is None:
-            self.schedule = [1] * 24
-        else:
-            self.schedule = schedule
-
-    def set_schedule(self, new_schedule):
-        """
-        Aktualisiert den Zeitplan, wann die Last gestartet werden kann.
-
-        :param new_schedule: Ein 24-Stunden-Array (0/1)
-        """
-        self.schedule = new_schedule
-
-    def set_optimal_start_time(self, start_time):
-        """
-        Setzt die optimale Startzeit für die Last.
-
-        :param start_time: Die Stunde des Tages (0-23), zu der die Last starten soll
-        """
-        if 0 <= start_time < 24 and self.is_activatable(start_time):
-            self.optimal_start_time = start_time
-
-    def is_active_at_hour(self, hour):
-        """
-        Überprüft, ob die Last zu einer bestimmten Stunde aktiv ist, basierend auf ihrem Startzeitpunkt und der Dauer.
-
-        :param hour: Stunde des Tages (0-23)
-        :return: True, wenn die Last aktiv ist, sonst False
-        """
-        if self.optimal_start_time is None:
-            return False
-        return self.optimal_start_time <= hour < self.optimal_start_time + self.duration
-
-    def power_at_hour(self, hour):
-        """
-        Gibt die Leistung der Last zu einer bestimmten Stunde zurück.
-
-        :param hour: Stunde des Tages (0-23)
-        :return: Leistung der Last in kW, wenn sie aktiv ist, sonst 0
-        """
-        if self.is_active_at_hour(hour):
-            return self.power
-        return 0
-
-    def __str__(self):
-        return f"OptimizableLoad(Name: {self.name}, Power: {self.power}kW, Duration: {self.duration}h, Schedule: {self.schedule})"

modules/class_optimize.py

@@ -9,6 +9,7 @@ from modules.class_heatpump import *
 from modules.class_load_container import * 
 from modules.class_sommerzeit import *
 from modules.visualize import *
+from modules.class_haushaltsgeraet import *
 import os
 from flask import Flask, send_from_directory
 from pprint import pprint
@@ -32,52 +33,93 @@ def isfloat(num):
 
 class optimization_problem:
     def __init__(self, prediction_hours=24, strafe = 10):
-        
-        # Werkzeug-Setup
-        creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
-        creator.create("Individual", list, fitness=creator.FitnessMin)
-        self.toolbox = base.Toolbox()
         self.prediction_hours = prediction_hours#
         self.strafe = strafe
+        self.opti_param = None
+
+    def setup_deap_environment(self,opti_param):
+        self.opti_param = opti_param
+        if "FitnessMin" in creator.__dict__:
+                del creator.FitnessMin
+        if "Individual" in creator.__dict__:
+                del creator.Individual
+
+        creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
+        creator.create("Individual", list, fitness=creator.FitnessMin)
         
         # PARAMETER
+        self.toolbox = base.Toolbox()
+
+
         self.toolbox.register("attr_bool", random.randint, 0, 1)
-        self.toolbox.register("attr_bool", random.randint, 0, 1)
-        self.toolbox.register("individual", tools.initCycle, creator.Individual, (self.toolbox.attr_bool,self.toolbox.attr_bool), n=self.prediction_hours)
+        self.toolbox.register("attr_int", random.randint, 0, 23)
+        
+        ###################
+        # Haushaltsgeraete
+        if opti_param["haushaltsgeraete"]>0:   
+                def create_individual():
+                        attrs = [self.toolbox.attr_bool() for _ in range(2*self.prediction_hours)] + [self.toolbox.attr_int()]
+                        return creator.Individual(attrs)
+
+        else:
+                def create_individual():
+                        attrs = [self.toolbox.attr_bool() for _ in range(2*self.prediction_hours)] 
+                        return creator.Individual(attrs)
+
+        
+        self.toolbox.register("individual", create_individual)#tools.initCycle, creator.Individual, (self.toolbox.attr_bool,self.toolbox.attr_bool), n=self.prediction_hours+1)
         self.toolbox.register("population", tools.initRepeat, list, self.toolbox.individual)
         self.toolbox.register("mate", tools.cxTwoPoint)
         self.toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
         self.toolbox.register("select", tools.selTournament, tournsize=3)    
         
-        return
-        
     def evaluate_inner(self,individual, ems,start_hour):
+        ems.reset()
         
+        
+        # Haushaltsgeraete
+        if self.opti_param["haushaltsgeraete"]>0:   
+                spuelstart_int = individual[-1]
+                individual = individual[:-1]
+                ems.set_haushaltsgeraet_start(spuelstart_int,global_start_hour=start_hour)
+                
         discharge_hours_bin = individual[0::2]
         eautocharge_hours_float = individual[1::2]
+
         
-        ems.reset()
         ems.set_akku_discharge_hours(discharge_hours_bin)
         ems.set_eauto_charge_hours(eautocharge_hours_float)
+        
+        
         o = ems.simuliere(start_hour)
 
         return o
 
     # Fitness-Funktion (muss Ihre EnergieManagementSystem-Logik integrieren)
-    def evaluate(self,individual,ems,parameter,start_hour):
-        o = self.evaluate_inner(individual,ems,start_hour)
-        
+    def evaluate(self,individual,ems,parameter,start_hour,worst_case):
+        try:
+                o = self.evaluate_inner(individual,ems,start_hour)
+        except: 
+                return (100000.0,)
+                
         gesamtbilanz = o["Gesamtbilanz_Euro"]
+        if worst_case:
+                gesamtbilanz = gesamtbilanz * -1.0
         
         # Überprüfung, ob der Mindest-SoC erreicht wird
         final_soc = ems.eauto.ladezustand_in_prozent()  # Nimmt den SoC am Ende des Optimierungszeitraums
         
         
         strafe = 0.0
-        strafe = max(0,(parameter['eauto_min_soc']-ems.eauto.ladezustand_in_prozent()) * self.strafe ) 
-        
-        gesamtbilanz += strafe    
-        gesamtbilanz += o["Gesamt_Verluste"]/1000.0
+        if worst_case:
+                strafe = abs(parameter['eauto_min_soc']-ems.eauto.ladezustand_in_prozent()) * self.strafe  
+                gesamtbilanz += strafe    
+
+                gesamtbilanz -= o["Gesamt_Verluste"]/1000.0
+        else:
+                strafe = max(0,(parameter['eauto_min_soc']-ems.eauto.ladezustand_in_prozent()) * self.strafe ) 
+                gesamtbilanz += strafe    
+                gesamtbilanz += o["Gesamt_Verluste"]/1000.0
         return (gesamtbilanz,)
 
 
@@ -104,7 +146,7 @@ class optimization_problem:
         return hof[0]
 
 
-    def optimierung_ems(self,parameter=None, start_hour=None):
+    def optimierung_ems(self,parameter=None, start_hour=None,worst_case=False):
 
         ############
         # Parameter 
@@ -130,10 +172,18 @@ class optimization_problem:
         eauto = PVAkku(kapazitaet_wh=parameter["eauto_cap"], hours=self.prediction_hours, lade_effizienz=parameter["eauto_charge_efficiency"], entlade_effizienz=1.0, max_ladeleistung_w=parameter["eauto_charge_power"] ,start_soc_prozent=parameter["eauto_soc"])
         eauto.set_charge_per_hour(laden_moeglich)
         min_soc_eauto = parameter['eauto_min_soc']
-
         start_params = parameter['start_solution']
-
         gesamtlast = Gesamtlast()
+        
+        ###############
+        # spuelmaschine
+        ##############
+        if parameter["haushaltsgeraet_dauer"] >0:
+                spuelmaschine = Haushaltsgeraet(hours=self.prediction_hours, verbrauch_kwh=parameter["haushaltsgeraet_wh"], dauer_h=parameter["haushaltsgeraet_dauer"])
+                spuelmaschine.set_startzeitpunkt(start_hour)  # Startet jetzt
+        else: 
+                spuelmaschine = None
+
 
         ###############
         # Load Forecast
@@ -173,29 +223,49 @@ class optimization_problem:
         leistung_wp = wp.simulate_24h(temperature_forecast)
         gesamtlast.hinzufuegen("Heatpump", leistung_wp)
 
-        ems = EnergieManagementSystem(akku=akku, gesamtlast = gesamtlast, pv_prognose_wh=pv_forecast, strompreis_euro_pro_wh=specific_date_prices, einspeiseverguetung_euro_pro_wh=einspeiseverguetung_euro_pro_wh, eauto=eauto)
+        ems = EnergieManagementSystem(akku=akku, gesamtlast = gesamtlast, pv_prognose_wh=pv_forecast, strompreis_euro_pro_wh=specific_date_prices, einspeiseverguetung_euro_pro_wh=einspeiseverguetung_euro_pro_wh, eauto=eauto, haushaltsgeraet=spuelmaschine)
         o = ems.simuliere(start_hour)
     
+        ###############
+        # Optimizer Init
+        ##############
+        opti_param = {}
+        opti_param["haushaltsgeraete"] = 0
+        if spuelmaschine != None:
+                opti_param["haushaltsgeraete"] = 1
+                
+        self.setup_deap_environment(opti_param)
 
         def evaluate_wrapper(individual):
-            return self.evaluate(individual, ems, parameter,start_hour)
+            return self.evaluate(individual, ems, parameter,start_hour,worst_case)
         
         self.toolbox.register("evaluate", evaluate_wrapper)
         start_solution = self.optimize(start_params)
         best_solution = start_solution
         o = self.evaluate_inner(best_solution, ems,start_hour)
         eauto = ems.eauto.to_dict()
+        spuelstart_int = None
+        # Haushaltsgeraete
+        if self.opti_param["haushaltsgeraete"]>0:   
+                spuelstart_int = best_solution[-1]
+                best_solution = best_solution[:-1]
         discharge_hours_bin = best_solution[0::2]
         eautocharge_hours_float = best_solution[1::2]
         
-        #print(o)
+
+     
         
-        visualisiere_ergebnisse(gesamtlast, pv_forecast, specific_date_prices, o,best_solution[0::2],best_solution[1::2] , temperature_forecast, start_hour, self.prediction_hours,einspeiseverguetung_euro_pro_wh)
+        print(o)
+        if worst_case:
+                visualisiere_ergebnisse(gesamtlast, pv_forecast, specific_date_prices, o,best_solution[0::2],best_solution[1::2] , temperature_forecast, start_hour, self.prediction_hours,einspeiseverguetung_euro_pro_wh,filename="visualisierungsergebnisse_worst.pdf")
+                os.system("scp visualisierungsergebnisse_worst.pdf andreas@192.168.1.135:")
+        else:
+                visualisiere_ergebnisse(gesamtlast, pv_forecast, specific_date_prices, o,best_solution[0::2],best_solution[1::2] , temperature_forecast, start_hour, self.prediction_hours,einspeiseverguetung_euro_pro_wh)
         
-        os.system("scp visualisierungsergebnisse.pdf andreas@192.168.1.135:")
+                os.system("scp visualisierungsergebnisse.pdf andreas@192.168.1.135:")
         
         #print(eauto)
-        return {"discharge_hours_bin":discharge_hours_bin, "eautocharge_hours_float":eautocharge_hours_float ,"result":o ,"eauto_obj":eauto,"start_solution":best_solution}
+        return {"discharge_hours_bin":discharge_hours_bin, "eautocharge_hours_float":eautocharge_hours_float ,"result":o ,"eauto_obj":eauto,"start_solution":best_solution,"spuelstart":spuelstart_int}
 
 
 

modules/visualize.py

@@ -9,12 +9,12 @@ from matplotlib.backends.backend_pdf import PdfPages
 from datetime import datetime
 
 
-def visualisiere_ergebnisse(gesamtlast, pv_forecast, strompreise, ergebnisse,  discharge_hours, laden_moeglich, temperature, start_hour, prediction_hours,einspeiseverguetung_euro_pro_wh):
+def visualisiere_ergebnisse(gesamtlast, pv_forecast, strompreise, ergebnisse,  discharge_hours, laden_moeglich, temperature, start_hour, prediction_hours,einspeiseverguetung_euro_pro_wh, filename="visualisierungsergebnisse.pdf"):
 
     #####################
     # 24h 
     #####################
-    with PdfPages('visualisierungsergebnisse.pdf') as pdf:
+    with PdfPages(filename) as pdf:
 
         
         # Last und PV-Erzeugung
@@ -98,6 +98,7 @@ def visualisiere_ergebnisse(gesamtlast, pv_forecast, strompreise, ergebnisse,  d
         # 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['Haushaltsgeraet_wh_pro_stunde'], label='Haushaltsgerät (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, ergebnisse['Verluste_Pro_Stunde'], label='Verluste (Wh)', marker='^')