Mirrors/EOS
1
0
Fork 0
mirror of https://github.com/Akkudoktor-EOS/EOS.git synced 2025-04-19 08:55:15 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Verluste stündlich / gesamt werden ausgegeben und mit minimiert

Browse Source 
Start ab Stunde X jetzt möglich
This commit is contained in:
Bla Bla 2024-03-25 14:40:48 +01:00
parent 2c0e355845
commit a1f7d683d4
4 changed files with 194 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
modules/class_akku.py
View File

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

67
modules/class_ems.py
View File

@ -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
def set_gesamtlast(self,load):
self.lastkurve_wh = load
self.eauto = eauto
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)
self.akku.energie_laden(geladene_energie)
#geladene_energie = min(überschuss, self.akku.kapazitaet_wh - self.akku.soc_wh)
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']
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]
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,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)
}

103
modules/visualize.py
View File

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

97
test.py
View File

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