Mirrors/EOS
1
0
Fork 0
mirror of https://github.com/Akkudoktor-EOS/EOS.git synced 2025-11-09 06:56:29 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

chore: eosdash improve plan display (#739)
Some checks are pending
docker-build / platform-excludes (push) Waiting to run
Details
docker-build / build (push) Blocked by required conditions
Details
docker-build / merge (push) Blocked by required conditions
Details
pre-commit / pre-commit (push) Waiting to run
Details
Run Pytest on Pull Request / test (push) Waiting to run
Details

Browse Source 
* chore: improve plan solution display

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

Add total results.

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

* fix: genetic battery and home appliance device simulation

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

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

Improve simulation speed.

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

---------

Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com>
This commit is contained in:
Bobby Noelte
2025-11-08 15:42:18 +01:00
committed by GitHub
parent c50cdd95cb
commit 3599088dce
18 changed files with 1769 additions and 1345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
docs/_generated/config.md
View File

@@ -195,7 +195,7 @@ Properties:
"levelized_cost_of_storage_kwh": 0.0,
"max_charge_power_w": 5000,
"min_charge_power_w": 50,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 0,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",
@@ -222,7 +222,7 @@ Properties:
"levelized_cost_of_storage_kwh": 0.0,
"max_charge_power_w": 5000,
"min_charge_power_w": 50,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 0,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",
@@ -264,7 +264,7 @@ Properties:
"levelized_cost_of_storage_kwh": 0.0,
"max_charge_power_w": 5000,
"min_charge_power_w": 50,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 0,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",
@@ -291,7 +291,7 @@ Properties:
"levelized_cost_of_storage_kwh": 0.0,
"max_charge_power_w": 5000,
"min_charge_power_w": 50,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 0,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",
@@ -601,7 +601,7 @@ Properties:
| levelized_cost_of_storage_kwh | `float` | `rw` | `0.0` | Levelized cost of storage (LCOS), the average lifetime cost of delivering one kWh [€/kWh]. |
| max_charge_power_w | `Optional[float]` | `rw` | `5000` | Maximum charging power [W]. |
| min_charge_power_w | `Optional[float]` | `rw` | `50` | Minimum charging power [W]. |
| charge_rates | `Optional[list[float]]` | `rw` | `None` | Charge rates as factor of maximum charging power [0.00 ... 1.00]. None denotes all charge rates are available. |
| charge_rates | `Optional[numpydantic.vendor.npbase_meta_classes.NDArray]` | `rw` | `[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]` | Charge rates as factor of maximum charging power [0.00 ... 1.00]. None triggers fallback to default charge-rates. |
| min_soc_percentage | `int` | `rw` | `0` | Minimum state of charge (SOC) as percentage of capacity [%]. This is the target SoC for charging |
| max_soc_percentage | `int` | `rw` | `100` | Maximum state of charge (SOC) as percentage of capacity [%]. |
| measurement_key_soc_factor | `str` | `ro` | `N/A` | Measurement key for the battery state of charge (SoC) as factor of total capacity [0.0 ... 1.0]. |
@@ -630,13 +630,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": [
0.0,
0.25,
0.5,
0.75,
1.0
],
"charge_rates": "[0. 0.25 0.5 0.75 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100
},
@@ -648,7 +642,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100
},
@@ -660,7 +654,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100
},
@@ -672,7 +666,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100
}
@@ -697,13 +691,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": [
0.0,
0.25,
0.5,
0.75,
1.0
],
"charge_rates": "[0. 0.25 0.5 0.75 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",
@@ -727,7 +715,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "ev1-soc-factor",
@@ -751,7 +739,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "inverter1-soc-factor",
@@ -775,7 +763,7 @@ Battery SoC, power. |
"levelized_cost_of_storage_kwh": 0.12,
"max_charge_power_w": 5000.0,
"min_charge_power_w": 50.0,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 10,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "dishwasher-soc-factor",
@@ -1821,7 +1809,7 @@ Validators:
"levelized_cost_of_storage_kwh": 0.0,
"max_charge_power_w": 5000,
"min_charge_power_w": 50,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 0,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",
@@ -1848,7 +1836,7 @@ Validators:
"levelized_cost_of_storage_kwh": 0.0,
"max_charge_power_w": 5000,
"min_charge_power_w": 50,
"charge_rates": null,
"charge_rates": "[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]",
"min_soc_percentage": 0,
"max_soc_percentage": 100,
"measurement_key_soc_factor": "battery1-soc-factor",

39
openapi.json
View File

