mirror of
https://github.com/Akkudoktor-EOS/EOS.git
synced 2026-11-13 09:13:30 +01:00
Bobby NoelteandClaude Opus 5.5
faf37abfe7
An inverter profile describes the technical data of an inverter model: its nominal AC power, the DC→AC and AC→DC efficiency curves over the load fraction (AC power relative to the nominal power), the AC charge power limit of the model, whether that limit also limits PV charging, and an optional power derating over the ambient temperature. Curves are read linearly and clamped at their ends, so every lookup yields a value. The packaged profile generic-hybrid has typical hybrid inverter efficiencies, no nominal power (the inverter device has to provide it) and full power up to 45 degC. Inverter settings name their profile (inverter_profile, default generic-hybrid) and hold the differences of the unit in profile_adjustment: nominal_power_w (replaces the profile value, required for a generic profile), max_power_w and max_ac_charge_power_w (installation limits that can only lower; an AC charge limit of 0 disables AC charging). The effective parameters are resolved at the ambient temperature of the inverter, given by the new measurement key <device_id>-temperature-degc (45 degC without a fresh value); the power derating lowers the maximum power and the AC charge limit. Optimization parameters are always valid: the GENETIC and GENETIC0 parameter preparation resolve the inverter with resolve_current_operating_parameters_or_defaults, which never raises. An unusable profile gives the generic-hybrid profile, a missing nominal power the fallback of 10000 W, an inverter derated to zero power the parameters at 45 degC, and no usable profile at all the profile adjustment with constant efficiency; each is logged as error. The GENETIC inverter takes the AC→DC efficiency curve of the profile, solved exactly on each linear piece of the curve (about 2 % longer runs); GENETIC0 keeps constant efficiencies and no longer replaces the configured inverters with the demo inverter; a battery, electric vehicle or inverter that cannot be prepared is left out of the GENETIC0 run, never replaced by a demo device. Configurations migrate: max_power_w becomes profile_adjustment.nominal_power_w, max_ac_charge_power_w moves into the adjustment, an ac_to_dc_efficiency of 0 keeps AC charging disabled, and the efficiency fields are dropped with an error log, as for batteries, so the profile efficiencies apply. Home Assistant config paths follow. Additional changes - Move the curve algorithms of the battery profile into profilecurve, so battery and inverter profiles share them; the battery profile keeps its document format and classes. - Move ProfileBaseModel, the strict base of profile documents, into profilestore. - Serve inverter profiles through the profile REST API. Refuse to delete a profile that a configured device uses and that has no packaged profile to revert to (409). - Share the measurement access of the device settings in devicemeasurement. - Rename check_battery_profiles to check_device_profiles; the device profile check at configuration setup covers inverters, too. - Document inverter profiles, their configuration, defaults and sharing; regenerate the configuration and OpenAPI documentation. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Assisted-by: Claude Code (claude-opus-5-5)
469 lines
20 KiB
Python
469 lines
20 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", "profile_adjustment": {"nominal_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", "profile_adjustment": {"nominal_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", "profile_adjustment": {"nominal_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
|
|
)
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"settings_class, method, field, device_id",
|
|
[
|
|
("BatteriesCommonSettings", "to_genetic0_pv_bat_param", "pv_battery", "storage"),
|
|
("BatteriesCommonSettings", "to_genetic0_ev_bat_param", "ev", "car"),
|
|
("InverterCommonSettings", "to_genetic0_param", "inverter", "hybrid"),
|
|
],
|
|
)
|
|
async def test_device_that_cannot_be_prepared_is_left_out(
|
|
self, config_eos, monkeypatch, settings_class, method, field, device_id
|
|
):
|
|
"""No demo device replaces a configured device that cannot be prepared."""
|
|
from loguru import logger
|
|
|
|
from akkudoktoreos.devices.settings import batterysettings, invertersettings
|
|
|
|
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": 1,
|
|
"max_home_appliances": 0,
|
|
"batteries": {
|
|
"storage": {"profile_adjustment": {"nominal_capacity_wh": 5000}}
|
|
},
|
|
"electric_vehicles": {
|
|
"car": {"profile_adjustment": {"nominal_capacity_wh": 40000}}
|
|
},
|
|
"inverters": {
|
|
"hybrid": {
|
|
"battery_id": "storage",
|
|
"profile_adjustment": {"nominal_power_w": 6000},
|
|
}
|
|
},
|
|
},
|
|
}
|
|
)
|
|
configured = config_eos.devices.model_dump(exclude_computed_fields=True)
|
|
module = batterysettings if settings_class == "BatteriesCommonSettings" else invertersettings
|
|
|
|
def broken(self, *args, **kwargs):
|
|
raise RuntimeError("conversion failed")
|
|
|
|
monkeypatch.setattr(getattr(module, settings_class), method, broken)
|
|
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 getattr(parameters, field) is None
|
|
assert any(f"'{device_id}'" in m and "left out" in m for m in messages)
|
|
assert not any("demo" in m for m in messages)
|
|
# The other devices are prepared, the configuration is unchanged.
|
|
for other in {"pv_battery", "ev", "inverter"} - {field}:
|
|
assert getattr(parameters, other) is not None
|
|
assert config_eos.devices.model_dump(exclude_computed_fields=True) == configured
|