chore: eosdash improve plan display (#739)

* chore: improve plan solution display

Add genetic optimization results to general solution provided by EOSdash plan display.

Add total results.

Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com>

* fix: genetic battery and home appliance device simulation

Fix genetic solution to make ac_charge, dc_charge, discharge, ev_charge or
home appliance start time reflect what the simulation was doing. Sometimes
the simulation decided to charge less or to start the appliance at another
time and this was not brought back to e.g. ac_charge.

Make home appliance simulation activate time window for the next day if it can not be
run today.

Improve simulation speed.

Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com>

---------

Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com>

src/akkudoktoreos/devices/devices.py

@@ -1,10 +1,13 @@
 """General configuration settings for simulated devices for optimization."""
 
 import json
+import re
 from typing import Any, Optional, TextIO, cast
 
+import numpy as np
 from loguru import logger
-from pydantic import Field, computed_field, model_validator
+from numpydantic import NDArray, Shape
+from pydantic import Field, computed_field, field_validator, model_validator
 
 from akkudoktoreos.config.configabc import SettingsBaseModel
 from akkudoktoreos.core.cache import CacheFileStore
@@ -14,6 +17,9 @@ from akkudoktoreos.core.pydantic import ConfigDict, PydanticBaseModel
 from akkudoktoreos.devices.devicesabc import DevicesBaseSettings
 from akkudoktoreos.utils.datetimeutil import DateTime, TimeWindowSequence, to_datetime
 
+# Default charge rates for battery
+BATTERY_DEFAULT_CHARGE_RATES = np.linspace(0.0, 1.0, 11)  # 0.0, 0.1, ..., 1.0
+
 
 class BatteriesCommonSettings(DevicesBaseSettings):
     """Battery devices base settings."""
@@ -61,9 +67,12 @@ class BatteriesCommonSettings(DevicesBaseSettings):
         examples=[50],
     )
 
-    charge_rates: Optional[list[float]] = Field(
-        default=None,
-        description="Charge rates as factor of maximum charging power [0.00 ... 1.00]. None denotes all charge rates are available.",
+    charge_rates: Optional[NDArray[Shape["*"], float]] = Field(
+        default=BATTERY_DEFAULT_CHARGE_RATES,
+        description=(
+            "Charge rates as factor of maximum charging power [0.00 ... 1.00]. "
+            "None triggers fallback to default charge-rates."
+        ),
         examples=[[0.0, 0.25, 0.5, 0.75, 1.0], None],
     )
 
@@ -71,7 +80,10 @@ class BatteriesCommonSettings(DevicesBaseSettings):
         default=0,
         ge=0,
         le=100,
-        description="Minimum state of charge (SOC) as percentage of capacity [%]. This is the target SoC for charging",
+        description=(
+            "Minimum state of charge (SOC) as percentage of capacity [%]. "
+            "This is the target SoC for charging"
+        ),
         examples=[10],
     )
 
@@ -83,6 +95,36 @@ class BatteriesCommonSettings(DevicesBaseSettings):
         examples=[100],
     )
 
+    @field_validator("charge_rates", mode="before")
+    def validate_and_sort_charge_rates(cls, v: Any) -> NDArray[Shape["*"], float]:
+        # None means fallback to default values
+        if v is None:
+            return BATTERY_DEFAULT_CHARGE_RATES.copy()
+
+        # Convert to numpy array
+        if isinstance(v, str):
+            # Remove brackets and split by comma or whitespace
+            numbers = re.split(r"[,\s]+", v.strip("[]"))
+
+            # Filter out any empty strings and convert to floats
+            arr = np.array([float(x) for x in numbers if x])
+        else:
+            arr = np.array(v, dtype=float)
+
+        # Must not be empty
+        if arr.size == 0:
+            raise ValueError("charge_rates must contain at least one value.")
+
+        # Enforce bounds: 0.0 ≤ x ≤ 1.0
+        if (arr < 0.0).any() or (arr > 1.0).any():
+            raise ValueError("charge_rates must be within [0.0, 1.0].")
+
+        # Remove duplicates + sort
+        arr = np.unique(arr)
+        arr.sort()
+
+        return arr
+
     @computed_field  # type: ignore[prop-decorator]
     @property
     def measurement_key_soc_factor(self) -> str:

src/akkudoktoreos/devices/genetic/battery.py

@@ -1,7 +1,8 @@
-from typing import Any, Optional
+from typing import Any, Iterator, Optional
 
 import numpy as np
 