@@ -2122,7 +2122,7 @@
}
],
"title": "Charge Rates",
"description": "Charge rates as factor of maximum charging power [0.00 ... 1.00]. None denotes all charge rates are available.",
"description": "Charge rates as factor of maximum charging power [0.00 ... 1.00]. None triggers fallback to default charge-rates.",
"examples": [
[
0.0,
@@ -2263,7 +2263,7 @@
}
],
"title": "Charge Rates",
"description": "Charge rates as factor of maximum charging power [0.00 ... 1.00]. None denotes all charge rates are available.",
"description": "Charge rates as factor of maximum charging power [0.00 ... 1.00]. None triggers fallback to default charge-rates.",
"examples": [
[
0.0,
@@ -5921,6 +5921,15 @@
"title": "Total Costs Amt",
"description": "The total costs [money amount]."
},
"fitness_score": {
"items": {
"type": "number"
},
"type": "array",
"uniqueItems": true,
"title": "Fitness Score",
"description": "The fitness score as a set of fitness values."
},
"prediction": {
"$ref": "#/components/schemas/PydanticDateTimeDataFrame",
"description": "Datetime data frame with time series prediction data per optimization interval:- pv_energy_wh: PV energy prediction (positive) in wh- elec_price_amt_kwh: Electricity price prediction in money per kwh- feed_in_tariff_amt_kwh: Feed in tariff prediction in money per kwh- weather_temp_air_celcius: Temperature in \u00b0C- loadforecast_energy_wh: Load mean 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"
@@ -5937,6 +5946,7 @@
"total_losses_energy_wh",
"total_revenues_amt",
"total_costs_amt",
"fitness_score",
"prediction",
"solution"
],
@@ -7585,6 +7595,31 @@
"title": "Max Soc Percentage",
"description": "An integer representing the maximum state of charge (SOC) of the battery in percentage.",
"default": 100
},
"charge_rates": {
"anyOf": [
{
"items": {
"type": "number"
},
"type": "array"
},
{
"type": "null"
}
],
"title": "Charge Rates",
"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
],
null
]
}
},
"additionalProperties": false,

52
src/akkudoktoreos/devices/devices.py
View File

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

223
src/akkudoktoreos/devices/genetic/battery.py
View File

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

35
src/akkudoktoreos/devices/genetic/homeappliance.py
View File

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

357
src/akkudoktoreos/optimization/genetic/genetic.py
View File

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

10
src/akkudoktoreos/optimization/genetic/geneticdevices.py
View File

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

4
src/akkudoktoreos/optimization/genetic/geneticparams.py
View File

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

113
src/akkudoktoreos/optimization/genetic/geneticsolution.py
View File

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

2
src/akkudoktoreos/optimization/optimization.py
View File

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

130
src/akkudoktoreos/server/dash/plan.py
View File

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

98
tests/test_battery.py
View File

