EOS/modules/class_akku.py

import numpy as np
class PVAkku:
    def __init__(self, kapazitaet_wh=None, hours=None, lade_effizienz=0.88, entlade_effizienz=0.88,max_ladeleistung_w=None,start_soc_prozent=0,min_soc_prozent=0,max_soc_prozent=100):
        # Kapazität des Akkus in Wh
        self.kapazitaet_wh = kapazitaet_wh
        # Initialer Ladezustand des Akkus in Wh
        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
        self.min_soc_prozent = min_soc_prozent
        self.max_soc_prozent = max_soc_prozent
        

    def to_dict(self):
        return {
            "kapazitaet_wh": self.kapazitaet_wh,
            "start_soc_prozent": self.start_soc_prozent,
            "soc_wh": self.soc_wh,
            "hours": self.hours,
            "discharge_array": self.discharge_array.tolist(),  # Umwandlung von np.array in Liste
            "charge_array": self.charge_array.tolist(),
            "lade_effizienz": self.lade_effizienz,
            "entlade_effizienz": self.entlade_effizienz,
            "max_ladeleistung_w": self.max_ladeleistung_w
        }

    @classmethod
    def from_dict(cls, data):
        # Erstellung eines neuen Objekts mit Basisdaten
        obj = cls(
            kapazitaet_wh=data["kapazitaet_wh"],
            hours=data["hours"],
            lade_effizienz=data["lade_effizienz"],
            entlade_effizienz=data["entlade_effizienz"],
            max_ladeleistung_w=data["max_ladeleistung_w"],
            start_soc_prozent=data["start_soc_prozent"]
        )
        # Setzen von Arrays
        obj.discharge_array = np.array(data["discharge_array"])
        obj.charge_array = np.array(data["charge_array"])
        obj.soc_wh = data["soc_wh"]  # Setzt den aktuellen Ladezustand, der möglicherweise von start_soc_prozent abweicht
        
        return obj


    def reset(self):
        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 = np.array(discharge_array)

    def set_charge_per_hour(self, charge_array):
        assert(len(charge_array) == self.hours)
        self.charge_array = np.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, 0.0  # Keine Energieabgabe und keine Verluste
        
        # Berechnung der maximal abgebenden Energiemenge unter Berücksichtigung der Entladeeffizienz
        max_abgebbar_wh = self.soc_wh * self.entlade_effizienz
        
        # Berücksichtigen der maximalen Entladeleistung des Akkus
        max_abgebbar_wh = min(max_abgebbar_wh, self.max_ladeleistung_w)
        
        
        # 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
        
        # Relativ zur maximalen Ladeleistung (zwischen 0 und 1)
        relative_ladeleistung = self.charge_array[hour]
        effektive_ladeleistung = relative_ladeleistung * self.max_ladeleistung_w

        # Berechnung der tatsächlichen Lademenge unter Berücksichtigung der Ladeeffizienz
        effektive_lademenge = min(wh, effektive_ladeleistung) 

        # 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)


        return geladene_menge, verluste_wh

    def aktueller_energieinhalt(self):
        """
        Diese Methode gibt die aktuelle Restenergie unter Berücksichtigung des Wirkungsgrades zurück.
        Sie berücksichtigt dabei die Lade- und Entladeeffizienz.
        """
        # Berechnung der Restenergie unter Berücksichtigung der Entladeeffizienz
        nutzbare_energie = self.soc_wh * self.entlade_effizienz
        return nutzbare_energie




    # 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

        # # Berechnung der tatsächlichen Lademenge unter Berücksichtigung der Ladeeffizienz
        # effektive_lademenge = min(wh, self.max_ladeleistung_w) 

        # # 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:
            # # zusatz_verluste_wh = (effektive_lademenge - geladene_menge_ohne_verlust) * self.lade_effizienz
        
        # # # Gesamtverluste berechnen
        # # gesamt_verluste_wh = verluste_wh + zusatz_verluste_wh
        
        
        # return geladene_menge, verluste_wh
        # # effektive_lademenge = wh * self.lade_effizienz
        # # self.soc_wh = min(self.soc_wh + effektive_lademenge, self.kapazitaet_wh)




if __name__ == '__main__':
    # Beispiel zur Nutzung der Klasse
    akku = PVAkku(10000) # Ein Akku mit 10.000 Wh Kapazität
    print(f"Initialer Ladezustand: {akku.ladezustand_in_prozent()}%")

    akku.energie_laden(5000)
    print(f"Ladezustand nach Laden: {akku.ladezustand_in_prozent()}%, Aktueller Energieinhalt: {akku.aktueller_energieinhalt()} Wh")

    abgegebene_energie_wh = akku.energie_abgeben(3000)
    print(f"Abgegebene Energie: {abgegebene_energie_wh} Wh, Ladezustand danach: {akku.ladezustand_in_prozent()}%, Aktueller Energieinhalt: {akku.aktueller_energieinhalt()} Wh")

    akku.energie_laden(6000)
    print(f"Ladezustand nach weiterem Laden: {akku.ladezustand_in_prozent()}%, Aktueller Energieinhalt: {akku.aktueller_energieinhalt()} Wh")