mirror of
https://github.com/Akkudoktor-EOS/EOS.git
synced 2026-11-13 09:13:30 +01:00
Bobby NoelteandClaude Opus 5.5
e255f987bf
A battery profile describes a battery model: the charge and discharge limit
maps over temperature and SoC, the charge and discharge efficiency curves
over C-rate, the technical SoC bounds, the hard temperature cutoffs and,
for a model, its nominal capacity and power limits. EOS packages the
generic profile generic-lfp; users add their own profiles.
A battery or electric vehicle selects its profile by battery_profile and
describes how the installation differs from it in profile_adjustment
(capacity, power limits of the installation, periodic full charge). The
effective values are resolved from both at the measured operating point
(temperature, SoC, power) and shown as effective_* fields.
The GENETIC simulation uses the limits and efficiencies of the profile over
SoC, with precomputed tables as a fast path; GENETIC0 gets the values at the
operating point. Optimization parameters are always valid: a battery whose
profile is missing, unreadable or invalid uses the packaged generic-lfp
profile, and the former defaults only if that is not usable either; each is
logged as error, and an optimization run is never cancelled because of a
battery.
Additional changes
- Add a generic device profile store: user and packaged profiles, atomic
saves, compiled profiles cached per file and checked again at most once a
second, plain file names as profile names ('schema' is reserved). On
Windows, a save or read that collides with the other is retried briefly.
- Add the REST API /v1/profile to list the profile kinds and to list, read
(document and JSON schema), save and delete profiles.
- Check the hard temperature cutoffs on the exact temperature.
- Resolve inhibited charging or discharging to a power of 0, e.g. for a cold
battery; give GENETIC0 its own discharge limit for that.
- Limit generic profiles without own power limits to the former 5000 W.
- Accept only the implemented units; current limits need the nominal
voltage.
- Migrate legacy battery settings into the profile adjustment, keep the
former charge power limit as discharge limit (also for a Home Assistant
entity on it) and report dropped efficiencies as errors.
- Limit GENETIC battery discharge by the discharge power.
- Allow battery profile lookups while the configuration is created.
- Resolve a battery once per configuration dump.
- Package the bundled profiles, document battery profiles and regenerate
the configuration and OpenAPI documentation.
- Ignore the report PDFs written by the visualization tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Assisted-by: Claude Code (claude-opus-5-5)
389 lines
16 KiB
Python
389 lines
16 KiB
Python
"""GENETIC0 parameter preparation: time alignment, tariff coverage, and measured SoC."""
|
|
|
|
from unittest.mock import AsyncMock, Mock, patch
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
import pendulum
|
|
import pytest
|
|
import pytest_asyncio
|
|
|
|
from akkudoktoreos.core.coreabc import get_ems, get_measurement
|
|
from akkudoktoreos.optimization.genetic0.genetic0params import (
|
|
Genetic0OptimizationParameters,
|
|
)
|
|
from akkudoktoreos.utils.datetimeutil import to_datetime
|
|
|
|
|
|
class TestGenetic0ParameterTimeAlignment:
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"start",
|
|
[
|
|
# Normal day: 23 elapsed hours since local midnight.
|
|
pendulum.datetime(2026, 10, 24, 23, tz="Europe/Berlin"),
|
|
# Fall back (CEST -> CET): 24 elapsed hours since local midnight.
|
|
pendulum.datetime(2026, 10, 25, 23, tz="Europe/Berlin"),
|
|
# Spring forward (CET -> CEST): 22 elapsed hours since local midnight.
|
|
pendulum.datetime(2026, 3, 29, 23, tz="Europe/Berlin"),
|
|
],
|
|
ids=["normal", "fall-back", "spring-forward"],
|
|
)
|
|
async def test_parameter_arrays_start_hour_aligned_on_dst_days(self, config_eos, start):
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"general": {"timezone_override": "Europe/Berlin"},
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"feedintariff": {"provider": "FeedInTariffDvhubOnline"},
|
|
"elecfee": {"provider": None},
|
|
"devices": {
|
|
"max_batteries": 0,
|
|
"max_electric_vehicles": 0,
|
|
"max_inverters": 0,
|
|
"max_home_appliances": 0,
|
|
},
|
|
}
|
|
)
|
|
get_ems().set_start_datetime(start)
|
|
ems_start = get_ems().start_datetime
|
|
assert ems_start.hour == 23
|
|
|
|
# The tariff is only published from the start slot on, as a live
|
|
# provider would do late in the evening.
|
|
prices = pd.Series(
|
|
np.full(24 * 4, 0.0001),
|
|
index=pd.date_range(ems_start, periods=24 * 4, freq="15min"),
|
|
)
|
|
array_starts = []
|
|
|
|
async def read_array(**kwargs):
|
|
array_starts.append(kwargs["start_datetime"])
|
|
return np.full(48, 1.0)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=prices),
|
|
)
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
|
|
assert parameters is not None
|
|
# Index ``start.hour`` of every array is the start slot.
|
|
assert array_starts
|
|
for array_start in array_starts:
|
|
assert array_start.add(hours=ems_start.hour) == ems_start
|
|
tariffs = parameters.ems.feed_in_tariff_per_wh
|
|
assert isinstance(tariffs, list)
|
|
assert np.isfinite(tariffs[ems_start.hour : ems_start.hour + 24]).all()
|
|
|
|
|
|
class TestGenetic0TariffCoverage:
|
|
"""Tariff arrays indexed from UTC midnight, independent of the host timezone."""
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize("published_hours", [20, 24])
|
|
async def test_dvhub_tariff_requires_real_control_horizon(self,
|
|
config_eos, published_hours, caplog
|
|
):
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"general": {"timezone_override": "UTC"},
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"feedintariff": {"provider": "FeedInTariffDvhubOnline"},
|
|
"elecfee": {"provider": None},
|
|
"devices": {
|
|
"max_batteries": 0,
|
|
"max_electric_vehicles": 0,
|
|
"max_inverters": 0,
|
|
"max_home_appliances": 0,
|
|
},
|
|
}
|
|
)
|
|
start = to_datetime("2026-08-01T00:00:00+00:00", in_timezone="UTC")
|
|
get_ems().set_start_datetime(start)
|
|
prices = pd.Series(
|
|
np.arange(published_hours * 4, dtype=float) / 1_000_000,
|
|
index=pd.date_range(start, periods=published_hours * 4, freq="15min"),
|
|
)
|
|
|
|
async def read_array(**kwargs):
|
|
return np.full(48, 1.0)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=prices),
|
|
)
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
|
|
prediction.update_data.assert_awaited_once()
|
|
assert config_eos.feedintariff.provider == "FeedInTariffDvhubOnline"
|
|
if published_hours < 24:
|
|
assert parameters is None
|
|
assert "Missing feed-in tariff within the GENETIC0 control horizon" in caplog.text
|
|
else:
|
|
assert parameters is not None
|
|
tariffs = parameters.ems.feed_in_tariff_per_wh
|
|
assert isinstance(tariffs, list)
|
|
assert tariffs[:24] == pytest.approx(
|
|
[(4 * hour + 1.5) / 1_000_000 for hour in range(24)]
|
|
)
|
|
assert np.isnan(tariffs[24:]).all()
|
|
|
|
|
|
class TestGenetic0MeasuredSOC:
|
|
@pytest_asyncio.fixture
|
|
async def isolated_measurement(self, config_eos):
|
|
"""Keep synthetic records out of the process-wide measurement singleton."""
|
|
measurement = get_measurement()
|
|
await measurement.delete_by_datetime(None, None)
|
|
try:
|
|
yield measurement
|
|
finally:
|
|
await measurement.delete_by_datetime(None, None)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_soc_read_late_in_slot_beats_previous_reading(self, config_eos, isolated_measurement):
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"elecfee": {"provider": None},
|
|
"devices": {
|
|
"max_batteries": 1,
|
|
"max_electric_vehicles": 0,
|
|
"max_inverters": 1,
|
|
"max_home_appliances": 0,
|
|
"batteries": {
|
|
"storage": {"profile_adjustment": {"nominal_capacity_wh": 2000, "max_charge_power_w": 1000}}
|
|
},
|
|
"inverters": {"inverter": {"battery_id": "storage", "max_power_w": 1000}},
|
|
},
|
|
}
|
|
)
|
|
# A run at 14:40 belongs to the 14:00 slot. The previous run (13:40) is closer
|
|
# to the slot start than the reading taken now.
|
|
run_time = to_datetime("2026-08-01T14:40:00+00:00")
|
|
get_ems().set_start_datetime(run_time)
|
|
measurement = isolated_measurement
|
|
await measurement.update_value(run_time.subtract(hours=1), "storage-soc-factor", 0.10)
|
|
await measurement.update_value(run_time, "storage-soc-factor", 0.42)
|
|
|
|
tariff = pd.Series(
|
|
0.00008, index=pd.date_range("2026-08-01T00:00:00Z", periods=72 * 4, freq="15min")
|
|
)
|
|
|
|
async def read_array(**kwargs):
|
|
return np.full(48, 0.0003)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=tariff),
|
|
)
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
|
|
assert parameters is not None
|
|
assert parameters.pv_battery is not None
|
|
assert parameters.pv_battery.initial_soc_percentage == 42
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_meter_only_record_does_not_mask_soc(self, config_eos, isolated_measurement):
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"elecfee": {"provider": None},
|
|
"measurement": {"load_emr_keys": ["load_meter"]},
|
|
"devices": {
|
|
"max_batteries": 1,
|
|
"max_electric_vehicles": 0,
|
|
"max_inverters": 1,
|
|
"max_home_appliances": 0,
|
|
"batteries": {
|
|
"storage": {"profile_adjustment": {"nominal_capacity_wh": 2000, "max_charge_power_w": 1000}}
|
|
},
|
|
"inverters": {"inverter": {"battery_id": "storage", "max_power_w": 1000}},
|
|
},
|
|
}
|
|
)
|
|
run_time = to_datetime("2026-08-01T14:40:00+00:00")
|
|
get_ems().set_start_datetime(run_time)
|
|
measurement = isolated_measurement
|
|
# SoC through the measurement API at 13:30, the adapter's meter reading at the
|
|
# slot start (14:00); the run at 14:40 must still find the SoC.
|
|
await measurement.update_value(run_time.subtract(minutes=70), "storage-soc-factor", 0.42)
|
|
await measurement.update_value(get_ems().start_datetime, "load_meter", 1234.5)
|
|
|
|
tariff = pd.Series(
|
|
0.00008, index=pd.date_range("2026-08-01T00:00:00Z", periods=72 * 4, freq="15min")
|
|
)
|
|
|
|
async def read_array(**kwargs):
|
|
return np.full(48, 0.0003)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=tariff),
|
|
)
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
|
|
assert parameters is not None
|
|
assert parameters.pv_battery is not None
|
|
assert parameters.pv_battery.initial_soc_percentage == 42
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_older_missing_value_does_not_spoil_current_soc(self, config_eos, isolated_measurement):
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"elecfee": {"provider": None},
|
|
"devices": {
|
|
"max_batteries": 1,
|
|
"max_electric_vehicles": 0,
|
|
"max_inverters": 1,
|
|
"max_home_appliances": 0,
|
|
"batteries": {
|
|
"storage": {"profile_adjustment": {"nominal_capacity_wh": 2000, "max_charge_power_w": 1000}}
|
|
},
|
|
"inverters": {"inverter": {"battery_id": "storage", "max_power_w": 1000}},
|
|
},
|
|
}
|
|
)
|
|
run_time = to_datetime("2026-08-01T14:40:00+00:00")
|
|
get_ems().set_start_datetime(run_time)
|
|
measurement = isolated_measurement
|
|
# An older reading stored as pandas NA (e.g. a JSON null in a Float64 series).
|
|
await measurement.update_value(run_time.subtract(hours=1), "storage-soc-factor", pd.NA)
|
|
await measurement.update_value(run_time, "storage-soc-factor", 0.42)
|
|
|
|
tariff = pd.Series(
|
|
0.00008, index=pd.date_range("2026-08-01T00:00:00Z", periods=72 * 4, freq="15min")
|
|
)
|
|
|
|
async def read_array(**kwargs):
|
|
return np.full(48, 0.0003)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=tariff),
|
|
)
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
|
|
assert parameters is not None
|
|
assert parameters.pv_battery is not None
|
|
assert parameters.pv_battery.initial_soc_percentage == 42
|
|
|
|
|
|
class TestGenetic0DemoData:
|
|
"""Demo device data used when no battery / electric vehicle is configured."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_demo_devices_use_nominal_capacity(self, config_eos):
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"elecfee": {"provider": None},
|
|
"devices": {
|
|
"max_batteries": 1,
|
|
"max_electric_vehicles": 1,
|
|
"max_inverters": 0,
|
|
"max_home_appliances": 0,
|
|
"batteries": None,
|
|
"electric_vehicles": None,
|
|
},
|
|
}
|
|
)
|
|
get_ems().set_start_datetime(to_datetime("2026-08-01T14:00:00+00:00"))
|
|
tariff = pd.Series(
|
|
0.00008, index=pd.date_range("2026-08-01T00:00:00Z", periods=72 * 4, freq="15min")
|
|
)
|
|
|
|
async def read_array(**kwargs):
|
|
return np.full(48, 0.0003)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=tariff),
|
|
)
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
|
|
assert parameters is not None
|
|
# The demo capacities must reach the profile adjustment of the settings;
|
|
# the generic default profile provides no capacity of its own.
|
|
assert config_eos.devices.batteries["battery1"].profile_adjustment.nominal_capacity_wh == 8000
|
|
assert (
|
|
config_eos.devices.electric_vehicles["ev1"].profile_adjustment.nominal_capacity_wh
|
|
== 50000
|
|
)
|
|
assert parameters.pv_battery is not None
|
|
assert parameters.pv_battery.capacity_wh == 8000
|
|
assert parameters.ev is not None
|
|
assert parameters.ev.capacity_wh == 50000
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_battery_configuration_error_uses_defaults_not_demo_data(self, config_eos):
|
|
"""A misconfigured battery keeps its configuration, with defaults for the rest."""
|
|
from loguru import logger
|
|
|
|
config_eos.merge_settings_from_dict(
|
|
{
|
|
"prediction": {"hours": 48},
|
|
"optimization": {"genetic0": {"horizon_hours": 24}},
|
|
"elecfee": {"provider": None},
|
|
"devices": {
|
|
"max_batteries": 1,
|
|
"max_electric_vehicles": 0,
|
|
"max_inverters": 0,
|
|
"max_home_appliances": 0,
|
|
# generic-lfp provides no capacity and the adjustment none either.
|
|
"batteries": {"storage": {"min_soc_percentage": 20}},
|
|
"electric_vehicles": None,
|
|
},
|
|
}
|
|
)
|
|
get_ems().set_start_datetime(to_datetime("2026-08-01T14:00:00+00:00"))
|
|
tariff = pd.Series(
|
|
0.00008, index=pd.date_range("2026-08-01T00:00:00Z", periods=72 * 4, freq="15min")
|
|
)
|
|
|
|
async def read_array(**kwargs):
|
|
return np.full(48, 0.0003)
|
|
|
|
prediction = Mock(
|
|
update_data=AsyncMock(),
|
|
key_to_array=AsyncMock(side_effect=read_array),
|
|
key_to_raw_series=AsyncMock(return_value=tariff),
|
|
)
|
|
messages: list[str] = []
|
|
sink_id = logger.add(
|
|
lambda message: messages.append(message.record["message"]), level="ERROR"
|
|
)
|
|
try:
|
|
with patch.object(Genetic0OptimizationParameters, "prediction", prediction):
|
|
parameters = await Genetic0OptimizationParameters.prepare()
|
|
finally:
|
|
logger.remove(sink_id)
|
|
assert parameters is not None
|
|
assert parameters.pv_battery is not None
|
|
# The configured battery, not the demo battery: its own SoC minimum.
|
|
assert parameters.pv_battery.device_id == "storage"
|
|
assert parameters.pv_battery.min_soc_percentage == 20
|
|
assert parameters.pv_battery.capacity_wh == 8000
|
|
assert any(
|
|
"Battery 'storage'" in m and "nominal capacity 8000 Wh" in m for m in messages
|
|
)
|