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

cleanup class_ems.py

Browse Source 
- type hints added
- translated to English
- reduced not needed function calls 

improves optimization time by 50%
This commit is contained in:
Normann 2024-10-05 21:26:31 +02:00 committed by Andreas
parent 3b5fc18665
commit c31a6c457f
1 changed files with 65 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
modules/class_ems.py
View File

@ -1,18 +1,22 @@
from datetime import datetime from datetime import datetime
from typing import Dict, List, Optional, Union
import numpy as np import numpy as np
def replace_nan_with_none(data): def replace_nan_with_none(
if isinstance(data, dict): data: Union[np.ndarray, dict, list, float],
) -> Union[List, dict, float, None]:
if data is None:
return None
if isinstance(data, np.ndarray):
# Use numpy vectorized approach
return np.where(np.isnan(data), None, data).tolist()
elif 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, 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): 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
@ -21,112 +25,82 @@ def replace_nan_with_none(data):
class EnergieManagementSystem: class EnergieManagementSystem:
def __init__( def __init__(
self, self,
pv_prognose_wh=None, pv_prognose_wh: Optional[np.ndarray] = None,
strompreis_euro_pro_wh=None, strompreis_euro_pro_wh: Optional[np.ndarray] = None,
einspeiseverguetung_euro_pro_wh=None, einspeiseverguetung_euro_pro_wh: Optional[np.ndarray] = None,
eauto=None, eauto: Optional[object] = None,
gesamtlast=None, gesamtlast: Optional[np.ndarray] = None,
haushaltsgeraet=None, haushaltsgeraet: Optional[object] = None,
wechselrichter=None, wechselrichter: Optional[object] = None,
): ):
self.akku = wechselrichter.akku self.akku = wechselrichter.akku
# self.lastkurve_wh = lastkurve_wh
self.gesamtlast = gesamtlast self.gesamtlast = gesamtlast
self.pv_prognose_wh = pv_prognose_wh self.pv_prognose_wh = pv_prognose_wh
self.strompreis_euro_pro_wh = ( self.strompreis_euro_pro_wh = strompreis_euro_pro_wh
strompreis_euro_pro_wh # Strompreis in Cent pro Wh self.einspeiseverguetung_euro_pro_wh = einspeiseverguetung_euro_pro_wh
)
self.einspeiseverguetung_euro_pro_wh = (
einspeiseverguetung_euro_pro_wh # Einspeisevergütung in Cent pro Wh
)
self.eauto = eauto self.eauto = eauto
self.haushaltsgeraet = haushaltsgeraet self.haushaltsgeraet = haushaltsgeraet
self.wechselrichter = wechselrichter self.wechselrichter = wechselrichter
def set_akku_discharge_hours(self, ds): def set_akku_discharge_hours(self, ds: List[int]) -> None:
self.akku.set_discharge_per_hour(ds) self.akku.set_discharge_per_hour(ds)
def set_eauto_charge_hours(self, ds): def set_eauto_charge_hours(self, ds: List[int]) -> None:
self.eauto.set_charge_per_hour(ds) self.eauto.set_charge_per_hour(ds)
def set_haushaltsgeraet_start(self, ds, global_start_hour=0): def set_haushaltsgeraet_start(
self, ds: List[int], global_start_hour: int = 0
) -> None:
self.haushaltsgeraet.set_startzeitpunkt(ds, global_start_hour=global_start_hour) self.haushaltsgeraet.set_startzeitpunkt(ds, global_start_hour=global_start_hour)
def reset(self): def reset(self) -> None:
self.eauto.reset() self.eauto.reset()
self.akku.reset() self.akku.reset()
def simuliere_ab_jetzt(self): def simuliere_ab_jetzt(self) -> dict:
jetzt = datetime.now() jetzt = datetime.now()
start_stunde = jetzt.hour start_stunde = jetzt.hour
# Berechne die Anzahl der Stunden bis zum gleichen Zeitpunkt am nächsten Tag
stunden_bis_ende_tag = 24 - start_stunde
# Füge diese Stunden zum nächsten Tag hinzu
gesamt_stunden = stunden_bis_ende_tag + 24
# Beginne die Simulation ab der aktuellen Stunde und führe sie für die berechnete Dauer aus
return self.simuliere(start_stunde) return self.simuliere(start_stunde)
def simuliere(self, start_stunde): def simuliere(self, start_stunde: int) -> dict:
# Ensure arrays have the same length
lastkurve_wh = self.gesamtlast lastkurve_wh = self.gesamtlast
# Anzahl der Stunden berechnen
assert ( assert (
len(lastkurve_wh) len(lastkurve_wh)
== len(self.pv_prognose_wh) == len(self.pv_prognose_wh)
== len(self.strompreis_euro_pro_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)}" ), f"Array sizes do not match: Load Curve = {len(lastkurve_wh)}, PV Forecast = {len(self.pv_prognose_wh)}, Electricity Price = {len(self.strompreis_euro_pro_wh)}"
ende = min(
len(lastkurve_wh),
len(self.pv_prognose_wh),
len(self.strompreis_euro_pro_wh),
)
# Optimized total hours calculation
ende = len(lastkurve_wh)
total_hours = ende - start_stunde total_hours = ende - start_stunde
# Initialisierung der Arrays mit NaN-Werten # Pre-allocate arrays for the results, optimized for speed
last_wh_pro_stunde = np.full(total_hours, np.nan) last_wh_pro_stunde = np.zeros(total_hours)
netzeinspeisung_wh_pro_stunde = np.full(total_hours, np.nan) netzeinspeisung_wh_pro_stunde = np.zeros(total_hours)
netzbezug_wh_pro_stunde = np.full(total_hours, np.nan) netzbezug_wh_pro_stunde = np.zeros(total_hours)
kosten_euro_pro_stunde = np.full(total_hours, np.nan) kosten_euro_pro_stunde = np.zeros(total_hours)
einnahmen_euro_pro_stunde = np.full(total_hours, np.nan) einnahmen_euro_pro_stunde = np.zeros(total_hours)
akku_soc_pro_stunde = np.full(total_hours, np.nan) akku_soc_pro_stunde = np.zeros(total_hours)
eauto_soc_pro_stunde = np.full(total_hours, np.nan) eauto_soc_pro_stunde = np.zeros(total_hours)
verluste_wh_pro_stunde = np.full(total_hours, np.nan) verluste_wh_pro_stunde = np.zeros(total_hours)
haushaltsgeraet_wh_pro_stunde = np.full(total_hours, np.nan) haushaltsgeraet_wh_pro_stunde = np.zeros(total_hours)
# Setze den initialen Ladezustand für Akku und E-Auto # Set initial state
akku_soc_pro_stunde[start_stunde] = self.akku.ladezustand_in_prozent() akku_soc_pro_stunde[0] = self.akku.ladezustand_in_prozent()
if self.eauto: if self.eauto:
eauto_soc_pro_stunde[start_stunde] = self.eauto.ladezustand_in_prozent() eauto_soc_pro_stunde[0] = self.eauto.ladezustand_in_prozent()
for stunde in range(start_stunde + 1, ende): for stunde in range(start_stunde + 1, ende):
stunde_since_now = stunde - start_stunde 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
)
# Verbrauch und zusätzliche Lasten bestimmen # Accumulate loads and PV generation
verbrauch = self.gesamtlast[stunde] verbrauch = self.gesamtlast[stunde]
haushalts_last = 0 if self.haushaltsgeraet:
verbrauch += self.haushaltsgeraet.get_last_fuer_stunde(stunde)
haushaltsgeraet_wh_pro_stunde[stunde_since_now] = verbrauch
if self.haushaltsgeraet is not None: # E-Auto handling
haushalts_last = self.haushaltsgeraet.get_last_fuer_stunde(stunde)
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]
strompreis = self.strompreis_euro_pro_wh[stunde]
# Verluste initialisieren
verluste_wh_pro_stunde[stunde_since_now] = 0.0
# E-Auto-Verbrauch bestimmen
if self.eauto: if self.eauto:
geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden( geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden(
None, stunde None, stunde
@ -137,31 +111,34 @@ class EnergieManagementSystem:
self.eauto.ladezustand_in_prozent() self.eauto.ladezustand_in_prozent()
) )
# Wechselrichter-Logik # Process inverter logic
erzeugung = self.pv_prognose_wh[stunde]
netzeinspeisung, netzbezug, verluste, eigenverbrauch = ( netzeinspeisung, netzbezug, verluste, eigenverbrauch = (
self.wechselrichter.energie_verarbeiten(erzeugung, verbrauch, stunde) self.wechselrichter.energie_verarbeiten(erzeugung, verbrauch, stunde)
) )
# Ergebnisse speichern
netzeinspeisung_wh_pro_stunde[stunde_since_now] = netzeinspeisung netzeinspeisung_wh_pro_stunde[stunde_since_now] = netzeinspeisung
netzbezug_wh_pro_stunde[stunde_since_now] = netzbezug netzbezug_wh_pro_stunde[stunde_since_now] = netzbezug
verluste_wh_pro_stunde[stunde_since_now] += verluste verluste_wh_pro_stunde[stunde_since_now] += verluste
last_wh_pro_stunde[stunde_since_now] = verbrauch last_wh_pro_stunde[stunde_since_now] = verbrauch
# Finanzen berechnen
kosten_euro_pro_stunde[stunde_since_now] = netzbezug * strompreis # Financial calculations
kosten_euro_pro_stunde[stunde_since_now] = (
netzbezug * self.strompreis_euro_pro_wh[stunde]
)
einnahmen_euro_pro_stunde[stunde_since_now] = ( einnahmen_euro_pro_stunde[stunde_since_now] = (
netzeinspeisung * self.einspeiseverguetung_euro_pro_wh[stunde] netzeinspeisung * self.einspeiseverguetung_euro_pro_wh[stunde]
) )
# Letzter Akkuzustand speichern # Akku SOC tracking
akku_soc_pro_stunde[stunde_since_now] = self.akku.ladezustand_in_prozent() akku_soc_pro_stunde[stunde_since_now] = self.akku.ladezustand_in_prozent()
# Gesamtkosten berechnen # Total cost and return
gesamtkosten_euro = np.nansum(kosten_euro_pro_stunde) - np.nansum( gesamtkosten_euro = np.sum(kosten_euro_pro_stunde) - np.sum(
einnahmen_euro_pro_stunde einnahmen_euro_pro_stunde
) )
out = { # Prepare output dictionary
out: Dict[str, Union[np.ndarray, float]] = {
"Last_Wh_pro_Stunde": last_wh_pro_stunde, "Last_Wh_pro_Stunde": last_wh_pro_stunde,
"Netzeinspeisung_Wh_pro_Stunde": netzeinspeisung_wh_pro_stunde, "Netzeinspeisung_Wh_pro_Stunde": netzeinspeisung_wh_pro_stunde,
"Netzbezug_Wh_pro_Stunde": netzbezug_wh_pro_stunde, "Netzbezug_Wh_pro_Stunde": netzbezug_wh_pro_stunde,
@ -170,12 +147,11 @@ class EnergieManagementSystem:
"Einnahmen_Euro_pro_Stunde": einnahmen_euro_pro_stunde, "Einnahmen_Euro_pro_Stunde": einnahmen_euro_pro_stunde,
"Gesamtbilanz_Euro": gesamtkosten_euro, "Gesamtbilanz_Euro": gesamtkosten_euro,
"E-Auto_SoC_pro_Stunde": eauto_soc_pro_stunde, "E-Auto_SoC_pro_Stunde": eauto_soc_pro_stunde,
"Gesamteinnahmen_Euro": np.nansum(einnahmen_euro_pro_stunde), "Gesamteinnahmen_Euro": np.sum(einnahmen_euro_pro_stunde),
"Gesamtkosten_Euro": np.nansum(kosten_euro_pro_stunde), "Gesamtkosten_Euro": np.sum(kosten_euro_pro_stunde),
"Verluste_Pro_Stunde": verluste_wh_pro_stunde, "Verluste_Pro_Stunde": verluste_wh_pro_stunde,
"Gesamt_Verluste": np.nansum(verluste_wh_pro_stunde), "Gesamt_Verluste": np.sum(verluste_wh_pro_stunde),
"Haushaltsgeraet_wh_pro_stunde": haushaltsgeraet_wh_pro_stunde, "Haushaltsgeraet_wh_pro_stunde": haushaltsgeraet_wh_pro_stunde,
} }
out = replace_nan_with_none(out) return replace_nan_with_none(out)
return out