diff --git a/modules/class_optimize.py b/modules/class_optimize.py index 975cc28a..78f76254 100644 --- a/modules/class_optimize.py +++ b/modules/class_optimize.py @@ -1,25 +1,23 @@ import os +import random import sys +from typing import Any, Dict, List, Optional, Tuple -import matplotlib import numpy as np +from deap import algorithms, base, creator, tools from modules.class_akku import PVAkku -from modules.class_ems import EnergieManagementSystem, Wechselrichter +from modules.class_ems import EnergieManagementSystem from modules.class_haushaltsgeraet import Haushaltsgeraet +from modules.class_inverter import Wechselrichter from modules.visualize import visualisiere_ergebnisse -matplotlib.use("Agg") # Setzt das Backend auf Agg -import random -from datetime import datetime, timedelta - -from deap import algorithms, base, creator, tools - sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from config import moegliche_ladestroeme_in_prozent -def isfloat(num): +def isfloat(num: Any) -> bool: + """Check if a given input can be converted to float.""" try: float(num) return True @@ -27,281 +25,209 @@ def isfloat(num): return False -def differential_evolution( - population, - toolbox, - cxpb, - mutpb, - ngen, - stats=None, - halloffame=None, - verbose=__debug__, -): - """Differential Evolution Algorithm""" - - # Evaluate the entire population - fitnesses = list(map(toolbox.evaluate, population)) - for ind, fit in zip(population, fitnesses): - ind.fitness.values = fit - - if halloffame is not None: - halloffame.update(population) - - logbook = tools.Logbook() - logbook.header = ["gen", "nevals"] + (stats.fields if stats else []) - - for gen in range(ngen): - # Generate the next generation by mutation and recombination - for i, target in enumerate(population): - a, b, c = random.sample([ind for ind in population if ind != target], 3) - mutant = toolbox.clone(a) - for k in range(len(mutant)): - mutant[k] = c[k] + mutpb * (a[k] - b[k]) # Mutation step - if random.random() < cxpb: # Recombination step - mutant[k] = target[k] - - # Evaluate the mutant - mutant.fitness.values = toolbox.evaluate(mutant) - - # Replace if mutant is better - if mutant.fitness > target.fitness: - population[i] = mutant - - # Update hall of fame - if halloffame is not None: - halloffame.update(population) - - # Gather all the fitnesses in one list and print the stats - record = stats.compile(population) if stats else {} - logbook.record(gen=gen, nevals=len(population), **record) - if verbose: - print(logbook.stream) - - return population, logbook - - class optimization_problem: - def __init__(self, prediction_hours=24, strafe=10, optimization_hours=24): - self.prediction_hours = prediction_hours # + def __init__( + self, + prediction_hours: int = 24, + strafe: float = 10, + optimization_hours: int = 24, + verbose: bool = False, + fixed_seed: Optional[int] = None, + ): + """Initialize the optimization problem with the required parameters.""" + self.prediction_hours = prediction_hours self.strafe = strafe self.opti_param = None self.fixed_eauto_hours = prediction_hours - optimization_hours self.possible_charge_values = moegliche_ladestroeme_in_prozent + self.verbose = verbose + self.fix_seed = fixed_seed + + # Set a fixed seed for random operations if provided + if fixed_seed is not None: + random.seed(fixed_seed) - def split_individual(self, individual): + def split_individual( + self, individual: List[float] + ) -> Tuple[List[int], List[float], Optional[int]]: """ - Teilt das gegebene Individuum in die verschiedenen Parameter auf: - - Entladeparameter (discharge_hours_bin) - - Ladeparameter (eautocharge_hours_float) - - Haushaltsgeräte (spuelstart_int, falls vorhanden) + Split the individual solution into its components: + 1. Discharge hours (binary), + 2. Electric vehicle charge hours (float), + 3. Dishwasher start time (integer if applicable). """ - # Extrahiere die Entlade- und Ladeparameter direkt aus dem Individuum - discharge_hours_bin = individual[ - : self.prediction_hours - ] # Erste 24 Werte sind Bool (Entladen) + discharge_hours_bin = individual[: self.prediction_hours] eautocharge_hours_float = individual[ self.prediction_hours : self.prediction_hours * 2 - ] # Nächste 24 Werte sind Float (Laden) - - spuelstart_int = None - if self.opti_param and self.opti_param.get("haushaltsgeraete", 0) > 0: - spuelstart_int = individual[ - -1 - ] # Letzter Wert ist Startzeit für Haushaltsgerät - + ] + spuelstart_int = ( + individual[-1] + if self.opti_param and self.opti_param.get("haushaltsgeraete", 0) > 0 + else None + ) return discharge_hours_bin, eautocharge_hours_float, spuelstart_int - def setup_deap_environment(self, opti_param, start_hour): + def setup_deap_environment( + self, opti_param: Dict[str, Any], start_hour: int + ) -> None: + """ + Set up the DEAP environment with fitness and individual creation rules. + """ self.opti_param = opti_param - if "FitnessMin" in creator.__dict__: - del creator.FitnessMin - if "Individual" in creator.__dict__: - del creator.Individual + # Remove existing FitnessMin and Individual classes from creator if present + for attr in ["FitnessMin", "Individual"]: + if attr in creator.__dict__: + del creator.__dict__[attr] + # Create new FitnessMin and Individual classes creator.create("FitnessMin", base.Fitness, weights=(-1.0,)) creator.create("Individual", list, fitness=creator.FitnessMin) - # PARAMETER + # Initialize toolbox with attributes and operations self.toolbox = base.Toolbox() self.toolbox.register("attr_bool", random.randint, 0, 1) - self.toolbox.register( - "attr_float", random.uniform, 0, 1 - ) # Für kontinuierliche Werte zwischen 0 und 1 (z.B. für E-Auto-Ladeleistung) - # self.toolbox.register("attr_choice", random.choice, self.possible_charge_values) # Für diskrete Ladeströme - + self.toolbox.register("attr_float", random.uniform, 0, 1) self.toolbox.register("attr_int", random.randint, start_hour, 23) - ################### - # Haushaltsgeraete - # print("Haushalt:",opti_param["haushaltsgeraete"]) + # Register individual creation method based on household appliance parameter if opti_param["haushaltsgeraete"] > 0: - - def create_individual(): - attrs = [ - self.toolbox.attr_bool() for _ in range(self.prediction_hours) - ] # 24 Bool-Werte für Entladen - attrs += [ - self.toolbox.attr_float() for _ in range(self.prediction_hours) - ] # 24 Float-Werte für Laden - attrs.append(self.toolbox.attr_int()) # Haushaltsgerät-Startzeit - return creator.Individual(attrs) - + self.toolbox.register( + "individual", + lambda: creator.Individual( + [self.toolbox.attr_bool() for _ in range(self.prediction_hours)] + + [self.toolbox.attr_float() for _ in range(self.prediction_hours)] + + [self.toolbox.attr_int()] + ), + ) else: + self.toolbox.register( + "individual", + lambda: creator.Individual( + [self.toolbox.attr_bool() for _ in range(self.prediction_hours)] + + [self.toolbox.attr_float() for _ in range(self.prediction_hours)] + ), + ) - def create_individual(): - attrs = [ - self.toolbox.attr_bool() for _ in range(self.prediction_hours) - ] # 24 Bool-Werte für Entladen - attrs += [ - self.toolbox.attr_float() for _ in range(self.prediction_hours) - ] # 24 Float-Werte für Laden - return creator.Individual(attrs) - - self.toolbox.register( - "individual", create_individual - ) # tools.initCycle, creator.Individual, (self.toolbox.attr_bool,self.toolbox.attr_bool), n=self.prediction_hours+1) + # Register population, mating, mutation, and selection functions self.toolbox.register( "population", tools.initRepeat, list, self.toolbox.individual ) self.toolbox.register("mate", tools.cxTwoPoint) self.toolbox.register("mutate", tools.mutFlipBit, indpb=0.1) - - # self.toolbox.register("mutate", mutate_choice, self.possible_charge_values, indpb=0.1) - # self.toolbox.register("mutate", tools.mutUniformInt, low=0, up=len(self.possible_charge_values)-1, indpb=0.1) - self.toolbox.register("select", tools.selTournament, tournsize=3) - def evaluate_inner(self, individual, ems, start_hour): + def evaluate_inner( + self, individual: List[float], ems: EnergieManagementSystem, start_hour: int + ) -> Dict[str, Any]: + """ + Internal evaluation function that simulates the energy management system (EMS) + using the provided individual solution. + """ ems.reset() - - # print("Spuel:",self.opti_param) - discharge_hours_bin, eautocharge_hours_float, spuelstart_int = ( self.split_individual(individual) ) - - # Haushaltsgeraete - if self.opti_param["haushaltsgeraete"] > 0: + if self.opti_param.get("haushaltsgeraete", 0) > 0: ems.set_haushaltsgeraet_start(spuelstart_int, global_start_hour=start_hour) - # discharge_hours_bin = np.full(self.prediction_hours,0) ems.set_akku_discharge_hours(discharge_hours_bin) - - # Setze die festen Werte für die letzten x Stunden - for i in range( - self.prediction_hours - self.fixed_eauto_hours, self.prediction_hours - ): - eautocharge_hours_float[i] = ( - 0.0 # Setze die letzten x Stunden auf einen festen Wert (oder vorgegebenen Wert) - ) - - # print(eautocharge_hours_float) - + eautocharge_hours_float[self.prediction_hours - self.fixed_eauto_hours :] = [ + 0.0 + ] * self.fixed_eauto_hours ems.set_eauto_charge_hours(eautocharge_hours_float) - - o = ems.simuliere(start_hour) - - return o - - # Fitness-Funktion (muss Ihre EnergieManagementSystem-Logik integrieren) - def evaluate(self, individual, ems, parameter, start_hour, worst_case): + return ems.simuliere(start_hour) + + def evaluate( + self, + individual: List[float], + ems: EnergieManagementSystem, + parameter: Dict[str, Any], + start_hour: int, + worst_case: bool, + ) -> Tuple[float]: + """ + Evaluate the fitness of an individual solution based on the simulation results. + """ try: o = self.evaluate_inner(individual, ems, start_hour) except Exception: - return (100000.0,) + return (100000.0,) # Return a high penalty in case of an exception - gesamtbilanz = o["Gesamtbilanz_Euro"] - if worst_case: - gesamtbilanz = gesamtbilanz * -1.0 - - discharge_hours_bin, eautocharge_hours_float, spuelstart_int = ( - self.split_individual(individual) + gesamtbilanz = o["Gesamtbilanz_Euro"] * (-1.0 if worst_case else 1.0) + discharge_hours_bin, eautocharge_hours_float, _ = self.split_individual( + individual ) max_ladeleistung = np.max(moegliche_ladestroeme_in_prozent) - strafe_überschreitung = 0.0 - - # Ladeleistung überschritten? - for ladeleistung in eautocharge_hours_float: - if ladeleistung > max_ladeleistung: - # Berechne die Überschreitung - überschreitung = ladeleistung - max_ladeleistung - # Füge eine Strafe hinzu (z.B. 10 Einheiten Strafe pro Prozentpunkt Überschreitung) - strafe_überschreitung += ( - self.strafe * 10 - ) # Hier ist die Strafe proportional zur Überschreitung - - # Für jeden Discharge 0, eine kleine Strafe von 1 Cent, da die Lastvertelung noch fehlt. Also wenn es egal ist, soll er den Akku entladen lassen - for i in range(0, self.prediction_hours): - if ( - discharge_hours_bin[i] == 0.0 - ): # Wenn die letzten x Stunden von einem festen Wert abweichen - gesamtbilanz += 0.01 # Bestrafe den Optimierer - - # E-Auto nur die ersten self.fixed_eauto_hours - for i in range( - self.prediction_hours - self.fixed_eauto_hours, self.prediction_hours - ): - if ( - eautocharge_hours_float[i] != 0.0 - ): # Wenn die letzten x Stunden von einem festen Wert abweichen - gesamtbilanz += self.strafe # Bestrafe den Optimierer - - # Überprüfung, ob der Mindest-SoC erreicht wird - final_soc = ( - ems.eauto.ladezustand_in_prozent() - ) # Nimmt den SoC am Ende des Optimierungszeitraums - - if (parameter["eauto_min_soc"] - ems.eauto.ladezustand_in_prozent()) <= 0.0: - # print (parameter['eauto_min_soc']," " ,ems.eauto.ladezustand_in_prozent()," ",(parameter['eauto_min_soc']-ems.eauto.ladezustand_in_prozent())) - for i in range(0, self.prediction_hours): - if ( - eautocharge_hours_float[i] != 0.0 - ): # Wenn die letzten x Stunden von einem festen Wert abweichen - gesamtbilanz += self.strafe # Bestrafe den Optimierer - - eauto_roi = parameter["eauto_min_soc"] - ems.eauto.ladezustand_in_prozent() + # Penalty for not discharging + gesamtbilanz += sum( + 0.01 for i in range(self.prediction_hours) if discharge_hours_bin[i] == 0.0 + ) + + # Penalty for charging the electric vehicle during restricted hours + gesamtbilanz += sum( + self.strafe + for i in range( + self.prediction_hours - self.fixed_eauto_hours, self.prediction_hours + ) + if eautocharge_hours_float[i] != 0.0 + ) + + # Penalty for exceeding maximum charge power + gesamtbilanz += sum( + self.strafe * 10 + for ladeleistung in eautocharge_hours_float + if ladeleistung > max_ladeleistung + ) + + # Penalty for not meeting the minimum SOC (State of Charge) requirement + if parameter["eauto_min_soc"] - ems.eauto.ladezustand_in_prozent() <= 0.0: + gesamtbilanz += sum( + self.strafe + for ladeleistung in eautocharge_hours_float + if ladeleistung != 0.0 + ) + individual.extra_data = ( o["Gesamtbilanz_Euro"], o["Gesamt_Verluste"], - eauto_roi, + parameter["eauto_min_soc"] - ems.eauto.ladezustand_in_prozent(), ) - restenergie_akku = ems.akku.aktueller_energieinhalt() - restwert_akku = restenergie_akku * parameter["preis_euro_pro_wh_akku"] - # print(restenergie_akku) - # print(parameter["preis_euro_pro_wh_akku"]) - # print(restwert_akku) - # print() - strafe = 0.0 - strafe = max( - 0, - (parameter["eauto_min_soc"] - ems.eauto.ladezustand_in_prozent()) - * self.strafe, + # Adjust total balance with battery value and penalties for unmet SOC + restwert_akku = ( + ems.akku.aktueller_energieinhalt() * parameter["preis_euro_pro_wh_akku"] + ) + gesamtbilanz += ( + max( + 0, + (parameter["eauto_min_soc"] - ems.eauto.ladezustand_in_prozent()) + * self.strafe, + ) + - restwert_akku ) - gesamtbilanz += strafe - restwert_akku + strafe_überschreitung - # gesamtbilanz += o["Gesamt_Verluste"]/10000.0 return (gesamtbilanz,) - # Genetischer Algorithmus - def optimize(self, start_solution=None): + def optimize( + self, start_solution: Optional[List[float]] = None + ) -> Tuple[Any, Dict[str, List[Any]]]: + """Run the optimization process using a genetic algorithm.""" population = self.toolbox.population(n=300) 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) - print("Start:", start_solution) + if self.verbose: + print("Start optimize:", start_solution) - if start_solution is not None and start_solution != -1: - population.insert(0, creator.Individual(start_solution)) - population.insert(1, creator.Individual(start_solution)) - population.insert(2, creator.Individual(start_solution)) + # Insert the start solution into the population if provided + if start_solution not in [None, -1]: + for _ in range(3): + population.insert(0, creator.Individual(start_solution)) + # Run the evolutionary algorithm algorithms.eaMuPlusLambda( population, self.toolbox, @@ -312,11 +238,8 @@ def optimize(self, start_solution=None): ngen=400, stats=stats, halloffame=hof, - verbose=True, + verbose=self.verbose, ) - # algorithms.eaSimple(population, self.toolbox, cxpb=0.3, mutpb=0.3, ngen=200, stats=stats, halloffame=hof, verbose=True) - # algorithms.eaMuCommaLambda(population, self.toolbox, mu=100, lambda_=200, cxpb=0.2, mutpb=0.4, ngen=300, stats=stats, halloffame=hof, verbose=True) - # population, log = differential_evolution(population, self.toolbox, cxpb=0.2, mutpb=0.5, ngen=200, stats=stats, halloffame=hof, verbose=True) member = {"bilanz": [], "verluste": [], "nebenbedingung": []} for ind in population: @@ -329,42 +252,28 @@ def optimize(self, start_solution=None): return hof[0], member def optimierung_ems( - self, parameter=None, start_hour=None, worst_case=False, startdate=None - ): - ############ - # Parameter - ############ - if startdate is None: - date = ( - datetime.now().date() + timedelta(hours=self.prediction_hours) - ).strftime("%Y-%m-%d") - date_now = datetime.now().strftime("%Y-%m-%d") - else: - date = (startdate + timedelta(hours=self.prediction_hours)).strftime( - "%Y-%m-%d" - ) - date_now = startdate.strftime("%Y-%m-%d") - # print("Start_date:",date_now) - - akku_size = parameter["pv_akku_cap"] # Wh - + self, + parameter: Optional[Dict[str, Any]] = None, + start_hour: Optional[int] = None, + worst_case: bool = False, + startdate: Optional[Any] = None, # startdate is not used! + ) -> Dict[str, Any]: + """ + Perform EMS (Energy Management System) optimization and visualize results. + """ einspeiseverguetung_euro_pro_wh = np.full( self.prediction_hours, parameter["einspeiseverguetung_euro_pro_wh"] - ) # = # € / Wh 7/(1000.0*100.0) - discharge_array = np.full( - self.prediction_hours, 1 - ) # np.array([1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]) # + ) + + # Initialize PV and EV batteries akku = PVAkku( - kapazitaet_wh=akku_size, + kapazitaet_wh=parameter["pv_akku_cap"], hours=self.prediction_hours, start_soc_prozent=parameter["pv_soc"], max_ladeleistung_w=5000, ) - akku.set_charge_per_hour(discharge_array) + akku.set_charge_per_hour(np.full(self.prediction_hours, 1)) - laden_moeglich = np.full( - self.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]) eauto = PVAkku( kapazitaet_wh=parameter["eauto_cap"], hours=self.prediction_hours, @@ -373,121 +282,71 @@ def optimierung_ems( max_ladeleistung_w=parameter["eauto_charge_power"], start_soc_prozent=parameter["eauto_soc"], ) - eauto.set_charge_per_hour(laden_moeglich) - min_soc_eauto = parameter["eauto_min_soc"] - start_params = parameter["start_solution"] - - ############### - # spuelmaschine - ############## - print(parameter) - if parameter["haushaltsgeraet_dauer"] > 0: - spuelmaschine = Haushaltsgeraet( + eauto.set_charge_per_hour(np.full(self.prediction_hours, 1)) + + # Initialize household appliance if applicable + spuelmaschine = ( + Haushaltsgeraet( hours=self.prediction_hours, verbrauch_kwh=parameter["haushaltsgeraet_wh"], dauer_h=parameter["haushaltsgeraet_dauer"], - ) - spuelmaschine.set_startzeitpunkt(start_hour) # Startet jetzt - else: - spuelmaschine = None - - ############### - # PV Forecast - ############### - # PVforecast = PVForecast(filepath=os.path.join(r'test_data', r'pvprognose.json')) - # PVforecast = PVForecast(prediction_hours = self.prediction_hours, url=pv_forecast_url) - # #print("PVPOWER",parameter['pvpowernow']) - # if isfloat(parameter['pvpowernow']): - # PVforecast.update_ac_power_measurement(date_time=datetime.now(), ac_power_measurement=float(parameter['pvpowernow'])) - # #PVforecast.print_ac_power_and_measurement() - pv_forecast = parameter[ - "pv_forecast" - ] # PVforecast.get_pv_forecast_for_date_range(date_now,date) #get_forecast_for_date(date) - temperature_forecast = parameter[ - "temperature_forecast" - ] # PVforecast.get_temperature_for_date_range(date_now,date) - - ############### - # Strompreise - ############### - specific_date_prices = parameter["strompreis_euro_pro_wh"] - print(specific_date_prices) - # print("https://api.akkudoktor.net/prices?start="+date_now+"&end="+date) + ).set_startzeitpunkt(start_hour) + if parameter["haushaltsgeraet_dauer"] > 0 + else None + ) + # Initialize the inverter and energy management system wr = Wechselrichter(10000, akku) - ems = EnergieManagementSystem( gesamtlast=parameter["gesamtlast"], - pv_prognose_wh=pv_forecast, - strompreis_euro_pro_wh=specific_date_prices, + pv_prognose_wh=parameter["pv_forecast"], + strompreis_euro_pro_wh=parameter["strompreis_euro_pro_wh"], einspeiseverguetung_euro_pro_wh=einspeiseverguetung_euro_pro_wh, eauto=eauto, haushaltsgeraet=spuelmaschine, wechselrichter=wr, ) - o = ems.simuliere(start_hour) - - ############### - # Optimizer Init - ############## - opti_param = {} - opti_param["haushaltsgeraete"] = 0 - if spuelmaschine is not None: - opti_param["haushaltsgeraete"] = 1 - - self.setup_deap_environment(opti_param, start_hour) - - def evaluate_wrapper(individual): - return self.evaluate(individual, ems, parameter, start_hour, worst_case) - - self.toolbox.register("evaluate", evaluate_wrapper) - start_solution, extra_data = self.optimize(start_params) - best_solution = start_solution - o = self.evaluate_inner(best_solution, ems, start_hour) - eauto = ems.eauto.to_dict() - spuelstart_int = None + + # Setup the DEAP environment and optimization process + self.setup_deap_environment( + {"haushaltsgeraete": 1 if spuelmaschine else 0}, start_hour + ) + self.toolbox.register( + "evaluate", + lambda ind: self.evaluate(ind, ems, parameter, start_hour, worst_case), + ) + start_solution, extra_data = self.optimize(parameter["start_solution"]) + + # Perform final evaluation on the best solution + o = self.evaluate_inner(start_solution, ems, start_hour) discharge_hours_bin, eautocharge_hours_float, spuelstart_int = ( - self.split_individual(best_solution) + self.split_individual(start_solution) ) - print(parameter) - print(best_solution) + # Visualize the results visualisiere_ergebnisse( parameter["gesamtlast"], - pv_forecast, - specific_date_prices, + parameter["pv_forecast"], + parameter["strompreis_euro_pro_wh"], o, discharge_hours_bin, eautocharge_hours_float, - temperature_forecast, + parameter["temperature_forecast"], start_hour, self.prediction_hours, einspeiseverguetung_euro_pro_wh, extra_data=extra_data, ) + os.system("cp visualisierungsergebnisse.pdf ~/") - # 'Eigenverbrauch_Wh_pro_Stunde': eigenverbrauch_wh_pro_stunde, - # 'Netzeinspeisung_Wh_pro_Stunde': netzeinspeisung_wh_pro_stunde, - # 'Netzbezug_Wh_pro_Stunde': netzbezug_wh_pro_stunde, - # 'Kosten_Euro_pro_Stunde': kosten_euro_pro_stunde, - # '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), - # "Verluste_Pro_Stunde":verluste_wh_pro_stunde, - # "Gesamt_Verluste":sum(verluste_wh_pro_stunde), - # "Haushaltsgeraet_wh_pro_stunde":haushaltsgeraet_wh_pro_stunde - - # print(eauto) + # Return final results as a dictionary return { "discharge_hours_bin": discharge_hours_bin, "eautocharge_hours_float": eautocharge_hours_float, "result": o, - "eauto_obj": eauto, - "start_solution": best_solution, + "eauto_obj": ems.eauto.to_dict(), + "start_solution": start_solution, "spuelstart": spuelstart_int, "simulation_data": o, }