mirror of
https://github.com/Akkudoktor-EOS/EOS.git
synced 2026-11-14 01:33:38 +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)
120 lines
4.6 KiB
Python
120 lines
4.6 KiB
Python
"""Contracts shared by the configuration, tariff and optimizer PRs."""
|
|
|
|
from types import SimpleNamespace
|
|
from unittest.mock import Mock
|
|
|
|
import pytest
|
|
|
|
from akkudoktoreos.optimization.genetic0.genetic0params import (
|
|
Genetic0EnergyManagementParameters,
|
|
)
|
|
from akkudoktoreos.optimization.genetic.geneticparams import (
|
|
GeneticEnergyManagementParameters,
|
|
)
|
|
from akkudoktoreos.optimization.optimization import OptimizationAlgorithm
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"model", [GeneticEnergyManagementParameters, Genetic0EnergyManagementParameters]
|
|
)
|
|
@pytest.mark.parametrize("tariff", [0.00008, [0.00008, -0.00002]])
|
|
def test_energy_parameter_aliases_preserve_wh_prices(model, tariff):
|
|
raw = {
|
|
"pv_prognose_wh": [250.0, 0.0],
|
|
"gesamtlast": [125.0, 125.0],
|
|
"strompreis_euro_pro_wh": [0.0003, -0.0001],
|
|
"einspeiseverguetung_euro_pro_wh": tariff,
|
|
"preis_euro_pro_wh_akku": 0.00005,
|
|
}
|
|
params = model.model_validate(raw)
|
|
data = params.model_dump(mode="json")
|
|
pairs = {
|
|
"pv_prognose_wh": "pv_forecast_wh",
|
|
"gesamtlast": "total_load",
|
|
"strompreis_euro_pro_wh": "electricity_price_per_wh",
|
|
"einspeiseverguetung_euro_pro_wh": "feed_in_tariff_per_wh",
|
|
"preis_euro_pro_wh_akku": "price_per_wh_battery",
|
|
}
|
|
for deprecated, canonical in pairs.items():
|
|
assert data[deprecated] == data[canonical] == raw[deprecated]
|
|
assert (
|
|
model.model_validate({pairs[k]: v for k, v in raw.items()}).model_dump(mode="json") == data
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize("algorithm", list(OptimizationAlgorithm))
|
|
async def test_algorithm_result_endpoint_keeps_solution_types_separate(monkeypatch, algorithm):
|
|
from akkudoktoreos.server import eos
|
|
|
|
genetic, genetic0 = object(), object()
|
|
fake = SimpleNamespace(
|
|
genetic_solution=Mock(return_value=genetic),
|
|
genetic0_solution=Mock(return_value=genetic0),
|
|
)
|
|
monkeypatch.setattr(eos, "get_ems", lambda: fake)
|
|
monkeypatch.setattr(
|
|
eos,
|
|
"get_config",
|
|
lambda: SimpleNamespace(optimization=SimpleNamespace(algorithms=["GENETIC", "GENETIC0"])),
|
|
)
|
|
result = await eos.fastapi_energy_management_optimization_solution_algorithm_get(algorithm)
|
|
if algorithm == OptimizationAlgorithm.GENETIC:
|
|
assert result is genetic
|
|
fake.genetic_solution.assert_called_once_with()
|
|
fake.genetic0_solution.assert_not_called()
|
|
else:
|
|
assert result is genetic0
|
|
fake.genetic0_solution.assert_called_once_with()
|
|
fake.genetic_solution.assert_not_called()
|
|
|
|
|
|
@pytest.mark.parametrize("algorithm", ["genetic", "genetic0"])
|
|
def test_device_maps_feed_algorithm_specific_converters(algorithm):
|
|
from akkudoktoreos.devices.devices import DevicesCommonSettings
|
|
|
|
settings = DevicesCommonSettings.model_validate(
|
|
{
|
|
"batteries": {
|
|
"storage": {"profile_adjustment": {"nominal_capacity_wh": 12000, "max_charge_power_w": 3200}}
|
|
},
|
|
"electric_vehicles": {
|
|
"car": {"profile_adjustment": {"nominal_capacity_wh": 60000, "max_charge_power_w": 7000}}
|
|
},
|
|
"inverters": {"inverter": {"battery_id": "storage", "max_power_w": 5000}},
|
|
"home_appliances": {
|
|
"washer": {
|
|
"consumption_wh": 1800,
|
|
"duration_h": 2,
|
|
"num_cycles": 2,
|
|
"min_cycle_gap_h": 1,
|
|
}
|
|
},
|
|
}
|
|
)
|
|
assert settings.batteries is not None
|
|
assert settings.electric_vehicles is not None
|
|
assert settings.inverters is not None
|
|
battery = getattr(settings.batteries["storage"], "to_" + algorithm + "_pv_bat_param")()
|
|
ev = getattr(settings.electric_vehicles["car"], "to_" + algorithm + "_ev_bat_param")()
|
|
inverter = getattr(settings.inverters["inverter"], "to_" + algorithm + "_param")()
|
|
appliance = getattr(settings.home_appliances["washer"], "to_" + algorithm + "_param")()
|
|
assert (battery.device_id, ev.device_id, inverter.device_id, appliance.device_id) == (
|
|
"storage",
|
|
"car",
|
|
"inverter",
|
|
"washer",
|
|
)
|
|
assert battery.capacity_wh == 12000
|
|
assert battery.max_charge_power_w == 3200
|
|
assert ev.capacity_wh == 60000
|
|
assert ev.max_charge_power_w == 7000
|
|
assert inverter.max_power_wh == 5000
|
|
assert inverter.battery_id == "storage"
|
|
assert appliance.consumption_wh == 1800
|
|
assert appliance.duration_h == 2
|
|
assert settings.batteries["storage"].measurement_key_soc_factor == "storage-soc-factor"
|
|
if algorithm == "genetic":
|
|
assert appliance.num_cycles == 2
|
|
assert appliance.min_cycle_gap_h == 1
|