+from akkudoktoreos.devices.devices import BATTERY_DEFAULT_CHARGE_RATES
 from akkudoktoreos.optimization.genetic.geneticdevices import (
     BaseBatteryParameters,
     SolarPanelBatteryParameters,
@@ -17,12 +18,20 @@ class Battery:
         self._setup()
 
     def _setup(self) -> None:
-        """Sets up the battery parameters based on configuration or provided parameters."""
+        """Sets up the battery parameters based on provided parameters."""
         self.capacity_wh = self.parameters.capacity_wh
         self.initial_soc_percentage = self.parameters.initial_soc_percentage
         self.charging_efficiency = self.parameters.charging_efficiency
         self.discharging_efficiency = self.parameters.discharging_efficiency
 
+        # Charge rates, in case of None use default
+        self.charge_rates = BATTERY_DEFAULT_CHARGE_RATES
+        if self.parameters.charge_rates:
+            charge_rates = np.array(self.parameters.charge_rates, dtype=float)
+            charge_rates = np.unique(charge_rates)
+            charge_rates.sort()
+            self.charge_rates = charge_rates
+
         # Only assign for storage battery
         self.min_soc_percentage = (
             self.parameters.min_soc_percentage
@@ -36,12 +45,30 @@ class Battery:
             self.max_charge_power_w = self.parameters.max_charge_power_w
         else:
             self.max_charge_power_w = self.capacity_wh  # TODO this should not be equal capacity_wh
-        self.discharge_array = np.full(self.prediction_hours, 1)
-        self.charge_array = np.full(self.prediction_hours, 1)
+        self.discharge_array = np.full(self.prediction_hours, 0)
+        self.charge_array = np.full(self.prediction_hours, 0)
         self.soc_wh = (self.initial_soc_percentage / 100) * self.capacity_wh
         self.min_soc_wh = (self.min_soc_percentage / 100) * self.capacity_wh
         self.max_soc_wh = (self.max_soc_percentage / 100) * self.capacity_wh
 
+    def _lower_charge_rates_desc(self, start_rate: float) -> Iterator[float]:
+        """Yield all charge rates lower than a given rate in descending order.
+
+        Args:
+            charge_rates (np.ndarray): Sorted 1D array of available charge rates.
+            start_rate (float): The reference charge rate.
+
+        Yields:
+            float: Charge rates lower than `start_rate`, in descending order.
+        """
+        charge_rates_fast = self.charge_rates
+
+        # Find the insertion index for start_rate (left-most position)
+        idx = np.searchsorted(charge_rates_fast, start_rate, side="left")
+
+        # Yield values before idx in reverse (descending)
+        return (charge_rates_fast[j] for j in range(idx - 1, -1, -1))
+
     def to_dict(self) -> dict[str, Any]:
         """Converts the object to a dictionary representation."""
         return {
@@ -61,8 +88,8 @@ class Battery:
         """Resets the battery state to its initial values."""
         self.soc_wh = (self.initial_soc_percentage / 100) * self.capacity_wh
         self.soc_wh = min(max(self.soc_wh, self.min_soc_wh), self.max_soc_wh)
-        self.discharge_array = np.full(self.prediction_hours, 1)
-        self.charge_array = np.full(self.prediction_hours, 1)
+        self.discharge_array = np.full(self.prediction_hours, 0)
+        self.charge_array = np.full(self.prediction_hours, 0)
 
     def set_discharge_per_hour(self, discharge_array: np.ndarray) -> None:
         """Sets the discharge values for each hour."""
@@ -80,70 +107,172 @@ class Battery:
             )
         self.charge_array = np.array(charge_array)
 
-    def set_charge_allowed_for_hour(self, charge: float, hour: int) -> None:
-        """Sets the charge for a specific hour."""
-        if hour >= self.prediction_hours:
-            raise ValueError(
-                f"Hour {hour} is out of range. Must be less than {self.prediction_hours}."
-            )
-        self.charge_array[hour] = charge
-
     def current_soc_percentage(self) -> float:
         """Calculates the current state of charge in percentage."""
         return (self.soc_wh / self.capacity_wh) * 100
 
     def discharge_energy(self, wh: float, hour: int) -> tuple[float, float]:
-        """Discharges energy from the battery."""
+        """Discharge energy from the battery.
+
+        Discharge is limited by:
+        * Requested delivered energy
+        * Remaining energy above minimum SoC
+        * Maximum discharge power
+        * Discharge efficiency
+
+        Args:
+            wh (float): Requested delivered energy in watt-hours.
+            hour (int): Time index. If `self.discharge_array[hour] == 0`,
+                no discharge occurs.
+
+        Returns:
+            tuple[float, float]:
+                delivered_wh (float): Actual delivered energy [Wh].
+                losses_wh (float): Conversion losses [Wh].
+
+        """
         if self.discharge_array[hour] == 0:
             return 0.0, 0.0
 
-        max_possible_discharge_wh = (self.soc_wh - self.min_soc_wh) * self.discharging_efficiency
-        max_possible_discharge_wh = max(max_possible_discharge_wh, 0.0)
+        # Raw extractable energy above minimum SoC
+        raw_available_wh = max(self.soc_wh - self.min_soc_wh, 0.0)
 
-        max_possible_discharge_wh = min(
-            max_possible_discharge_wh, self.max_charge_power_w
-        )  # TODO make a new cfg variable max_discharge_power_w
+        # Maximum raw discharge due to power limit
+        max_raw_wh = self.max_charge_power_w  # TODO rename to max_discharge_power_w
 
-        actual_discharge_wh = min(wh, max_possible_discharge_wh)
-        actual_withdrawal_wh = (
-            actual_discharge_wh / self.discharging_efficiency
-            if self.discharging_efficiency > 0
-            else 0.0
-        )
+        # Actual raw withdrawal (internal)
+        raw_withdrawal_wh = min(raw_available_wh, max_raw_wh)
 
-        self.soc_wh -= actual_withdrawal_wh
+        # Convert raw to delivered
+        max_deliverable_wh = raw_withdrawal_wh * self.discharging_efficiency
+
+        # Cap by requested delivered energy
+        delivered_wh = min(wh, max_deliverable_wh)
+
+        # Effective raw withdrawal based on what is delivered
+        raw_used_wh = delivered_wh / self.discharging_efficiency
+
+        # Update SoC
+        self.soc_wh -= raw_used_wh
         self.soc_wh = max(self.soc_wh, self.min_soc_wh)
 
-        losses_wh = actual_withdrawal_wh - actual_discharge_wh
-        return actual_discharge_wh, losses_wh
+        # Losses
+        losses_wh = raw_used_wh - delivered_wh
+
+        return delivered_wh, losses_wh
 
     def charge_energy(
-        self, wh: Optional[float], hour: int, relative_power: float = 0.0
+        self,
+        wh: Optional[float],
+        hour: int,
+        charge_factor: float = 0.0,
     ) -> tuple[float, float]:
-        """Charges energy into the battery."""
+        """Charge energy into the battery.
+
+        Two **exclusive** modes:
+
+        Mode 1:
+            - `wh is not None` and `charge_factor == 0`
+            → The raw requested charge energy is `wh` (pre-efficiency).
+            → If remaining capacity is insufficient, charging is automatically limited.
+            → No exception is raised due to capacity limits.
+
+        Mode 2:
+            - `wh is None` and `charge_factor > 0`
+            → The raw requested energy is `max_charge_power_w * charge_factor`.
+            → If the request exceeds remaining capacity, the algorithm tries to
+              find a lower charge_factor that is compatible. If such a charge factor
+              exists, this hour’s charge_factor is replaced.
+            → If no charge factor can accommodate charging, the request is ignored
+              (`(0.0, 0.0)` is returned) and a penalty is applied elsewhere.
+
+        Charging is constrained by:
+            • Available SoC headroom (max_soc_wh − soc_wh)
+            • max_charge_power_w
+            • charging_efficiency
+
+        Args:
+            wh (float | None):
+                Requested raw energy [Wh] before efficiency.
+                Must be provided only for Mode 1 (charge_factor must be 0).
+
+            hour (int):
+                Time index. If charging is disabled at this hour (charge_array[hour] == 0),
+                returns `(0.0, 0.0)`.
+
+            charge_factor (float):
+                Fraction (0–1) of max charge power.
+                Must be >0 only in Mode 2 (`wh is None`).
+
+        Returns:
+            tuple[float, float]:
+                stored_wh : float
+                    Energy stored after efficiency [Wh].
+                losses_wh : float
+                    Conversion losses [Wh].
+
+        Raises:
+            ValueError:
+                - If the mode is ambiguous (neither Mode 1 nor Mode 2).
+                - If the final new SoC would exceed capacity_wh.
+
+        Notes:
+            stored_wh = raw_input_wh * charging_efficiency
+            losses_wh = raw_input_wh − stored_wh
+        """
+        # Charging allowed in this hour?
         if hour is not None and self.charge_array[hour] == 0:
-            return 0.0, 0.0  # Charging not allowed in this hour
+            return 0.0, 0.0
 
-        if relative_power > 0.0:
-            wh = self.max_charge_power_w * relative_power
+        # Provide fast (3x..5x) local read access (vs. self.xxx) for repetitive read access
+        soc_wh_fast = self.soc_wh
+        max_charge_power_w_fast = self.max_charge_power_w
+        charging_efficiency_fast = self.charging_efficiency
 
-        wh = wh if wh is not None else self.max_charge_power_w
+        # Decide mode & determine raw_request_wh and raw_charge_wh
+        if wh is not None and charge_factor == 0.0:  # mode 1
+            raw_request_wh = wh
+            raw_charge_wh = max(self.max_soc_wh - soc_wh_fast, 0.0) / charging_efficiency_fast
+        elif wh is None and charge_factor > 0.0:  # mode 2
+            raw_request_wh = max_charge_power_w_fast * charge_factor
+            raw_charge_wh = max(self.max_soc_wh - soc_wh_fast, 0.0) / charging_efficiency_fast
+            if raw_request_wh > raw_charge_wh:
+                # Use a lower charge factor
+                lower_charge_factors = self._lower_charge_rates_desc(charge_factor)
+                for charge_factor in lower_charge_factors:
+                    raw_request_wh = max_charge_power_w_fast * charge_factor
+                    if raw_request_wh <= raw_charge_wh:
+                        self.charge_array[hour] = charge_factor
+                        break
+                if raw_request_wh > raw_charge_wh:
+                    # ignore request - penalty for missing SoC will be applied
+                    self.charge_array[hour] = 0
+                    return 0.0, 0.0
+        else:
+            raise ValueError(
+                f"{self.parameters.device_id}: charge_energy must be called either "
+                "with wh != None and charge_factor == 0, or with wh == None and charge_factor > 0."
+            )
 
-        max_possible_charge_wh = (
-            (self.max_soc_wh - self.soc_wh) / self.charging_efficiency
-            if self.charging_efficiency > 0
-            else 0.0
-        )
-        max_possible_charge_wh = max(max_possible_charge_wh, 0.0)
+        # Remaining capacity
+        max_raw_wh = min(raw_charge_wh, max_charge_power_w_fast)
 
-        effective_charge_wh = min(wh, max_possible_charge_wh)
-        charged_wh = effective_charge_wh * self.charging_efficiency
+        # Actual raw intake
+        raw_input_wh = raw_request_wh if raw_request_wh < max_raw_wh else max_raw_wh
 
-        self.soc_wh += charged_wh
-        self.soc_wh = min(self.soc_wh, self.max_soc_wh)
+        # Apply efficiency
+        stored_wh = raw_input_wh * charging_efficiency_fast
+        new_soc = soc_wh_fast + stored_wh
 
-        losses_wh = effective_charge_wh - charged_wh
-        return charged_wh, losses_wh
+        if new_soc > self.capacity_wh:
+            raise ValueError(
+                f"{self.parameters.device_id}: SoC {new_soc} Wh exceeds capacity {self.capacity_wh} Wh"
+            )
+
+        self.soc_wh = new_soc
+        losses_wh = raw_input_wh - stored_wh
+
+        return stored_wh, losses_wh
 
     def current_energy_content(self) -> float:
         """Returns the current usable energy in the battery."""

src/akkudoktoreos/devices/genetic/homeappliance.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 
 from akkudoktoreos.optimization.genetic.geneticdevices import HomeApplianceParameters
@@ -28,7 +26,6 @@ class HomeAppliance:
         self.load_curve = np.zeros(self.prediction_hours)  # Initialize the load curve with zeros
         self.duration_h = self.parameters.duration_h
         self.consumption_wh = self.parameters.consumption_wh
-        self.appliance_start: Optional[int] = None
         # setup possible start times
         if self.parameters.time_windows is None:
             self.parameters.time_windows = TimeWindowSequence(
@@ -59,33 +56,32 @@ class HomeAppliance:
         else:
             self.start_latest = 23
 
-    def set_starting_time(self, start_hour: int, global_start_hour: int = 0) -> None:
+    def set_starting_time(self, start_hour: int, global_start_hour: int = 0) -> int:
         """Sets the start time of the device and generates the corresponding load curve.
 
         :param start_hour: The hour at which the device should start.
         """
-        self.reset_load_curve()
-
-        # Check if the duration of use is within the available time windows
         if not self.start_allowed[start_hour]:
-            # No available time window to start home appliance
-            # Use the earliest one
-            start_hour = self.start_earliest
+            # It is not allowed (by the time windows) to start the application at this time
+            if global_start_hour <= self.start_latest:
+                # There is a time window left to start the appliance. Use it
+                start_hour = self.start_latest
+            else:
+                # There is no time window left to run the application
+                # Set the start into tomorrow
+                start_hour = self.start_earliest + 24
 
-        # Check if it is possibility to start the appliance
-        if start_hour < global_start_hour:
-            # Start is before current time
-            # Use the latest one
-            start_hour = self.start_latest
+        self.reset_load_curve()
 
         # Calculate power per hour based on total consumption and duration
         power_per_hour = self.consumption_wh / self.duration_h  # Convert to watt-hours
 
         # Set the power for the duration of use in the load curve array
-        self.load_curve[start_hour : start_hour + self.duration_h] = power_per_hour
+        if start_hour < len(self.load_curve):
+            end_hour = min(start_hour + self.duration_h, self.prediction_hours)
+            self.load_curve[start_hour:end_hour] = power_per_hour
 
-        # Set the selected start hour
-        self.appliance_start = start_hour
+        return start_hour
 
     def reset_load_curve(self) -> None:
         """Resets the load curve."""
@@ -107,6 +103,3 @@ class HomeAppliance:
             )
 
         return self.load_curve[hour]
-
-    def get_appliance_start(self) -> Optional[int]:
-        return self.appliance_start

src/akkudoktoreos/optimization/genetic/genetic.py

@@ -69,7 +69,16 @@ class GeneticSimulation(PydanticBaseModel):
 
     ac_charge_hours: Optional[NDArray[Shape["*"], float]] = Field(default=None, description="TBD")
     dc_charge_hours: Optional[NDArray[Shape["*"], float]] = Field(default=None, description="TBD")
+    bat_discharge_hours: Optional[NDArray[Shape["*"], float]] = Field(
+        default=None, description="TBD"
+    )
     ev_charge_hours: Optional[NDArray[Shape["*"], float]] = Field(default=None, description="TBD")
+    ev_discharge_hours: Optional[NDArray[Shape["*"], float]] = Field(
+        default=None, description="TBD"
+    )
+    home_appliance_start_hour: Optional[int] = Field(
+        default=None, description="Home appliance start hour - None denotes no start."
+    )
 
     def prepare(
         self,
@@ -100,8 +109,11 @@ class GeneticSimulation(PydanticBaseModel):
         self.home_appliance = home_appliance
         self.inverter = inverter
         self.ac_charge_hours = np.full(self.prediction_hours, 0.0)
-        self.dc_charge_hours = np.full(self.prediction_hours, 1.0)
+        self.dc_charge_hours = np.full(self.prediction_hours, 0.0)
+        self.bat_discharge_hours = np.full(self.prediction_hours, 0.0)
         self.ev_charge_hours = np.full(self.prediction_hours, 0.0)
+        self.ev_discharge_hours = np.full(self.prediction_hours, 0.0)
+        self.home_appliance_start_hour = None
         """Prepare simulation runs."""
         self.load_energy_array = np.array(parameters.gesamtlast, float)
         self.pv_prediction_wh = np.array(parameters.pv_prognose_wh, float)
@@ -114,28 +126,12 @@ class GeneticSimulation(PydanticBaseModel):
             )
         )
 
-    def set_akku_discharge_hours(self, ds: np.ndarray) -> None:
-        if self.battery:
-            self.battery.set_discharge_per_hour(ds)
-
-    def set_akku_ac_charge_hours(self, ds: np.ndarray) -> None:
-        self.ac_charge_hours = ds
-
-    def set_akku_dc_charge_hours(self, ds: np.ndarray) -> None:
-        self.dc_charge_hours = ds
-
-    def set_ev_charge_hours(self, ds: np.ndarray) -> None:
-        self.ev_charge_hours = ds
-
-    def set_home_appliance_start(self, ds: int, global_start_hour: int = 0) -> None:
-        if self.home_appliance:
-            self.home_appliance.set_starting_time(ds, global_start_hour=global_start_hour)
-
     def reset(self) -> None:
         if self.ev:
             self.ev.reset()
         if self.battery:
             self.battery.reset()
+        self.home_appliance_start_hour = None
 
     def simulate(self, start_hour: int) -> dict[str, Any]:
         """Simulate energy usage and costs for the given start hour.
@@ -146,45 +142,66 @@ class GeneticSimulation(PydanticBaseModel):
         # Remember start hour
         self.start_hour = start_hour
 
-        # Check for simulation integrity
-        required_attrs = [
-            "load_energy_array",
-            "pv_prediction_wh",
-            "elect_price_hourly",
-            "ev_charge_hours",
-            "ac_charge_hours",
-            "dc_charge_hours",
-            "elect_revenue_per_hour_arr",
-        ]
-        missing_data = [
-            attr.replace("_", " ").title() for attr in required_attrs if getattr(self, attr) is None
-        ]
+        # Provide fast (3x..5x) local read access (vs. self.xxx) for repetitive read access
+        load_energy_array_fast = self.load_energy_array
+        ev_charge_hours_fast = self.ev_charge_hours
+        ev_discharge_hours_fast = self.ev_discharge_hours
+        ac_charge_hours_fast = self.ac_charge_hours
+        dc_charge_hours_fast = self.dc_charge_hours
+        bat_discharge_hours_fast = self.bat_discharge_hours
+        elect_price_hourly_fast = self.elect_price_hourly
+        elect_revenue_per_hour_arr_fast = self.elect_revenue_per_hour_arr
+        pv_prediction_wh_fast = self.pv_prediction_wh
+        battery_fast = self.battery
+        ev_fast = self.ev
+        home_appliance_fast = self.home_appliance
+        inverter_fast = self.inverter
 
-        if missing_data:
-            logger.error("Mandatory data missing - %s", ", ".join(missing_data))
-            raise ValueError(f"Mandatory data missing: {', '.join(missing_data)}")
+        # Check for simulation integrity (in a way that mypy understands)
+        if (
+            load_energy_array_fast is None
+            or pv_prediction_wh_fast is None
+            or elect_price_hourly_fast is None
+            or ev_charge_hours_fast is None
+            or ac_charge_hours_fast is None
+            or dc_charge_hours_fast is None
+            or elect_revenue_per_hour_arr_fast is None
+            or bat_discharge_hours_fast is None
+            or ev_discharge_hours_fast is None
+        ):
+            missing = []
+            if load_energy_array_fast is None:
+                missing.append("Load Energy Array")
+            if pv_prediction_wh_fast is None:
+                missing.append("PV Prediction Wh")
+            if elect_price_hourly_fast is None:
+                missing.append("Electricity Price Hourly")
+            if ev_charge_hours_fast is None:
+                missing.append("EV Charge Hours")
+            if ac_charge_hours_fast is None:
+                missing.append("AC Charge Hours")
+            if dc_charge_hours_fast is None:
+                missing.append("DC Charge Hours")
+            if elect_revenue_per_hour_arr_fast is None:
+                missing.append("Electricity Revenue Per Hour")
+            if bat_discharge_hours_fast is None:
+                missing.append("Battery Discharge Hours")
+            if ev_discharge_hours_fast is None:
+                missing.append("EV Discharge Hours")
+            msg = ", ".join(missing)
+            logger.error("Mandatory data missing - %s", msg)
+            raise ValueError(f"Mandatory data missing: {msg}")
 
-        # Pre-fetch data
-        load_energy_array = np.array(self.load_energy_array)
-        pv_prediction_wh = np.array(self.pv_prediction_wh)
-        elect_price_hourly = np.array(self.elect_price_hourly)
-        ev_charge_hours = np.array(self.ev_charge_hours)
-        ac_charge_hours = np.array(self.ac_charge_hours)
-        dc_charge_hours = np.array(self.dc_charge_hours)
-        elect_revenue_per_hour_arr = np.array(self.elect_revenue_per_hour_arr)
-
-        # Fetch objects
-        battery = self.battery
-        ev = self.ev
-        home_appliance = self.home_appliance
-        inverter = self.inverter
-
-        if not (len(load_energy_array) == len(pv_prediction_wh) == len(elect_price_hourly)):
-            error_msg = f"Array sizes do not match: Load Curve = {len(load_energy_array)}, PV Forecast = {len(pv_prediction_wh)}, Electricity Price = {len(elect_price_hourly)}"
+        if not (
+            len(load_energy_array_fast)
+            == len(pv_prediction_wh_fast)
+            == len(elect_price_hourly_fast)
+        ):
+            error_msg = f"Array sizes do not match: Load Curve = {len(load_energy_array_fast)}, PV Forecast = {len(pv_prediction_wh_fast)}, Electricity Price = {len(elect_price_hourly_fast)}"
             logger.error(error_msg)
             raise ValueError(error_msg)
 
-        end_hour = len(load_energy_array)
+        end_hour = len(load_energy_array_fast)
         total_hours = end_hour - start_hour
 
         # Pre-allocate arrays for the results, optimized for speed
@@ -200,82 +217,104 @@ class GeneticSimulation(PydanticBaseModel):
         electricity_price_per_hour = np.full((total_hours), np.nan)
 
         # Set initial state
-        if battery:
-            soc_per_hour[0] = battery.current_soc_percentage()
-        if ev:
-            soc_ev_per_hour[0] = ev.current_soc_percentage()
+        if battery_fast:
+            soc_per_hour[0] = battery_fast.current_soc_percentage()
+            # Fill the charge array of the battery
+            dc_charge_hours_fast[0:start_hour] = 0
+            dc_charge_hours_fast[end_hour:] = 0
+            ac_charge_hours_fast[0:start_hour] = 0
+            dc_charge_hours_fast[end_hour:] = 0
+            battery_fast.charge_array = np.where(
+                ac_charge_hours_fast != 0, ac_charge_hours_fast, dc_charge_hours_fast
+            )
+            # Fill the discharge array of the battery
+            bat_discharge_hours_fast[0:start_hour] = 0
+            bat_discharge_hours_fast[end_hour:] = 0
+            battery_fast.discharge_array = bat_discharge_hours_fast
+
+        if ev_fast:
+            soc_ev_per_hour[0] = ev_fast.current_soc_percentage()
+            # Fill the charge array of the ev
+            ev_charge_hours_fast[0:start_hour] = 0
+            ev_charge_hours_fast[end_hour:] = 0
+            ev_fast.charge_array = ev_charge_hours_fast
+            # Fill the discharge array of the ev
+            ev_discharge_hours_fast[0:start_hour] = 0
+            ev_discharge_hours_fast[end_hour:] = 0
+            ev_fast.discharge_array = ev_discharge_hours_fast
+
+        if home_appliance_fast and self.home_appliance_start_hour:
+            home_appliance_enabled = True
+            self.home_appliance_start_hour = home_appliance_fast.set_starting_time(
+                self.home_appliance_start_hour, start_hour
+            )
+        else:
+            home_appliance_enabled = False
 
         for hour in range(start_hour, end_hour):
             hour_idx = hour - start_hour
 
-            # save begin states
-            if battery:
-                soc_per_hour[hour_idx] = battery.current_soc_percentage()
-            if ev:
-                soc_ev_per_hour[hour_idx] = ev.current_soc_percentage()
-
             # Accumulate loads and PV generation
-            consumption = load_energy_array[hour]
+            consumption = load_energy_array_fast[hour]
             losses_wh_per_hour[hour_idx] = 0.0
 
             # Home appliances
-            if home_appliance:
-                ha_load = home_appliance.get_load_for_hour(hour)
+            if home_appliance_enabled:
+                ha_load = home_appliance_fast.get_load_for_hour(hour)  # type: ignore[union-attr]
                 consumption += ha_load
                 home_appliance_wh_per_hour[hour_idx] = ha_load
 
             # E-Auto handling
-            if ev and ev_charge_hours[hour] > 0:
-                loaded_energy_ev, verluste_eauto = ev.charge_energy(
-                    None, hour, relative_power=ev_charge_hours[hour]
-                )
-                consumption += loaded_energy_ev
-                losses_wh_per_hour[hour_idx] += verluste_eauto
+            if ev_fast:
+                soc_ev_per_hour[hour_idx] = ev_fast.current_soc_percentage()  # save begin state
+                if ev_charge_hours_fast[hour] > 0:
+                    loaded_energy_ev, verluste_eauto = ev_fast.charge_energy(
+                        wh=None, hour=hour, charge_factor=ev_charge_hours_fast[hour]
+                    )
+                    consumption += loaded_energy_ev
+                    losses_wh_per_hour[hour_idx] += verluste_eauto
 
             # Process inverter logic
             energy_feedin_grid_actual = energy_consumption_grid_actual = losses = eigenverbrauch = (
                 0.0
             )
 
-            hour_ac_charge = ac_charge_hours[hour]
-            hour_dc_charge = dc_charge_hours[hour]
-            hourly_electricity_price = elect_price_hourly[hour]
-            hourly_energy_revenue = elect_revenue_per_hour_arr[hour]
-
-            if battery:
-                battery.set_charge_allowed_for_hour(hour_dc_charge, hour)
-
-            if inverter:
-                energy_produced = pv_prediction_wh[hour]
+            if inverter_fast:
+                energy_produced = pv_prediction_wh_fast[hour]
                 (
                     energy_feedin_grid_actual,
                     energy_consumption_grid_actual,
                     losses,
                     eigenverbrauch,
-                ) = inverter.process_energy(energy_produced, consumption, hour)
+                ) = inverter_fast.process_energy(energy_produced, consumption, hour)
 
             # AC PV Battery Charge
-            if battery and hour_ac_charge > 0.0:
-                battery.set_charge_allowed_for_hour(1, hour)
-                battery_charged_energy_actual, battery_losses_actual = battery.charge_energy(
-                    None, hour, relative_power=hour_ac_charge
-                )
+            if battery_fast:
+                soc_per_hour[hour_idx] = battery_fast.current_soc_percentage()  # save begin state
+                hour_ac_charge = ac_charge_hours_fast[hour]
+                if hour_ac_charge > 0.0:
+                    battery_charged_energy_actual, battery_losses_actual = (
+                        battery_fast.charge_energy(None, hour, charge_factor=hour_ac_charge)
+                    )
 
-                total_battery_energy = battery_charged_energy_actual + battery_losses_actual
-                consumption += total_battery_energy
-                energy_consumption_grid_actual += total_battery_energy
-                losses_wh_per_hour[hour_idx] += battery_losses_actual
+                    total_battery_energy = battery_charged_energy_actual + battery_losses_actual
+                    consumption += total_battery_energy
+                    energy_consumption_grid_actual += total_battery_energy
+                    losses_wh_per_hour[hour_idx] += battery_losses_actual
 
             # Update hourly arrays
             feedin_energy_per_hour[hour_idx] = energy_feedin_grid_actual
             consumption_energy_per_hour[hour_idx] = energy_consumption_grid_actual
             losses_wh_per_hour[hour_idx] += losses
             loads_energy_per_hour[hour_idx] = consumption
+            hourly_electricity_price = elect_price_hourly_fast[hour]
             electricity_price_per_hour[hour_idx] = hourly_electricity_price
 
             # Financial calculations
             costs_per_hour[hour_idx] = energy_consumption_grid_actual * hourly_electricity_price
-            revenue_per_hour[hour_idx] = energy_feedin_grid_actual * hourly_energy_revenue
+            revenue_per_hour[hour_idx] = (
+                energy_feedin_grid_actual * elect_revenue_per_hour_arr_fast[hour]
+            )
 
         total_cost = np.nansum(costs_per_hour)
         total_losses = np.nansum(losses_wh_per_hour)
@@ -289,7 +328,7 @@ class GeneticSimulation(PydanticBaseModel):
             "Kosten_Euro_pro_Stunde": costs_per_hour,
             "akku_soc_pro_stunde": soc_per_hour,
             "Einnahmen_Euro_pro_Stunde": revenue_per_hour,
-            "Gesamtbilanz_Euro": total_cost - total_revenue,
+            "Gesamtbilanz_Euro": total_cost - total_revenue,  # Fitness score ("FitnessMin")
             "EAuto_SoC_pro_Stunde": soc_ev_per_hour,
             "Gesamteinnahmen_Euro": total_revenue,
             "Gesamtkosten_Euro": total_cost,
@@ -574,27 +613,33 @@ class GeneticOptimization(OptimizationBase):
         discharge_hours_bin, eautocharge_hours_index, washingstart_int = self.split_individual(
             individual
         )
+
         if self.opti_param.get("home_appliance", 0) > 0 and washingstart_int:
-            self.simulation.set_home_appliance_start(
-                washingstart_int, global_start_hour=self.ems.start_datetime.hour
-            )
+            # Set start hour for appliance
+            self.simulation.home_appliance_start_hour = washingstart_int
 
-        ac, dc, discharge = self.decode_charge_discharge(discharge_hours_bin)
+        ac_charge_hours, dc_charge_hours, discharge = self.decode_charge_discharge(
+            discharge_hours_bin
+        )
 
-        self.simulation.set_akku_discharge_hours(discharge)
+        self.simulation.bat_discharge_hours = discharge
         # Set DC charge hours only if DC optimization is enabled
         if self.optimize_dc_charge:
-            self.simulation.set_akku_dc_charge_hours(dc)
-        self.simulation.set_akku_ac_charge_hours(ac)
+            self.simulation.dc_charge_hours = dc_charge_hours
+        else:
+            self.simulation.dc_charge_hours = np.full(self.config.prediction.hours, 1)
+        self.simulation.ac_charge_hours = ac_charge_hours
 
         if eautocharge_hours_index is not None:
             eautocharge_hours_float = np.array(
                 [self.ev_possible_charge_values[i] for i in eautocharge_hours_index],
                 float,
             )
-            self.simulation.set_ev_charge_hours(eautocharge_hours_float)
+            # discharge is set to 0 by default
+            self.simulation.ev_charge_hours = eautocharge_hours_float
         else:
-            self.simulation.set_ev_charge_hours(np.full(self.config.prediction.hours, 0))
+            # discharge is set to 0 by default
+            self.simulation.ev_charge_hours = np.full(self.config.prediction.hours, 0)
 
         # Do the simulation and return result.
         return self.simulation.simulate(self.ems.start_datetime.hour)
@@ -606,21 +651,57 @@ class GeneticOptimization(OptimizationBase):
         start_hour: int,
         worst_case: bool,
     ) -> tuple[float]:
-        """Evaluate the fitness of an individual solution based on the simulation results."""
+        """Evaluate the fitness score of a single individual in the DEAP genetic algorithm.
+
+        This method runs a simulation based on the provided individual genome and
+        optimization parameters. The resulting performance is converted into a
+        fitness score compatible with DEAP (i.e., returned as a 1-tuple).
+
+        Args:
+            individual (list[int]):
+                The genome representing one candidate solution.
+            parameters (GeneticOptimizationParameters):
+                Optimization parameters that influence simulation behavior,
+                constraints, and scoring logic.
+            start_hour (int):
+                The simulation start hour (0–23 or domain-specific).
+                Used to initialize time-based scheduling or constraints.
+            worst_case (bool):
+                If True, evaluates the solution under worst-case assumptions
+                (e.g., pessimistic forecasts or boundary conditions).
+                If False, uses nominal assumptions.
+
+        Returns:
+            tuple[float]:
+                A single-element tuple containing the computed fitness score.
+                Lower score is better: "FitnessMin".
+
+        Raises:
+            ValueError: If input arguments are invalid or the individual structure
+                is not compatible with the simulation.
+            RuntimeError: If the simulation fails or cannot produce results.
+
+        Notes:
+            The resulting score should match DEAP's expected format: a tuple, even
+            if only a single scalar fitness value is returned.
+        """
         try:
-            o = self.evaluate_inner(individual)
+            simulation_result = self.evaluate_inner(individual)
         except Exception as e:
-            return (100000.0,)  # Return a high penalty in case of an exception
+            # Return bad fitness score ("FitnessMin") in case of an exception
+            return (100000.0,)
 
-        gesamtbilanz = o["Gesamtbilanz_Euro"] * (-1.0 if worst_case else 1.0)
-
-        discharge_hours_bin, eautocharge_hours_index, washingstart_int = self.split_individual(
-            individual
-        )
+        gesamtbilanz = simulation_result["Gesamtbilanz_Euro"] * (-1.0 if worst_case else 1.0)
 
         # EV 100% & charge not allowed
         if self.optimize_ev:
-            eauto_soc_per_hour = np.array(o.get("EAuto_SoC_pro_Stunde", []))  # Beispielkey
+            discharge_hours_bin, eautocharge_hours_index, washingstart_int = self.split_individual(
+                individual
+            )
+
+            eauto_soc_per_hour = np.array(
+                simulation_result.get("EAuto_SoC_pro_Stunde", [])
+            )  # Beispielkey
 
             if eauto_soc_per_hour is None or eautocharge_hours_index is None:
                 raise ValueError("eauto_soc_per_hour or eautocharge_hours_index is None")
@@ -686,8 +767,8 @@ class GeneticOptimization(OptimizationBase):
 
         # More metrics
         individual.extra_data = (  # type: ignore[attr-defined]
-            o["Gesamtbilanz_Euro"],
-            o["Gesamt_Verluste"],
+            simulation_result["Gesamtbilanz_Euro"],
+            simulation_result["Gesamt_Verluste"],
             parameters.eauto.min_soc_percentage - self.simulation.ev.current_soc_percentage()
             if parameters.eauto and self.simulation.ev
             else 0,
@@ -701,7 +782,7 @@ class GeneticOptimization(OptimizationBase):
             )
             gesamtbilanz += -restwert_akku
 
-        if self.optimize_ev:
+        if self.optimize_ev and parameters.eauto and self.simulation.ev:
             try:
                 penalty = self.config.optimization.genetic.penalties["ev_soc_miss"]
             except:
@@ -710,16 +791,14 @@ class GeneticOptimization(OptimizationBase):
                 logger.error(
                     "Penalty function parameter `ev_soc_miss` not configured, using {}.", penalty
                 )
-            gesamtbilanz += max(
-                0,
-                (
-                    parameters.eauto.min_soc_percentage
-                    - self.simulation.ev.current_soc_percentage()
-                    if parameters.eauto and self.simulation.ev
-                    else 0
+            ev_soc_percentage = self.simulation.ev.current_soc_percentage()
+            if (
+                ev_soc_percentage < parameters.eauto.min_soc_percentage
+                or ev_soc_percentage > parameters.eauto.max_soc_percentage
+            ):
+                gesamtbilanz += (
+                    abs(parameters.eauto.min_soc_percentage - ev_soc_percentage) * penalty
                 )
-                * penalty,
-            )
 
         return (gesamtbilanz,)
 
@@ -825,7 +904,7 @@ class GeneticOptimization(OptimizationBase):
                 parameters.pv_akku,
                 prediction_hours=self.config.prediction.hours,
             )
-            akku.set_charge_per_hour(np.full(self.config.prediction.hours, 1))
+            akku.set_charge_per_hour(np.full(self.config.prediction.hours, 0))
 
         eauto: Optional[Battery] = None
         if parameters.eauto:
@@ -917,7 +996,7 @@ class GeneticOptimization(OptimizationBase):
         )
         # home appliance may have choosen a different appliance start hour
         if self.simulation.home_appliance:
-            washingstart_int = self.simulation.home_appliance.get_appliance_start()
+            washingstart_int = self.simulation.home_appliance_start_hour
 
         eautocharge_hours_float = (
             [self.ev_possible_charge_values[i] for i in eautocharge_hours_index]
@@ -925,12 +1004,28 @@ class GeneticOptimization(OptimizationBase):
             else None
         )
 
-        ac_charge, dc_charge, discharge = self.decode_charge_discharge(discharge_hours_bin)
+        # Simulation may have changed something, use simulation values
+        ac_charge_hours = self.simulation.ac_charge_hours
+        if ac_charge_hours is None:
+            ac_charge_hours = []
+        else:
+            ac_charge_hours = ac_charge_hours.tolist()
+        dc_charge_hours = self.simulation.dc_charge_hours
+        if dc_charge_hours is None:
+            dc_charge_hours = []
+        else:
+            dc_charge_hours = dc_charge_hours.tolist()
+        discharge = self.simulation.bat_discharge_hours
+        if discharge is None:
+            discharge = []
+        else:
+            discharge = discharge.tolist()
+
         # Visualize the results
         visualize = {
-            "ac_charge": ac_charge.tolist(),
-            "dc_charge": dc_charge.tolist(),
-            "discharge_allowed": discharge.tolist(),
+            "ac_charge": ac_charge_hours,
+            "dc_charge": dc_charge_hours,
+            "discharge_allowed": discharge,
             "eautocharge_hours_float": eautocharge_hours_float,
             "result": simulation_result,
             "eauto_obj": self.simulation.ev.to_dict() if self.simulation.ev else None,
@@ -946,8 +1041,8 @@ class GeneticOptimization(OptimizationBase):
 
         return GeneticSolution(
             **{
-                "ac_charge": ac_charge,
-                "dc_charge": dc_charge,
+                "ac_charge": ac_charge_hours,
+                "dc_charge": dc_charge_hours,
                 "discharge_allowed": discharge,
                 "eautocharge_hours_float": eautocharge_hours_float,
                 "result": GeneticSimulationResult(**simulation_result),

src/akkudoktoreos/optimization/genetic/geneticdevices.py

@@ -74,6 +74,11 @@ class BaseBatteryParameters(DeviceParameters):
         le=100,
         description="An integer representing the maximum state of charge (SOC) of the battery in percentage.",
     )
+    charge_rates: Optional[list[float]] = Field(
+        default=None,
+        description="Charge rates as factor of maximum charging power [0.00 ... 1.00]. None denotes all charge rates are available.",
+        examples=[[0.0, 0.25, 0.5, 0.75, 1.0], None],
+    )
 
 
 class SolarPanelBatteryParameters(BaseBatteryParameters):
@@ -90,11 +95,6 @@ class ElectricVehicleParameters(BaseBatteryParameters):
     initial_soc_percentage: int = initial_soc_percentage_field(
         "An integer representing the current state of charge (SOC) of the battery in percentage."
     )
-    charge_rates: Optional[list[float]] = Field(
-        default=None,
-        description="Charge rates as factor of maximum charging power [0.00 ... 1.00]. None denotes all charge rates are available.",
-        examples=[[0.0, 0.25, 0.5, 0.75, 1.0], None],
-    )
 
 
 class HomeApplianceParameters(DeviceParameters):

src/akkudoktoreos/optimization/genetic/geneticparams.py

@@ -457,7 +457,7 @@ class GeneticOptimizationParameters(
                         {
                             "device_id": "ev11",
                             "capacity_wh": 50000,
-                            "charge_rates": [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
+                            "charge_rates": [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
                             "min_soc_percentage": 70,
                         }
                     ]
@@ -483,7 +483,7 @@ class GeneticOptimizationParameters(
                         {
                             "device_id": "ev12",
                             "capacity_wh": 50000,
-                            "charge_rates": [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
+                            "charge_rates": [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
                             "min_soc_percentage": 70,
                         }
                     ]

src/akkudoktoreos/optimization/genetic/geneticsolution.py

@@ -6,7 +6,9 @@ import pandas as pd
 from loguru import logger
 from pydantic import Field, field_validator
 
-from akkudoktoreos.config.config import get_config
+from akkudoktoreos.core.coreabc import (
+    ConfigMixin,
+)
 from akkudoktoreos.core.emplan import (
     DDBCInstruction,
     EnergyManagementPlan,
@@ -109,7 +111,7 @@ class GeneticSimulationResult(GeneticParametersBaseModel):
         return NumpyEncoder.convert_numpy(field)[0]
 
 
-class GeneticSolution(GeneticParametersBaseModel):
+class GeneticSolution(ConfigMixin, GeneticParametersBaseModel):
     """**Note**: The first value of "Last_Wh_per_hour", "Netzeinspeisung_Wh_per_hour", and "Netzbezug_Wh_per_hour", will be set to null in the JSON output and represented as NaN or None in the corresponding classes' data returns. This approach is adopted to ensure that the current hour's processing remains unchanged."""
 
     ac_charge: list[float] = Field(
@@ -228,18 +230,20 @@ class GeneticSolution(GeneticParametersBaseModel):
         """
         from akkudoktoreos.core.ems import get_ems
 
-        config = get_config()
         start_datetime = get_ems().start_datetime
+        start_day_hour = start_datetime.in_timezone(self.config.general.timezone).hour
         interval_hours = 1
         power_to_energy_per_interval_factor = 1.0
 
         # --- Create index based on list length and interval ---
-        n_points = len(self.result.Kosten_Euro_pro_Stunde)
+        # Ensure we only use the minimum of results and commands if differing
+        periods = min(len(self.result.Kosten_Euro_pro_Stunde), len(self.ac_charge) - start_day_hour)
         time_index = pd.date_range(
             start=start_datetime,
-            periods=n_points,
+            periods=periods,
             freq=f"{interval_hours}h",
         )
+        n_points = len(time_index)
         end_datetime = start_datetime.add(hours=n_points)
 
         # Fill solution into dataframe with correct column names
@@ -256,26 +260,42 @@ class GeneticSolution(GeneticParametersBaseModel):
         solution = pd.DataFrame(
             {
                 "date_time": time_index,
-                "load_energy_wh": self.result.Last_Wh_pro_Stunde,
-                "grid_feedin_energy_wh": self.result.Netzeinspeisung_Wh_pro_Stunde,
-                "grid_consumption_energy_wh": self.result.Netzbezug_Wh_pro_Stunde,
-                "elec_price_prediction_amt_kwh": [v * 1000 for v in self.result.Electricity_price],
-                "costs_amt": self.result.Kosten_Euro_pro_Stunde,
-                "revenue_amt": self.result.Einnahmen_Euro_pro_Stunde,
-                "losses_energy_wh": self.result.Verluste_Pro_Stunde,
+                # result starts at start_day_hour
+                "load_energy_wh": self.result.Last_Wh_pro_Stunde[:n_points],
+                "grid_feedin_energy_wh": self.result.Netzeinspeisung_Wh_pro_Stunde[:n_points],
+                "grid_consumption_energy_wh": self.result.Netzbezug_Wh_pro_Stunde[:n_points],
+                "costs_amt": self.result.Kosten_Euro_pro_Stunde[:n_points],
+                "revenue_amt": self.result.Einnahmen_Euro_pro_Stunde[:n_points],
+                "losses_energy_wh": self.result.Verluste_Pro_Stunde[:n_points],
             },
             index=time_index,
         )
 
         # Add battery data
-        solution["battery1_soc_factor"] = [v / 100 for v in self.result.akku_soc_pro_stunde]
-        operation: dict[str, list[float]] = {}
-        for hour, rate in enumerate(self.ac_charge):
-            if hour >= n_points:
+        solution["battery1_soc_factor"] = [
+            v / 100
+            for v in self.result.akku_soc_pro_stunde[:n_points]  # result starts at start_day_hour
+        ]
+        operation: dict[str, list[float]] = {
+            "genetic_ac_charge_factor": [],
+            "genetic_dc_charge_factor": [],
+            "genetic_discharge_allowed_factor": [],
+        }
+        # ac_charge, dc_charge, discharge_allowed start at hour 0 of start day
+        for hour_idx, rate in enumerate(self.ac_charge):
+            if hour_idx < start_day_hour:
+                continue
+            if hour_idx >= start_day_hour + n_points:
                 break
+            ac_charge_hour = self.ac_charge[hour_idx]
+            dc_charge_hour = self.dc_charge[hour_idx]
+            discharge_allowed_hour = bool(self.discharge_allowed[hour_idx])
             operation_mode, operation_mode_factor = self._battery_operation_from_solution(
-                self.ac_charge[hour], self.dc_charge[hour], bool(self.discharge_allowed[hour])
+                ac_charge_hour, dc_charge_hour, discharge_allowed_hour
             )
+            operation["genetic_ac_charge_factor"].append(ac_charge_hour)
+            operation["genetic_dc_charge_factor"].append(dc_charge_hour)
+            operation["genetic_discharge_allowed_factor"].append(discharge_allowed_hour)
             for mode in BatteryOperationMode:
                 mode_key = f"battery1_{mode.lower()}_op_mode"
                 factor_key = f"battery1_{mode.lower()}_op_factor"
@@ -289,15 +309,22 @@ class GeneticSolution(GeneticParametersBaseModel):
                     operation[mode_key].append(0.0)
                     operation[factor_key].append(0.0)
         for key in operation.keys():
+            if len(operation[key]) != n_points:
+                error_msg = f"instruction {key} has invalid length {len(operation[key])} - expected {n_points}"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
             solution[key] = operation[key]
 
         # Add EV battery solution
+        # eautocharge_hours_float start at hour 0 of start day
+        # result.EAuto_SoC_pro_Stunde start at start_datetime.hour
         if self.eauto_obj:
             if self.eautocharge_hours_float is None:
                 # Electric vehicle is full enough. No load times.
                 solution[f"{self.eauto_obj.device_id}_soc_factor"] = [
                     self.eauto_obj.initial_soc_percentage / 100.0
                 ] * n_points
+                solution["genetic_ev_charge_factor"] = [0.0] * n_points
                 # operation modes
                 operation_mode = BatteryOperationMode.IDLE
                 for mode in BatteryOperationMode:
@@ -311,12 +338,17 @@ class GeneticSolution(GeneticParametersBaseModel):
                         solution[factor_key] = [0.0] * n_points
             else:
                 solution[f"{self.eauto_obj.device_id}_soc_factor"] = [
-                    v / 100 for v in self.result.EAuto_SoC_pro_Stunde
+                    v / 100 for v in self.result.EAuto_SoC_pro_Stunde[:n_points]
                 ]
-                operation = {}
-                for hour, rate in enumerate(self.eautocharge_hours_float):
-                    if hour >= n_points:
+                operation = {
+                    "genetic_ev_charge_factor": [],
+                }
+                for hour_idx, rate in enumerate(self.eautocharge_hours_float):
+                    if hour_idx < start_day_hour:
+                        continue
+                    if hour_idx >= start_day_hour + n_points:
                         break
+                    operation["genetic_ev_charge_factor"].append(rate)
                     operation_mode, operation_mode_factor = self._battery_operation_from_solution(
                         rate, 0.0, False
                     )
@@ -333,11 +365,16 @@ class GeneticSolution(GeneticParametersBaseModel):
                             operation[mode_key].append(0.0)
                             operation[factor_key].append(0.0)
                 for key in operation.keys():
+                    if len(operation[key]) != n_points:
+                        error_msg = f"instruction {key} has invalid length {len(operation[key])} - expected {n_points}"
+                        logger.error(error_msg)
+                        raise ValueError(error_msg)
                     solution[key] = operation[key]
 
         # Add home appliance data
         if self.washingstart:
-            solution["homeappliance1_energy_wh"] = self.result.Home_appliance_wh_per_hour
+            # result starts at start_day_hour
+            solution["homeappliance1_energy_wh"] = self.result.Home_appliance_wh_per_hour[:n_points]
 
         # Fill prediction into dataframe with correct column names
         # - pvforecast_ac_energy_wh_energy_wh: PV energy prediction (positive) in wh
@@ -445,10 +482,13 @@ class GeneticSolution(GeneticParametersBaseModel):
             generated_at=to_datetime(),
             comment="Optimization solution derived from GeneticSolution.",
             valid_from=start_datetime,
-            valid_until=start_datetime.add(hours=config.optimization.horizon_hours),
+            valid_until=start_datetime.add(hours=self.config.optimization.horizon_hours),
             total_losses_energy_wh=self.result.Gesamt_Verluste,
             total_revenues_amt=self.result.Gesamteinnahmen_Euro,
             total_costs_amt=self.result.Gesamtkosten_Euro,
+            fitness_score={
+                self.result.Gesamtkosten_Euro,
+            },
             prediction=PydanticDateTimeDataFrame.from_dataframe(prediction),
             solution=PydanticDateTimeDataFrame.from_dataframe(solution),
         )