@@ -6,20 +6,53 @@ from akkudoktoreos.devices.genetic.battery import Battery, SolarPanelBatteryPara
@pytest.fixture
def setup_pv_battery():
device_id="battery1"
capacity_wh=10000
initial_soc_percentage=50
charging_efficiency=0.88
discharging_efficiency=0.88
min_soc_percentage=20
max_soc_percentage=80
max_charge_power_w=8000
hours=24
params = SolarPanelBatteryParameters(
device_id="battery1",
capacity_wh=10000,
initial_soc_percentage=50,
min_soc_percentage=20,
max_soc_percentage=80,
max_charge_power_w=8000,
hours=24,
device_id=device_id,
capacity_wh=capacity_wh,
initial_soc_percentage=initial_soc_percentage,
charging_efficiency=charging_efficiency,
discharging_efficiency=discharging_efficiency,
min_soc_percentage=min_soc_percentage,
max_soc_percentage=max_soc_percentage,
max_charge_power_w=max_charge_power_w,
hours=hours,
)
battery = Battery(
params,
prediction_hours=48,
)
battery.reset()
assert battery.parameters.device_id==device_id
assert battery.capacity_wh==capacity_wh
assert battery.initial_soc_percentage==initial_soc_percentage
assert battery.charging_efficiency==charging_efficiency
assert battery.initial_soc_percentage==initial_soc_percentage
assert battery.discharging_efficiency==discharging_efficiency
assert battery.max_soc_percentage==max_soc_percentage
assert battery.max_charge_power_w==max_charge_power_w
assert battery.soc_wh==float((initial_soc_percentage / 100) * capacity_wh)
assert battery.min_soc_wh==float((min_soc_percentage / 100) * capacity_wh)
assert battery.max_soc_wh==float((max_soc_percentage / 100) * capacity_wh)
assert np.all(battery.charge_array == 0)
assert np.all(battery.discharge_array == 0)
# Init for test
battery.charge_array = np.full(battery.prediction_hours, 1)
battery.discharge_array = np.full(battery.prediction_hours, 1)
assert np.all(battery.charge_array == 1)
assert np.all(battery.discharge_array == 1)
return battery
@@ -164,17 +197,47 @@ def test_charge_energy_not_allowed_hour(setup_pv_battery):
), "SOC should remain unchanged"
def test_charge_energy_relative_power(setup_pv_battery):
@pytest.mark.parametrize(
"wh, charge_factor, expected_raises",
[
(None, 0.5, False), # Expected to work normally (if capacity allows)
(None, 1.0, False), # Often still OK, depending on fixture capacity
(None, 2.0, False), # Exceeds max charge → always ValueError
(1000, 0, False),
(1000, 1.0, True),
],
)
def test_charge_energy_with_charge_factor(setup_pv_battery, wh, charge_factor, expected_raises):
battery = setup_pv_battery
hour = 4
relative_power = 0.5 # 50% of max charge power
charged_wh, losses_wh = battery.charge_energy(wh=None, hour=4, relative_power=relative_power)
if wh is not None and charge_factor == 0.0: # mode 1
raw_request_wh = wh
else:
raw_request_wh = battery.max_charge_power_w * charge_factor
raw_capacity_wh = max(battery.max_soc_wh - battery.soc_wh, 0.0)
assert charged_wh > 0, "Charging should occur with relative power"
assert losses_wh >= 0, "Losses should not be negative"
assert charged_wh <= battery.max_charge_power_w * relative_power, (
"Charging should respect relative power limit"
if expected_raises:
# Should raise
with pytest.raises(ValueError):
battery.charge_energy(
wh=wh,
hour=hour,
charge_factor=charge_factor,
)
return
# Should NOT raise
charged_wh, losses_wh = battery.charge_energy(
wh=wh,
hour=hour,
charge_factor=charge_factor,
)
# Expectations
assert charged_wh > 0, "Charging should occur with charge factor"
assert losses_wh >= 0, "Losses must not be negative"
assert charged_wh <= raw_request_wh, "Charging must not exceed request"
assert battery.soc_wh > 0, "SOC should increase after charging"
@@ -198,6 +261,13 @@ def setup_car_battery():
prediction_hours=48,
)
battery.reset()
# Init for test
battery.charge_array = np.full(battery.prediction_hours, 1)
battery.discharge_array = np.full(battery.prediction_hours, 1)
assert np.all(battery.charge_array == 1)
assert np.all(battery.discharge_array == 1)
return battery

39
tests/test_config.py
View File

