Inverter Klasse hinzugefügt

Kleinere Bugs bei max_WR Leistung behoben

modules/class_akku.py

@@ -105,13 +105,16 @@ class PVAkku:
 
         # Aktualisierung des Ladezustands ohne die Kapazität zu überschreiten
         geladene_menge_ohne_verlust = min(self.kapazitaet_wh - self.soc_wh, effektive_lademenge)
-        
+
         geladene_menge = geladene_menge_ohne_verlust * self.lade_effizienz
+
         
         self.soc_wh += geladene_menge
     
         verluste_wh = geladene_menge_ohne_verlust* (1.0-self.lade_effizienz)
         
+
+        
         # Zusätzliche Verluste, wenn die Energiezufuhr die Kapazitätsgrenze überschreitet
         # zusatz_verluste_wh = 0
         # if effektive_lademenge > geladene_menge_ohne_verlust:

modules/class_inverter.py

@@ -0,0 +1,140 @@
+class Wechselrichter:
+    def __init__(self, max_leistung_wh, akku):
+        self.max_leistung_wh = max_leistung_wh  # Maximale Leistung, die der Wechselrichter verarbeiten kann
+        self.akku = akku  # Verbindung zu einem Akku-Objekt
+
+    def energie_verarbeiten(self, erzeugung, verbrauch, hour):
+        verluste = 0
+        netzeinspeisung = 0
+        netzbezug = 0.0
+        eigenverbrauch = 0.0
+        #eigenverbrauch = min(erzeugung, verbrauch)  # Direkt verbrauchte Energie
+
+        if erzeugung > verbrauch:
+            if verbrauch > self.max_leistung_wh:
+
+                verluste += erzeugung - self.max_leistung_wh
+                restleistung_nach_verbrauch = self.max_leistung_wh - verbrauch                
+                netzbezug = -restleistung_nach_verbrauch
+                eigenverbrauch = self.max_leistung_wh
+                
+            else: 
+                # if hour==10:
+                    # print("PV:",erzeugung)
+                    # print("Load:",verbrauch)
+                    # print("Max Leist:",self.max_leistung_wh)
+                # PV > WR Leistung dann Verlust
+                
+                # Load
+                restleistung_nach_verbrauch = erzeugung-verbrauch #min(self.max_leistung_wh - verbrauch, erzeugung-verbrauch)
+                # Akku
+                geladene_energie, verluste_laden_akku = self.akku.energie_laden(restleistung_nach_verbrauch, hour)
+                rest_überschuss = restleistung_nach_verbrauch - geladene_energie
+                # if hour == 12:
+                    # print("Erzeugung:",erzeugung)
+                    # print("Last:",verbrauch)
+                    # print("Akku:",geladene_energie)
+                    # print("Akku:",self.akku.ladezustand_in_prozent())
+                    # print("RestÜberschuss"," - ",rest_überschuss)
+                    # print("RestLesitung WR:",self.max_leistung_wh - verbrauch)
+                # Einspeisung, restliche WR Kapazität
+                if rest_überschuss > self.max_leistung_wh - verbrauch:
+                    netzeinspeisung = self.max_leistung_wh - verbrauch
+                    verluste += rest_überschuss - netzeinspeisung
+                else:
+                    netzeinspeisung = rest_überschuss
+                
+                verluste += verluste_laden_akku
+
+                
+                
+                eigenverbrauch = verbrauch
+ 
+        else:
+            benötigte_energie = verbrauch - erzeugung
+            max_akku_leistung = self.akku.max_ladeleistung_w
+            
+            rest_ac_leistung = max(max_akku_leistung - erzeugung,0)
+            
+            if benötigte_energie < rest_ac_leistung:
+                aus_akku, akku_entladeverluste = self.akku.energie_abgeben(benötigte_energie, hour)
+            else: 
+                aus_akku, akku_entladeverluste = self.akku.energie_abgeben(rest_ac_leistung, hour)
+            
+            
+            verluste += akku_entladeverluste
+
+            netzbezug = benötigte_energie - aus_akku
+            eigenverbrauch = erzeugung + aus_akku
+
+
+        # if erzeugung > verbrauch:
+            # if verbrauch > self.max_leistung_wh:
+                
+            # else: 
+            
+            
+                # überschuss = self.max_leistung_wh - verbrauch
+                
+                # geladene_energie, verluste_laden_akku = self.akku.energie_laden(überschuss, hour)
+                # rest_überschuss = überschuss - geladene_energie
+                # verluste += verluste_laden_akku
+                
+                # if (rest_überschuss > self.max_leistung_wh):
+                    # netzeinspeisung  = self.max_leistung_wh
+                    # verluste += rest_überschuss - self.max_leistung_wh
+                # else:
+                    # netzeinspeisung = rest_überschuss
+                
+                # eigenverbrauch = verbrauch
+ 
+        # else:
+            # benötigte_energie = verbrauch - erzeugung
+            # max_akku_leistung = self.akku.max_ladeleistung_w
+            
+            # rest_ac_leistung = max(max_akku_leistung - erzeugung,0)
+            
+            # if benötigte_energie < rest_ac_leistung:
+                # aus_akku, akku_entladeverluste = self.akku.energie_abgeben(benötigte_energie, hour)
+            # else: 
+                # aus_akku, akku_entladeverluste = self.akku.energie_abgeben(rest_ac_leistung, hour)
+            
+            
+            # verluste += akku_entladeverluste
+
+            # netzbezug = benötigte_energie - aus_akku
+            # eigenverbrauch = erzeugung + aus_akku
+
+            # # Berechnung der gesamten verarbeiteten Energie
+            # total_verarbeitet = eigenverbrauch
+            # if total_verarbeitet > self.max_leistung_wh:
+                # verluste += total_verarbeitet - self.max_leistung_wh
+
+        return netzeinspeisung, netzbezug, verluste, eigenverbrauch
+
+
+    # def energie_verarbeiten(self, erzeugung, verbrauch, hour):
+    
+        # verluste = 0
+        # netzeinspeisung = 0
+        # netzbezug = 0.0
+        # eigenverbrauch = 0.0
+        
+        # if erzeugung > verbrauch:
+            # überschuss = erzeugung - verbrauch
+            # geladene_energie, verluste_laden_akku = self.akku.energie_laden(überschuss, hour)
+            # verluste += verluste_laden_akku
+
+            # netzeinspeisung = überschuss - geladene_energie-verluste_laden_akku
+            # eigenverbrauch = verbrauch
+            # netzbezug = 0.0
+        # # Noch Netzbezug nötig
+        # else:
+            # netzeinspeisung = 0.0
+            # benötigte_energie = verbrauch - erzeugung
+            # aus_akku, akku_entladeverluste = self.akku.energie_abgeben(benötigte_energie, hour)
+            # verluste += akku_entladeverluste
+            # netzbezug = benötigte_energie - aus_akku
+            # eigenverbrauch = erzeugung+aus_akku
+
+        # return netzeinspeisung, netzbezug, verluste, eigenverbrauch  # Keine Einspeisung, Netzbezug, aus Akku, Verluste, Eigenverbrauch

