chore: prepare for update of genetic algorithm (#1190)

Andreas will update the genetic algorithm for 15-minutes optimization
intervals.

Copy the current GENETIC optimization algorithm to GENETIC0 to enable
to keep the algorithm with the current functionality. Also copy resources
like the load interpolator to the GENETIC0 algorithm to keep them despite
possible later changes to the interpolator.

Make the deprecated legacy /optimize endpoint use the GENETIC0 optimization
algorithm to in-fact behave the same way even if there will later be changes
to the GENETIC algorithm by Andreas. Add a new REST endpoint to provide
the unprocessed optimisation results of the GENETIC and GENETIC0 algorithm
in case one wants to use them as done with the deprecated /optimize endpoint.

Adapt the optimization configuration to have distinct configurations for the
GENETIC and the GENETIC0 algorithm.

Create a copy of the current tests for the GENETIC algorithm to be used
for the GENETIC0 algorithm. This avoids the tests for the GENETIC0
algorithm to be influenced by later changes by Andreas.

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

src/akkudoktoreos/config/configmigrate.py

@@ -112,12 +112,14 @@ MIGRATION_MAP: Dict[
     "measurement/load4_name": "measurement/load_emr_keys/4",
     # optimization
     # ============
+    "optimization/interval": None,
+    "optimization/horizon_hours": "optimization/genetic0/horizon_hours",
     "optimization/ev_available_charge_rates_percent": (
         "devices/electric_vehicles/0/charge_rates",
         lambda v: [x / 100 for x in v],
     ),
-    "optimization/hours": "optimization/horizon_hours",
-    "optimization/penalty": ("optimization/genetic/penalties/ev_soc_miss", lambda v: float(v)),
+    "optimization/hours": "optimization/genetic0/horizon_hours",
+    "optimization/penalty": ("optimization/genetic0/penalties/ev_soc_miss", lambda v: float(v)),
     # pvforecast
     # ==========
     # - PVForecastAkkudoktor

src/akkudoktoreos/core/ems.py

@@ -17,6 +17,11 @@ from akkudoktoreos.core.coreabc import (
 from akkudoktoreos.core.emplan import EnergyManagementPlan
 from akkudoktoreos.core.emsettings import EnergyManagementMode
 from akkudoktoreos.core.pydantic import PydanticBaseModel
+from akkudoktoreos.optimization.genetic0.genetic0 import Genetic0Optimization
+from akkudoktoreos.optimization.genetic0.genetic0params import (
+    Genetic0OptimizationParameters,
+)
+from akkudoktoreos.optimization.genetic0.genetic0solution import Genetic0Solution
 from akkudoktoreos.optimization.genetic.genetic import GeneticOptimization
 from akkudoktoreos.optimization.genetic.geneticparams import (
     GeneticOptimizationParameters,
@@ -72,6 +77,10 @@ class EnergyManagement(
     # For classic API
     _genetic_solution: ClassVar[Optional[GeneticSolution]] = None
 
+    # Solution of the genetic0 algorithm of latest energy management run with optimization
+    # For classic API
+    _genetic0_solution: ClassVar[Optional[Genetic0Solution]] = None
+
     # energy management lock (for energy management run)
     _run_lock: ClassVar[Lock] = Lock()
 
@@ -146,14 +155,26 @@ class EnergyManagement(
         """
         return cls._genetic_solution
 
+    @classmethod
+    def genetic0_solution(cls) -> Optional[Genetic0Solution]:
+        """Get the latest solution of the genetic0 algorithm.
+
+        Returns:
+            Optional[Genetic0Solution]: The latest solution of the genetic algorithm.
+        """
+        return cls._genetic0_solution
+
     async def run(
         self,
         start_datetime: Optional[DateTime] = None,
         mode: Optional[EnergyManagementMode] = None,
         algorithm: Optional[str] = None,
         genetic_parameters: Optional[GeneticOptimizationParameters] = None,
-        genetic_individuals: Optional[int] = None,
+        genetic_generations: Optional[int] = None,
         genetic_seed: Optional[int] = None,
+        genetic0_parameters: Optional[Genetic0OptimizationParameters] = None,
+        genetic0_generations: Optional[int] = None,
+        genetic0_seed: Optional[int] = None,
         force_enable: Optional[bool] = False,
         force_update: Optional[bool] = False,
     ) -> None:
@@ -174,16 +195,25 @@ class EnergyManagement(
             algorithm (str, optional):
                 The algorithm to use. Must be one of:
                 - "GENETIC": Optimization uses the `GENETIC` optimization algorithm.
+                - "GENETIC0": Optimization uses the `GENETIC0` optimization algorithm.
 
                 Defaults to the algorithm defined in the current configuration.
             genetic_parameters (GeneticOptimizationParameters, optional): The
                 parameter set for the `GENETIC` algorithm. If not provided, it will
                 be constructed based on the current configuration and predictions.
-            genetic_individuals (int, optional): The number of individuals for the
+            genetic_generations (int, optional): The number of generations for the
                 `GENETIC` algorithm. Defaults to the algorithm's internal default (400)
                 if not specified.
             genetic_seed (int, optional): The seed for the `GENETIC` algorithm. Defaults
                 to the algorithm's internal random seed if not specified.
+            genetic0_parameters (Genetic0OptimizationParameters, optional): The
+                parameter set for the `GENETIC0` algorithm. If not provided, it will
+                be constructed based on the current configuration and predictions.
+            genetic0_generations (int, optional): The number of generations for the
+                `GENETIC0` algorithm. Defaults to the algorithm's internal default (400)
+                if not specified.
+            genetic0_seed (int, optional): The seed for the `GENETIC0` algorithm. Defaults
+                to the algorithm's internal random seed if not specified.
             force_enable (bool, optional): If True, bypasses any disabled state
                 to force the update process. This is mostly applicable to
                 prediction providers.
@@ -245,53 +275,138 @@ class EnergyManagement(
             if algorithm is None:
                 algorithm = self.config.optimization.algorithm
 
+            # --- GENETIC algorithm ---
             if algorithm == "GENETIC":
                 # Prepare optimization parameters
                 # This also creates default configurations for missing values and updates the predictions
-                logger.info("Starting optimzation parameter preparation.")
+                logger.info(f"{algorithm}: Starting optimzation parameter preparation.")
                 if genetic_parameters is None:
                     genetic_parameters = await GeneticOptimizationParameters.prepare()
                     if genetic_parameters is None:
                         logger.error(
-                            "Energy management run canceled. Could not prepare optimisation parameters."
+                            f"{algorithm}: Energy management run canceled. "
+                            "Could not prepare optimisation parameters."
                         )
                         EnergyManagement._stage = EnergyManagementStage.IDLE
                         return
 
                 # Take values from config if not given
-                if genetic_individuals is None:
-                    genetic_individuals = self.config.optimization.genetic.individuals
+                if genetic_generations is None:
+                    genetic_generations = self.config.optimization.genetic.generations
                 if genetic_seed is None:
                     genetic_seed = self.config.optimization.genetic.seed
 
                 if EnergyManagement._start_datetime is None:  # Make mypy happy - already set by us
-                    raise RuntimeError("Start datetime not set.")
+                    raise RuntimeError(f"{algorithm}: Start datetime not set.")
 
                 # --- Optimization (CPU-bound → MUST offload) ---
                 try:
-                    optimization = GeneticOptimization(
+                    genetic_optimization = GeneticOptimization(
                         verbose=bool(self.config.server.verbose),
                         fixed_seed=genetic_seed,
                     )
 
                     loop = get_running_loop()
                     start_hour = EnergyManagement._start_datetime.hour
-                    solution = await loop.run_in_executor(
+                    genetic_solution = await loop.run_in_executor(
                         None,
-                        lambda: optimization.optimize_ems(
+                        lambda: genetic_optimization.optimize_ems(
                             start_hour=start_hour,
                             parameters=cast(
                                 GeneticOptimizationParameters, genetic_parameters
                             ),  # cast for mypy
-                            ngen=genetic_individuals,
+                            ngen=genetic_generations,
                         ),
                     )
 
                 except Exception:
-                    logger.exception("Energy management optimization failed.")
+                    logger.exception(f"{algorithm}: Energy management optimization failed.")
                     EnergyManagement._stage = EnergyManagementStage.IDLE
                     return
 
+                # Make genetic solution public
+                EnergyManagement._genetic_solution = genetic_solution
+
+                # Make optimization solution public
+                EnergyManagement._optimization_solution = (
+                    await genetic_solution.optimization_solution()
+                )
+
+                # Make plan public
+                EnergyManagement._plan = genetic_solution.energy_management_plan()
+
+                logger.debug(
+                    "{}: Energy management genetic solution:\n{}",
+                    algorithm,
+                    EnergyManagement._genetic_solution,
+                )
+
+            # --- GENETIC0 algorithm ---
+            elif algorithm == "GENETIC0":
+                # Prepare optimization parameters
+                # This also creates default configurations for missing values and updates the predictions
+                logger.info(f"{algorithm}: Starting optimzation parameter preparation.")
+                if genetic0_parameters is None:
+                    genetic0_parameters = await Genetic0OptimizationParameters.prepare()
+                    if genetic0_parameters is None:
+                        logger.error(
+                            f"{algorithm}: Energy management run canceled. "
+                            "Could not prepare optimisation parameters."
+                        )
+                        EnergyManagement._stage = EnergyManagementStage.IDLE
+                        return
+
+                # Take values from config if not given
+                if genetic0_generations is None:
+                    genetic0_generations = self.config.optimization.genetic0.generations
+                if genetic0_seed is None:
+                    genetic0_seed = self.config.optimization.genetic0.seed
+
+                if EnergyManagement._start_datetime is None:  # Make mypy happy - already set by us
+                    raise RuntimeError(f"{algorithm}: Start datetime not set.")
+
+                # --- Optimization (CPU-bound → MUST offload) ---
+                try:
+                    genetic0_optimization = Genetic0Optimization(
+                        verbose=bool(self.config.server.verbose),
+                        fixed_seed=genetic0_seed,
+                    )
+
+                    loop = get_running_loop()
+                    start_hour = EnergyManagement._start_datetime.hour
+                    genetic0_solution = await loop.run_in_executor(
+                        None,
+                        lambda: genetic0_optimization.optimize_ems(
+                            start_hour=start_hour,
+                            parameters=cast(
+                                Genetic0OptimizationParameters, genetic0_parameters
+                            ),  # cast for mypy
+                            ngen=genetic0_generations,
+                        ),
+                    )
+
+                except Exception:
+                    logger.exception(f"{algorithm}: Energy management optimization failed.")
+                    EnergyManagement._stage = EnergyManagementStage.IDLE
+                    return
+
+                # Make genetic0 solution public
+                EnergyManagement._genetic0_solution = genetic0_solution
+
+                # Make optimization solution public
+                EnergyManagement._optimization_solution = (
+                    await genetic0_solution.optimization_solution()
+                )
+
+                # Make plan public
+                EnergyManagement._plan = genetic0_solution.energy_management_plan()
+
+                logger.debug(
+                    "{}: Energy management genetic solution:\n{}",
+                    algorithm,
+                    EnergyManagement._genetic0_solution,
+                )
+
             else:
                 logger.error(f"Unknown optimization algorithm: '{algorithm}'. Skipping.")
                 EnergyManagement._stage = EnergyManagementStage.IDLE
@@ -299,82 +414,19 @@ class EnergyManagement(
 
             optimization_duration = to_datetime() - optimization_start
             logger.info(
-                "Energy management optimization ({}) completed in {:.1f} seconds.",
+                "{}: Energy management optimization completed in {:.1f} seconds.",
                 algorithm,
                 optimization_duration.total_seconds(),
             )
 
             logger.debug(
-                "Energy management optimization solution:\n{}",
+                "{}: Energy management optimization solution:\n{}",
+                algorithm,
                 EnergyManagement._optimization_solution,
             )
-            logger.debug("Energy management plan:\n{}", EnergyManagement._plan)
+            logger.debug("{}: Energy management plan:\n{}", algorithm, EnergyManagement._plan)
 
-            # --- Control dispatch by adapters ---
-            EnergyManagement._stage = EnergyManagementStage.CONTROL_DISPATCH
-
-            # Make genetic solution public
-            EnergyManagement._genetic_solution = solution
-
-            # Make optimization solution public
-            EnergyManagement._optimization_solution = await solution.optimization_solution()
-
-            # Make plan public
-            EnergyManagement._plan = solution.energy_management_plan()
-
-            logger.debug(
-                "Energy management genetic solution:\n{}", EnergyManagement._genetic_solution
-            )
-
-            if genetic_parameters is None:
-                genetic_parameters = await GeneticOptimizationParameters.prepare()
-
-            if not genetic_parameters:
-                logger.error("Energy management run canceled. Could not prepare parameters.")
-                EnergyManagement._stage = EnergyManagementStage.IDLE
-                return
-
-            EnergyManagement._stage = EnergyManagementStage.OPTIMIZATION
-
-            if genetic_individuals is None:
-                genetic_individuals = self.config.optimization.genetic.individuals
-            if genetic_seed is None:
-                genetic_seed = self.config.optimization.genetic.seed
-
-            if EnergyManagement._start_datetime is None:
-                raise RuntimeError("Start datetime not set.")
-
-            # --- Optimization (CPU-bound → MUST offload) ---
-            try:
-                optimization = GeneticOptimization(
-                    verbose=bool(self.config.server.verbose),
-                    fixed_seed=genetic_seed,
-                )
-
-                loop = get_running_loop()
-                start_hour = EnergyManagement._start_datetime.hour
-                solution = await loop.run_in_executor(
-                    None,
-                    lambda: optimization.optimize_ems(
-                        start_hour=start_hour,
-                        parameters=genetic_parameters,
-                        ngen=genetic_individuals,
-                    ),
-                )
-
-            except Exception:
-                logger.exception("Energy management optimization failed.")
-                EnergyManagement._stage = EnergyManagementStage.IDLE
-                return
-
-            EnergyManagement._genetic_solution = solution
-            EnergyManagement._optimization_solution = await solution.optimization_solution()
-            EnergyManagement._plan = solution.energy_management_plan()
-
-            logger.debug("Genetic solution:\n{}", EnergyManagement._genetic_solution)
-            logger.debug("Optimization solution:\n{}", EnergyManagement._optimization_solution)
-            logger.debug("Plan:\n{}", EnergyManagement._plan)
-            logger.info("Energy management run done (optimization updated)")
+            logger.info("{}: Energy management run done (optimization updated)", algorithm)
 
             # --- Dispatch control by adapters ---
             EnergyManagement._stage = EnergyManagementStage.CONTROL_DISPATCH

src/akkudoktoreos/devices/genetic0/genetic0battery.py

@@ -0,0 +1,283 @@
+from typing import Any, Iterator, Optional
+
+import numpy as np
+
+from akkudoktoreos.devices.devices import BATTERY_DEFAULT_CHARGE_RATES
+from akkudoktoreos.optimization.genetic0.genetic0devices import (
+    Genetic0BaseBatteryParameters,
+    Genetic0SolarPanelBatteryParameters,
+)
+
+
+class Genetic0Battery:
+    """Represents a battery device with methods to simulate energy charging and discharging."""
+
+    def __init__(self, parameters: Genetic0BaseBatteryParameters, prediction_hours: int):
+        self.parameters = parameters
+        self.prediction_hours = prediction_hours
+        self._setup()
+
+    def _setup(self) -> None:
+        """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 = np.array(BATTERY_DEFAULT_CHARGE_RATES, dtype=float)
+        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
+            if isinstance(self.parameters, Genetic0SolarPanelBatteryParameters)
+            else 0
+        )
+        self.max_soc_percentage = self.parameters.max_soc_percentage
+
+        # Initialize state of charge
+        if self.parameters.max_charge_power_w is not None:
+            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, 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 {
+            "device_id": self.parameters.device_id,
+            "capacity_wh": self.capacity_wh,
+            "initial_soc_percentage": self.initial_soc_percentage,
+            "soc_wh": self.soc_wh,
+            "hours": self.prediction_hours,
+            "discharge_array": self.discharge_array,
+            "charge_array": self.charge_array,
+            "charging_efficiency": self.charging_efficiency,
+            "discharging_efficiency": self.discharging_efficiency,
+            "max_charge_power_w": self.max_charge_power_w,
+        }
+
+    def reset(self) -> None:
+        """Resets the battery state to its initial values."""
+        self.soc_wh = (self.initial_soc_percentage / 100) * self.capacity_wh
+        self.soc_wh = min(self.soc_wh, self.max_soc_wh)  # Only clamp to max
+        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."""
+        if len(discharge_array) != self.prediction_hours:
+            raise ValueError(
+                f"Discharge array must have exactly {self.prediction_hours} elements. Got {len(discharge_array)} elements."
+            )
+        self.discharge_array = np.array(discharge_array)
+
+    def set_charge_per_hour(self, charge_array: np.ndarray) -> None:
+        """Sets the charge values for each hour."""
+        if len(charge_array) != self.prediction_hours:
+            raise ValueError(
+                f"Charge array must have exactly {self.prediction_hours} elements. Got {len(charge_array)} elements."
+            )
+        self.charge_array = np.array(charge_array)
+
+    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]:
+        """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
+
+        # Raw extractable energy above minimum SoC
+        raw_available_wh = max(self.soc_wh - self.min_soc_wh, 0.0)
+
+        # Maximum raw discharge due to power limit
+        max_raw_wh = self.max_charge_power_w  # TODO rename to max_discharge_power_w
+
+        # Actual raw withdrawal (internal)
+        raw_withdrawal_wh = min(raw_available_wh, max_raw_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
+        losses_wh = raw_used_wh - delivered_wh
+
+        return delivered_wh, losses_wh
+
+    def charge_energy(
+        self,
+        wh: Optional[float],
+        hour: int,
+        charge_factor: float = 0.0,
+    ) -> tuple[float, float]:
+        """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
+
+        # 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
+
+        # 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."
+            )
+
+        # Remaining capacity
+        max_raw_wh = min(raw_charge_wh, max_charge_power_w_fast)
+
+        # Actual raw intake
+        raw_input_wh = raw_request_wh if raw_request_wh < max_raw_wh else max_raw_wh
+
+        # Apply efficiency
+        stored_wh = raw_input_wh * charging_efficiency_fast
+        new_soc = soc_wh_fast + stored_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."""
+        usable_energy = (self.soc_wh - self.min_soc_wh) * self.discharging_efficiency
+        return max(usable_energy, 0.0)

src/akkudoktoreos/devices/genetic0/genetic0homeappliance.py

@@ -0,0 +1,102 @@
+import numpy as np
+
+from akkudoktoreos.config.configabc import TimeWindow, TimeWindowSequence
+from akkudoktoreos.optimization.genetic0.genetic0devices import (
+    Genetic0HomeApplianceParameters,
+)
+from akkudoktoreos.utils.datetimeutil import to_datetime, to_duration, to_time
+
+
+class Genetic0HomeAppliance:
+    def __init__(
+        self,
+        parameters: Genetic0HomeApplianceParameters,
+        optimization_hours: int,
+        prediction_hours: int,
+    ):
+        self.parameters: Genetic0HomeApplianceParameters = parameters
+        self.prediction_hours = prediction_hours
+        self._setup()
+
+    def _setup(self) -> None:
+        """Sets up the home appliance parameters based provided parameters."""
+        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
+        # setup possible start times
+        if self.parameters.time_windows is None:
+            self.parameters.time_windows = TimeWindowSequence(
+                windows=[
+                    TimeWindow(
+                        start_time=to_time("00:00"),
+                        duration=to_duration(f"{self.prediction_hours} hours"),
+                    ),
+                ]
+            )
+        start_datetime = to_datetime().set(hour=0, minute=0, second=0)
+        duration = to_duration(f"{self.duration_h} hours")
+        self.start_allowed: list[bool] = []
+        for hour in range(0, self.prediction_hours):
+            self.start_allowed.append(
+                self.parameters.time_windows.contains(
+                    start_datetime.add(hours=hour), duration=duration
+                )
+            )
+        start_earliest = self.parameters.time_windows.earliest_start_time(duration, start_datetime)
+        if start_earliest:
+            self.start_earliest = start_earliest.hour
+        else:
+            self.start_earliest = 0
+        start_latest = self.parameters.time_windows.latest_start_time(duration, start_datetime)
+        if start_latest:
+            self.start_latest = start_latest.hour
+        else:
+            self.start_latest = 23
+
+    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.
+        """
+        if not self.start_allowed[start_hour]:
+            # 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
+
+        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
+        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
+
+        return start_hour
+
+    def reset_load_curve(self) -> None:
+        """Resets the load curve."""
+        self.load_curve = np.zeros(self.prediction_hours)
+
+    def get_load_curve(self) -> np.ndarray:
+        """Returns the current load curve."""
+        return self.load_curve
+
+    def get_load_for_hour(self, hour: int) -> float:
+        """Returns the load for a specific hour.
+
+        :param hour: The hour for which the load is queried.
+        :return: The load in watts for the specified hour.
+        """
+        if hour < 0 or hour >= self.prediction_hours:
+            raise ValueError(
+                f"The specified hour {hour} is outside the available time frame {self.prediction_hours}."
+            )
+
+        return self.load_curve[hour]

src/akkudoktoreos/devices/genetic0/genetic0inverter.py

@@ -0,0 +1,136 @@
+from typing import Optional
+
+from loguru import logger
+
+from akkudoktoreos.devices.genetic0.genetic0battery import Genetic0Battery
+from akkudoktoreos.optimization.genetic0.genetic0devices import (
+    Genetic0InverterParameters,
+)
+from akkudoktoreos.optimization.genetic0.genetic0loadinterpolator import (
+    get_genetic0_load_interpolator,
+)
+
+
+class Genetic0Inverter:
+    def __init__(
+        self,
+        parameters: Genetic0InverterParameters,
+        battery: Optional[Genetic0Battery] = None,
+    ):
+        self.parameters: Genetic0InverterParameters = parameters
+        self.battery: Optional[Genetic0Battery] = battery
+        self._setup()
+
+    def _setup(self) -> None:
+        if self.battery and self.parameters.battery_id != self.battery.parameters.device_id:
+            error_msg = f"Battery ID mismatch - {self.parameters.battery_id} is configured; got {self.battery.parameters.device_id}."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        self.self_consumption_predictor = get_genetic0_load_interpolator()
+        self.max_power_wh = (
+            self.parameters.max_power_wh
+        )  # Maximum power that the inverter can handle
+        self.dc_to_ac_efficiency = self.parameters.dc_to_ac_efficiency
+        self.ac_to_dc_efficiency = self.parameters.ac_to_dc_efficiency
+        self.max_ac_charge_power_w = self.parameters.max_ac_charge_power_w
+
+    def process_energy(
+        self, generation: float, consumption: float, hour: int
+    ) -> tuple[float, float, float, float]:
+        losses = 0.0
+        grid_export = 0.0
+        grid_import = 0.0
+        self_consumption = 0.0
+
+        # Cache inverter DC→AC efficiency for discharge path
+        dc_to_ac_eff = self.dc_to_ac_efficiency
+
+        if generation >= consumption:
+            if consumption > self.max_power_wh:
+                # If consumption exceeds maximum inverter power
+                losses += generation - self.max_power_wh
+                remaining_power = self.max_power_wh - consumption
+                grid_import = -remaining_power  # Negative indicates feeding into the grid
+                self_consumption = self.max_power_wh
+            else:
+                # Calculate scr using cached results per energy management/optimization run
+                scr = self.self_consumption_predictor.calculate_self_consumption(
+                    consumption, generation
+                )
+
+                # Remaining power after consumption
+                remaining_power = (generation - consumption) * scr  # EVQ
+                # Remaining load Self Consumption not perfect
+                remaining_load_evq = (generation - consumption) * (1.0 - scr)
+
+                if remaining_load_evq > 0:
+                    # The battery must cover the remaining consumption
+                    if self.battery:
+                        # Request more DC from battery to account for DC→AC conversion loss
+                        dc_request = remaining_load_evq / dc_to_ac_eff
+                        from_battery_dc, discharge_losses = self.battery.discharge_energy(
+                            dc_request, hour
+                        )
+                        # Convert DC output to AC
+                        from_battery_ac = from_battery_dc * dc_to_ac_eff
+                        inverter_discharge_losses = from_battery_dc - from_battery_ac
+                        remaining_load_evq -= from_battery_ac
+                        losses += discharge_losses + inverter_discharge_losses
+                    else:
+                        from_battery_ac = 0.0
+
+                    # If the battery cannot fully cover the remaining consumption, the rest is drawn from the grid
+                    if remaining_load_evq > 0:
+                        grid_import += remaining_load_evq
+                        remaining_load_evq = 0
+                else:
+                    from_battery_ac = 0.0
+
+                if remaining_power > 0:
+                    # Load battery with excess energy (DC path, no inverter conversion needed)
+                    charge_losses = 0.0
+                    if self.battery:
+                        charged_energie, charge_losses = self.battery.charge_energy(
+                            remaining_power, hour
+                        )
+                        remaining_surplus = remaining_power - (charged_energie + charge_losses)
+                    else:
+                        remaining_surplus = remaining_power
+
+                    # Feed-in to the grid based on remaining capacity
+                    if remaining_surplus > self.max_power_wh - consumption:
+                        grid_export = self.max_power_wh - consumption
+                        losses += remaining_surplus - grid_export
+                    else:
+                        grid_export = remaining_surplus
+
+                    losses += charge_losses
+                self_consumption = (
+                    consumption + from_battery_ac
+                )  # Self-consumption is equal to the load
+
+        else:
+            # Case 2: Insufficient generation, cover shortfall
+            shortfall = consumption - generation
+            available_ac_power = max(self.max_power_wh - generation, 0)
+
+            # Discharge battery to cover shortfall, if possible
+            if self.battery:
+                # Need shortfall in AC, request more DC from battery for DC→AC conversion
+                ac_needed = min(shortfall, available_ac_power)
+                dc_request = ac_needed / dc_to_ac_eff
+                battery_discharge_dc, discharge_losses = self.battery.discharge_energy(
+                    dc_request, hour
+                )
+                # Convert DC output to AC
+                battery_discharge_ac = battery_discharge_dc * dc_to_ac_eff
+                inverter_discharge_losses = battery_discharge_dc - battery_discharge_ac
+                losses += discharge_losses + inverter_discharge_losses
+            else:
+                battery_discharge_ac = 0
+
+            # Draw remaining required power from the grid (discharge_losses are already subtracted in the battery)
+            grid_import = shortfall - battery_discharge_ac
+            self_consumption = generation + battery_discharge_ac
+
+        return grid_export, grid_import, losses, self_consumption

src/akkudoktoreos/optimization/genetic/genetic.py

@@ -435,7 +435,9 @@ class GeneticOptimization(OptimizationBase):
     ):
         """Initialize the optimization problem with the required parameters."""
         self.opti_param: dict[str, Any] = {}
-        self.fixed_ev_hours = self.config.prediction.hours - self.config.optimization.horizon_hours
+        self.fixed_ev_hours = (
+            self.config.prediction.hours - self.config.optimization.genetic.horizon_hours
+        )
         self.ev_possible_charge_values: list[float] = [1.0]
         # Separate charge-level list for battery AC charging (independent of EV rates).
         # Populated from parameters.pv_battery.charge_rates in optimize_ems.
@@ -1148,7 +1150,7 @@ class GeneticOptimization(OptimizationBase):
         dishwasher = (
             HomeAppliance(
                 parameters=parameters.dishwasher,
-                optimization_hours=self.config.optimization.horizon_hours,
+                optimization_hours=self.config.optimization.genetic.horizon_hours,
                 prediction_hours=self.config.prediction.hours,
             )
             if parameters.dishwasher is not None
@@ -1166,7 +1168,7 @@ class GeneticOptimization(OptimizationBase):
         # Prepare device simulation
         self.simulation.prepare(
             parameters=parameters.ems,
-            optimization_hours=self.config.optimization.horizon_hours,
+            optimization_hours=self.config.optimization.genetic.horizon_hours,
             prediction_hours=self.config.prediction.hours,
             inverter=inverter,  # battery is part of inverter
             ev=ev,

src/akkudoktoreos/optimization/genetic/geneticparams.py

@@ -247,17 +247,18 @@ class GeneticOptimizationParameters(
             logger.info("Prediction historic hours unknown - defaulting to 24 hours.")
             cls.config.prediction.historic_hours = 24
         # Check optimization definitions
-        if cls.config.optimization.horizon_hours is None:
+        if cls.config.optimization.genetic.horizon_hours is None:
             logger.info("Optimization horizon unknown - defaulting to 24 hours.")
-            cls.config.optimization.horizon_hours = 24
-        if cls.config.optimization.interval is None:
+            cls.config.optimization.genetic.horizon_hours = 24
+        if cls.config.optimization.genetic.interval_sec is None:
             logger.info("Optimization interval unknown - defaulting to 3600 seconds.")
-            cls.config.optimization.interval = 3600
-        if cls.config.optimization.interval != 3600:
+            cls.config.optimization.genetic.interval_sec = 3600
+        if cls.config.optimization.genetic.interval_sec != 3600:
             logger.info(
-                "Optimization interval '{}' seconds not supported - forced to 3600 seconds."
+                f"Optimization interval '{cls.config.optimization.genetic.interval_sec}' seconds "
+                "not supported - forced to 3600 seconds."
             )
-            cls.config.optimization.interval = 3600
+            cls.config.optimization.genetic.interval_sec = 3600
         # Check genetic algorithm definitions
         if cls.config.optimization.genetic.individuals is None:
             logger.info("Genetic individuals unknown - defaulting to 300.")
@@ -276,8 +277,8 @@ class GeneticOptimizationParameters(
             start_solution = last_solution.start_solution
 
         # Add forecast and device data
-        interval = to_duration(cls.config.optimization.interval)
-        power_to_energy_per_interval_factor = cls.config.optimization.interval / 3600
+        interval = to_duration(cls.config.optimization.genetic.interval_sec)
+        power_to_energy_per_interval_factor = cls.config.optimization.genetic.interval_sec / 3600
         parameter_start_datetime = ems.start_datetime.set(hour=0, second=0, microsecond=0)
         parameter_end_datetime = parameter_start_datetime.add(hours=cls.config.prediction.hours)
         max_retries = 10

src/akkudoktoreos/optimization/genetic/geneticsettings.py

@@ -0,0 +1,82 @@
+"""Settings for the GENETIC optimization algorithm.
+
+Kept in an extra module to avoid cyclic dependencies on package import.
+"""
+
+from typing import Optional, Union
+
+from pydantic import Field, computed_field
+
+from akkudoktoreos.config.configabc import SettingsBaseModel
+
+
+class GeneticCommonSettings(SettingsBaseModel):
+    """GENETIC Optimization Algorithm Configuration."""
+
+    interval_sec: int = Field(
+        default=3600,
+        ge=15 * 60,
+        le=60 * 60,
+        json_schema_extra={
+            "description": "The optimization interval [sec]. Defaults to 3600 seconds (1 hour)",
+            "examples": [60 * 60, 15 * 60],
+        },
+    )
+
+    horizon_hours: int = Field(
+        default=24,
+        ge=0,
+        json_schema_extra={
+            "description": "The general time window within which the energy optimization goal shall be achieved [h]. Defaults to 24 hours.",
+            "examples": [24],
+        },
+    )
+
+    individuals: Optional[int] = Field(
+        default=300,
+        ge=10,
+        json_schema_extra={
+            "description": "Number of individuals (solutions) in the population [>= 10]. Defaults to 300.",
+            "examples": [300],
+        },
+    )
+
+    generations: Optional[int] = Field(
+        default=400,
+        ge=10,
+        json_schema_extra={
+            "description": "Number of generations to evolve [>= 10]. Defaults to 400.",
+            "examples": [400],
+        },
+    )
+
+    seed: Optional[int] = Field(
+        default=None,
+        ge=0,
+        json_schema_extra={
+            "description": "Random seed for reproducibility. None = random.",
+            "examples": [None, 42],
+        },
+    )
+
+    # --- Penalties (existing) -------------------------------------------------
+
+    penalties: dict[str, Union[float, int, str]] = Field(
+        default_factory=lambda: {
+            "ev_soc_miss": 10,
+            "ac_charge_break_even": 1.0,
+        },
+        json_schema_extra={
+            "description": "Penalty parameters used in fitness evaluation.",
+            "examples": [{"ev_soc_miss": 10}],
+        },
+    )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def horizon(self) -> int:
+        """Number of optimization steps."""
+        if self.interval_sec is None or self.interval_sec == 0 or self.horizon_hours is None:
+            return 0
+        num_steps = int(float(self.horizon_hours * 3600) / self.interval_sec)
+        return num_steps

src/akkudoktoreos/optimization/genetic/geneticsolution.py

@@ -740,7 +740,7 @@ class GeneticSolution(ConfigMixin, GeneticParametersBaseModel):
             generated_at=to_datetime(),
             comment="Optimization solution derived from GeneticSolution.",
             valid_from=start_datetime,
-            valid_until=start_datetime.add(hours=self.config.optimization.horizon_hours),
+            valid_until=start_datetime.add(hours=self.config.optimization.genetic.horizon_hours),
             total_losses_energy_wh=self.result.total_losses,
             total_revenues_amt=self.result.total_revenue,
             total_costs_amt=self.result.total_costs,

src/akkudoktoreos/optimization/genetic0/genetic0abc.py

@@ -0,0 +1,11 @@
+"""Genetic0 optimization algorithm abstract and base classes."""
+
+from pydantic import ConfigDict
+
+from akkudoktoreos.core.pydantic import PydanticBaseModel
+
+
+class Genetic0ParametersBaseModel(PydanticBaseModel):
+    """Pydantic base model for parameters for the GENETIC algorithm."""
+
+    model_config = ConfigDict(extra="forbid")

src/akkudoktoreos/optimization/genetic0/genetic0devices.py

@@ -0,0 +1,196 @@
+"""Genetic0 optimization algorithm device interfaces/ parameters."""
+
+from typing import Optional
+
+from pydantic import Field
+
+from akkudoktoreos.config.configabc import TimeWindowSequence
+from akkudoktoreos.optimization.genetic0.genetic0abc import Genetic0ParametersBaseModel
+
+
+class Genetic0DeviceParameters(Genetic0ParametersBaseModel):
+    device_id: str = Field(json_schema_extra={"description": "ID of device", "examples": "device1"})
+    hours: Optional[int] = Field(
+        default=None,
+        gt=0,
+        json_schema_extra={
+            "description": "Number of prediction hours. Defaults to global config prediction hours.",
+            "examples": [None],
+        },
+    )
+
+
+def max_charging_power_field(description: Optional[str] = None) -> float:
+    if description is None:
+        description = "Maximum charging power in watts."
+    return Field(default=5000, gt=0, json_schema_extra={"description": description})
+
+
+def initial_soc_percentage_field(description: str) -> int:
+    return Field(
+        default=0, ge=0, le=100, json_schema_extra={"description": description, "examples": [42]}
+    )
+
+
+def discharging_efficiency_field(default_value: float) -> float:
+    return Field(
+        default=default_value,
+        gt=0,
+        le=1,
+        json_schema_extra={
+            "description": "A float representing the discharge efficiency of the battery."
+        },
+    )
+
+
+class Genetic0BaseBatteryParameters(Genetic0DeviceParameters):
+    """Battery Device Simulation Configuration."""
+
+    device_id: str = Field(
+        json_schema_extra={"description": "ID of battery", "examples": ["battery1"]}
+    )
+    capacity_wh: int = Field(
+        gt=0,
+        json_schema_extra={
+            "description": "An integer representing the capacity of the battery in watt-hours.",
+            "examples": [8000],
+        },
+    )
+    charging_efficiency: float = Field(
+        default=0.88,
+        gt=0,
+        le=1,
+        json_schema_extra={
+            "description": "A float representing the charging efficiency of the battery."
+        },
+    )
+    discharging_efficiency: float = discharging_efficiency_field(0.88)
+    max_charge_power_w: Optional[float] = max_charging_power_field()
+    initial_soc_percentage: int = initial_soc_percentage_field(
+        "An integer representing the state of charge of the battery at the **start** of the current hour (not the current state)."
+    )
+    min_soc_percentage: int = Field(
+        default=0,
+        ge=0,
+        le=100,
+        json_schema_extra={
+            "description": "An integer representing the minimum state of charge (SOC) of the battery in percentage.",
+            "examples": [10],
+        },
+    )
+    max_soc_percentage: int = Field(
+        default=100,
+        ge=0,
+        le=100,
+        json_schema_extra={
+            "description": "An integer representing the maximum state of charge (SOC) of the battery in percentage."
+        },
+    )
+    charge_rates: Optional[list[float]] = Field(
+        default=None,
+        json_schema_extra={
+            "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 Genetic0SolarPanelBatteryParameters(Genetic0BaseBatteryParameters):
+    """PV battery device simulation configuration."""
+
+    max_charge_power_w: Optional[float] = max_charging_power_field()
+
+
+class Genetic0ElectricVehicleParameters(Genetic0BaseBatteryParameters):
+    """Battery Electric Vehicle Device Simulation Configuration."""
+
+    device_id: str = Field(
+        json_schema_extra={"description": "ID of electric vehicle", "examples": ["ev1"]}
+    )
+    discharging_efficiency: float = discharging_efficiency_field(1.0)
+    initial_soc_percentage: int = initial_soc_percentage_field(
+        "An integer representing the current state of charge (SOC) of the battery in percentage."
+    )
+
+
+class Genetic0HomeApplianceParameters(Genetic0DeviceParameters):
+    """Home Appliance Device Simulation Configuration."""
+
+    device_id: str = Field(
+        json_schema_extra={"description": "ID of home appliance", "examples": ["dishwasher"]}
+    )
+    consumption_wh: int = Field(
+        gt=0,
+        json_schema_extra={
+            "description": "An integer representing the energy consumption of a household device in watt-hours.",
+            "examples": [2000],
+        },
+    )
+    duration_h: int = Field(
+        gt=0,
+        json_schema_extra={
+            "description": "An integer representing the usage duration of a household device in hours.",
+            "examples": [3],
+        },
+    )
+    time_windows: Optional[TimeWindowSequence] = Field(
+        default=None,
+        json_schema_extra={
+            "description": "List of allowed time windows. Defaults to optimization general time window.",
+            "examples": [
+                [
+                    {"start_time": "10:00", "duration": "3 hours"},
+                ],
+            ],
+        },
+    )
+
+
+class Genetic0InverterParameters(Genetic0DeviceParameters):
+    """Inverter Device Simulation Configuration."""
+
+    device_id: str = Field(
+        json_schema_extra={"description": "ID of inverter", "examples": ["inverter1"]}
+    )
+    max_power_wh: float = Field(gt=0, json_schema_extra={"examples": [10000]})
+    battery_id: Optional[str] = Field(
+        default=None,
+        json_schema_extra={"description": "ID of battery", "examples": [None, "battery1"]},
+    )
+    ac_to_dc_efficiency: float = Field(
+        default=1.0,
+        ge=0,
+        le=1,
+        json_schema_extra={
+            "description": (
+                "Efficiency of AC to DC conversion (for AC/grid charging of battery). "
+                "Set to 0 to disable AC charging via inverter. "
+                "Default 1.0 for backward compatibility (no additional inverter loss)."
+            ),
+            "examples": [0.95, 1.0, 0.0],
+        },
+    )
+    dc_to_ac_efficiency: float = Field(
+        default=1.0,
+        gt=0,
+        le=1,
+        json_schema_extra={
+            "description": (
+                "Efficiency of DC to AC conversion (for battery discharging to AC load/grid). "
+                "Default 1.0 for backward compatibility (no additional inverter loss)."
+            ),
+            "examples": [0.95, 1.0],
+        },
+    )
+    max_ac_charge_power_w: Optional[float] = Field(
+        default=None,
+        ge=0,
+        json_schema_extra={
+            "description": (
+                "Maximum AC charging power in watts. "
+                "None means no additional limit (battery's own max_charge_power_w applies). "
+                "Set to 0 to disable AC charging."
+            ),
+            "examples": [None, 0, 5000],
+        },
+    )

src/akkudoktoreos/optimization/genetic0/genetic0loadinterpolator.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+import pickle
+from pathlib import Path
+
+import numpy as np
+from scipy.interpolate import RegularGridInterpolator
+
+from akkudoktoreos.core.cache import cache_energy_management
+from akkudoktoreos.core.coreabc import SingletonMixin
+
+
+class SelfConsumptionProbabilityInterpolator:
+    def __init__(self, filepath: str | Path):
+        self.filepath = filepath
+        # Load the RegularGridInterpolator
+        with open(self.filepath, "rb") as file:
+            self.interpolator: RegularGridInterpolator = pickle.load(file)  # noqa: S301
+
+    def _generate_points(
+        self, load_1h_power: float, pv_power: float
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Generate the grid points for interpolation."""
+        partial_loads = np.arange(0, pv_power + 50, 50)
+        points = np.array([np.full_like(partial_loads, load_1h_power), partial_loads]).T
+        return points, partial_loads
+
+    @cache_energy_management
+    def calculate_self_consumption(self, load_1h_power: float, pv_power: float) -> float:
+        """Calculate the PV self-consumption rate using RegularGridInterpolator.
+
+        The results are cached until the start of the next energy management run/ optimization.
+
+        Args:
+         - last_1h_power: 1h power levels (W).
+         - pv_power: Current PV power output (W).
+
+        Returns:
+         - Self-consumption rate as a float.
+        """
+        points, partial_loads = self._generate_points(load_1h_power, pv_power)
+        probabilities = self.interpolator(points)
+        return probabilities.sum()
+
+    # def calculate_self_consumption(self, load_1h_power: float, pv_power: float) -> float:
+    #     """Calculate the PV self-consumption rate using RegularGridInterpolator.
+
+    #     Args:
+    #     - last_1h_power: 1h power levels (W).
+    #     - pv_power: Current PV power output (W).
+
+    #     Returns:
+    #     - Self-consumption rate as a float.
+    #     """
+    #     # Generate the range of partial loads (0 to last_1h_power)
+    #     partial_loads = np.arange(0, pv_power + 50, 50)
+
+    #     # Get probabilities for all partial loads
+    #     points = np.array([np.full_like(partial_loads, load_1h_power), partial_loads]).T
+    #     if self.interpolator == None:
+    #         return -1.0
+    #     probabilities = self.interpolator(points)
+    #     self_consumption_rate = probabilities.sum()
+
+    #     # probabilities = probabilities / (np.sum(probabilities))  # / (pv_power / 3450))
+    #     # # for i, w in enumerate(partial_loads):
+    #     # #    print(w, ": ", probabilities[i])
+    #     # print(probabilities.sum())
+
+    #     # # Ensure probabilities are within [0, 1]
+    #     # probabilities = np.clip(probabilities, 0, 1)
+
+    #     # # Mask: Only include probabilities where the load is <= PV power
+    #     # mask = partial_loads <= pv_power
+
+    #     # # Calculate the cumulative probability for covered loads
+    #     # self_consumption_rate = np.sum(probabilities[mask]) / np.sum(probabilities)
+    #     # print(self_consumption_rate)
+    #     # sys.exit()
+
+    #     return self_consumption_rate
+
+
+class Genetic0LoadInterpolator(SelfConsumptionProbabilityInterpolator, SingletonMixin):
+    def __init__(self) -> None:
+        if hasattr(self, "_initialized"):
+            return
+        filename = (
+            Path(__file__).parent.parent.parent.resolve()
+            / "data"
+            / "genetic0_load_interpolator.pkl"
+        )
+        super().__init__(filename)
+
+
+# Initialize the Energy Management System, it is a singleton.
+genetic0_load_interpolator = Genetic0LoadInterpolator()
+
+
+def get_genetic0_load_interpolator() -> Genetic0LoadInterpolator:
+    return genetic0_load_interpolator

src/akkudoktoreos/optimization/genetic0/genetic0params.py

@@ -0,0 +1,702 @@
+"""GENETIC0 algorithm paramters.
+
+This module defines the Pydantic-based configuration and input parameter models
+used in the energy optimization routines, including photovoltaic forecasts,
+electricity pricing, and system component parameters.
+
+It also provides a method to assemble these parameters from predictions,
+forecasts, and fallback defaults, preparing them for optimization runs.
+"""
+
+from typing import Optional, Union
+
+from loguru import logger
+from pydantic import (
+    AliasChoices,
+    ConfigDict,
+    Field,
+    computed_field,
+    field_validator,
+    model_validator,
+)
+from typing_extensions import Self
+
+from akkudoktoreos.core.coreabc import (
+    ConfigMixin,
+    MeasurementMixin,
+    PredictionMixin,
+    get_ems,
+)
+from akkudoktoreos.optimization.genetic0.genetic0abc import Genetic0ParametersBaseModel
+from akkudoktoreos.optimization.genetic0.genetic0devices import (
+    Genetic0ElectricVehicleParameters,
+    Genetic0HomeApplianceParameters,
+    Genetic0InverterParameters,
+    Genetic0SolarPanelBatteryParameters,
+)
+from akkudoktoreos.utils.datetimeutil import to_duration
+
+# Do not import directly from akkudoktoreos.core.coreabc
+# EnergyManagementSystemMixin - Creates circular dependency with ems.py
+# StartMixin                  - Creates circular dependency with ems.py
+
+
+class Genetic0EnergyManagementParameters(Genetic0ParametersBaseModel):
+    """Encapsulates energy-related forecasts and costs used in GENETIC optimization."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    pv_forecast_wh: list[float] = Field(
+        validation_alias=AliasChoices("pv_forecast_wh", "pv_prognose_wh"),
+        json_schema_extra={
+            "description": "An array of floats representing the forecasted photovoltaic output in watts for different time intervals."
+        },
+    )
+    electricity_price_per_wh: list[float] = Field(
+        validation_alias=AliasChoices("electricity_price_per_wh", "strompreis_euro_pro_wh"),
+        json_schema_extra={
+            "description": "An array of floats representing the electricity price per watt-hour for different time intervals."
+        },
+    )
+    feed_in_tariff_per_wh: Union[list[float], float] = Field(
+        validation_alias=AliasChoices("feed_in_tariff_per_wh", "einspeiseverguetung_euro_pro_wh"),
+        json_schema_extra={
+            "description": "A float or array of floats representing the feed-in compensation per watt-hour."
+        },
+    )
+    price_per_wh_battery: float = Field(
+        validation_alias=AliasChoices("price_per_wh_battery", "preis_euro_pro_wh_akku"),
+        json_schema_extra={
+            "description": "A float representing the cost of battery energy per watt-hour."
+        },
+    )
+    total_load: list[float] = Field(
+        validation_alias=AliasChoices("total_load", "gesamtlast"),
+        json_schema_extra={
+            "description": "An array of floats representing the total load (consumption) in watts for different time intervals."
+        },
+    )
+
+    # Computed fields for backward compatibility (deprecated German names)
+    @computed_field(json_schema_extra={"deprecated": True})
+    def pv_prognose_wh(self) -> list[float]:
+        """Deprecated: Use pv_forecast_wh instead."""
+        return self.pv_forecast_wh
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def strompreis_euro_pro_wh(self) -> list[float]:
+        """Deprecated: Use electricity_price_per_wh instead."""
+        return self.electricity_price_per_wh
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def einspeiseverguetung_euro_pro_wh(self) -> Union[list[float], float]:
+        """Deprecated: Use feed_in_tariff_per_wh instead."""
+        return self.feed_in_tariff_per_wh
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def preis_euro_pro_wh_akku(self) -> float:
+        """Deprecated: Use price_per_wh_battery instead."""
+        return self.price_per_wh_battery
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def gesamtlast(self) -> list[float]:
+        """Deprecated: Use total_load instead."""
+        return self.total_load
+
+    @model_validator(mode="after")
+    def validate_list_length(self) -> Self:
+        """Validate that all input lists are of the same length.
+
+        Raises:
+            ValueError: If input list lengths differ.
+        """
+        pv_forecast_length = len(self.pv_forecast_wh)
+        if (
+            pv_forecast_length != len(self.electricity_price_per_wh)
+            or pv_forecast_length != len(self.total_load)
+            or (
+                isinstance(self.feed_in_tariff_per_wh, list)
+                and pv_forecast_length != len(self.feed_in_tariff_per_wh)
+            )
+        ):
+            raise ValueError("Input lists have different lengths")
+        return self
+
+
+class Genetic0OptimizationParameters(
+    ConfigMixin,
+    MeasurementMixin,
+    PredictionMixin,
+    # EnergyManagementSystemMixin, # Creates circular dependency with ems.py
+    # StartMixin,                  # Creates circular dependency with ems.py
+    Genetic0ParametersBaseModel,
+):
+    """Main parameter class for running the genetic energy optimization.
+
+    Collects all model and configuration parameters necessary to run the
+    optimization process, such as forecasts, pricing, battery and appliance models.
+    """
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    ems: Genetic0EnergyManagementParameters
+    pv_battery: Optional[Genetic0SolarPanelBatteryParameters] = Field(
+        validation_alias=AliasChoices("pv_battery", "pv_akku"),
+        json_schema_extra={"description": "PV battery parameters."},
+    )
+    inverter: Optional[Genetic0InverterParameters]
+    ev: Optional[Genetic0ElectricVehicleParameters] = Field(
+        validation_alias=AliasChoices("ev", "eauto"),
+        json_schema_extra={"description": "Electric vehicle parameters."},
+    )
+    dishwasher: Optional[Genetic0HomeApplianceParameters] = None
+    temperature_forecast: Optional[list[Optional[float]]] = Field(
+        default=None,
+        json_schema_extra={
+            "description": "An array of floats representing the temperature forecast in degrees Celsius for different time intervals."
+        },
+    )
+    start_solution: Optional[list[float]] = Field(
+        default=None,
+        json_schema_extra={
+            "description": "Can be `null` or contain a previous solution (if available)."
+        },
+    )
+
+    # Computed fields for backward compatibility (deprecated German names)
+    @computed_field(json_schema_extra={"deprecated": True})
+    def pv_akku(self) -> Optional[Genetic0SolarPanelBatteryParameters]:
+        """Deprecated: Use pv_battery instead."""
+        return self.pv_battery
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def eauto(self) -> Optional[Genetic0ElectricVehicleParameters]:
+        """Deprecated: Use ev instead."""
+        return self.ev
+
+    @model_validator(mode="after")
+    def validate_list_length(self) -> Self:
+        """Ensure that temperature forecast list matches the PV forecast length.
+
+        Raises:
+            ValueError: If list lengths mismatch.
+        """
+        arr_length = len(self.ems.pv_forecast_wh)
+        if self.temperature_forecast is not None and arr_length != len(self.temperature_forecast):
+            raise ValueError("Input lists have different lengths")
+        return self
+
+    @field_validator("start_solution")
+    def validate_start_solution(
+        cls, start_solution: Optional[list[float]]
+    ) -> Optional[list[float]]:
+        """Validate that the starting solution has at least two elements.
+
+        Args:
+            start_solution (list[float]): Optional list of solution values.
+
+        Returns:
+            list[float]: Validated list.
+
+        Raises:
+            ValueError: If the solution is too short.
+        """
+        if start_solution is not None and len(start_solution) < 2:
+            raise ValueError("Requires at least two values.")
+        return start_solution
+
+    @classmethod
+    async def prepare(cls) -> "Optional[Genetic0OptimizationParameters]":
+        """Prepare optimization parameters from config, forecast and measurement data.
+
+        Fills in values needed for optimization from available configuration, predictions and
+        measurements. If some data is missing, default or demo values are used.
+
+        Parameters start by definition of the genetic algorithm at hour 0 of the actual date
+        (not at start datetime of energy management run)
+
+        Returns:
+            Genetic0OptimizationParameters: The fully prepared optimization parameters.
+
+        Raises:
+            ValueError: If required configuration values like start time are missing.
+        """
+        ems = get_ems()
+
+        # The optimization paramters
+        oparams: "Optional[Genetic0OptimizationParameters]" = None
+
+        # Check for run definitions
+        if ems.start_datetime is None:
+            error_msg = "Start datetime unknown."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        # Check for general predictions conditions
+        if cls.config.general.latitude is None:
+            default_latitude = 52.52
+            logger.info(f"Latitude unknown - defaulting to {default_latitude}.")
+            cls.config.general.latitude = default_latitude
+        if cls.config.general.longitude is None:
+            default_longitude = 13.405
+            logger.info(f"Longitude unknown - defaulting to {default_longitude}.")
+            cls.config.general.longitude = default_longitude
+        if cls.config.prediction.hours is None:
+            logger.info("Prediction hours unknown - defaulting to 48 hours.")
+            cls.config.prediction.hours = 48
+        if cls.config.prediction.historic_hours is None:
+            logger.info("Prediction historic hours unknown - defaulting to 24 hours.")
+            cls.config.prediction.historic_hours = 24
+        # Check optimization definitions. interval_sec is fixed to 1 hour.
+        if cls.config.optimization.genetic0.horizon_hours is None:
+            logger.info("Optimization horizon unknown - defaulting to 24 hours.")
+            cls.config.optimization.genetic0.horizon_hours = 24
+        # Check genetic algorithm definitions
+        if cls.config.optimization.genetic0.individuals is None:
+            logger.info("Genetic individuals unknown - defaulting to 300.")
+            cls.config.optimization.genetic0.individuals = 300
+        if cls.config.optimization.genetic0.generations is None:
+            logger.info("Genetic generations unknown - defaulting to 400.")
+            cls.config.optimization.genetic0.generations = 400
+        if "ev_soc_miss" not in cls.config.optimization.genetic0.penalties:
+            logger.info("Genetic penalties unknown - defaulting to ev_soc_miss = 10.")
+            cls.config.optimization.genetic0.penalties["ev_soc_miss"] = 10
+
+        # Get start solution from last run
+        start_solution = None
+        last_solution = ems.genetic0_solution()
+        if last_solution and last_solution.start_solution:
+            start_solution = last_solution.start_solution
+
+        # Add forecast and device data
+        interval = to_duration(cls.config.optimization.genetic0.interval_sec)
+        power_to_energy_per_interval_factor = cls.config.optimization.genetic0.interval_sec / 3600
+        parameter_start_datetime = ems.start_datetime.set(hour=0, second=0, microsecond=0)
+        parameter_end_datetime = parameter_start_datetime.add(hours=cls.config.prediction.hours)
+        max_retries = 10
+
+        for attempt in range(1, max_retries + 1):
+            # Collect all the data for optimisation, but do not exceed max retries
+            if attempt > max_retries:
+                error_msg = f"Maximum retries {max_retries} for parameter collection exceeded. Parameter preparation attempt {attempt}."
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+
+            # Assure predictions are uptodate
+            await cls.prediction.update_data()
+
+            try:
+                array = await cls.prediction.key_to_array(
+                    key="pvforecast_ac_power",
+                    start_datetime=parameter_start_datetime,
+                    end_datetime=parameter_end_datetime,
+                    interval=interval,
+                    fill_method="linear",
+                )
+                pvforecast_ac_power = (array * power_to_energy_per_interval_factor).tolist()
+            except Exception as e:
+                logger.info(
+                    "No PV forecast data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                    attempt,
+                    e,
+                )
+                cls.config.merge_settings_from_dict(
+                    {
+                        "pvforecast": {
+                            "provider": "PVForecastAkkudoktor",
+                            "max_planes": 4,
+                            "planes": [
+                                {
+                                    "peakpower": 5.0,
+                                    "surface_azimuth": 170,
+                                    "surface_tilt": 7,
+                                    "userhorizon": [20, 27, 22, 20],
+                                    "inverter_paco": 10000,
+                                },
+                                {
+                                    "peakpower": 4.8,
+                                    "surface_azimuth": 90,
+                                    "surface_tilt": 7,
+                                    "userhorizon": [30, 30, 30, 50],
+                                    "inverter_paco": 10000,
+                                },
+                                {
+                                    "peakpower": 1.4,
+                                    "surface_azimuth": 140,
+                                    "surface_tilt": 60,
+                                    "userhorizon": [60, 30, 0, 30],
+                                    "inverter_paco": 2000,
+                                },
+                                {
+                                    "peakpower": 1.6,
+                                    "surface_azimuth": 185,
+                                    "surface_tilt": 45,
+                                    "userhorizon": [45, 25, 30, 60],
+                                    "inverter_paco": 1400,
+                                },
+                            ],
+                        },
+                    }
+                )
+                # Retry
+                continue
+            try:
+                array = await cls.prediction.key_to_array(
+                    key="elecprice_marketprice_wh",
+                    start_datetime=parameter_start_datetime,
+                    end_datetime=parameter_end_datetime,
+                    interval=interval,
+                    fill_method="ffill",
+                )
+                elecprice_marketprice_wh = array.tolist()
+            except Exception as e:
+                logger.info(
+                    "No Electricity Marketprice forecast data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                    attempt,
+                    e,
+                )
+                cls.config.elecprice.provider = "ElecPriceAkkudoktor"
+                # Retry
+                continue
+            try:
+                array = await cls.prediction.key_to_array(
+                    key="loadforecast_power_w",
+                    start_datetime=parameter_start_datetime,
+                    end_datetime=parameter_end_datetime,
+                    interval=interval,
+                    fill_method="ffill",
+                )
+                loadforecast_power_w = array.tolist()
+            except Exception as e:
+                logger.info(
+                    "No Load forecast data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                    attempt,
+                    e,
+                )
+                cls.config.merge_settings_from_dict(
+                    {
+                        "load": {
+                            "provider": "LoadAkkudoktor",
+                            "loadakkudoktor": {
+                                "loadakkudoktor_year_energy_kwh": "3000",
+                            },
+                        },
+                    }
+                )
+                # Retry
+                continue
+            try:
+                array = await cls.prediction.key_to_array(
+                    key="feed_in_tariff_wh",
+                    start_datetime=parameter_start_datetime,
+                    end_datetime=parameter_end_datetime,
+                    interval=interval,
+                    fill_method="ffill",
+                )
+                feed_in_tariff_wh = array.tolist()
+            except Exception as e:
+                logger.info(
+                    "No feed in tariff forecast data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                    attempt,
+                    e,
+                )
+                cls.config.merge_settings_from_dict(
+                    {
+                        "feedintariff": {
+                            "provider": "FeedInTariffFixed",
+                            "feedintarifffixed": {
+                                "feed_in_tariff_kwh": 0.078,
+                            },
+                        },
+                    }
+                )
+                # Retry
+                continue
+            try:
+                array = await cls.prediction.key_to_array(
+                    key="weather_temp_air",
+                    start_datetime=parameter_start_datetime,
+                    end_datetime=parameter_end_datetime,
+                    interval=interval,
+                    fill_method="ffill",
+                )
+                weather_temp_air = array.tolist()
+            except Exception as e:
+                logger.info(
+                    "No weather forecast data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                    attempt,
+                    e,
+                )
+                cls.config.weather.provider = "BrightSky"
+                # Retry
+                continue
+
+            # Add device data
+
+            # Batteries
+            # ---------
+            if cls.config.devices.max_batteries is None:
+                logger.info("Number of battery devices not configured - defaulting to 1.")
+                cls.config.devices.max_batteries = 1
+            if cls.config.devices.max_batteries == 0:
+                battery_params = None
+                battery_lcos_kwh = 0
+            else:
+                if cls.config.devices.batteries is None:
+                    logger.info("No battery device data available - defaulting to demo data.")
+                    cls.config.devices.batteries = [{"device_id": "battery1", "capacity_wh": 8000}]
+                try:
+                    battery_config = cls.config.devices.batteries[0]
+                    battery_params = Genetic0SolarPanelBatteryParameters(
+                        device_id=battery_config.device_id,
+                        capacity_wh=battery_config.capacity_wh,
+                        charging_efficiency=battery_config.charging_efficiency,
+                        discharging_efficiency=battery_config.discharging_efficiency,
+                        max_charge_power_w=battery_config.max_charge_power_w,
+                        min_soc_percentage=battery_config.min_soc_percentage,
+                        max_soc_percentage=battery_config.max_soc_percentage,
+                        charge_rates=battery_config.charge_rates,
+                    )
+                except Exception as e:
+                    logger.info(
+                        "No battery device data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                        attempt,
+                        e,
+                    )
+                    cls.config.devices.batteries = [{"device_id": "battery1", "capacity_wh": 8000}]
+                    # Retry
+                    continue
+                # Levelized cost of ownership
+                if battery_config.levelized_cost_of_storage_kwh is None:
+                    logger.info(
+                        "No battery device LCOS data available - defaulting to 0 [amount/kWh]. Parameter preparation attempt {}.",
+                        attempt,
+                    )
+                    battery_config.levelized_cost_of_storage_kwh = 0
+                battery_lcos_kwh = battery_config.levelized_cost_of_storage_kwh
+                # Initial SOC
+                try:
+                    initial_soc_factor = await cls.measurement.key_to_value(
+                        key=battery_config.measurement_key_soc_factor,
+                        target_datetime=ems.start_datetime,
+                        time_window=to_duration(to_duration("48 hours")),
+                    )
+                    if initial_soc_factor > 1.0 or initial_soc_factor < 0.0:
+                        logger.error(
+                            f"Invalid battery initial SoC factor {initial_soc_factor} - defaulting to 0.0."
+                        )
+                        initial_soc_factor = 0.0
+                    # genetic parameter is 0..100 as int
+                    initial_soc_percentage = int(initial_soc_factor * 100)
+                except Exception:
+                    initial_soc_percentage = None
+                if initial_soc_percentage is None:
+                    logger.info(
+                        f"No battery device SoC data (measurement key = '{battery_config.measurement_key_soc_factor}') available - defaulting to 0."
+                    )
+                    initial_soc_percentage = 0
+                battery_params.initial_soc_percentage = initial_soc_percentage
+
+            # Electric Vehicles
+            # -----------------
+            if cls.config.devices.max_electric_vehicles is None:
+                logger.info("Number of electric_vehicle devices not configured - defaulting to 1.")
+                cls.config.devices.max_electric_vehicles = 1
+            if cls.config.devices.max_electric_vehicles == 0:
+                electric_vehicle_params = None
+            else:
+                if cls.config.devices.electric_vehicles is None:
+                    logger.info(
+                        "No electric vehicle device data available - defaulting to demo data."
+                    )
+                    cls.config.devices.max_electric_vehicles = 1
+                    cls.config.devices.electric_vehicles = [
+                        {
+                            "device_id": "ev11",
+                            "capacity_wh": 50000,
+                            "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,
+                        }
+                    ]
+                try:
+                    electric_vehicle_config = cls.config.devices.electric_vehicles[0]
+                    electric_vehicle_params = Genetic0ElectricVehicleParameters(
+                        device_id=electric_vehicle_config.device_id,
+                        capacity_wh=electric_vehicle_config.capacity_wh,
+                        charging_efficiency=electric_vehicle_config.charging_efficiency,
+                        discharging_efficiency=electric_vehicle_config.discharging_efficiency,
+                        charge_rates=electric_vehicle_config.charge_rates,
+                        max_charge_power_w=electric_vehicle_config.max_charge_power_w,
+                        min_soc_percentage=electric_vehicle_config.min_soc_percentage,
+                        max_soc_percentage=electric_vehicle_config.max_soc_percentage,
+                    )
+                except Exception as e:
+                    logger.info(
+                        "No electric_vehicle device data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                        attempt,
+                        e,
+                    )
+                    cls.config.devices.max_electric_vehicles = 1
+                    cls.config.devices.electric_vehicles = [
+                        {
+                            "device_id": "ev12",
+                            "capacity_wh": 50000,
+                            "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,
+                        }
+                    ]
+                    # Retry
+                    continue
+                # Initial SOC
+                try:
+                    initial_soc_factor = await cls.measurement.key_to_value(
+                        key=electric_vehicle_config.measurement_key_soc_factor,
+                        target_datetime=ems.start_datetime,
+                        time_window=to_duration(to_duration("48 hours")),
+                    )
+                    if initial_soc_factor > 1.0 or initial_soc_factor < 0.0:
+                        logger.error(
+                            f"Invalid electric vehicle initial SoC factor {initial_soc_factor} - defaulting to 0.0."
+                        )
+                        initial_soc_factor = 0.0
+                    # genetic parameter is 0..100 as int
+                    initial_soc_percentage = int(initial_soc_factor * 100)
+                except Exception:
+                    initial_soc_percentage = None
+                if initial_soc_percentage is None:
+                    logger.info(
+                        f"No electric vehicle device SoC data (measurement key = '{electric_vehicle_config.measurement_key_soc_factor}') available - defaulting to 0."
+                    )
+                    initial_soc_percentage = 0
+                electric_vehicle_params.initial_soc_percentage = initial_soc_percentage
+
+            # Inverters
+            # ---------
+            if cls.config.devices.max_inverters is None:
+                logger.info("Number of inverter devices not configured - defaulting to 1.")
+                cls.config.devices.max_inverters = 1
+            if cls.config.devices.max_inverters == 0:
+                inverter_params = None
+            else:
+                if cls.config.devices.inverters is None:
+                    logger.info("No inverter device data available - defaulting to demo data.")
+                    cls.config.devices.inverters = [
+                        {
+                            "device_id": "inverter1",
+                            "max_power_w": 10000,
+                            "battery_id": battery_config.device_id,
+                        }
+                    ]
+                try:
+                    inverter_config = cls.config.devices.inverters[0]
+                    inverter_params = Genetic0InverterParameters(
+                        device_id=inverter_config.device_id,
+                        max_power_wh=inverter_config.max_power_w,
+                        battery_id=inverter_config.battery_id,
+                        ac_to_dc_efficiency=inverter_config.ac_to_dc_efficiency,
+                        dc_to_ac_efficiency=inverter_config.dc_to_ac_efficiency,
+                        max_ac_charge_power_w=inverter_config.max_ac_charge_power_w,
+                    )
+                except Exception as e:
+                    logger.info(
+                        "No inverter device data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                        attempt,
+                        e,
+                    )
+                    cls.config.devices.inverters = [
+                        {
+                            "device_id": "inverter1",
+                            "max_power_w": 10000,
+                            "battery_id": battery_config.device_id,
+                        }
+                    ]
+                    # Retry
+                    continue
+
+            # Home Appliances
+            # ---------------
+            if cls.config.devices.max_home_appliances is None:
+                logger.info("Number of home appliance devices not configured - defaulting to 1.")
+                cls.config.devices.max_home_appliances = 1
+            if cls.config.devices.max_home_appliances == 0:
+                home_appliance_params = None
+            else:
+                home_appliance_params = None
+                if cls.config.devices.home_appliances is None:
+                    logger.info(
+                        "No home appliance device data available - defaulting to demo data."
+                    )
+                    cls.config.devices.home_appliances = [
+                        {
+                            "device_id": "dishwasher1",
+                            "consumption_wh": 2000,
+                            "duration_h": 3.0,
+                            "time_windows": {
+                                "windows": [
+                                    {
+                                        "start_time": "08:00",
+                                        "duration": "5 hours",
+                                    },
+                                    {
+                                        "start_time": "15:00",
+                                        "duration": "3 hours",
+                                    },
+                                ],
+                            },
+                        }
+                    ]
+                try:
+                    home_appliance_config = cls.config.devices.home_appliances[0]
+                    home_appliance_params = Genetic0HomeApplianceParameters(
+                        device_id=home_appliance_config.device_id,
+                        consumption_wh=home_appliance_config.consumption_wh,
+                        duration_h=home_appliance_config.duration_h,
+                        time_windows=home_appliance_config.time_windows,
+                    )
+                except Exception as e:
+                    logger.info(
+                        "No home appliance device data available - defaulting to demo data. Parameter preparation attempt {}: {}",
+                        attempt,
+                        e,
+                    )
+                    cls.config.devices.home_appliances = [
+                        {
+                            "device_id": "dishwasher1",
+                            "consumption_wh": 2000,
+                            "duration_h": 3.0,
+                            "time_windows": None,
+                        }
+                    ]
+                    # Retry
+                    continue
+
+            # We got all parameter data
+            try:
+                oparams = Genetic0OptimizationParameters(
+                    ems=Genetic0EnergyManagementParameters(
+                        pv_forecast_wh=pvforecast_ac_power,
+                        electricity_price_per_wh=elecprice_marketprice_wh,
+                        feed_in_tariff_per_wh=feed_in_tariff_wh,
+                        total_load=loadforecast_power_w,
+                        price_per_wh_battery=battery_lcos_kwh / 1000,
+                    ),
+                    temperature_forecast=weather_temp_air,
+                    pv_battery=battery_params,
+                    ev=electric_vehicle_params,
+                    inverter=inverter_params,
+                    dishwasher=home_appliance_params,
+                    start_solution=start_solution,
+                )
+            except Exception as e:
+                logger.info(
+                    "Can not prepare optimization parameters - will retry. Parameter preparation attempt {}: {}",
+                    attempt,
+                    e,
+                )
+                oparams = None
+                # Retry
+                continue
+
+            # Parameters prepared
+            break
+
+        return oparams

src/akkudoktoreos/optimization/genetic0/genetic0settings.py

@@ -0,0 +1,78 @@
+"""Settings for the GENETIC0 optimization algorithm.
+
+Kept in an extra module to avoid cyclic dependencies on package import.
+"""
+
+from typing import Optional, Union
+
+from pydantic import Field, computed_field
+
+from akkudoktoreos.config.configabc import SettingsBaseModel
+
+
+class Genetic0CommonSettings(SettingsBaseModel):
+    """GENETIC0 Optimization Algorithm Configuration."""
+
+    horizon_hours: int = Field(
+        default=24,
+        ge=0,
+        json_schema_extra={
+            "description": "The general time window within which the energy optimization goal shall be achieved [h]. Defaults to 24 hours.",
+            "examples": [24],
+        },
+    )
+
+    individuals: Optional[int] = Field(
+        default=300,
+        ge=10,
+        json_schema_extra={
+            "description": "Number of individuals (solutions) in the population [>= 10]. Defaults to 300.",
+            "examples": [300],
+        },
+    )
+
+    generations: Optional[int] = Field(
+        default=400,
+        ge=10,
+        json_schema_extra={
+            "description": "Number of generations to evolve [>= 10]. Defaults to 400.",
+            "examples": [400],
+        },
+    )
+
+    seed: Optional[int] = Field(
+        default=None,
+        ge=0,
+        json_schema_extra={
+            "description": "Random seed for reproducibility. None = random.",
+            "examples": [None, 42],
+        },
+    )
+
+    # --- Penalties (existing) -------------------------------------------------
+
+    penalties: dict[str, Union[float, int, str]] = Field(
+        default_factory=lambda: {
+            "ev_soc_miss": 10,
+            "ac_charge_break_even": 1.0,
+        },
+        json_schema_extra={
+            "description": "Penalty parameters used in fitness evaluation.",
+            "examples": [{"ev_soc_miss": 10}],
+        },
+    )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def interval_sec(self) -> int:
+        """The optimization interval [sec]. Fixed to 1 hour (3600 seconds)."""
+        return 3600
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def horizon(self) -> int:
+        """Number of optimization steps."""
+        if self.horizon_hours is None:
+            return 0
+        num_steps = int(float(self.horizon_hours * 3600) / self.interval_sec)
+        return num_steps

src/akkudoktoreos/optimization/genetic0/genetic0solution.py

@@ -0,0 +1,893 @@
+"""Genetic0 algorithm optimisation solution."""
+
+from typing import Any, Optional
+
+import numpy as np
+import pandas as pd
+from loguru import logger
+from pydantic import AliasChoices, ConfigDict, Field, computed_field, field_validator
+
+from akkudoktoreos.core.coreabc import (
+    ConfigMixin,
+    get_ems,
+    get_prediction,
+)
+from akkudoktoreos.core.emplan import (
+    DDBCInstruction,
+    EnergyManagementPlan,
+    FRBCInstruction,
+)
+from akkudoktoreos.core.pydantic import PydanticDateTimeDataFrame
+from akkudoktoreos.devices.devicesabc import (
+    ApplianceOperationMode,
+    BatteryOperationMode,
+)
+from akkudoktoreos.devices.genetic0.genetic0battery import Genetic0Battery
+from akkudoktoreos.optimization.genetic0.genetic0devices import (
+    Genetic0ParametersBaseModel,
+)
+from akkudoktoreos.optimization.optimization import OptimizationSolution
+from akkudoktoreos.utils.datetimeutil import to_datetime, to_duration
+from akkudoktoreos.utils.utils import NumpyEncoder
+
+
+class DeviceOptimizeResult(Genetic0ParametersBaseModel):
+    device_id: str = Field(
+        json_schema_extra={"description": "ID of device", "examples": ["device1"]}
+    )
+    hours: int = Field(
+        gt=0,
+        json_schema_extra={"description": "Number of hours in the simulation.", "examples": [24]},
+    )
+
+
+class Genetic0ElectricVehicleResult(DeviceOptimizeResult):
+    """Result class containing information related to the electric vehicle's charging and discharging behavior."""
+
+    device_id: str = Field(
+        json_schema_extra={"description": "ID of electric vehicle", "examples": ["ev1"]}
+    )
+    charge_array: list[float] = Field(
+        json_schema_extra={
+            "description": "Hourly charging status (0 for no charging, 1 for charging)."
+        }
+    )
+    discharge_array: list[int] = Field(
+        json_schema_extra={
+            "description": "Hourly discharging status (0 for no discharging, 1 for discharging)."
+        }
+    )
+    discharging_efficiency: float = Field(
+        json_schema_extra={"description": "The discharge efficiency as a float.."}
+    )
+    capacity_wh: int = Field(
+        json_schema_extra={"description": "Capacity of the EV’s battery in watt-hours."}
+    )
+    charging_efficiency: float = Field(
+        json_schema_extra={"description": "Charging efficiency as a float.."}
+    )
+    max_charge_power_w: int = Field(
+        json_schema_extra={"description": "Maximum charging power in watts."}
+    )
+    soc_wh: float = Field(
+        json_schema_extra={
+            "description": "State of charge of the battery in watt-hours at the start of the simulation."
+        }
+    )
+    initial_soc_percentage: int = Field(
+        json_schema_extra={
+            "description": "State of charge at the start of the simulation in percentage."
+        }
+    )
+
+    @field_validator("discharge_array", "charge_array", mode="before")
+    def convert_numpy(cls, field: Any) -> Any:
+        return NumpyEncoder.convert_numpy(field)[0]
+
+
+class Genetic0SimulationResult(Genetic0ParametersBaseModel):
+    """This object contains the results of the simulation and provides insights into various parameters over the entire forecast period."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    load_wh_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("load_wh_per_hour", "Last_Wh_pro_Stunde"),
+        json_schema_extra={"description": "The load in watt-hours per hour."},
+    )
+    ev_soc_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("ev_soc_per_hour", "EAuto_SoC_pro_Stunde"),
+        json_schema_extra={"description": "The state of charge of the EV for each hour."},
+    )
+    revenue_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("revenue_per_hour", "Einnahmen_Euro_pro_Stunde"),
+        json_schema_extra={
+            "description": "The revenue from grid feed-in or other sources per hour."
+        },
+    )
+    total_losses: float = Field(
+        validation_alias=AliasChoices("total_losses", "Gesamt_Verluste"),
+        json_schema_extra={"description": "The total losses in watt-hours over the entire period."},
+    )
+    total_balance: float = Field(
+        validation_alias=AliasChoices("total_balance", "Gesamtbilanz_Euro"),
+        json_schema_extra={"description": "The total balance of revenues minus costs."},
+    )
+    total_revenue: float = Field(
+        validation_alias=AliasChoices("total_revenue", "Gesamteinnahmen_Euro"),
+        json_schema_extra={"description": "The total revenues."},
+    )
+    total_costs: float = Field(
+        validation_alias=AliasChoices("total_costs", "Gesamtkosten_Euro"),
+        json_schema_extra={"description": "The total costs."},
+    )
+    home_appliance_wh_per_hour: list[Optional[float]] = Field(
+        validation_alias=AliasChoices("home_appliance_wh_per_hour", "Home_appliance_wh_per_hour"),
+        json_schema_extra={
+            "description": "The energy consumption of a household appliance in watt-hours per hour."
+        },
+    )
+    costs_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("costs_per_hour", "Kosten_Euro_pro_Stunde"),
+        json_schema_extra={"description": "The costs per hour."},
+    )
+    grid_consumption_wh_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("grid_consumption_wh_per_hour", "Netzbezug_Wh_pro_Stunde"),
+        json_schema_extra={"description": "The grid energy drawn in watt-hours per hour."},
+    )
+    grid_feed_in_wh_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("grid_feed_in_wh_per_hour", "Netzeinspeisung_Wh_pro_Stunde"),
+        json_schema_extra={"description": "The energy fed into the grid in watt-hours per hour."},
+    )
+    losses_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("losses_per_hour", "Verluste_Pro_Stunde"),
+        json_schema_extra={"description": "The losses in watt-hours per hour."},
+    )
+    battery_soc_per_hour: list[float] = Field(
+        validation_alias=AliasChoices("battery_soc_per_hour", "akku_soc_pro_stunde"),
+        json_schema_extra={
+            "description": "The state of charge of the battery (not the EV) in percentage per hour."
+        },
+    )
+    electricity_price: list[float] = Field(
+        validation_alias=AliasChoices("electricity_price", "Electricity_price"),
+        json_schema_extra={"description": "Used Electricity Price, including predictions"},
+    )
+
+    # Computed fields for backward compatibility (deprecated German names)
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Last_Wh_pro_Stunde(self) -> list[float]:
+        """Deprecated: Use load_wh_per_hour instead."""
+        return self.load_wh_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def EAuto_SoC_pro_Stunde(self) -> list[float]:
+        """Deprecated: Use ev_soc_per_hour instead."""
+        return self.ev_soc_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Einnahmen_Euro_pro_Stunde(self) -> list[float]:
+        """Deprecated: Use revenue_per_hour instead."""
+        return self.revenue_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Gesamt_Verluste(self) -> float:
+        """Deprecated: Use total_losses instead."""
+        return self.total_losses
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Gesamtbilanz_Euro(self) -> float:
+        """Deprecated: Use total_balance instead."""
+        return self.total_balance
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Gesamteinnahmen_Euro(self) -> float:
+        """Deprecated: Use total_revenue instead."""
+        return self.total_revenue
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Gesamtkosten_Euro(self) -> float:
+        """Deprecated: Use total_costs instead."""
+        return self.total_costs
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Home_appliance_wh_per_hour(self) -> list[Optional[float]]:
+        """Deprecated: Use home_appliance_wh_per_hour instead."""
+        return self.home_appliance_wh_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Kosten_Euro_pro_Stunde(self) -> list[float]:
+        """Deprecated: Use costs_per_hour instead."""
+        return self.costs_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Netzbezug_Wh_pro_Stunde(self) -> list[float]:
+        """Deprecated: Use grid_consumption_wh_per_hour instead."""
+        return self.grid_consumption_wh_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Netzeinspeisung_Wh_pro_Stunde(self) -> list[float]:
+        """Deprecated: Use grid_feed_in_wh_per_hour instead."""
+        return self.grid_feed_in_wh_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Verluste_Pro_Stunde(self) -> list[float]:
+        """Deprecated: Use losses_per_hour instead."""
+        return self.losses_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def akku_soc_pro_stunde(self) -> list[float]:
+        """Deprecated: Use battery_soc_per_hour instead."""
+        return self.battery_soc_per_hour
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def Electricity_price(self) -> list[float]:
+        """Deprecated: Use electricity_price instead."""
+        return self.electricity_price
+
+    @field_validator(
+        "load_wh_per_hour",
+        "grid_feed_in_wh_per_hour",
+        "battery_soc_per_hour",
+        "grid_consumption_wh_per_hour",
+        "costs_per_hour",
+        "revenue_per_hour",
+        "ev_soc_per_hour",
+        "losses_per_hour",
+        "home_appliance_wh_per_hour",
+        "electricity_price",
+        mode="before",
+    )
+    def convert_numpy(cls, field: Any) -> Any:
+        return NumpyEncoder.convert_numpy(field)[0]
+
+
+class Genetic0Solution(ConfigMixin, Genetic0ParametersBaseModel):
+    """**Note**: The first value of "load_wh_per_hour", "grid_feed_in_wh_per_hour", and "grid_consumption_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."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    ac_charge: list[float] = Field(
+        json_schema_extra={
+            "description": "Array with AC charging values as relative power (0.0-1.0), other values set to 0."
+        }
+    )
+    dc_charge: list[float] = Field(
+        json_schema_extra={
+            "description": "Array with DC charging values as relative power (0-1), other values set to 0."
+        }
+    )
+    discharge_allowed: list[int] = Field(
+        json_schema_extra={
+            "description": "Array with discharge values (1 for discharge, 0 otherwise)."
+        }
+    )
+    ev_charge_hours_float: Optional[list[float]] = Field(
+        validation_alias=AliasChoices("ev_charge_hours_float", "eautocharge_hours_float"),
+        json_schema_extra={
+            "description": "Array with EV charging values as relative power (0.0-1.0), or `null` if no EV is optimized."
+        },
+    )
+    result: Genetic0SimulationResult
+    ev_obj: Optional[Genetic0ElectricVehicleResult] = Field(
+        validation_alias=AliasChoices("ev_obj", "eauto_obj"),
+        json_schema_extra={"description": "Electric vehicle state after optimization."},
+    )
+    start_solution: Optional[list[float]] = Field(
+        default=None,
+        json_schema_extra={
+            "description": "An array of binary values (0 or 1) representing a possible starting solution for the simulation."
+        },
+    )
+    washingstart: Optional[int] = Field(
+        default=None,
+        json_schema_extra={
+            "description": "Can be `null` or contain an object representing the start of washing (if applicable)."
+        },
+    )
+
+    # Computed fields for backward compatibility (deprecated German names)
+    @computed_field(json_schema_extra={"deprecated": True})
+    def eautocharge_hours_float(self) -> Optional[list[float]]:
+        """Deprecated: Use ev_charge_hours_float instead."""
+        return self.ev_charge_hours_float
+
+    @computed_field(json_schema_extra={"deprecated": True})
+    def eauto_obj(self) -> Optional[Genetic0ElectricVehicleResult]:
+        """Deprecated: Use ev_obj instead."""
+        return self.ev_obj
+
+    @field_validator(
+        "ac_charge",
+        "dc_charge",
+        "discharge_allowed",
+        mode="before",
+    )
+    def convert_numpy(cls, field: Any) -> Any:
+        return NumpyEncoder.convert_numpy(field)[0]
+
+    @field_validator(
+        "ev_obj",
+        mode="before",
+    )
+    def convert_eauto(cls, field: Any) -> Any:
+        if isinstance(field, Genetic0Battery):
+            return Genetic0ElectricVehicleResult(**field.to_dict())
+        return field
+
+    def _battery_device_id(self) -> str:
+        """Get battery device id."""
+        try:
+            return self.config.devices.batteries[0].device_id
+        except Exception:
+            return "battery1"
+
+    def _ev_device_id(self) -> str:
+        """Get electric vehicle device id."""
+        try:
+            return self.config.devices.electric_vehicles[0].device_id
+        except Exception:
+            return "ev1"
+
+    def _homeappliance_device_id(self) -> str:
+        """Get home appliance device id."""
+        try:
+            return self.config.devices.home_appliances[0].device_id
+        except Exception:
+            return "homeappliance1"
+
+    def _battery_operation_from_solution(
+        self,
+        ac_charge: float,
+        dc_charge: float,
+        discharge_allowed: bool,
+    ) -> tuple[BatteryOperationMode, float]:
+        """Maps low-level solution to a representative operation mode and factor.
+
+        Args:
+            ac_charge (float): Allowed AC-side charging power (relative units).
+            dc_charge (float): Allowed DC-side charging power (relative units).
+            discharge_allowed (bool): Whether discharging is permitted.
+
+        Returns:
+            tuple[BatteryOperationMode, float]: A tuple containing
+                - `BatteryOperationMode`: the representative high-level operation mode.
+                - `float`: the operation factor corresponding to the active signal.
+
+        Notes:
+            - The mapping prioritizes AC charge > DC charge > discharge.
+            - Multiple strategies can produce the same low-level signals; this function
+              returns a representative mode based on a defined priority order.
+        """
+        # (0,0,0) → Nothing allowed
+        if ac_charge <= 0.0 and dc_charge <= 0.0 and not discharge_allowed:
+            return BatteryOperationMode.IDLE, 1.0
+
+        # (0,0,1) → Discharge only
+        if ac_charge <= 0.0 and dc_charge <= 0.0 and discharge_allowed:
+            return BatteryOperationMode.PEAK_SHAVING, 1.0
+
+        # (ac>0,0,0) → AC charge only
+        if ac_charge > 0.0 and dc_charge <= 0.0 and not discharge_allowed:
+            return BatteryOperationMode.GRID_SUPPORT_IMPORT, ac_charge
+
+        # (0,dc>0,0) → DC charge only
+        if ac_charge <= 0.0 and dc_charge > 0.0 and not discharge_allowed:
+            return BatteryOperationMode.NON_EXPORT, dc_charge
+
+        # (ac>0,dc>0,0) → Both charge paths, no discharge
+        if ac_charge > 0.0 and dc_charge > 0.0 and not discharge_allowed:
+            return BatteryOperationMode.FORCED_CHARGE, ac_charge
+
+        # (ac>0,0,1) → AC charge + discharge - does not make sense
+        if ac_charge > 0.0 and dc_charge <= 0.0 and discharge_allowed:
+            raise ValueError(
+                f"Illegal state: ac_charge: {ac_charge} and discharge_allowed: {discharge_allowed}"
+            )
+
+        # (0,dc>0,1) → DC charge + discharge
+        if ac_charge <= 0.0 and dc_charge > 0.0 and discharge_allowed:
+            return BatteryOperationMode.SELF_CONSUMPTION, dc_charge
+
+        # (ac>0,dc>0,1) → Fully flexible - does not make sense
+        if ac_charge > 0.0 and dc_charge > 0.0 and discharge_allowed:
+            raise ValueError(
+                f"Illegal state: ac_charge: {ac_charge} and discharge_allowed: {discharge_allowed}"
+            )
+
+        # Fallback → safe idle
+        return BatteryOperationMode.IDLE, 1.0
+
+    def _soc_clamped_operation_factors(
+        self,
+        ac_charge: float,
+        dc_charge: float,
+        discharge_allowed: bool,
+        soc_pct: float,
+    ) -> tuple[float, float, bool]:
+        """Clamp raw genetic gene values by the battery's actual SOC at that hour.
+
+        The raw gene values represent the optimizer's *intent* and are stored
+        verbatim in the ``genetic_*`` solution columns.  This method derives
+        the *effective* values that can physically be executed given the
+        battery's state of charge, used for the ``battery1_*_op_*`` columns
+        and for ``energy_management_plan`` instructions.
+
+        Clamping rules:
+          - AC charge factor: scaled down proportionally when the battery
+            headroom (max_soc − current_soc) is smaller than what the
+            commanded factor would store in one hour.  Set to 0 when full.
+          - DC charge factor (PV): zeroed when battery is at or above max SOC
+            (the inverter curtails automatically, but this makes intent clear).
+          - Discharge: blocked when SOC is at or below min SOC.
+        """
+        bat_list = self.config.devices.batteries
+        if not bat_list:
+            return ac_charge, dc_charge, discharge_allowed
+
+        bat = bat_list[0]
+        min_soc = float(bat.min_soc_percentage)
+        max_soc = float(bat.max_soc_percentage)
+        capacity_wh = float(bat.capacity_wh)
+        ch_eff = float(bat.charging_efficiency)
+        headroom_wh = max(0.0, (max_soc - soc_pct) / 100.0 * capacity_wh)
+
+        # --- AC charge: scale to available headroom ---
+        effective_ac = ac_charge
+        if effective_ac > 0.0:
+            if headroom_wh <= 0.0:
+                effective_ac = 0.0
+            else:
+                inv_list = self.config.devices.inverters
+                ac_to_dc_eff = float(inv_list[0].ac_to_dc_efficiency) if inv_list else 1.0
+                max_ac_cp_w = (
+                    float(inv_list[0].max_ac_charge_power_w)
+                    if inv_list and inv_list[0].max_ac_charge_power_w is not None
+                    else float(bat.max_charge_power_w)
+                )
+                max_dc_per_h_wh = effective_ac * max_ac_cp_w * ac_to_dc_eff * ch_eff
+                if max_dc_per_h_wh > headroom_wh:
+                    effective_ac = effective_ac * (headroom_wh / max_dc_per_h_wh)
+
+        # --- DC charge (PV): zero when battery is full ---
+        effective_dc = dc_charge
+        if effective_dc > 0.0 and headroom_wh <= 0.0:
+            effective_dc = 0.0
+
+        # --- Discharge: block at min SOC ---
+        effective_dis = discharge_allowed and (soc_pct > min_soc)
+
+        return effective_ac, effective_dc, effective_dis
+
+    async def optimization_solution(self) -> OptimizationSolution:
+        """Provide the genetic solution as a general optimization solution.
+
+        The battery modes are controlled by the grid control triggers:
+        - ac_charge: charge from grid
+        - discharge_allowed: discharge to grid
+
+        The following battery modes are supported:
+        - SELF_CONSUMPTION:    ac_charge == 0 and discharge_allowed == 0
+        - GRID_SUPPORT_EXPORT: ac_charge == 0 and discharge_allowed == 1
+        - GRID_SUPPORT_IMPORT: ac_charge  > 0 and discharge_allowed == 0 or 1
+        """
+        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 ---
+        # Ensure we only use the minimum of results and commands if differing
+        periods = min(len(self.result.costs_per_hour), len(self.ac_charge) - start_day_hour)
+        time_index = pd.date_range(
+            start=start_datetime,
+            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
+        # - load_energy_wh: Load of all energy consumers in wh"
+        # - grid_energy_wh: Grid energy feed in (negative) or consumption (positive) in wh"
+        # - costs_amt: Costs in money amount"
+        # - revenue_amt: Revenue in money amount"
+        # - losses_energy_wh: Energy losses in wh"
+        # - <device-id>_<operation>_op_mode: Operation mode of the device (1.0 when active)."
+        # - <device-id>_<operation>_op_factor: Operation mode factor of the device."
+        # - <device-id>_soc_factor: State of charge of a battery/ electric vehicle device as factor of total capacity."
+        # - <device-id>_energy_wh: Energy consumption (positive) of a device in wh."
+
+        solution = pd.DataFrame(
+            {
+                "date_time": time_index,
+                # result starts at start_day_hour
+                "load_energy_wh": self.result.load_wh_per_hour[:n_points],
+                "grid_feedin_energy_wh": self.result.grid_feed_in_wh_per_hour[:n_points],
+                "grid_consumption_energy_wh": self.result.grid_consumption_wh_per_hour[:n_points],
+                "costs_amt": self.result.costs_per_hour[:n_points],
+                "revenue_amt": self.result.revenue_per_hour[:n_points],
+                "losses_energy_wh": self.result.losses_per_hour[:n_points],
+            },
+            index=time_index,
+        )
+
+        # Add battery data
+        battery_device_id = self._battery_device_id()
+        solution[f"{battery_device_id}_soc_factor"] = [
+            v / 100
+            for v in self.result.battery_soc_per_hour[: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])
+
+            # Raw genetic gene values — optimizer intent, stored verbatim
+            operation["genetic_ac_charge_factor"].append(ac_charge_hour)
+            operation["genetic_dc_charge_factor"].append(dc_charge_hour)
+            operation["genetic_discharge_allowed_factor"].append(float(discharge_allowed_hour))
+
+            # SOC-clamped effective values — what can physically be executed at
+            # this hour given the expected battery state of charge.
+            result_idx = hour_idx - start_day_hour
+            soc_h_pct = (
+                self.result.battery_soc_per_hour[result_idx]
+                if result_idx < len(self.result.battery_soc_per_hour)
+                else 0.0
+            )
+            eff_ac, eff_dc, eff_dis = self._soc_clamped_operation_factors(
+                ac_charge_hour, dc_charge_hour, discharge_allowed_hour, soc_h_pct
+            )
+            operation_mode, operation_mode_factor = self._battery_operation_from_solution(
+                eff_ac, eff_dc, eff_dis
+            )
+            for mode in BatteryOperationMode:
+                mode_key = f"{battery_device_id}_{mode.lower()}_op_mode"
+                factor_key = f"{battery_device_id}_{mode.lower()}_op_factor"
+                if mode_key not in operation.keys():
+                    operation[mode_key] = []
+                    operation[factor_key] = []
+                if mode == operation_mode:
+                    operation[mode_key].append(1.0)
+                    operation[factor_key].append(operation_mode_factor)
+                else:
+                    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
+        # ev_charge_hours_float start at hour 0 of start day
+        # result.ev_soc_per_hour start at start_datetime.hour
+        if self.ev_obj:
+            ev_device_id = self._ev_device_id()
+            if self.ev_charge_hours_float is None:
+                # Electric vehicle is full enough. No load times.
+                solution[f"{ev_device_id}_soc_factor"] = [
+                    self.ev_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:
+                    mode_key = f"{ev_device_id}_{mode.lower()}_op_mode"
+                    factor_key = f"{ev_device_id}_{mode.lower()}_op_factor"
+                    if mode == operation_mode:
+                        solution[mode_key] = [1.0] * n_points
+                        solution[factor_key] = [1.0] * n_points
+                    else:
+                        solution[mode_key] = [0.0] * n_points
+                        solution[factor_key] = [0.0] * n_points
+            else:
+                solution[f"{ev_device_id}_soc_factor"] = [
+                    v / 100 for v in self.result.ev_soc_per_hour[:n_points]
+                ]
+                operation = {
+                    "genetic_ev_charge_factor": [],
+                }
+                for hour_idx, rate in enumerate(self.ev_charge_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
+                    )
+                    for mode in BatteryOperationMode:
+                        mode_key = f"{ev_device_id}_{mode.lower()}_op_mode"
+                        factor_key = f"{ev_device_id}_{mode.lower()}_op_factor"
+                        if mode_key not in operation.keys():
+                            operation[mode_key] = []
+                            operation[factor_key] = []
+                        if mode == operation_mode:
+                            operation[mode_key].append(1.0)
+                            operation[factor_key].append(operation_mode_factor)
+                        else:
+                            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.config.devices.max_home_appliances and self.config.devices.max_home_appliances > 0:
+            # Use config and not self.washingstart as washingstart may be None (no start)
+            # even if configured to be started.
+            homeappliance_device_id = self._homeappliance_device_id()
+            # result starts at start_day_hour
+            solution[f"{homeappliance_device_id}_energy_wh"] = (
+                self.result.home_appliance_wh_per_hour[:n_points]
+            )
+            operation = {
+                f"{homeappliance_device_id}_run_op_mode": [],
+                f"{homeappliance_device_id}_run_op_factor": [],
+                f"{homeappliance_device_id}_off_op_mode": [],
+                f"{homeappliance_device_id}_off_op_factor": [],
+            }
+            for hour_idx, energy in enumerate(solution[f"{homeappliance_device_id}_energy_wh"]):
+                if energy > 0.0:
+                    operation[f"{homeappliance_device_id}_run_op_mode"].append(1.0)
+                    operation[f"{homeappliance_device_id}_run_op_factor"].append(1.0)
+                    operation[f"{homeappliance_device_id}_off_op_mode"].append(0.0)
+                    operation[f"{homeappliance_device_id}_off_op_factor"].append(0.0)
+                else:
+                    operation[f"{homeappliance_device_id}_run_op_mode"].append(0.0)
+                    operation[f"{homeappliance_device_id}_run_op_factor"].append(0.0)
+                    operation[f"{homeappliance_device_id}_off_op_mode"].append(1.0)
+                    operation[f"{homeappliance_device_id}_off_op_factor"].append(1.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]
+
+        # Fill prediction into dataframe with correct column names
+        # - pvforecast_ac_energy_wh_energy_wh: PV energy prediction (positive) in wh
+        # - elec_price_amt_kwh: Electricity price prediction in money per kwh
+        # - weather_temp_air_celcius: Temperature in °C"
+        # - loadforecast_energy_wh: Load energy prediction in wh
+        # - loadakkudoktor_std_energy_wh: Load energy standard deviation prediction in wh
+        # - loadakkudoktor_mean_energy_wh: Load mean energy prediction in wh
+        prediction = pd.DataFrame(
+            {
+                "date_time": time_index,
+            },
+            index=time_index,
+        )
+        pred = get_prediction()
+
+        for pred_key, pred_fill_method, pred_solution_key, pred_solution_factor in [
+            (
+                "pvforecast_ac_power",
+                "linear",
+                "pvforecast_ac_energy_wh",
+                power_to_energy_per_interval_factor,
+            ),
+            (
+                "pvforecast_dc_power",
+                "linear",
+                "pvforecast_dc_energy_wh",
+                power_to_energy_per_interval_factor,
+            ),
+            (
+                "elecprice_marketprice_wh",
+                "ffill",
+                "elec_price_amt_kwh",
+                1000.0,
+            ),
+            (
+                "feed_in_tariff_wh",
+                "ffill",
+                "feed_in_tariff_amt_kwh",
+                1000.0,
+            ),
+            (
+                "weather_temp_air",
+                "linear",
+                "weather_air_temp_celcius",
+                1.0,
+            ),
+            (
+                "loadforecast_power_w",
+                "linear",
+                "loadforecast_energy_wh",
+                power_to_energy_per_interval_factor,
+            ),
+            (
+                "loadakkudoktor_std_power_w",
+                "linear",
+                "loadakkudoktor_std_energy_wh",
+                power_to_energy_per_interval_factor,
+            ),
+            (
+                "loadakkudoktor_mean_power_w",
+                "linear",
+                "loadakkudoktor_mean_energy_wh",
+                power_to_energy_per_interval_factor,
+            ),
+        ]:
+            if pred_key in pred.record_keys:
+                array = await pred.key_to_array(
+                    key=pred_key,
+                    start_datetime=start_datetime,
+                    end_datetime=end_datetime,
+                    interval=to_duration(f"{interval_hours} hours"),
+                    fill_method=pred_fill_method,
+                )
+                # 'key_to_array()' creates None values array if no data records are available.
+                if array is not None and array.size > 0 and not np.any(pd.isna(array)):
+                    prediction[pred_solution_key] = (array * pred_solution_factor).tolist()
+
+        optimization_solution = OptimizationSolution(
+            id=f"optimization-genetic@{to_datetime(as_string=True)}",
+            generated_at=to_datetime(),
+            comment="Optimization solution derived from GeneticSolution.",
+            valid_from=start_datetime,
+            valid_until=start_datetime.add(hours=self.config.optimization.genetic0.horizon_hours),
+            total_losses_energy_wh=self.result.total_losses,
+            total_revenues_amt=self.result.total_revenue,
+            total_costs_amt=self.result.total_costs,
+            fitness_score={
+                self.result.total_costs,
+            },
+            prediction=PydanticDateTimeDataFrame.from_dataframe(prediction),
+            solution=PydanticDateTimeDataFrame.from_dataframe(solution),
+        )
+
+        return optimization_solution
+
+    def energy_management_plan(self) -> EnergyManagementPlan:
+        """Provide the genetic solution as an energy management plan."""
+        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(),
+            instructions=[],
+            comment="Energy management plan derived from GeneticSolution.",
+        )
+
+        # Add battery instructions (fill rate based control)
+        last_operation_mode: Optional[str] = None
+        last_operation_mode_factor: Optional[float] = None
+        resource_id = self._battery_device_id()
+        # 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
+            # Derive SOC-clamped effective factors so that FRBCInstruction
+            # operation_mode_factor reflects what can physically be executed,
+            # while the raw genetic gene values are preserved in the solution
+            # dataframe (genetic_*_factor columns).
+            result_idx = hour_idx - start_day_hour
+            soc_h_pct = (
+                self.result.battery_soc_per_hour[result_idx]
+                if result_idx < len(self.result.battery_soc_per_hour)
+                else 0.0
+            )
+            eff_ac, eff_dc, eff_dis = self._soc_clamped_operation_factors(
+                self.ac_charge[hour_idx],
+                self.dc_charge[hour_idx],
+                bool(self.discharge_allowed[hour_idx]),
+                soc_h_pct,
+            )
+            operation_mode, operation_mode_factor = self._battery_operation_from_solution(
+                eff_ac, eff_dc, eff_dis
+            )
+            if (
+                operation_mode == last_operation_mode
+                and operation_mode_factor == last_operation_mode_factor
+            ):
+                # Skip, we already added the instruction
+                continue
+            last_operation_mode = operation_mode
+            last_operation_mode_factor = operation_mode_factor
+            execution_time = start_datetime.add(hours=hour_idx - start_day_hour)
+            plan.add_instruction(
+                FRBCInstruction(
+                    resource_id=resource_id,
+                    execution_time=execution_time,
+                    actuator_id=resource_id,
+                    operation_mode_id=operation_mode,
+                    operation_mode_factor=operation_mode_factor,
+                )
+            )
+
+        # Add EV battery instructions (fill rate based control)
+        # ev_charge_hours_float start at hour 0 of start day
+        if self.ev_obj:
+            resource_id = self._ev_device_id()
+            if self.ev_charge_hours_float is None:
+                # Electric vehicle is full enough. No load times.
+                logger.debug("EV: {} - SoC >= min, no optimization", resource_id)
+                plan.add_instruction(
+                    FRBCInstruction(
+                        resource_id=resource_id,
+                        execution_time=start_datetime,
+                        actuator_id=resource_id,
+                        operation_mode_id=BatteryOperationMode.IDLE,
+                        operation_mode_factor=1.0,
+                    )
+                )
+            else:
+                last_operation_mode = None
+                last_operation_mode_factor = None
+                logger.debug(
+                    "EV: {} - {}", resource_id, self.ev_charge_hours_float[start_day_hour:]
+                )
+                for hour_idx, rate in enumerate(self.ev_charge_hours_float):
+                    if hour_idx < start_day_hour:
+                        continue
+                    operation_mode, operation_mode_factor = self._battery_operation_from_solution(
+                        rate, 0.0, False
+                    )
+                    if (
+                        operation_mode == last_operation_mode
+                        and operation_mode_factor == last_operation_mode_factor
+                    ):
+                        # Skip, we already added the instruction
+                        continue
+                    last_operation_mode = operation_mode
+                    last_operation_mode_factor = operation_mode_factor
+                    execution_time = start_datetime.add(hours=hour_idx - start_day_hour)
+                    plan.add_instruction(
+                        FRBCInstruction(
+                            resource_id=resource_id,
+                            execution_time=execution_time,
+                            actuator_id=resource_id,
+                            operation_mode_id=operation_mode,
+                            operation_mode_factor=operation_mode_factor,
+                        )
+                    )
+
+        # Add home appliance instructions (demand driven based control)
+        if self.config.devices.max_home_appliances and self.config.devices.max_home_appliances > 0:
+            # Use config and not self.washingstart as washingstart may be None (no start)
+            # even if configured to be started.
+            resource_id = self._homeappliance_device_id()
+            last_energy: Optional[float] = None
+            for hours, energy in enumerate(self.result.home_appliance_wh_per_hour):
+                # hours starts at start_datetime with 0
+                if energy is None:
+                    raise ValueError(
+                        f"Unexpected value {energy} in {self.result.home_appliance_wh_per_hour}"
+                    )
+                if last_energy is None or energy != last_energy:
+                    if energy > 0.0:
+                        operation_mode = ApplianceOperationMode.RUN  # type: ignore[assignment]
+                    else:
+                        operation_mode = ApplianceOperationMode.OFF  # type: ignore[assignment]
+                    operation_mode_factor = 1.0
+                    execution_time = start_datetime.add(hours=hours)
+                    plan.add_instruction(
+                        DDBCInstruction(
+                            resource_id=resource_id,
+                            execution_time=execution_time,
+                            actuator_id=resource_id,
+                            operation_mode_id=operation_mode,
+                            operation_mode_factor=operation_mode_factor,
+                        )
+                    )
+                    last_energy = energy
+
+        return plan

src/akkudoktoreos/optimization/optimization.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Optional
 
 from pydantic import Field, computed_field
 
@@ -8,92 +8,54 @@ from akkudoktoreos.core.pydantic import (
     PydanticBaseModel,
     PydanticDateTimeDataFrame,
 )
+from akkudoktoreos.optimization.genetic0.genetic0settings import Genetic0CommonSettings
+from akkudoktoreos.optimization.genetic.geneticsettings import GeneticCommonSettings
 from akkudoktoreos.utils.datetimeutil import DateTime
 
 
-class GeneticCommonSettings(SettingsBaseModel):
-    """General Genetic Optimization Algorithm Configuration."""
-
-    individuals: Optional[int] = Field(
-        default=300,
-        ge=10,
-        json_schema_extra={
-            "description": "Number of individuals (solutions) in the population [>= 10]. Defaults to 300.",
-            "examples": [300],
-        },
-    )
-
-    generations: Optional[int] = Field(
-        default=400,
-        ge=10,
-        json_schema_extra={
-            "description": "Number of generations to evolve [>= 10]. Defaults to 400.",
-            "examples": [400],
-        },
-    )
-
-    seed: Optional[int] = Field(
-        default=None,
-        ge=0,
-        json_schema_extra={
-            "description": "Random seed for reproducibility. None = random.",
-            "examples": [None, 42],
-        },
-    )
-
-    # --- Penalties (existing) -------------------------------------------------
-
-    penalties: dict[str, Union[float, int, str]] = Field(
-        default_factory=lambda: {
-            "ev_soc_miss": 10,
-            "ac_charge_break_even": 1.0,
-        },
-        json_schema_extra={
-            "description": "Penalty parameters used in fitness evaluation.",
-            "examples": [{"ev_soc_miss": 10}],
-        },
-    )
+def optimization_algorithms() -> list[str]:
+    """Valid optimization algorithms."""
+    # Return static built-in optimization algorithms.
+    return [
+        "GENETIC",
+        "GENETIC0",
+    ]
 
 
 class OptimizationCommonSettings(SettingsBaseModel):
     """General Optimization Configuration."""
 
-    horizon_hours: int = Field(
-        default=24,
-        ge=0,
-        json_schema_extra={
-            "description": "The general time window within which the energy optimization goal shall be achieved [h]. Defaults to 24 hours.",
-            "examples": [24],
-        },
-    )
-
-    interval: int = Field(
-        default=3600,
-        ge=15 * 60,
-        le=60 * 60,
-        json_schema_extra={
-            "description": "The optimization interval [sec]. Defaults to 3600 seconds (1 hour)",
-            "examples": [60 * 60, 15 * 60],
-        },
-    )
-
     algorithm: str = Field(
         default="GENETIC",
         json_schema_extra={
             "description": "The optimization algorithm. Defaults to GENETIC",
-            "examples": ["GENETIC"],
+            "examples": ["GENETIC", "GENETIC0"],
         },
     )
 
     genetic: GeneticCommonSettings = Field(
         default_factory=GeneticCommonSettings,
         json_schema_extra={
-            "description": "Genetic optimization algorithm configuration.",
+            "description": "GENETIC optimization algorithm configuration.",
+            "examples": [{"individuals": 400, "seed": None, "penalties": {"ev_soc_miss": 10}}],
+        },
+    )
+
+    genetic0: Genetic0CommonSettings = Field(
+        default_factory=Genetic0CommonSettings,
+        json_schema_extra={
+            "description": "GENETIC0 optimization algorithm configuration.",
             "examples": [{"individuals": 400, "seed": None, "penalties": {"ev_soc_miss": 10}}],
         },
     )
 
     # Computed fields
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def algorithms(self) -> list[str]:
+        """Available optimization algorithms."""
+        return optimization_algorithms()
+
     @computed_field  # type: ignore[prop-decorator]
     @property
     def keys(self) -> list[str]:
@@ -112,15 +74,6 @@ class OptimizationCommonSettings(SettingsBaseModel):
             key_list = df.columns.tolist()
         return sorted(set(key_list))
 
-    @computed_field  # type: ignore[prop-decorator]
-    @property
-    def horizon(self) -> int:
-        """Number of optimization steps."""
-        if self.interval is None or self.interval == 0 or self.horizon_hours is None:
-            return 0
-        num_steps = int(float(self.horizon_hours * 3600) / self.interval)
-        return num_steps
-
 
 class OptimizationSolution(PydanticBaseModel):
     """General Optimization Solution."""

src/akkudoktoreos/prediction/elecpricefixed.py

@@ -80,7 +80,7 @@ class ElecPriceFixed(ElecPriceProvider):
             raise ValueError(error_msg)
 
         start_datetime = self.ems_start_datetime
-        interval_seconds = self.config.optimization.interval
+        interval_seconds = 900  # Usual smallest time interval (15 min) used in electricty prices
         total_hours = self.config.prediction.hours
         interval = to_duration(interval_seconds)
 

src/akkudoktoreos/server/eos.py

@@ -48,9 +48,10 @@ from akkudoktoreos.core.pydantic import (
 )
 from akkudoktoreos.core.version import __version__
 from akkudoktoreos.devices.devices import ResourceKey
-from akkudoktoreos.optimization.genetic.geneticparams import (
-    GeneticOptimizationParameters,
+from akkudoktoreos.optimization.genetic0.genetic0params import (
+    Genetic0OptimizationParameters,
 )
+from akkudoktoreos.optimization.genetic0.genetic0solution import Genetic0Solution
 from akkudoktoreos.optimization.genetic.geneticsolution import GeneticSolution
 from akkudoktoreos.optimization.optimization import OptimizationSolution
 from akkudoktoreos.prediction.elecprice import ElecPriceCommonSettings
@@ -1161,6 +1162,38 @@ def fastapi_energy_management_optimization_solution_get() -> OptimizationSolutio
     return solution
 
 
+@app.get("/v1/energy-management/optimization/solution/{algorithm}", tags=["energy-management"])
+async def fastapi_energy_management_optimization_solution_algorithm_get(
+    algorithm: str,
+) -> Union[GeneticSolution, Genetic0Solution]:
+    """Get the latest algorithm specific solution of the optimization.
+
+    Args:
+        algorithm: Optimization algorithm
+    """
+    algorithm = algorithm.upper()
+    if algorithm not in get_config().optimization.algorithms:
+        raise HTTPException(
+            status_code=404, detail=f"Optimization algorithm '{algorithm}' unknown."
+        )
+    if algorithm == "GENETIC":
+        genetic_solution = get_ems().genetic_solution()
+        if genetic_solution is None:
+            raise HTTPException(
+                status_code=404, detail=f"'{algorithm}' optimization solution not available."
+            )
+        return genetic_solution
+    if algorithm == "GENETIC0":
+        genetic0_solution = get_ems().genetic0_solution()
+        if genetic0_solution is None:
+            raise HTTPException(
+                status_code=404, detail=f"'{algorithm}' optimization solution not available."
+            )
+        return genetic0_solution
+    # Should never happen
+    raise HTTPException(status_code=500, detail=f"'{algorithm}' validated but not handled.")
+
+
 @app.get("/v1/energy-management/plan", tags=["energy-management"])
 def fastapi_energy_management_plan_get() -> EnergyManagementPlan:
     """Get the latest energy management plan."""
@@ -1458,20 +1491,23 @@ async def fastapi_pvforecast() -> ForecastResponse:
 
 @app.post("/optimize", tags=["optimize"])
 async def fastapi_optimize(
-    parameters: GeneticOptimizationParameters,
+    parameters: Genetic0OptimizationParameters,
     start_hour: Annotated[
         Optional[int], Query(description="Defaults to current hour of the day.")
     ] = None,
     ngen: Annotated[
         Optional[int], Query(description="Number of indivuals to generate for genetic algorithm.")
     ] = None,
-) -> GeneticSolution:
+) -> Genetic0Solution:
     """Deprecated: Optimize.
 
     Endpoint to handle optimization.
 
+    Uses the `classic` GENETIC0 optimisation algorithm (__NO__ 15-minutes slots).
+
     Note:
         Use automatic optimization instead.
+        "v1/energy-management/optimization/solution/GENETIC0"
     """
     if start_hour is None:
         start_datetime = None
@@ -1483,13 +1519,14 @@ async def fastapi_optimize(
         await get_ems().run(
             start_datetime=start_datetime,
             mode=EnergyManagementMode.OPTIMIZATION,
-            genetic_parameters=parameters,
-            genetic_individuals=ngen,
+            algorithm="GENETIC0",
+            genetic0_parameters=parameters,
+            genetic0_generations=ngen,
         )
     except Exception as e:
         raise HTTPException(status_code=400, detail=f"Optimize error: {e}.")
 
-    solution = get_ems().genetic_solution()
+    solution = get_ems().genetic0_solution()
     if solution is None:
         raise HTTPException(status_code=400, detail="Optimize error: no solution stored by run.")