@@ -3,11 +3,24 @@ from pathlib import Path
from typing import Any, Optional, Union
from unittest.mock import patch
import numpy as np
import pytest
from loguru import logger
from pydantic import IPvAnyAddress, ValidationError
from akkudoktoreos.config.config import ConfigEOS, GeneralSettings
from akkudoktoreos.devices.devices import BATTERY_DEFAULT_CHARGE_RATES
def assert_values_equal(actual, expected):
"""Compare values, handling lists and numpy arrays."""
if isinstance(actual, (list, np.ndarray)) or isinstance(expected, (list, np.ndarray)):
# Convert both to numpy arrays for comparison
actual_arr = np.array(actual)
expected_arr = np.array(expected)
assert np.array_equal(actual_arr, expected_arr), f"Expected {expected_arr}, but got {actual_arr}"
else:
assert actual == expected, f"Expected {expected}, but got {actual}"
# overwrite config_mixin fixture from conftest
@@ -352,7 +365,7 @@ def test_config_common_settings_timezone_none_when_coordinates_missing():
[
(
"devices.electric_vehicles[0].charge_rates",
[0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
BATTERY_DEFAULT_CHARGE_RATES,
)
],
ValueError,
@@ -364,10 +377,10 @@ def test_config_common_settings_timezone_none_when_coordinates_missing():
[
(
"devices.electric_vehicles[0].charge_rates",
[0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
BATTERY_DEFAULT_CHARGE_RATES,
)
],
TypeError,
KeyError,
),
# Invalid index (no number)
(
@@ -376,10 +389,10 @@ def test_config_common_settings_timezone_none_when_coordinates_missing():
[
(
"devices.electric_vehicles[0].charge_rates",
[0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
BATTERY_DEFAULT_CHARGE_RATES,
)
],
IndexError,
KeyError,
),
# Unset value (set None)
(
@@ -388,7 +401,7 @@ def test_config_common_settings_timezone_none_when_coordinates_missing():
[
(
"devices.electric_vehicles[0].charge_rates",
None,
BATTERY_DEFAULT_CHARGE_RATES,
)
],
None,
@@ -400,17 +413,13 @@ def test_set_nested_key(path, value, expected, exception, config_eos):
config_eos.set_nested_value(path, value)
for expected_path, expected_value in expected:
actual_value = eval(f"config_eos.{expected_path}")
assert actual_value == expected_value, (
f"Expected {expected_value} at {expected_path}, but got {actual_value}"
)
assert_values_equal(actual_value, expected_value)
else:
try:
config_eos.set_nested_value(path, value)
for expected_path, expected_value in expected:
actual_value = eval(f"config_eos.{expected_path}")
assert actual_value == expected_value, (
f"Expected {expected_value} at {expected_path}, but got {actual_value}"
)
assert_values_equal(actual_value, expected_value)
pytest.fail(
f"Expected exception {exception} but none was raised. Set '{expected_path}' to '{actual_value}'"
)
@@ -508,19 +517,19 @@ def test_merge_settings_partial(config_eos):
config_eos.merge_settings_from_dict(partial_settings)
assert config_eos.devices.max_electric_vehicles == 1
assert len(config_eos.devices.electric_vehicles) == 1
assert config_eos.devices.electric_vehicles[0].charge_rates == [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]
assert_values_equal(config_eos.devices.electric_vehicles[0].charge_rates, [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0])
# Assure re-apply generates the same config
config_eos.merge_settings_from_dict(partial_settings)
assert config_eos.devices.max_electric_vehicles == 1
assert len(config_eos.devices.electric_vehicles) == 1
assert config_eos.devices.electric_vehicles[0].charge_rates == [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]
assert_values_equal(config_eos.devices.electric_vehicles[0].charge_rates, [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0])
# Assure update keeps same values
config_eos.update()
assert config_eos.devices.max_electric_vehicles == 1
assert len(config_eos.devices.electric_vehicles) == 1
assert config_eos.devices.electric_vehicles[0].charge_rates == [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]
assert_values_equal(config_eos.devices.electric_vehicles[0].charge_rates, [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0])
def test_merge_settings_empty(config_eos):

40
tests/test_geneticsimulation.py
View File

@@ -65,7 +65,6 @@ def genetic_simulation(config_eos) -> GeneticSimulation:
optimization_hours = config_eos.optimization.horizon_hours,
prediction_hours = config_eos.prediction.hours,
)
home_appliance.set_starting_time(2)
# Example initialization of electric car battery
eauto = Battery(
@@ -250,6 +249,17 @@ def genetic_simulation(config_eos) -> GeneticSimulation:
home_appliance=home_appliance,
)
# Init for test
assert simulation.ac_charge_hours is not None
assert simulation.dc_charge_hours is not None
assert simulation.bat_discharge_hours is not None
assert simulation.ev_charge_hours is not None
simulation.ac_charge_hours[start_hour] = 1.0
simulation.dc_charge_hours[start_hour] = 1.0
simulation.bat_discharge_hours[start_hour] = 1.0
simulation.ev_charge_hours[start_hour] = 1.0
simulation.home_appliance_start_hour = 2
return simulation
@@ -321,34 +331,34 @@ def test_simulation(genetic_simulation):
# Verify that the value at index 0 is 'None'
# Check that 'Netzeinspeisung_Wh_pro_Stunde' and 'Netzbezug_Wh_pro_Stunde' are consistent
assert result["Netzbezug_Wh_pro_Stunde"][1] == 0, (
"The value at index 1 of 'Netzbezug_Wh_pro_Stunde' should be 0."
assert result["Netzbezug_Wh_pro_Stunde"][1] == 1527.13, (
"The value at index 1 of 'Netzbezug_Wh_pro_Stunde' should be 1527.13."
)
# Verify the total balance
assert abs(result["Gesamtbilanz_Euro"] - 1.958185274567674) < 1e-5, (
"Total balance should be 1.958185274567674."
assert abs(result["Gesamtbilanz_Euro"] - 6.612835813556755) < 1e-5, (
"Total balance should be 6.612835813556755."
)
# Check total revenue and total costs
assert abs(result["Gesamteinnahmen_Euro"] - 1.168863124510214) < 1e-5, (
"Total revenue should be 1.168863124510214."
assert abs(result["Gesamteinnahmen_Euro"] - 1.964301131937134) < 1e-5, (
"Total revenue should be 1.964301131937134."
)
assert abs(result["Gesamtkosten_Euro"] - 3.127048399077888) < 1e-5, (
"Total costs should be 3.127048399077888 ."
assert abs(result["Gesamtkosten_Euro"] - 8.577136945493889) < 1e-5, (
"Total costs should be 8.577136945493889 ."
)
# Check the losses
assert abs(result["Gesamt_Verluste"] - 2871.5330639359036) < 1e-5, (
"Total losses should be 2871.5330639359036 ."
assert abs(result["Gesamt_Verluste"] - 1620.0) < 1e-5, (
"Total losses should be 1620.0 ."
)
# Check the values in 'akku_soc_pro_stunde'
assert result["akku_soc_pro_stunde"][-1] == 42.151590909090906, (
"The value at index -1 of 'akku_soc_pro_stunde' should be 42.151590909090906."
assert result["akku_soc_pro_stunde"][-1] == 98.0, (
"The value at index -1 of 'akku_soc_pro_stunde' should be 98.0."
)
assert result["akku_soc_pro_stunde"][1] == 60.08659090909091, (
"The value at index 1 of 'akku_soc_pro_stunde' should be 60.08659090909091."
assert result["akku_soc_pro_stunde"][1] == 98.0, (
"The value at index 1 of 'akku_soc_pro_stunde' should be 98.0."
)
# Check home appliances

66
tests/test_geneticsimulation2.py
View File

@@ -65,7 +65,6 @@ def genetic_simulation_2(config_eos) -> GeneticSimulation:
optimization_hours = config_eos.optimization.horizon_hours,
prediction_hours = config_eos.prediction.hours,
)
home_appliance.set_starting_time(2)
# Example initialization of electric car battery
eauto = Battery(
@@ -158,10 +157,11 @@ def genetic_simulation_2(config_eos) -> GeneticSimulation:
ac = np.full(config_eos.prediction.hours, 0.0)
ac[20] = 1
simulation.set_akku_ac_charge_hours(ac)
simulation.ac_charge_hours = ac
dc = np.full(config_eos.prediction.hours, 0.0)
dc[11] = 1
simulation.set_akku_dc_charge_hours(dc)
simulation.dc_charge_hours = dc
simulation.home_appliance_start_hour = 2
return simulation
@@ -242,26 +242,26 @@ def test_simulation(genetic_simulation_2):
)
# Verfify DC and AC Charge Bins
assert abs(result["akku_soc_pro_stunde"][2] - 44.70681818181818) < 1e-5, (
"'akku_soc_pro_stunde[2]' should be 44.70681818181818."
assert abs(result["akku_soc_pro_stunde"][2] - 80.0) < 1e-5, (
"'akku_soc_pro_stunde[2]' should be 80.0."
)
assert abs(result["akku_soc_pro_stunde"][10] - 10.0) < 1e-5, (
"'akku_soc_pro_stunde[10]' should be 10."
assert abs(result["akku_soc_pro_stunde"][10] - 80.0) < 1e-5, (
"'akku_soc_pro_stunde[10]' should be 80."
)
assert abs(result["Netzeinspeisung_Wh_pro_Stunde"][10] - 3946.93) < 1e-3, (
"'Netzeinspeisung_Wh_pro_Stunde[11]' should be 3946.93."
)
assert abs(result["Netzeinspeisung_Wh_pro_Stunde"][11] - 0.0) < 1e-3, (
"'Netzeinspeisung_Wh_pro_Stunde[11]' should be 0.0."
assert abs(result["Netzeinspeisung_Wh_pro_Stunde"][11] - 2799.7263636361786) < 1e-3, (
"'Netzeinspeisung_Wh_pro_Stunde[11]' should be 2799.7263636361786."
)
assert abs(result["akku_soc_pro_stunde"][20] - 10) < 1e-5, (
"'akku_soc_pro_stunde[20]' should be 10."
assert abs(result["akku_soc_pro_stunde"][20] - 100) < 1e-5, (
"'akku_soc_pro_stunde[20]' should be 100."
)
assert abs(result["Last_Wh_pro_Stunde"][20] - 6050.98) < 1e-3, (
"'Last_Wh_pro_Stunde[20]' should be 6050.98."
assert abs(result["Last_Wh_pro_Stunde"][20] - 1050.98) < 1e-3, (
"'Last_Wh_pro_Stunde[20]' should be 1050.98."
)
print("All tests passed successfully.")
@@ -280,46 +280,6 @@ def test_set_parameters(genetic_simulation_2):
)
def test_set_akku_discharge_hours(genetic_simulation_2):
"""Test the set_akku_discharge_hours method of EnergyManagement."""
simulation = genetic_simulation_2
discharge_hours = np.full(simulation.prediction_hours, 1.0)
simulation.set_akku_discharge_hours(discharge_hours)
assert np.array_equal(simulation.battery.discharge_array, discharge_hours), (
"Discharge hours should be set correctly"
)
def test_set_akku_ac_charge_hours(genetic_simulation_2):
"""Test the set_akku_ac_charge_hours method of EnergyManagement."""
simulation = genetic_simulation_2
ac_charge_hours = np.full(simulation.prediction_hours, 1.0)
simulation.set_akku_ac_charge_hours(ac_charge_hours)
assert np.array_equal(simulation.ac_charge_hours, ac_charge_hours), (
"AC charge hours should be set correctly"
)
def test_set_akku_dc_charge_hours(genetic_simulation_2):
"""Test the set_akku_dc_charge_hours method of EnergyManagement."""
simulation = genetic_simulation_2
dc_charge_hours = np.full(simulation.prediction_hours, 1.0)
simulation.set_akku_dc_charge_hours(dc_charge_hours)
assert np.array_equal(simulation.dc_charge_hours, dc_charge_hours), (
"DC charge hours should be set correctly"
)
def test_set_ev_charge_hours(genetic_simulation_2):
"""Test the set_ev_charge_hours method of EnergyManagement."""
simulation = genetic_simulation_2
ev_charge_hours = np.full(simulation.prediction_hours, 1.0)
simulation.set_ev_charge_hours(ev_charge_hours)
assert np.array_equal(simulation.ev_charge_hours, ev_charge_hours), (
"EV charge hours should be set correctly"
)
def test_reset(genetic_simulation_2):
"""Test the reset method of EnergyManagement."""
simulation = genetic_simulation_2

232
tests/testdata/optimize_result_1.json vendored
View File

@@ -2,14 +2,14 @@
"ac_charge": [
0.0,
0.0,
0.875,
0.0,
0.875,
0.0,
0.625,
0.75,
0.0,
0.375,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
@@ -50,16 +50,16 @@
0.0
],
"dc_charge": [
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.0,
1.0,
1.0,
@@ -103,9 +103,9 @@
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
@@ -476,7 +476,6 @@
0.0
],
"akku_soc_pro_stunde": [
80.0,
80.0,
79.91107093663912,
79.91107093663912,
@@ -504,7 +503,7 @@
76.64231728537023,
77.71252293120729,
81.22045681594867,
87.86517878095492,
81.61517878095492,
100.0,
100.0,
100.0,
@@ -513,6 +512,7 @@
100.0,
100.0,
100.0,
96.84060778236915,
96.84060778236915
],
"Electricity_price": [
@@ -558,108 +558,108 @@
},
"eauto_obj": {
"device_id": "ev1",
"hours": 48,
"charge_array": [
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"discharge_array": [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"discharging_efficiency": 1.0,
"hours": 48,
"capacity_wh": 60000,
"charging_efficiency": 0.95,
"max_charge_power_w": 11040,

818
tests/testdata/optimize_result_2.json vendored
View File

File diff suppressed because it is too large Load Diff

812
tests/testdata/optimize_result_2_full.json vendored
View File

@@ -3,13 +3,6 @@
0.0,
0.0,
0.0,
1.0,
1.0,
0.75,
0.0,
0.0,
0.0,
0.5,
0.0,
0.0,
0.0,
@@ -18,7 +11,14 @@
0.0,
0.0,
0.0,
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
@@ -50,16 +50,16 @@
0.0
],
"dc_charge": [
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.0,
1.0,
1.0,
@@ -101,7 +101,9 @@
],
"discharge_allowed": [
0,
1,
0,
0,
0,
0,
0,
0,
@@ -109,36 +111,12 @@
0,
0,
1,
0,
1,
1,
1,
0,
0,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
1,
0,
0,
1,
@@ -147,69 +125,91 @@
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
],
"eautocharge_hours_float": [
0.5,
1.0,
0.625,
0.0,
1.0,
0.375,
0.375,
0.875,
0.0,
0.0,
0.375,
0.625,
0.375,
0.875,
1.0,
0.875,
0.375,
0.75,
1.0,
0.625,
0.625,
0.75,
0.375,
1.0,
0.375,
0.375,
1.0,
1.0,
0.0,
0.0,
0.375,
0.625,
0.5,
0.5,
0.375,
1.0,
0.875,
0.625,
0.625,
0.0,
0.0,
0.75,
0.375,
0.75,
0.0,
0.5,
0.375,
0.0,
0.0,
0.5,
0.5,
1.0,
0.625,
0.5,
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.375,
0.0,
0.0,
0.0,
0.375,
0.0,
0.0,
0.625,
0.0,
0.0,
0.0,
0.0,
0.0
0.875,
1.0
],
"result": {
"Last_Wh_pro_Stunde": [
4986.07,
1063.91,
1320.56,
8876.029999999999,
8907.67,
7731.82,
6460.22,
6347.78,
3629.12,
7618.91,
5253.5599999999995,
12809.029999999999,
14151.67,
10353.82,
5149.22,
8969.78,
2177.92,
1178.71,
1050.98,
988.56,
@@ -226,14 +226,14 @@
1141.98,
1056.97,
992.46,
5088.99,
1155.99,
827.01,
1257.98,
1232.67,
4804.26,
871.26,
860.88,
1158.03,
7777.72,
1222.72,
1221.04,
949.99,
987.01,
@@ -243,42 +243,42 @@
"EAuto_SoC_pro_Stunde": [
5.0,
11.555,
11.555,
11.555,
20.294999999999998,
22.48,
29.035,
39.96,
48.699999999999996,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
57.440000000000005,
63.995000000000005,
63.995000000000005,
63.995000000000005,
63.995000000000005,
70.55,
70.55,
70.55,
81.475,
81.475,
81.475,
81.475,
81.475
44.330000000000005,
61.809999999999995,
77.105,
83.66,
96.77,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518,
98.518
],
"Einnahmen_Euro_pro_Stunde": [
0.0,
@@ -320,10 +320,10 @@
0.0,
0.0
],
"Gesamt_Verluste": 7755.845910804702,
"Gesamtbilanz_Euro": 4.690157296412734,
"Gesamt_Verluste": 7633.823819992856,
"Gesamtbilanz_Euro": 7.648978330847156,
"Gesamteinnahmen_Euro": 0.0,
"Gesamtkosten_Euro": 4.690157296412734,
"Gesamtkosten_Euro": 7.648978330847156,
"Home_appliance_wh_per_hour": [
0.0,
0.0,
@@ -366,83 +366,83 @@
],
"Kosten_Euro_pro_Stunde": [
0.0,
0.48125599199999997,
0.8679294259999999,
2.1885351859999997,
1.4948178300000001,
0.9688838999999999,
0.0,
0.0,
1.4495244859999996,
0.53097063,
0.44343509999999997,
0.0,
0.0,
0.8107800974767518,
0.0,
0.0,
0.291163892,
1.3510631400000002,
0.07038454500000005,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.182970359,
0.0,
0.0,
0.26411047,
0.0,
0.0,
0.0,
0.0,
0.0,
0.12044799000000005,
0.08545095,
0.007989913613567745,
0.0,
0.002459704740224363,
0.0,
0.0,
0.05016012000000004,
0.0076430797975209205,
0.0,
0.31687880399999996,
0.012219458233588571,
0.0,
0.0,
0.0,
0.16722497978466921,
0.16484566
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"Netzbezug_Wh_pro_Stunde": [
0.0,
2175.66,
4146.82,
11647.339999999998,
8132.85,
4834.75,
0.0,
0.0,
7714.339999999998,
2888.8500000000004,
2212.75,
0.0,
0.0,
2705.305630553059,
0.0,
0.0,
980.68,
5951.820000000001,
234.85000000000014,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
556.31,
0.0,
0.0,
799.85,
0.0,
0.0,
0.0,
0.0,
0.0,
395.9500000000001,
351.65,
35.04348076126204,
0.0,
11.752053226107805,
0.0,
0.0,
250.30000000000018,
34.77288351920346,
0.0,
1057.3199999999997,
55.24167375040041,
0.0,
0.0,
0.0,
572.4922279516235,
592.97
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"Netzeinspeisung_Wh_pro_Stunde": [
0.0,
@@ -486,83 +486,83 @@
],
"Verluste_Pro_Stunde": [
760.062272727273,
2.817272727272737,
29.157272727272726,
276.0,
276.0,
345.0,
615.5918181818183,
730.0663636363638,
373.0373243336329,
945.0,
207.0,
483.0,
552.0,
483.0,
367.81909090909085,
414.0,
55.200000000000045,
23.391818181818195,
99.72409090909093,
0.0,
133.72909090909081,
124.41545454545451,
96.08318181818186,
70.41409090909087,
118.37045454545455,
94.68272727272722,
83.01681818181817,
0.0,
75.86045454545456,
66.66681818181814,
69.12409090909085,
109.0704545454546,
55.96909090909088,
0.0,
109.96227272727276,
47.952272727272714,
11.233982308648535,
682.1181818181817,
160.0271308670193,
48.41330768174522,
161.62968357967037,
21.962728535423857,
538.2984000000038,
207.0,
255.8276539776955,
441.95211196761403,
260.56941082122324,
171.99990368477063,
1026.818181818182,
62.214291413756285,
35.132727272727266,
77.27590909090907,
134.59227272727276,
22.022423461142267,
0.0
100.08954545454549,
80.85954545454547
],
"akku_soc_pro_stunde": [
80.0,
62.54222623966943,
62.45329717630854,
61.532928719008275,
61.532928719008275,
61.532928719008275,
61.532928719008275,
50.81349001377411,
36.480587121212125,
46.842735019368604,
46.10435692019505,
42.95650051523637,
42.95650051523637,
39.029245005594504,
35.996316286586236,
33.77364927556696,
30.03720815986448,
27.048485708073848,
24.428005336173022,
24.428005336173022,
22.32362344912068,
20.141676135071094,
20.141676135071094,
16.670644798982938,
15.156999826531148,
15.469054890660274,
0.471637535288375,
4.030157048585656,
4.180158754905081,
19.132892088236673,
19.132892088236673,
26.239215809839333,
30.01393669097958,
8.49189812348647,
7.382910520180684,
4.9436457130181495,
0.6951522557178741,
0.0
43.60283230027549,
43.60283230027549,
43.60283230027549,
43.60283230027549,
43.60283230027549,
38.52647210743802,
38.52647210743802,
38.52647210743802,
37.78809400826446,
34.64023760330579,
30.418991046831955,
26.49173553719008,
23.458806818181817,
21.236139807162534,
17.499698691460054,
14.510976239669422,
11.890495867768596,
9.495910812672175,
7.391528925619835,
5.209581611570248,
1.7667011019283745,
0.0,
0.0,
0.3120550641291261,
1.07020564583707,
4.578139530578446,
4.728141236897871,
19.68087457022947,
31.94341995234899,
38.90006700591099,
42.674787887051245,
43.17025540478875,
42.06126780148296,
39.622002994320425,
35.373509537020155,
32.214117319389295,
29.661732677516017
],
"Electricity_price": [
0.000228,
@@ -607,211 +607,211 @@
},
"eauto_obj": {
"device_id": "ev1",
"hours": 48,
"charge_array": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.375,
0.625,
0.375,
0.875,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0
0.875,
0.375,
0.75,
0.1,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"discharge_array": [
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
],
"discharging_efficiency": 1.0,
"hours": 48,
"capacity_wh": 60000,
"charging_efficiency": 0.95,
"max_charge_power_w": 11040,
"soc_wh": 48885.0,
"soc_wh": 59110.8,
"initial_soc_percentage": 5
},
"start_solution": [
14.0,
13.0,
0.0,
20.0,
20.0,
19.0,
18.0,
18.0,
5.0,
3.0,
9.0,
16.0,
12.0,
13.0,
8.0,
4.0,
0.0,
14.0,
11.0,
9.0,
16.0,
8.0,
9.0,
5.0,
10.0,
13.0,
13.0,
8.0,
8.0,
9.0,
5.0,
10.0,
7.0,
5.0,
20.0,
17.0,
15.0,
4.0,
12.0,
13.0,
8.0,
5.0,
1.0,
1.0,
4.0,
9.0,
2.0,
5.0,
8.0,
10.0,
12.0,
10.0,
9.0,
13.0,
7.0,
8.0,
7.0,
9.0,
13.0,
7.0,
10.0,
8.0,
8.0,
12.0,
2.0,
9.0,
12.0,
7.0,
10.0,
13.0,
11.0,
11.0,
10.0,
11.0,
10.0,
13.0,
10.0,
10.0,
12.0,
2.0,
6.0,
3.0,
0.0,
6.0,
1.0,
12.0,
9.0,
12.0,
13.0,
10.0,
13.0,
11.0,
2.0,
1.0,
5.0,
0.0,
0.0,
1.0,
3.0,
1.0,
5.0,
6.0,
5.0,
1.0,
4.0,
6.0,
3.0,
3.0,
4.0,
1.0,
6.0,
1.0,
1.0,
6.0,
6.0,
0.0,
0.0,
1.0,
3.0,
2.0,
2.0,
1.0,
6.0,
5.0,
3.0,
3.0,
0.0,
0.0,
4.0,
1.0,
4.0,
0.0,
2.0,
1.0,
0.0,
0.0,
2.0,
2.0,
6.0,
3.0,
2.0,
2.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0,
3.0,
0.0,
0.0,
0.0,
0.0,
0.0,
5.0,
6.0,
13.0
],
"washingstart": 13