modules/class_optimize.py

@@ -99,6 +99,7 @@ class optimization_problem:
 
     # Fitness-Funktion (muss Ihre EnergieManagementSystem-Logik integrieren)
     def evaluate(self,individual,ems,parameter,start_hour,worst_case):
+
         try:
                 o = self.evaluate_inner(individual,ems,start_hour)
         except: 
@@ -121,7 +122,7 @@ class optimization_problem:
         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
+        gesamtbilanz += o["Gesamt_Verluste"]/10000.0
                 
         return (gesamtbilanz,)
 
@@ -131,7 +132,7 @@ class optimization_problem:
 
     # Genetischer Algorithmus
     def optimize(self,start_solution=None):
-        population = self.toolbox.population(n=200)
+        population = self.toolbox.population(n=1000)
         hof = tools.HallOfFame(1)
         
         stats = tools.Statistics(lambda ind: ind.fitness.values)
@@ -144,8 +145,8 @@ class optimization_problem:
         if start_solution is not None and start_solution != -1:
                 population.insert(0, creator.Individual(start_solution))     
         
-        #algorithms.eaMuPlusLambda(population, self.toolbox, 100, 200, cxpb=0.4, mutpb=0.5, ngen=500,             stats=stats, halloffame=hof, verbose=True)
-        algorithms.eaSimple(population, self.toolbox, cxpb=0.4, mutpb=0.4, ngen=100,             stats=stats, halloffame=hof, verbose=True)
+        #algorithms.eaMuPlusLambda(population, self.toolbox, 100, 200, cxpb=0.2, mutpb=0.2, ngen=500,             stats=stats, halloffame=hof, verbose=True)
+        algorithms.eaSimple(population, self.toolbox, cxpb=0.2, mutpb=0.2, ngen=200,             stats=stats, halloffame=hof, verbose=True)
         
         member = {"bilanz":[],"verluste":[],"nebenbedingung":[]}
         for ind in population:
@@ -161,6 +162,7 @@ class optimization_problem:
 
     def optimierung_ems(self,parameter=None, start_hour=None,worst_case=False):
 
+        
         ############
         # Parameter 
         ############
@@ -256,7 +258,7 @@ class optimization_problem:
         
         self.toolbox.register("evaluate", evaluate_wrapper)
         start_solution, extra_data = self.optimize(start_params)
