Mirrors/EOS
1
0
Fork 0
mirror of https://github.com/Akkudoktor-EOS/EOS.git synced 2025-08-25 06:52:23 +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
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)

71
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 = []
#print(gesamtlast_pro_stunde)
#sys.exit()
eauto_soc_pro_stunde = []
verluste_wh_pro_stunde = []
lastkurve_wh = self.gesamtlast.gesamtlast_berechnen()
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,23 +88,30 @@ 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)
}

105
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,13 +93,7 @@ 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]
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.title('Gesamtkosten')
plt.ylabel('Euro')
# plt.title('Gesamtkosten')
# plt.ylabel('Euro')
plt.legend()
plt.grid(True)
# plt.legend()
# plt.grid(True)
plt.tight_layout()
# plt.tight_layout()
plt.show()