@@ -460,6 +500,7 @@ class GeneticSolution(GeneticParametersBaseModel):
         from akkudoktoreos.core.ems import get_ems
 
         start_datetime = get_ems().start_datetime
+        start_day_hour = start_datetime.in_timezone(self.config.general.timezone).hour
         plan = EnergyManagementPlan(
             id=f"plan-genetic@{to_datetime(as_string=True)}",
             generated_at=to_datetime(),
@@ -471,10 +512,15 @@ class GeneticSolution(GeneticParametersBaseModel):
         last_operation_mode: Optional[str] = None
         last_operation_mode_factor: Optional[float] = None
         resource_id = "battery1"
-        logger.debug("BAT: {} - {}", resource_id, self.ac_charge)
-        for hour, rate in enumerate(self.ac_charge):
+        # ac_charge, dc_charge, discharge_allowed start at hour 0 of start day
+        logger.debug("BAT: {} - {}", resource_id, self.ac_charge[start_day_hour:])
+        for hour_idx, rate in enumerate(self.ac_charge):
+            if hour_idx < start_day_hour:
+                continue
             operation_mode, operation_mode_factor = self._battery_operation_from_solution(
-                self.ac_charge[hour], self.dc_charge[hour], bool(self.discharge_allowed[hour])
+                self.ac_charge[hour_idx],
+                self.dc_charge[hour_idx],
+                bool(self.discharge_allowed[hour_idx]),
             )
             if (
                 operation_mode == last_operation_mode
@@ -484,7 +530,7 @@ class GeneticSolution(GeneticParametersBaseModel):
                 continue
             last_operation_mode = operation_mode
             last_operation_mode_factor = operation_mode_factor
-            execution_time = start_datetime.add(hours=hour)
+            execution_time = start_datetime.add(hours=hour_idx - start_day_hour)
             plan.add_instruction(
                 FRBCInstruction(
                     resource_id=resource_id,
@@ -496,6 +542,7 @@ class GeneticSolution(GeneticParametersBaseModel):
             )
 
         # Add EV battery instructions (fill rate based control)
+        # eautocharge_hours_float start at hour 0 of start day
         if self.eauto_obj:
             resource_id = self.eauto_obj.device_id
             if self.eautocharge_hours_float is None:
@@ -513,8 +560,12 @@ class GeneticSolution(GeneticParametersBaseModel):
             else:
                 last_operation_mode = None
                 last_operation_mode_factor = None
-                logger.debug("EV: {} - {}", resource_id, self.eauto_obj.charge_array)
-                for hour, rate in enumerate(self.eautocharge_hours_float):
+                logger.debug(
+                    "EV: {} - {}", resource_id, self.eautocharge_hours_float[start_day_hour:]
+                )
+                for hour_idx, rate in enumerate(self.eautocharge_hours_float):
+                    if hour_idx < start_day_hour:
+                        continue
                     operation_mode, operation_mode_factor = self._battery_operation_from_solution(
                         rate, 0.0, False
                     )
@@ -526,7 +577,7 @@ class GeneticSolution(GeneticParametersBaseModel):
                         continue
                     last_operation_mode = operation_mode
                     last_operation_mode_factor = operation_mode_factor
-                    execution_time = start_datetime.add(hours=hour)
+                    execution_time = start_datetime.add(hours=hour_idx - start_day_hour)
                     plan.add_instruction(
                         FRBCInstruction(
                             resource_id=resource_id,
@@ -542,7 +593,7 @@ class GeneticSolution(GeneticParametersBaseModel):
             resource_id = "homeappliance1"
             operation_mode = ApplianceOperationMode.RUN  # type: ignore[assignment]
             operation_mode_factor = 1.0
-            execution_time = start_datetime.add(hours=self.washingstart)
+            execution_time = start_datetime.add(hours=self.washingstart - start_day_hour)
             plan.add_instruction(
                 DDBCInstruction(
                     resource_id=resource_id,

src/akkudoktoreos/optimization/optimization.py

@@ -110,6 +110,8 @@ class OptimizationSolution(PydanticBaseModel):
 
     total_costs_amt: float = Field(description="The total costs [money amount].")
 
+    fitness_score: set[float] = Field(description="The fitness score as a set of fitness values.")
+
     prediction: PydanticDateTimeDataFrame = Field(
         description=(
             "Datetime data frame with time series prediction data per optimization interval:"

src/akkudoktoreos/server/dash/plan.py

@@ -54,8 +54,21 @@ color_palette = {
     "pink-500": "#EC4899",  # pink-500
     "rose-500": "#F43F5E",  # rose-500
 }
+# Color names
 colors = list(color_palette.keys())
 
+# Colums that are exclude from the the solution card display
+# They are currently not used or are covered by others
+solution_excludes = [
+    "date_time",
+    "_op_mode",
+    "_fault_",
+    "_outage_supply_",
+    "_reserve_backup_",
+    "_ramp_rate_control_",
+    "_frequency_regulation_",
+]
+
 # Current state of solution displayed
 solution_visible: dict[str, bool] = {
     "pv_energy_wh": True,
@@ -122,7 +135,9 @@ def SolutionCard(solution: OptimizationSolution, config: SettingsEOS, data: Opti
     instruction_columns = [
         instruction
         for instruction in solution_columns
-        if instruction.endswith("op_mode") or instruction.endswith("op_factor")
+        if instruction.endswith("op_mode")
+        or instruction.endswith("op_factor")
+        or instruction.startswith("genetic_")
     ]
     solution_columns = [x for x in solution_columns if x not in instruction_columns]
 
@@ -140,13 +155,26 @@ def SolutionCard(solution: OptimizationSolution, config: SettingsEOS, data: Opti
     prediction_columns_to_join = prediction_df.columns.difference(df.columns)
     df = df.join(prediction_df[prediction_columns_to_join], how="inner")
 
-    # Remove time offset from UTC to get naive local time and make bokey plot in local time
+    # Exclude columns that currently do not have a value
+    excludes = solution_excludes
+    for instruction in instruction_columns:
+        if instruction.endswith("op_mode") and df[instruction].eq(0).all():
+            # Exclude op_mode and op_factor if all op_mode is 0
+            excludes.append(instruction)
+            excludes.append(f"{instruction[:-4]}factor")
+
+    # Make bokey plot in local time at location
+    # Determine daylight saving time change
     dst_offsets = df.index.map(lambda x: x.dst().total_seconds() / 3600)
+    # Determine desired timezone
     if config.general is None or config.general.timezone is None:
         date_time_tz = "Europe/Berlin"
     else:
         date_time_tz = config.general.timezone
-    df["date_time"] = pd.to_datetime(df["date_time"], utc=True).dt.tz_convert(date_time_tz)
+    # Ensure original date_time is parsed as UTC and convert to local time
+    df["date_time_local"] = (
+        pd.to_datetime(df["date_time"], utc=True).dt.tz_convert(date_time_tz).dt.tz_localize(None)
+    )
 
     # There is a special case if we have daylight saving time change in the time series
     if dst_offsets.nunique() > 1:
@@ -241,21 +269,12 @@ def SolutionCard(solution: OptimizationSolution, config: SettingsEOS, data: Opti
     # Create line renderers for each column
     renderers = {}
 
+    # Have an index for the colors of predictions, solutions and instructions.
+    prediction_color_idx = 0
+    solution_color_idx = int(len(colors) * 0.33) + 1
+    instruction_color_idx = int(len(colors) * 0.66) + 1
     for i, col in enumerate(sorted(df.columns)):
         # Exclude some columns that are currently not used or are covered by others
-        excludes = [
-            "date_time",
-            "_op_mode",
-            "_fault_",
-            "_forced_discharge_",
-            "_outage_supply_",
-            "_reserve_backup_",
-            "_ramp_rate_control_",
-            "_frequency_regulation_",
-            "_grid_support_export_",
-            "_peak_shaving_",
-        ]
-        # excludes = ["date_time"]
         if any(exclude in col for exclude in excludes):
             continue
         if col in solution_visible:
@@ -265,73 +284,85 @@ def SolutionCard(solution: OptimizationSolution, config: SettingsEOS, data: Opti
             solution_visible[col] = visible
         if col in solution_color:
             color = solution_color[col]
-        elif col == "pv_energy_wh":
-            color = "yellow-500"
-            solution_color[col] = color
-        elif col == "elec_price_amt_kwh":
-            color = "red-500"
-            solution_color[col] = color
         else:
-            color = colors[i % len(colors)]
+            if col in prediction_columns:
+                color = colors[prediction_color_idx % len(colors)]
+                prediction_color_idx += 3
+            elif col in solution_columns:
+                color = colors[solution_color_idx % len(colors)]
+                solution_color_idx += 3
+            else:
+                color = colors[instruction_color_idx % len(colors)]
+                instruction_color_idx += 3
+            # Remember the color of this column
             solution_color[col] = color
+        if col in prediction_columns:
+            line_dash = "dotted"
+        else:
+            line_dash = "solid"
         if visible:
-            if col == "pv_energy_wh":
-                r = plot.vbar(
-                    x="date_time",
-                    top=col,
-                    source=source,
-                    width=BAR_WIDTH_1HOUR * 0.8,
-                    legend_label=col,
-                    color=color_palette[color],
-                    level="underlay",
-                )
-            elif col.endswith("energy_wh"):
+            if col.endswith("energy_wh"):
                 r = plot.step(
-                    x="date_time",
+                    x="date_time_local",
                     y=col,
-                    mode="before",
+                    mode="after",
                     source=source,
                     legend_label=col,
                     color=color_palette[color],
+                    line_dash=line_dash,
+                )
+            elif col.endswith("soc_factor"):
+                r = plot.line(
+                    x="date_time_local",
+                    y=col,
+                    source=source,
+                    legend_label=col,
+                    color=color_palette[color],
+                    line_dash=line_dash,
+                    y_range_name="factor",
                 )
             elif col.endswith("factor"):
                 r = plot.step(
-                    x="date_time",
+                    x="date_time_local",
                     y=col,
-                    mode="before",
+                    mode="after",
                     source=source,
                     legend_label=col,
                     color=color_palette[color],
+                    line_dash=line_dash,
                     y_range_name="factor",
                 )
             elif col.endswith("mode"):
                 r = plot.step(
-                    x="date_time",
+                    x="date_time_local",
                     y=col,
-                    mode="before",
+                    mode="after",
                     source=source,
                     legend_label=col,
                     color=color_palette[color],
+                    line_dash=line_dash,
                     y_range_name="factor",
                 )
             elif col.endswith("amt_kwh"):
                 r = plot.step(
-                    x="date_time",
+                    x="date_time_local",
                     y=col,
-                    mode="before",
+                    mode="after",
                     source=source,
                     legend_label=col,
                     color=color_palette[color],
+                    line_dash=line_dash,
                     y_range_name="amt_kwh",
                 )
             elif col.endswith("amt"):
                 r = plot.step(
-                    x="date_time",
+                    x="date_time_local",
                     y=col,
-                    mode="before",
+                    mode="after",
                     source=source,
                     legend_label=col,
                     color=color_palette[color],
+                    line_dash=line_dash,
                     y_range_name="amt",
                 )
             else:
@@ -430,7 +461,16 @@ def SolutionCard(solution: OptimizationSolution, config: SettingsEOS, data: Opti
     )
 
     return Grid(
-        Bokeh(plot),
+        Grid(
+            Bokeh(plot),
+            Card(
+                P(f"Total revenues: {solution.total_revenues_amt}"),
+                P(f"Total costs: {solution.total_costs_amt}"),
+                P(f"Total losses: {solution.total_losses_energy_wh / 1000} kWh"),
+                P(f"Fitness score: {solution.fitness_score}"),
+            ),
+            cols=1,
+        ),
         Checkbox,
         cls="w-full space-y-3 space-x-3",
     )