-        best_solution = start_solution
+        best_solution = start_params
         o = self.evaluate_inner(best_solution, ems,start_hour)
         eauto = ems.eauto.to_dict()
         spuelstart_int = None
@@ -269,8 +271,8 @@ class optimization_problem:
         
 
      
-        
-        print(o)
+        print(parameter)
+        print(best_solution)
         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,extra_data=extra_data)
         os.system("cp visualisierungsergebnisse.pdf ~/")
         

modules/visualize.py

@@ -170,52 +170,52 @@ def visualisiere_ergebnisse(gesamtlast, pv_forecast, strompreise, ergebnisse,  d
         
         
 
+        if extra_data != None:
+                plt.figure(figsize=(14, 10))
+                plt.subplot(1, 2, 1)
+                f1 = np.array(extra_data["verluste"])
+                f2 = np.array(extra_data["bilanz"])
+                n1 = np.array(extra_data["nebenbedingung"])
+                scatter = plt.scatter(f1, f2, c=n1, cmap='viridis')
 
-        plt.figure(figsize=(14, 10))
-        plt.subplot(1, 2, 1)
-        f1 = np.array(extra_data["verluste"])
-        f2 = np.array(extra_data["bilanz"])
-        n1 = np.array(extra_data["nebenbedingung"])
-        scatter = plt.scatter(f1, f2, c=n1, cmap='viridis')
+                # Farblegende hinzufügen
+                plt.colorbar(scatter, label='Nebenbedingung')
 
-        # Farblegende hinzufügen
-        plt.colorbar(scatter, label='Nebenbedingung')
+                pdf.savefig()  # Speichert die komplette Figure im PDF
+                plt.close()  # Schließt die Figure
 
-        pdf.savefig()  # Speichert die komplette Figure im PDF
-        plt.close()  # Schließt die Figure
+                
+                plt.figure(figsize=(14, 10))
+                filtered_verluste = np.array([v for v, n in zip(extra_data["verluste"], extra_data["nebenbedingung"]) if n < 0.01])
+                filtered_bilanz = np.array([b for b, n in zip(extra_data["bilanz"], extra_data["nebenbedingung"]) if n< 0.01])
+                
+                beste_verluste = min(filtered_verluste)
+                schlechteste_verluste = max(filtered_verluste)
+                beste_bilanz = min(filtered_bilanz)
+                schlechteste_bilanz = max(filtered_bilanz)
 
-        
-        plt.figure(figsize=(14, 10))
-        filtered_verluste = np.array([v for v, n in zip(extra_data["verluste"], extra_data["nebenbedingung"]) if n < 0.01])
-        filtered_bilanz = np.array([b for b, n in zip(extra_data["bilanz"], extra_data["nebenbedingung"]) if n< 0.01])
-        
-        beste_verluste = min(filtered_verluste)
-        schlechteste_verluste = max(filtered_verluste)
-        beste_bilanz = min(filtered_bilanz)
-        schlechteste_bilanz = max(filtered_bilanz)
+                data = [filtered_verluste, filtered_bilanz]
+                labels = ['Verluste', 'Bilanz']
+                # Plot-Erstellung
+                fig, axs = plt.subplots(1, 2, figsize=(10, 6), sharey=False)  # Zwei Subplots, getrennte y-Achsen
 
-        data = [filtered_verluste, filtered_bilanz]
-        labels = ['Verluste', 'Bilanz']
-        # Plot-Erstellung
-        fig, axs = plt.subplots(1, 2, figsize=(10, 6), sharey=False)  # Zwei Subplots, getrennte y-Achsen
+                # Erster Boxplot für Verluste
+                #axs[0].boxplot(data[0])
+                axs[0].violinplot(data[0],
+                          showmeans=True,
+                          showmedians=True)
+                axs[0].set_title('Verluste')
+                axs[0].set_xticklabels(['Verluste'])
 
-        # Erster Boxplot für Verluste
-        #axs[0].boxplot(data[0])
-        axs[0].violinplot(data[0],
-                  showmeans=True,
-                  showmedians=True)
-        axs[0].set_title('Verluste')
-        axs[0].set_xticklabels(['Verluste'])
+                # Zweiter Boxplot für Bilanz
+                axs[1].violinplot(data[1],
+                          showmeans=True,
+                          showmedians=True)
+                axs[1].set_title('Bilanz')
+                axs[1].set_xticklabels(['Bilanz'])
 
-        # Zweiter Boxplot für Bilanz
-        axs[1].violinplot(data[1],
-                  showmeans=True,
-                  showmedians=True)
-        axs[1].set_title('Bilanz')
-        axs[1].set_xticklabels(['Bilanz'])
-
-        # Feinabstimmung
-        plt.tight_layout()
+                # Feinabstimmung
+                plt.tight_layout()
         
         
         pdf.savefig()  # Speichert den aktuellen Figure-State im PDF