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

Merge branch 'main' of https://github.com/Akkudoktor-EOS/EOS

Browse Source
This commit is contained in:
Andreas 2024-10-01 06:47:25 +02:00
commit a132e83aab
1 changed files with 76 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
modules/class_ems.py
View File

@ -1,19 +1,25 @@
from datetime import datetime from datetime import datetime
from pprint import pprint from pprint import pprint
import numpy as np import numpy as np
import modules.class_akku as PVAkku
def replace_nan_with_none(data): def replace_nan_with_none(data):
if isinstance(data, dict): if isinstance(data, dict):
return {key: replace_nan_with_none(value) for key, value in data.items()} return {key: replace_nan_with_none(value) for key, value in data.items()}
elif isinstance(data, list): elif isinstance(data, list):
return [replace_nan_with_none(element) for element in data] return [replace_nan_with_none(element) for element in data]
elif isinstance(data, float) and np.isnan(data): elif isinstance(data, np.ndarray):
# Konvertiere das numpy-Array zu einer Liste und rekursiv ersetzen
return replace_nan_with_none(data.tolist())
elif isinstance(data, (float, np.floating)) and np.isnan(data):
# np.floating deckt auch numpy-NaNs ab
return None return None
else: else:
return data return data
class EnergieManagementSystem: class EnergieManagementSystem:
def __init__(self, pv_prognose_wh=None, strompreis_euro_pro_wh=None, einspeiseverguetung_euro_pro_wh=None, eauto=None, gesamtlast=None, haushaltsgeraet=None, wechselrichter=None): def __init__(self, pv_prognose_wh=None, strompreis_euro_pro_wh=None, einspeiseverguetung_euro_pro_wh=None, eauto=None, gesamtlast=None, haushaltsgeraet=None, wechselrichter=None):
self.akku = wechselrichter.akku self.akku = wechselrichter.akku
@ -53,102 +59,84 @@ class EnergieManagementSystem:
return self.simuliere(start_stunde) return self.simuliere(start_stunde)
def simuliere(self, start_stunde): def simuliere(self, start_stunde):
last_wh_pro_stunde = []
netzeinspeisung_wh_pro_stunde = []
netzbezug_wh_pro_stunde = []
kosten_euro_pro_stunde = []
einnahmen_euro_pro_stunde = []
akku_soc_pro_stunde = []
eauto_soc_pro_stunde = []
verluste_wh_pro_stunde = []
haushaltsgeraet_wh_pro_stunde = []
lastkurve_wh = self.gesamtlast lastkurve_wh = self.gesamtlast
# Anzahl der Stunden 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)}" 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)) ende = min( len(lastkurve_wh),len(self.pv_prognose_wh), len(self.strompreis_euro_pro_wh))
# Endzustände auf NaN setzen, damit diese übersprungen werden für die Stunde
last_wh_pro_stunde.append(np.nan)
netzeinspeisung_wh_pro_stunde.append(np.nan)
netzbezug_wh_pro_stunde.append(np.nan)
kosten_euro_pro_stunde.append(np.nan)
akku_soc_pro_stunde.append(self.akku.ladezustand_in_prozent())
einnahmen_euro_pro_stunde.append(np.nan)
eauto_soc_pro_stunde.append(self.eauto.ladezustand_in_prozent())
verluste_wh_pro_stunde.append(np.nan)
haushaltsgeraet_wh_pro_stunde.append(np.nan)
# Berechnet das Ende basierend auf der Länge der Lastkurve total_hours = ende-start_stunde
for stunde in range(start_stunde+1, ende):
# Zustand zu Beginn der Stunde (Anfangszustand) # Initialisierung der Arrays mit NaN-Werten
akku_soc_start = self.akku.ladezustand_in_prozent() # Anfangszustand Akku-SoC last_wh_pro_stunde = np.full(total_hours, np.nan)
netzeinspeisung_wh_pro_stunde = np.full(total_hours, np.nan)
netzbezug_wh_pro_stunde = np.full(total_hours, np.nan)
kosten_euro_pro_stunde = np.full(total_hours, np.nan)
einnahmen_euro_pro_stunde = np.full(total_hours, np.nan)
akku_soc_pro_stunde = np.full(total_hours, np.nan)
eauto_soc_pro_stunde = np.full(total_hours, np.nan)
verluste_wh_pro_stunde = np.full(total_hours, np.nan)
haushaltsgeraet_wh_pro_stunde = np.full(total_hours, np.nan)
# Setze den initialen Ladezustand für Akku und E-Auto
akku_soc_pro_stunde[start_stunde] = self.akku.ladezustand_in_prozent()
if self.eauto: if self.eauto:
eauto_soc_start = self.eauto.ladezustand_in_prozent() # Anfangszustand E-Auto-SoC eauto_soc_pro_stunde[start_stunde] = self.eauto.ladezustand_in_prozent()
for stunde in range(start_stunde + 1, ende):
stunde_since_now = stunde-start_stunde
#print(stunde_since_now)
# Anfangszustände
akku_soc_start = self.akku.ladezustand_in_prozent()
eauto_soc_start = self.eauto.ladezustand_in_prozent() if self.eauto else None
# Anpassung, um sicherzustellen, dass Indizes korrekt sind # Verbrauch und zusätzliche Lasten bestimmen
verbrauch = lastkurve_wh[stunde] # Verbrauch für die Stunde verbrauch = self.gesamtlast[stunde]
if self.haushaltsgeraet != None: haushalts_last = 0
verbrauch = verbrauch + self.haushaltsgeraet.get_last_fuer_stunde(stunde)
haushaltsgeraet_wh_pro_stunde.append(self.haushaltsgeraet.get_last_fuer_stunde(stunde)) if self.haushaltsgeraet is not None:
else: haushalts_last = self.haushaltsgeraet.get_last_fuer_stunde(stunde)
haushaltsgeraet_wh_pro_stunde.append(0) verbrauch += haushalts_last
haushaltsgeraet_wh_pro_stunde[stunde_since_now] = haushalts_last
# PV-Erzeugung und Strompreis für die Stunde
erzeugung = self.pv_prognose_wh[stunde] 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] strompreis = self.strompreis_euro_pro_wh[stunde]
verluste_wh_pro_stunde.append(0.0) # Verluste initialisieren
verluste_wh_pro_stunde[stunde_since_now] = 0.0
# Logik für die E-Auto-Ladung bzw. Entladung # E-Auto-Verbrauch bestimmen
if self.eauto: # Falls ein E-Auto vorhanden ist if self.eauto:
geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden(None, stunde) geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden(None, stunde)
verbrauch = verbrauch + geladene_menge_eauto verbrauch += geladene_menge_eauto
verluste_wh_pro_stunde[-1] += verluste_eauto verluste_wh_pro_stunde[stunde_since_now] += verluste_eauto
eauto_soc = self.eauto.ladezustand_in_prozent() eauto_soc_pro_stunde[stunde_since_now] = self.eauto.ladezustand_in_prozent()
# Wechselrichter-Logik
stündlicher_netzbezug_wh = 0.0
stündliche_kosten_euro = 0.0
stündliche_einnahmen_euro = 0.0
#Wieviel kann der WR
netzeinspeisung, netzbezug, verluste, eigenverbrauch = self.wechselrichter.energie_verarbeiten(erzeugung, verbrauch, stunde) netzeinspeisung, netzbezug, verluste, eigenverbrauch = self.wechselrichter.energie_verarbeiten(erzeugung, verbrauch, stunde)
# Speichern # Ergebnisse speichern
netzeinspeisung_wh_pro_stunde.append(netzeinspeisung) netzeinspeisung_wh_pro_stunde[stunde_since_now] = netzeinspeisung
stündliche_einnahmen_euro = netzeinspeisung* self.einspeiseverguetung_euro_pro_wh[stunde] netzbezug_wh_pro_stunde[stunde_since_now] = netzbezug
verluste_wh_pro_stunde[stunde_since_now] += verluste
stündliche_kosten_euro = netzbezug * strompreis # Finanzen berechnen
netzbezug_wh_pro_stunde.append(netzbezug) kosten_euro_pro_stunde[stunde_since_now] = netzbezug * strompreis
verluste_wh_pro_stunde[-1] += verluste einnahmen_euro_pro_stunde[stunde_since_now] = netzeinspeisung * self.einspeiseverguetung_euro_pro_wh[stunde]
last_wh_pro_stunde.append(eigenverbrauch+netzbezug)
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)
# Letzter Akkuzustand speichern
akku_soc_pro_stunde[stunde_since_now] = self.akku.ladezustand_in_prozent()
# Gesamtkosten berechnen
gesamtkosten_euro = np.nansum(kosten_euro_pro_stunde) - np.nansum(einnahmen_euro_pro_stunde) gesamtkosten_euro = np.nansum(kosten_euro_pro_stunde) - np.nansum(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','E-Auto_SoC_pro_Stunde', "Verluste_Pro_Stunde"]
all_arrays = [last_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]}")
out = { out = {
'Last_Wh_pro_Stunde': last_wh_pro_stunde, 'Last_Wh_pro_Stunde': last_wh_pro_stunde,
@ -167,5 +155,5 @@ class EnergieManagementSystem:
} }
out = replace_nan_with_none(out) out = replace_nan_with_none(out)
return out return out