mirror of
https://github.com/Akkudoktor-EOS/EOS.git
synced 2026-10-09 07:56:40 +00:00
feat: integrate device and runtime configuration foundation on main (#1328)
* feat: adapt configuration for multi optimization algorithms Decouple configuration from optimization algorithm parameters. Add to_[algorithm]_param() methods to the configuration that derive optimization algorithm specific parameters from the configuration. Add x-scope tags to the configuration options that describe for which specific algorithms the configuration option is for. The whole device settings are restructured. There are now general settings for the device classes with the afore mentioned to_[algorithm]_param() methods. The general device settings got their own directory `devices/settings`. By this the parameter class also does not have to be a pydantic model which can be used for future optimization/ simulations speed up. Also the parameter class for a device is now part of the device module. This better decouples and also is the natural place for parameters of a device. Besides this feature there are also fixes and improvements: * feat: extend home appliance time window settings and simulation Home appliance can now be configured for multiple runs with per-cycle allowed time windows. The number of remaining cycles to plan is determined at runtime by reading the ``cycles_completed_measurement_key`` from the measurement store. * feat: specialiced CycleTimeWindowSequence for time window sequences Sequence of time windows associated to cycles. This model specializes ``ValueTimeWindowSequence`` so that the ``value`` field of each ``ValueTimeWindow`` encodes the **cycle index** (0-based integer) the window belongs to. Typical use: an appliance that must run ``n`` times per day, each run constrained to a distinct time window. Assign ``value=0`` to windows for the first cycle, ``value=1`` for the second, and so on. Multiple windows may share the same cycle index (their allowed regions are unioned). Windows with ``value=None`` are silently ignored by all cycle-aware methods. * fix: Make test_configmigrate also regard the _ANY_SENTENIEL in key values * chore: Make devices configurations a map instead of a list This makes config paths stable regardless of declaration order and lets each device settings class build its own config path from ``self.device_id`` without needing an external index. Tests are adapted likewise. Devices configurations are automatically migrated from lists to maps. * chore: rename levelized_cost_of_storage_kwh to levelized_cost_of_storage_amt kwh This better fits in the naming scheme and also makes clear the costs are money. Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com> * fix: runtime config update ignored by config file Runtime settings were handed back to pydantic-settings as init settings, which rank below the config file and the environment. Any key already present in EOS.config.json or in the environment silently discarded the update, so a bulk PUT /v1/config returned 200 without applying anything, while the granular PUT /v1/config/{path} endpoint kept working. Add a dedicated runtime settings source ranked directly below the command line arguments and record granular updates there as well, so both endpoints share one store that survives re-evaluation of the settings sources. Environment variables keep precedence over the config file for all keys that were not set at runtime. Also repairs revert_settings() and update(), which passed their data through the same init settings. Closes #1303 * fix: env vars ignored on first config build ConfigEOS.__init__ passed self as first positional argument to _setup, which forwards it to pydantic_settings.BaseSettings.__init__. Its first positional parameter is _case_sensitive, so the environment source matched the upper case variable names against the lower case field names and returned nothing. Environment settings only took effect after the next configuration setup. * docs: changelog for config priority fixes * fix(config): preserve device identities and storage costs during migration * fix(devices): preserve charge-rate typing and public import compatibility * ruff format fix * fix(config): satisfy typed device conversion and migration contracts * docs(config): refresh validated configuration prerequisite schemas --------- Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com> Co-authored-by: Bobby Noelte <b0661n0e17e@gmail.com> Co-authored-by: r0b2g1t <r0b2g1t@users.noreply.github.com>
This commit is contained in:
Andreas
co-authored by
Bobby Noelte
r0b2g1t
Bobby Noelte
r0b2g1t
parent
431d7d57e5
commit
8224c64654
+2
-2
@@ -370,8 +370,8 @@ def config_eos_factory(
|
||||
assert not config_file_cwd.exists()
|
||||
|
||||
config_eos = get_config(init=init)
|
||||
# Ensure newly created configurations are respected
|
||||
# Note: Workaround for pydantic_settings and pytest
|
||||
# Ensure newly created configurations are respected and runtime settings of
|
||||
# previous tests are dropped
|
||||
config_eos.reset_settings()
|
||||
|
||||
# Check user data directory pathes (config_default_dirs[-1] == data_default_dir_user)
|
||||
|
||||
+241
-34
@@ -1,3 +1,4 @@
|
||||
import json
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
from typing import Any, Optional, Union
|
||||
@@ -9,7 +10,7 @@ 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
|
||||
from akkudoktoreos.devices.settings.batterysettings import BATTERY_DEFAULT_CHARGE_RATES
|
||||
|
||||
|
||||
def assert_values_equal(actual, expected):
|
||||
@@ -286,7 +287,6 @@ def test_config_common_settings_timezone_none_when_coordinates_missing():
|
||||
assert config_no_coords.timezone is None
|
||||
|
||||
|
||||
|
||||
# Test partial assignments and possible side effects
|
||||
@pytest.mark.parametrize(
|
||||
"path, value, expected, exception",
|
||||
@@ -349,70 +349,120 @@ def test_config_common_settings_timezone_none_when_coordinates_missing():
|
||||
),
|
||||
# Correct value assignment - preparation for list
|
||||
(
|
||||
"devices/max_electric_vehicles",
|
||||
"devices/max_home_appliances",
|
||||
1,
|
||||
[("devices.max_electric_vehicles", 1), ],
|
||||
[("devices.max_home_appliances", 1), ],
|
||||
None,
|
||||
),
|
||||
# Correct value for list
|
||||
# Correct value to generate a windows list
|
||||
(
|
||||
"devices/electric_vehicles/0/charge_rates",
|
||||
[0.1, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
|
||||
"devices/home_appliances",
|
||||
{
|
||||
"dishwasher1": {
|
||||
"device_id": "dishwasher1",
|
||||
"consumption_wh": 2000,
|
||||
"duration_h": 3,
|
||||
"cycle_time_windows": {
|
||||
"windows": [
|
||||
{
|
||||
"start_time": "08:00",
|
||||
"duration": "5 hours",
|
||||
"value": 0,
|
||||
},
|
||||
{
|
||||
"start_time": "15:00",
|
||||
"duration": "3 hours",
|
||||
"value": 0,
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
},
|
||||
[
|
||||
(
|
||||
"devices.electric_vehicles[0].charge_rates",
|
||||
[0.1, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
|
||||
)
|
||||
("devices.home_appliances['dishwasher1'].device_id", "dishwasher1"),
|
||||
("devices.home_appliances['dishwasher1'].consumption_wh", 2000),
|
||||
("devices.home_appliances['dishwasher1'].duration_h", 3),
|
||||
],
|
||||
None,
|
||||
),
|
||||
# Invalid value for list
|
||||
(
|
||||
"devices/electric_vehicles/0/charge_rates",
|
||||
"devices/home_appliances/dishwasher1/cycle_time_windows/windows",
|
||||
"invalid",
|
||||
[
|
||||
(
|
||||
"devices.electric_vehicles[0].charge_rates",
|
||||
BATTERY_DEFAULT_CHARGE_RATES,
|
||||
"devices.home_appliances['dishwasher1'].cycle_time_windows",
|
||||
[
|
||||
{
|
||||
"start_time": "08:00",
|
||||
"duration": "5 hours",
|
||||
"value": 0,
|
||||
},
|
||||
{
|
||||
"start_time": "15:00",
|
||||
"duration": "3 hours",
|
||||
"value": 0,
|
||||
},
|
||||
],
|
||||
)
|
||||
],
|
||||
ValueError,
|
||||
),
|
||||
# Invalid index (out of bound)
|
||||
(
|
||||
"devices/electric_vehicles/0/charge_rates/10",
|
||||
0,
|
||||
"devices/home_appliances/dishwasher1/cycle_time_windows/windows/10",
|
||||
{
|
||||
"start_time": "17:00",
|
||||
"duration": "1 hour",
|
||||
"value": 0,
|
||||
},
|
||||
[
|
||||
(
|
||||
"devices.electric_vehicles[0].charge_rates",
|
||||
BATTERY_DEFAULT_CHARGE_RATES,
|
||||
"devices.home_appliances['dishwasher1'].cycle_time_windows.windows[10]",
|
||||
{
|
||||
"start_time": "17:00",
|
||||
"duration": "1 hour",
|
||||
"value": 0,
|
||||
},
|
||||
)
|
||||
],
|
||||
TypeError,
|
||||
),
|
||||
# Invalid index (no number)
|
||||
(
|
||||
"devices/electric_vehicles/0/charge_rates/test",
|
||||
0,
|
||||
"devices/home_appliances/dishwasher1/cycle_time_windows/windows/test",
|
||||
{
|
||||
"start_time": "17:00",
|
||||
"duration": "1 hour",
|
||||
"value": 0,
|
||||
},
|
||||
[
|
||||
(
|
||||
"devices.electric_vehicles[0].charge_rates",
|
||||
BATTERY_DEFAULT_CHARGE_RATES,
|
||||
"devices.home_appliances['dishwasher1'].cycle_time_windows.windows[0]",
|
||||
{
|
||||
"start_time": "08:00",
|
||||
"duration": "5 hours",
|
||||
"value": 0,
|
||||
},
|
||||
)
|
||||
],
|
||||
IndexError,
|
||||
),
|
||||
# Unset value (set None)
|
||||
(
|
||||
"devices/electric_vehicles/0/charge_rates",
|
||||
"devices/home_appliances/dishwasher1/cycle_time_windows/windows/0",
|
||||
None,
|
||||
[
|
||||
(
|
||||
"devices.electric_vehicles[0].charge_rates",
|
||||
BATTERY_DEFAULT_CHARGE_RATES,
|
||||
"devices.home_appliances['dishwasher1'].cycle_time_windows.windows[0]",
|
||||
{
|
||||
"start_time": "08:00",
|
||||
"duration": "5 hours",
|
||||
"value": 0,
|
||||
},
|
||||
)
|
||||
],
|
||||
None,
|
||||
TypeError,
|
||||
),
|
||||
],
|
||||
)
|
||||
@@ -514,30 +564,28 @@ def test_merge_settings_partial(config_eos):
|
||||
partial_settings = {
|
||||
"devices": {
|
||||
"max_electric_vehicles": 1,
|
||||
"electric_vehicles": [
|
||||
{
|
||||
"charge_rates": [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
|
||||
}
|
||||
],
|
||||
"electric_vehicles": {
|
||||
"ev1": {"charge_rates": [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
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_values_equal(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["ev1"].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_values_equal(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["ev1"].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_values_equal(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["ev1"].charge_rates, [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0])
|
||||
|
||||
|
||||
def test_merge_settings_empty(config_eos):
|
||||
@@ -547,3 +595,162 @@ def test_merge_settings_empty(config_eos):
|
||||
config_eos.merge_settings_from_dict({}) # No changes
|
||||
|
||||
assert config_eos.general.latitude == original_latitude # Should remain unchanged
|
||||
|
||||
|
||||
# ------------------------------------
|
||||
# Runtime settings priority (issue #1303)
|
||||
# ------------------------------------
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def config_eos_file(config_eos_factory) -> ConfigEOS:
|
||||
"""ConfigEOS with the EOS configuration file as an active settings source."""
|
||||
return config_eos_factory(
|
||||
init={
|
||||
"with_init_settings": True,
|
||||
"with_env_settings": True,
|
||||
"with_dotenv_settings": False,
|
||||
"with_file_settings": True,
|
||||
"with_file_secret_settings": False,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def write_config_file(config_eos: ConfigEOS, settings: dict[str, Any]) -> None:
|
||||
"""Write settings to the EOS configuration file and load them."""
|
||||
settings = {"general": {"version": config_eos.general.version}, **settings}
|
||||
config_file_path = config_eos.general.config_file_path
|
||||
assert config_file_path is not None
|
||||
config_file_path.write_text(json.dumps(settings), encoding="utf-8")
|
||||
config_eos.reset_settings()
|
||||
|
||||
|
||||
def test_merge_settings_overrides_config_file(config_eos_file):
|
||||
"""Runtime settings take precedence over the EOS configuration file."""
|
||||
write_config_file(
|
||||
config_eos_file,
|
||||
{
|
||||
"optimization": {"genetic": {"individuals": 200}},
|
||||
"pvforecast": {
|
||||
"planes": [
|
||||
{"surface_tilt": 30.0, "surface_azimuth": azimuth, "peakpower": 5.0}
|
||||
for azimuth in (0.0, 90.0, 180.0, 270.0)
|
||||
]
|
||||
},
|
||||
},
|
||||
)
|
||||
assert config_eos_file.optimization.genetic.individuals == 200
|
||||
assert len(config_eos_file.pvforecast.planes) == 4
|
||||
|
||||
config_eos_file.merge_settings_from_dict(
|
||||
{
|
||||
"optimization": {"genetic": {"individuals": 300}},
|
||||
"pvforecast": {
|
||||
"planes": [{"surface_tilt": 30.0, "surface_azimuth": 180.0, "peakpower": 5.0}]
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
assert config_eos_file.optimization.genetic.individuals == 300
|
||||
assert len(config_eos_file.pvforecast.planes) == 1
|
||||
|
||||
|
||||
def test_merge_settings_overrides_env(config_eos_file, monkeypatch):
|
||||
"""Runtime settings take precedence over environment variables."""
|
||||
monkeypatch.setenv("EOS_OPTIMIZATION__GENETIC__INDIVIDUALS", "150")
|
||||
config_eos_file.reset_settings()
|
||||
assert config_eos_file.optimization.genetic.individuals == 150
|
||||
|
||||
config_eos_file.merge_settings_from_dict({"optimization": {"genetic": {"individuals": 300}}})
|
||||
|
||||
assert config_eos_file.optimization.genetic.individuals == 300
|
||||
|
||||
|
||||
def test_env_overrides_config_file_after_merge(config_eos_file, monkeypatch):
|
||||
"""Environment variables keep precedence over the config file for untouched keys."""
|
||||
write_config_file(config_eos_file, {"server": {"port": 9000}})
|
||||
monkeypatch.setenv("EOS_SERVER__PORT", "9500")
|
||||
config_eos_file.reset_settings()
|
||||
assert config_eos_file.server.port == 9500
|
||||
|
||||
# A runtime update of an unrelated key must not freeze the env value
|
||||
config_eos_file.merge_settings_from_dict({"general": {"latitude": 51.1657}})
|
||||
assert config_eos_file.general.latitude == 51.1657
|
||||
assert config_eos_file.server.port == 9500
|
||||
|
||||
monkeypatch.setenv("EOS_SERVER__PORT", "9600")
|
||||
config_eos_file.reset_settings()
|
||||
assert config_eos_file.server.port == 9600
|
||||
|
||||
|
||||
def test_reset_settings_drops_runtime_settings(config_eos_file):
|
||||
"""Reset drops runtime settings and falls back to the config file."""
|
||||
write_config_file(config_eos_file, {"optimization": {"genetic": {"individuals": 200}}})
|
||||
|
||||
config_eos_file.merge_settings_from_dict({"optimization": {"genetic": {"individuals": 300}}})
|
||||
assert config_eos_file.optimization.genetic.individuals == 300
|
||||
|
||||
config_eos_file.reset_settings()
|
||||
assert config_eos_file.optimization.genetic.individuals == 200
|
||||
|
||||
|
||||
def test_set_nested_value_survives_merge(config_eos_file):
|
||||
"""Granular updates are not lost by a later bulk update."""
|
||||
write_config_file(
|
||||
config_eos_file,
|
||||
{
|
||||
"general": {"latitude": 48.0},
|
||||
"optimization": {"genetic": {"individuals": 200}},
|
||||
"pvforecast": {
|
||||
"planes": [
|
||||
{"surface_tilt": 30.0, "surface_azimuth": azimuth, "peakpower": 5.0}
|
||||
for azimuth in (0.0, 90.0)
|
||||
]
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
config_eos_file.set_nested_value("optimization/genetic/individuals", 400)
|
||||
# A list index can not be expressed by the settings dictionary
|
||||
config_eos_file.set_nested_value("pvforecast/planes/1/peakpower", 9.9)
|
||||
# Clearing a value must not be reverted by the config file either
|
||||
config_eos_file.set_nested_value("general/latitude", None)
|
||||
|
||||
config_eos_file.merge_settings_from_dict({"server": {"port": 8600}})
|
||||
|
||||
assert config_eos_file.server.port == 8600
|
||||
assert config_eos_file.optimization.genetic.individuals == 400
|
||||
assert config_eos_file.pvforecast.planes[1].peakpower == 9.9
|
||||
assert config_eos_file.general.latitude is None
|
||||
|
||||
|
||||
def test_revert_settings_restores_backup(config_eos_file):
|
||||
"""Revert restores the backup values even if the config file differs."""
|
||||
write_config_file(config_eos_file, {"optimization": {"genetic": {"individuals": 200}}})
|
||||
|
||||
config_file_path = config_eos_file.general.config_file_path
|
||||
assert config_file_path is not None
|
||||
backup_path = config_file_path.with_suffix(".backup")
|
||||
backup_path.write_text(
|
||||
json.dumps(
|
||||
{
|
||||
"general": {"version": config_eos_file.general.version},
|
||||
"optimization": {"genetic": {"individuals": 500}},
|
||||
}
|
||||
),
|
||||
encoding="utf-8",
|
||||
)
|
||||
|
||||
config_eos_file.revert_settings("backup")
|
||||
|
||||
assert config_eos_file.optimization.genetic.individuals == 500
|
||||
|
||||
|
||||
def test_config_from_env_on_first_init(config_eos, config_default_dirs, monkeypatch):
|
||||
"""Environment variables are applied on the first configuration build."""
|
||||
config_eos.reset_instance()
|
||||
|
||||
monkeypatch.setenv("EOS_CONFIG_DIR", str(config_default_dirs[0]))
|
||||
monkeypatch.setenv("EOS_SERVER__PORT", "8553")
|
||||
|
||||
assert ConfigEOS().server.port == 8553
|
||||
|
||||
@@ -28,6 +28,9 @@ import pendulum
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from akkudoktoreos.config.configabc import ( # noqa — ensure Time is importable
|
||||
CycleTimeWindowSequence,
|
||||
)
|
||||
from akkudoktoreos.config.configabc import TimeWindow
|
||||
from akkudoktoreos.config.configabc import TimeWindow as _TW_check
|
||||
from akkudoktoreos.config.configabc import ( # noqa — ensure Time is importable
|
||||
@@ -1504,3 +1507,491 @@ class TestAlignToIntervalTimezoneInvariance:
|
||||
assert series.iloc[0] == pytest.approx(0.25)
|
||||
assert series.iloc[1] == pytest.approx(0.25)
|
||||
assert series.iloc[2] == pytest.approx(0.0)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# CycleTimeWindowSequence
|
||||
# ===========================================================================
|
||||
|
||||
class TestCycleTimeWindowSequence:
|
||||
"""Tests for CycleTimeWindowSequence.
|
||||
|
||||
Window layout:
|
||||
win1: 08:00–12:00 cycle=0
|
||||
win2: 14:00–18:00 cycle=1
|
||||
win3: 20:00–22:00 cycle=2
|
||||
"""
|
||||
|
||||
def setup_method(self, method):
|
||||
self.seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="4 hours", value=0.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="14:00:00", duration="4 hours", value=1.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="20:00:00", duration="2 hours", value=2.0)),
|
||||
]
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# cycle detection
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_num_cycles(self):
|
||||
assert self.seq.num_cycles() == 3
|
||||
|
||||
def test_num_cycles_ignores_none(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="2 hours", value=None)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="10:00:00", duration="2 hours", value=1.0)),
|
||||
]
|
||||
)
|
||||
assert seq.num_cycles() == 1
|
||||
|
||||
def test_num_cycles_non_contiguous(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="2 hours", value=2.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="10:00:00", duration="2 hours", value=5.0)),
|
||||
]
|
||||
)
|
||||
assert seq.num_cycles() == 2
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# cycle_to_array basic correctness
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_cycle0_array(self):
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 16, 0)
|
||||
|
||||
arr = self.seq.cycle_to_array(
|
||||
0, start, end, pendulum.duration(hours=1)
|
||||
)
|
||||
|
||||
assert arr.shape == (24,)
|
||||
assert arr[8] == pytest.approx(1.0)
|
||||
assert arr[11] == pytest.approx(1.0)
|
||||
assert arr[12] == pytest.approx(0.0)
|
||||
|
||||
def test_cycle1_array(self):
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 16, 0)
|
||||
|
||||
arr = self.seq.cycle_to_array(
|
||||
1, start, end, pendulum.duration(hours=1)
|
||||
)
|
||||
|
||||
assert arr[14] == pytest.approx(1.0)
|
||||
assert arr[17] == pytest.approx(1.0)
|
||||
assert arr[13] == pytest.approx(0.0)
|
||||
|
||||
def test_cycle2_array(self):
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 16, 0)
|
||||
|
||||
arr = self.seq.cycle_to_array(
|
||||
2, start, end, pendulum.duration(hours=1)
|
||||
)
|
||||
|
||||
assert arr[20] == pytest.approx(1.0)
|
||||
assert arr[21] == pytest.approx(1.0)
|
||||
assert arr[22] == pytest.approx(0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# cycle not present
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_cycle_not_present_all_zero(self):
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 15, 6)
|
||||
|
||||
arr = self.seq.cycle_to_array(
|
||||
5, start, end, pendulum.duration(hours=1)
|
||||
)
|
||||
|
||||
assert np.all(arr == 0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# aware datetime
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_cycle_array_aware_datetime(self):
|
||||
start = aware_dt(2024, 6, 15, 0, tz="Europe/Berlin")
|
||||
end = aware_dt(2024, 6, 16, 0, tz="Europe/Berlin")
|
||||
|
||||
arr = self.seq.cycle_to_array(
|
||||
1, start, end, pendulum.duration(hours=1)
|
||||
)
|
||||
|
||||
assert arr[14] == pytest.approx(1.0)
|
||||
assert arr[13] == pytest.approx(0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# dtype
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_cycle_array_dtype(self):
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 15, 6)
|
||||
|
||||
arr = self.seq.cycle_to_array(
|
||||
0, start, end, pendulum.duration(hours=1)
|
||||
)
|
||||
|
||||
assert arr.dtype == np.float64
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# dropna propagation
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_cycle_array_dropna_false(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="2 hours", value=None)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="10:00:00", duration="2 hours", value=1.0)),
|
||||
]
|
||||
)
|
||||
|
||||
start = naive_dt(2024, 6, 15, 8)
|
||||
end = naive_dt(2024, 6, 15, 13)
|
||||
|
||||
arr = seq.cycle_to_array(
|
||||
1, start, end, pendulum.duration(hours=1), dropna=False
|
||||
)
|
||||
|
||||
assert arr[2] == pytest.approx(1.0)
|
||||
assert arr[3] == pytest.approx(1.0)
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# CycleTimeWindowSequence.cycles_to_matrix
|
||||
# ===========================================================================
|
||||
|
||||
class TestCyclesToMatrix:
|
||||
"""Tests for CycleTimeWindowSequence.cycles_to_matrix.
|
||||
|
||||
The method returns ``(cycle_indices, matrix)`` where:
|
||||
|
||||
* ``cycle_indices`` — sorted list of distinct integer cycle indices
|
||||
(derived from the integer part of each window's ``value``).
|
||||
* ``matrix`` — shape ``(len(cycle_indices), n_steps)`` float64 array;
|
||||
``matrix[k, t] == 1.0`` iff step ``t`` falls inside a window whose
|
||||
cycle index equals ``cycle_indices[k]``, ``0.0`` otherwise.
|
||||
|
||||
Alignment contract (same as ``to_array`` and ``cycle_to_array``):
|
||||
* ``start_datetime`` is floored to the nearest interval boundary in
|
||||
wall-clock time before building the grid.
|
||||
* The step count uses ``math.ceil`` so that a partially-covered final
|
||||
step is included, consistent with ``to_array``'s while-loop.
|
||||
|
||||
Window layout used in ``setup_method`` unless overridden:
|
||||
cycle 0: 08:00–12:00 (4 h)
|
||||
cycle 1: 14:00–18:00 (4 h)
|
||||
cycle 2: 20:00–22:00 (2 h)
|
||||
All tests use 1-hour steps over a 24-hour horizon unless stated otherwise.
|
||||
"""
|
||||
|
||||
def setup_method(self, method):
|
||||
self.seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="4 hours", value=0.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="14:00:00", duration="4 hours", value=1.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="20:00:00", duration="2 hours", value=2.0)),
|
||||
]
|
||||
)
|
||||
self.start = naive_dt(2024, 6, 15, 0)
|
||||
self.end = naive_dt(2024, 6, 16, 0)
|
||||
self.interval = pendulum.duration(hours=1)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# return-value structure
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_returns_tuple_of_two(self):
|
||||
result = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert isinstance(result, tuple) and len(result) == 2
|
||||
|
||||
def test_cycle_indices_is_sorted_list(self):
|
||||
indices, _ = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == sorted(indices)
|
||||
assert isinstance(indices, list)
|
||||
|
||||
def test_cycle_indices_values(self):
|
||||
indices, _ = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == [0, 1, 2]
|
||||
|
||||
def test_matrix_shape(self):
|
||||
indices, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert matrix.shape == (len(indices), 24)
|
||||
|
||||
def test_matrix_dtype_float64(self):
|
||||
_, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert matrix.dtype == np.float64
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# correctness: cycle-row contents
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_cycle0_row_marks_correct_steps(self):
|
||||
# Cycle 0: 08:00–12:00 → steps 8, 9, 10, 11
|
||||
_, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert matrix[0, 7] == pytest.approx(0.0)
|
||||
assert matrix[0, 8] == pytest.approx(1.0)
|
||||
assert matrix[0, 11] == pytest.approx(1.0)
|
||||
assert matrix[0, 12] == pytest.approx(0.0)
|
||||
|
||||
def test_cycle1_row_marks_correct_steps(self):
|
||||
# Cycle 1: 14:00–18:00 → steps 14, 15, 16, 17
|
||||
_, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert matrix[1, 13] == pytest.approx(0.0)
|
||||
assert matrix[1, 14] == pytest.approx(1.0)
|
||||
assert matrix[1, 17] == pytest.approx(1.0)
|
||||
assert matrix[1, 18] == pytest.approx(0.0)
|
||||
|
||||
def test_cycle2_row_marks_correct_steps(self):
|
||||
# Cycle 2: 20:00–22:00 → steps 20, 21
|
||||
_, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert matrix[2, 19] == pytest.approx(0.0)
|
||||
assert matrix[2, 20] == pytest.approx(1.0)
|
||||
assert matrix[2, 21] == pytest.approx(1.0)
|
||||
assert matrix[2, 22] == pytest.approx(0.0)
|
||||
|
||||
def test_cycle_rows_are_mutually_exclusive(self):
|
||||
# No step should be 1.0 in more than one row
|
||||
_, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
overlap = (matrix > 0.5).sum(axis=0)
|
||||
assert np.all(overlap <= 1)
|
||||
|
||||
def test_steps_outside_all_windows_are_zero_in_all_rows(self):
|
||||
_, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
outside = list(range(0, 8)) + [12, 13, 18, 19] + list(range(22, 24))
|
||||
for t in outside:
|
||||
assert matrix[:, t].sum() == pytest.approx(0.0), f"step {t} should be all-zero"
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# None value windows are skipped
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_none_value_windows_skipped(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="2 hours", value=None)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="10:00:00", duration="2 hours", value=1.0)),
|
||||
]
|
||||
)
|
||||
indices, matrix = seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == [1]
|
||||
assert matrix.shape == (1, 24)
|
||||
# The None window (08:00–10:00) must not bleed into cycle 1's row
|
||||
assert matrix[0, 8] == pytest.approx(0.0)
|
||||
assert matrix[0, 10] == pytest.approx(1.0)
|
||||
assert matrix[0, 11] == pytest.approx(1.0)
|
||||
|
||||
def test_all_none_returns_empty(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="2 hours", value=None)),
|
||||
]
|
||||
)
|
||||
indices, matrix = seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == []
|
||||
assert matrix.shape == (0, 24)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# row ordering: sorted by cycle index regardless of window order
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_row_order_independent_of_window_order(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="20:00:00", duration="2 hours", value=2.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="4 hours", value=0.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="14:00:00", duration="4 hours", value=1.0)),
|
||||
]
|
||||
)
|
||||
indices, matrix = seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == [0, 1, 2]
|
||||
# Row 0 must be cycle 0 (08:00–12:00)
|
||||
assert matrix[0, 8] == pytest.approx(1.0)
|
||||
assert matrix[0, 14] == pytest.approx(0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# non-contiguous cycle indices
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_non_contiguous_cycle_indices(self):
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="06:00:00", duration="2 hours", value=3.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="16:00:00", duration="2 hours", value=7.0)),
|
||||
]
|
||||
)
|
||||
indices, matrix = seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == [3, 7]
|
||||
assert matrix.shape == (2, 24)
|
||||
assert matrix[0, 6] == pytest.approx(1.0)
|
||||
assert matrix[0, 7] == pytest.approx(1.0)
|
||||
assert matrix[1, 16] == pytest.approx(1.0)
|
||||
assert matrix[1, 17] == pytest.approx(1.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# multiple windows for the same cycle index (union)
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_same_cycle_multiple_windows_union(self):
|
||||
# Cycle 0 appears twice: 06:00–08:00 and 20:00–22:00
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="06:00:00", duration="2 hours", value=0.0)),
|
||||
ValueTimeWindow.model_validate(dict(start_time="20:00:00", duration="2 hours", value=0.0)),
|
||||
]
|
||||
)
|
||||
indices, matrix = seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == [0]
|
||||
assert matrix[0, 6] == pytest.approx(1.0)
|
||||
assert matrix[0, 7] == pytest.approx(1.0)
|
||||
assert matrix[0, 20] == pytest.approx(1.0)
|
||||
assert matrix[0, 21] == pytest.approx(1.0)
|
||||
assert matrix[0, 8] == pytest.approx(0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# sub-hour steps
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_30min_steps(self):
|
||||
# Cycle 0: 08:00–12:00 → 8 half-hour steps starting at step 16 (08:00 / 0.5h)
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="4 hours", value=0.0)),
|
||||
]
|
||||
)
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 16, 0)
|
||||
_, matrix = seq.cycles_to_matrix(start, end, pendulum.duration(minutes=30))
|
||||
assert matrix.shape == (1, 48)
|
||||
# Steps 16–23 (08:00–12:00 in 30-min slots)
|
||||
assert matrix[0, 15] == pytest.approx(0.0)
|
||||
assert matrix[0, 16] == pytest.approx(1.0)
|
||||
assert matrix[0, 23] == pytest.approx(1.0)
|
||||
assert matrix[0, 24] == pytest.approx(0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# aware datetime
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_aware_datetime_berlin(self):
|
||||
start = aware_dt(2024, 6, 15, 0, tz="Europe/Berlin")
|
||||
end = aware_dt(2024, 6, 16, 0, tz="Europe/Berlin")
|
||||
indices, matrix = self.seq.cycles_to_matrix(start, end, self.interval)
|
||||
assert indices == [0, 1, 2]
|
||||
assert matrix[0, 8] == pytest.approx(1.0)
|
||||
assert matrix[0, 11] == pytest.approx(1.0)
|
||||
assert matrix[0, 12] == pytest.approx(0.0)
|
||||
|
||||
def test_aware_datetime_utc(self):
|
||||
start = aware_dt(2024, 6, 15, 0, tz="UTC")
|
||||
end = aware_dt(2024, 6, 16, 0, tz="UTC")
|
||||
indices, matrix = self.seq.cycles_to_matrix(start, end, self.interval)
|
||||
assert matrix[0, 8] == pytest.approx(1.0)
|
||||
assert matrix[1, 14] == pytest.approx(1.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# short horizon — window partially or fully outside
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_window_fully_outside_horizon(self):
|
||||
# Only first 6 hours — all windows are outside
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 15, 6)
|
||||
indices, matrix = self.seq.cycles_to_matrix(start, end, self.interval)
|
||||
assert matrix.shape == (3, 6)
|
||||
assert np.all(matrix == 0.0)
|
||||
|
||||
def test_window_partially_inside_horizon_clipped(self):
|
||||
# Horizon ends at 10:00; cycle 0 window is 08:00–12:00 → only steps 8, 9 inside
|
||||
start = naive_dt(2024, 6, 15, 0)
|
||||
end = naive_dt(2024, 6, 15, 10)
|
||||
indices, matrix = self.seq.cycles_to_matrix(start, end, self.interval)
|
||||
assert matrix.shape == (3, 10)
|
||||
assert matrix[0, 8] == pytest.approx(1.0)
|
||||
assert matrix[0, 9] == pytest.approx(1.0)
|
||||
assert matrix[0, :8].sum() == pytest.approx(0.0)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# empty sequence
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_empty_sequence(self):
|
||||
seq = CycleTimeWindowSequence()
|
||||
indices, matrix = seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
assert indices == []
|
||||
assert matrix.shape == (0, 24)
|
||||
assert matrix.dtype == np.float64
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# alignment: misaligned start_datetime is floored (wall-clock floor)
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_misaligned_start_floored_step_count(self):
|
||||
# start=08:10, end=10:10, interval=1h
|
||||
# floor(08:10) = 08:00 → steps: 08:00, 09:00, 10:00 = 3 steps
|
||||
# (10:00 < 10:10, so it is included by ceil)
|
||||
# Window 08:00–12:00 → all three steps are inside → all 1.0
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="4 hours", value=0.0))]
|
||||
)
|
||||
start = naive_dt(2024, 6, 15, 8, 10)
|
||||
end = naive_dt(2024, 6, 15, 10, 10)
|
||||
_, matrix = seq.cycles_to_matrix(start, end, pendulum.duration(hours=1))
|
||||
assert matrix.shape == (1, 3)
|
||||
np.testing.assert_array_equal(matrix[0], [1.0, 1.0, 1.0])
|
||||
|
||||
def test_misaligned_start_30min_steps(self):
|
||||
# start=08:15, interval=30min → floor to 08:00
|
||||
# Window 08:00–10:00 → steps 08:00(1), 08:30(1), 09:00(1), 09:30(1)
|
||||
seq = CycleTimeWindowSequence(
|
||||
windows=[ValueTimeWindow.model_validate(dict(start_time="08:00:00", duration="2 hours", value=0.0))]
|
||||
)
|
||||
start = naive_dt(2024, 6, 15, 8, 15)
|
||||
end = naive_dt(2024, 6, 15, 10, 15)
|
||||
_, matrix = seq.cycles_to_matrix(start, end, pendulum.duration(minutes=30))
|
||||
# floor(08:15, 30min) = 08:00; steps: 08:00,08:30,09:00,09:30,10:00(ceil)
|
||||
# 10:00 is outside [08:00,10:00) → 0.0
|
||||
assert matrix.shape[1] >= 4
|
||||
np.testing.assert_array_equal(matrix[0, :4], [1.0, 1.0, 1.0, 1.0])
|
||||
assert matrix[0, 4] == pytest.approx(0.0) # 10:00 outside
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# consistency with cycle_to_array
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def test_matrix_rows_match_cycle_to_array(self):
|
||||
"""Each matrix row must exactly match the corresponding cycle_to_array output.
|
||||
|
||||
Both methods now use the same wall-clock floor alignment and math.ceil
|
||||
step count, so they must produce identical arrays for every cycle.
|
||||
"""
|
||||
indices, matrix = self.seq.cycles_to_matrix(self.start, self.end, self.interval)
|
||||
for k, cycle_idx in enumerate(indices):
|
||||
expected = self.seq.cycle_to_array(
|
||||
cycle_idx, self.start, self.end, self.interval
|
||||
)
|
||||
np.testing.assert_array_equal(
|
||||
matrix[k],
|
||||
expected,
|
||||
err_msg=f"Row {k} (cycle {cycle_idx}) differs from cycle_to_array",
|
||||
)
|
||||
|
||||
def test_matrix_rows_match_cycle_to_array_misaligned(self):
|
||||
"""Consistency holds even when start_datetime is not on an interval boundary."""
|
||||
start = naive_dt(2024, 6, 15, 8, 20)
|
||||
end = naive_dt(2024, 6, 15, 14, 20)
|
||||
interval = pendulum.duration(hours=1)
|
||||
indices, matrix = self.seq.cycles_to_matrix(start, end, interval)
|
||||
for k, cycle_idx in enumerate(indices):
|
||||
expected = self.seq.cycle_to_array(cycle_idx, start, end, interval)
|
||||
np.testing.assert_array_equal(
|
||||
matrix[k],
|
||||
expected,
|
||||
err_msg=f"Row {k} (cycle {cycle_idx}) differs from cycle_to_array (misaligned)",
|
||||
)
|
||||
|
||||
@@ -214,18 +214,20 @@ class TestConfigMigration:
|
||||
|
||||
# Verify the migrated value matches the expected one
|
||||
new_value = configmigrate._get_json_nested_value(new_data, new_path)
|
||||
if new_value != expected_value:
|
||||
value_errors = _dict_contains(new_value, expected_value, new_path)
|
||||
|
||||
if value_errors:
|
||||
# Check if this mapping uses _KEEP_DEFAULT and the old value was None/missing
|
||||
old_value = configmigrate._get_json_nested_value(old_data, old_path)
|
||||
keep_default = (
|
||||
isinstance(mapping, tuple)
|
||||
and configmigrate._KEEP_DEFAULT in mapping
|
||||
)
|
||||
|
||||
if keep_default and old_value is None:
|
||||
continue # acceptable: old was None, new model keeps its default
|
||||
mismatched_values.append(
|
||||
f"{old_path} → {new_path}: expected {expected_value!r}, got {new_value!r}"
|
||||
)
|
||||
|
||||
mismatched_values.extend(value_errors)
|
||||
|
||||
assert not missing_migrations, (
|
||||
"Some expected migration map entries were not migrated:\n"
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
"""Contracts required by the combined EOS configuration."""
|
||||
import copy
|
||||
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from akkudoktoreos.config.configmigrate import migrate_config_data
|
||||
from akkudoktoreos.devices.devices import DevicesCommonSettings
|
||||
from akkudoktoreos.devices.settings.invertersettings import InverterCommonSettings
|
||||
|
||||
|
||||
def test_device_map_supplies_stable_identity():
|
||||
raw = {"batteries": {"house": {"capacity_wh": 12000}}}
|
||||
a = DevicesCommonSettings.model_validate(raw)
|
||||
b = DevicesCommonSettings.model_validate(raw)
|
||||
assert a.batteries is not None and b.batteries is not None
|
||||
assert a.batteries["house"].device_id == b.batteries["house"].device_id == "house"
|
||||
assert "house-soc-factor" in a.measurement_keys
|
||||
|
||||
|
||||
def test_device_map_rejects_conflicting_identity():
|
||||
with pytest.raises(ValidationError, match="device_id"):
|
||||
DevicesCommonSettings.model_validate({"batteries": {"house": {"device_id": "other"}}})
|
||||
|
||||
|
||||
@pytest.mark.parametrize("as_list", [False, True])
|
||||
def test_migration_preserves_lcos_and_input(as_list):
|
||||
battery = {"device_id": "house", "capacity_wh": 12000,
|
||||
"levelized_cost_of_storage_kwh": 0.123}
|
||||
raw = {"devices": {"batteries": [battery] if as_list else {"house": battery}}}
|
||||
original = copy.deepcopy(raw)
|
||||
migrated = migrate_config_data(raw)
|
||||
assert migrated.devices.batteries is not None
|
||||
assert migrated.devices.batteries["house"].levelized_cost_of_storage_amt_kwh == 0.123
|
||||
assert raw == original
|
||||
|
||||
|
||||
@pytest.mark.parametrize("converter", ["to_genetic_param", "to_genetic0_param"])
|
||||
def test_inverter_conversion_requires_output_limit(converter):
|
||||
settings = InverterCommonSettings(device_id="inverter")
|
||||
with pytest.raises(ValueError, match="max_power_w"):
|
||||
getattr(settings, converter)()
|
||||
settings.max_power_w = 4200
|
||||
assert getattr(settings, converter)().max_power_wh == 4200
|
||||
@@ -17,17 +17,17 @@ from unittest.mock import Mock, patch
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.devices.genetic0.genetic0battery import Genetic0Battery
|
||||
from akkudoktoreos.devices.genetic0.genetic0inverter import Genetic0Inverter
|
||||
from akkudoktoreos.optimization.genetic0.genetic0 import (
|
||||
Genetic0Simulation,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic0.genetic0devices import (
|
||||
Genetic0InverterParameters,
|
||||
from akkudoktoreos.devices.genetic0.genetic0battery import (
|
||||
Genetic0Battery,
|
||||
Genetic0SolarPanelBatteryParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic0.genetic0params import (
|
||||
from akkudoktoreos.devices.genetic0.genetic0inverter import (
|
||||
Genetic0Inverter,
|
||||
Genetic0InverterParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic0.genetic0 import (
|
||||
Genetic0EnergyManagementParameters,
|
||||
Genetic0Simulation,
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@@ -83,11 +83,11 @@ async def test_optimize(
|
||||
},
|
||||
"devices": {
|
||||
"max_electric_vehicles": 1,
|
||||
"electric_vehicles": [
|
||||
"electric_vehicles": { "ev1":
|
||||
{
|
||||
"charge_rates": [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
|
||||
}
|
||||
],
|
||||
},
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
@@ -2,21 +2,23 @@ import numpy as np
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.config.configabc import TimeWindow, TimeWindowSequence
|
||||
from akkudoktoreos.devices.genetic0.genetic0battery import Genetic0Battery
|
||||
from akkudoktoreos.devices.genetic0.genetic0homeappliance import Genetic0HomeAppliance
|
||||
from akkudoktoreos.devices.genetic0.genetic0inverter import Genetic0Inverter
|
||||
from akkudoktoreos.optimization.genetic0.genetic0 import (
|
||||
Genetic0Simulation,
|
||||
Genetic0SimulationResult,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic0.genetic0devices import (
|
||||
from akkudoktoreos.devices.genetic0.genetic0battery import (
|
||||
Genetic0Battery,
|
||||
Genetic0ElectricVehicleParameters,
|
||||
Genetic0HomeApplianceParameters,
|
||||
Genetic0InverterParameters,
|
||||
Genetic0SolarPanelBatteryParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic0.genetic0params import (
|
||||
from akkudoktoreos.devices.genetic0.genetic0homeappliance import (
|
||||
Genetic0HomeAppliance,
|
||||
Genetic0HomeApplianceParameters,
|
||||
)
|
||||
from akkudoktoreos.devices.genetic0.genetic0inverter import (
|
||||
Genetic0Inverter,
|
||||
Genetic0InverterParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic0.genetic0 import (
|
||||
Genetic0EnergyManagementParameters,
|
||||
Genetic0Simulation,
|
||||
Genetic0SimulationResult,
|
||||
)
|
||||
from akkudoktoreos.utils.datetimeutil import to_duration, to_time
|
||||
|
||||
|
||||
@@ -0,0 +1,372 @@
|
||||
"""Regression test suite for the repaired HomeAppliance module.
|
||||
|
||||
TODO: fix this import to match wherever HomeApplianceParameters / HomeAppliance
|
||||
actually live in the repo.
|
||||
"""
|
||||
from typing import Any
|
||||
from unittest.mock import Mock
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.config.configabc import CycleTimeWindowSequence, ValueTimeWindow
|
||||
from akkudoktoreos.devices.genetic.homeappliance import (
|
||||
HomeAppliance,
|
||||
HomeApplianceParameters,
|
||||
)
|
||||
from akkudoktoreos.utils.datetimeutil import to_duration, to_time
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Fixtures / factories
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def make_params(**overrides) -> HomeApplianceParameters:
|
||||
defaults: dict[str, Any] = dict(
|
||||
device_id="dishwasher",
|
||||
consumption_wh=2000,
|
||||
duration_h=2,
|
||||
num_cycles=1,
|
||||
min_cycle_gap_h=0,
|
||||
time_windows=None,
|
||||
)
|
||||
defaults.update(overrides)
|
||||
return HomeApplianceParameters(**defaults)
|
||||
|
||||
|
||||
def make_appliance(
|
||||
prediction_hours: int = 24,
|
||||
optimization_hours: int = 24,
|
||||
**param_overrides,
|
||||
) -> HomeAppliance:
|
||||
params = make_params(**param_overrides)
|
||||
return HomeAppliance(
|
||||
parameters=params,
|
||||
optimization_hours=optimization_hours,
|
||||
prediction_hours=prediction_hours,
|
||||
)
|
||||
|
||||
|
||||
def cycle_window(cycle: int, start: str, duration: str) -> CycleTimeWindowSequence:
|
||||
"""Build a CycleTimeWindowSequence with a single window for one cycle."""
|
||||
return CycleTimeWindowSequence(
|
||||
windows=[
|
||||
ValueTimeWindow(
|
||||
start_time=to_time(start),
|
||||
duration=to_duration(duration),
|
||||
value=float(cycle),
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
def mock_cycle_windows(cycle_matrix: dict[int, np.ndarray]) -> Mock:
|
||||
"""Build a Mock standing in for CycleTimeWindowSequence.
|
||||
|
||||
``Mock(spec=CycleTimeWindowSequence)`` satisfies both the pydantic
|
||||
field-type check on ``HomeApplianceParameters.time_windows`` and any
|
||||
isinstance check in the module, without needing real windows/pendulum
|
||||
datetimes -- useful for isolating _build_duration_feasibility and the
|
||||
scheduling/repair logic from the real cycles_to_matrix() implementation.
|
||||
"""
|
||||
cycle_indices = list(cycle_matrix.keys())
|
||||
matrix = np.array([cycle_matrix[c] for c in cycle_indices])
|
||||
mock = Mock(spec=CycleTimeWindowSequence)
|
||||
mock.cycles_to_matrix = Mock(return_value=(cycle_indices, matrix))
|
||||
return mock
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Setup / defaults
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestSetup:
|
||||
def test_default_time_windows_created_when_none_given(self):
|
||||
appliance = make_appliance(time_windows=None, num_cycles=1)
|
||||
assert appliance.parameters.time_windows is not None
|
||||
assert isinstance(appliance.parameters.time_windows, CycleTimeWindowSequence)
|
||||
|
||||
def test_default_time_window_value_left_unset(self):
|
||||
# A None-valued window is invisible to cycles_to_matrix() and so
|
||||
# never masquerades as a real per-cycle window; every remaining
|
||||
# cycle instead falls through to the "unconstrained" fallback.
|
||||
appliance = make_appliance(time_windows=None, num_cycles=3)
|
||||
assert appliance.parameters.time_windows is not None
|
||||
windows = appliance.parameters.time_windows.windows
|
||||
assert len(windows) == 1
|
||||
assert windows[0].value is None
|
||||
|
||||
def test_default_time_window_serializes_without_a_cycle_value(self):
|
||||
appliance = make_appliance(time_windows=None, num_cycles=1)
|
||||
assert appliance.parameters.time_windows is not None
|
||||
dumped = appliance.parameters.time_windows.model_dump()
|
||||
assert dumped["windows"][0]["value"] is None
|
||||
|
||||
def test_num_remaining_cycles_initial(self):
|
||||
appliance = make_appliance(num_cycles=3)
|
||||
assert appliance.num_remaining_cycles == 3
|
||||
|
||||
def test_num_remaining_cycles_never_negative(self):
|
||||
appliance = make_appliance(num_cycles=2)
|
||||
appliance.completed_cycles = 5
|
||||
assert appliance.num_remaining_cycles == 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Allowed-start computation: default (unconstrained) per-cycle windows
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestDefaultStartAllowed:
|
||||
def test_starts_allowed_up_to_horizon_minus_duration(self):
|
||||
appliance = make_appliance(prediction_hours=10, duration_h=3)
|
||||
max_start = 10 - 3
|
||||
allowed = appliance.start_allowed[0]
|
||||
assert allowed[: max_start + 1].all()
|
||||
|
||||
def test_starts_beyond_horizon_minus_duration_forbidden(self):
|
||||
appliance = make_appliance(prediction_hours=10, duration_h=3)
|
||||
max_start = 10 - 3
|
||||
allowed = appliance.start_allowed[0]
|
||||
assert not allowed[max_start + 1 :].any()
|
||||
|
||||
def test_start_earliest_and_latest(self):
|
||||
appliance = make_appliance(prediction_hours=10, duration_h=3)
|
||||
assert appliance.start_earliest[0] == 0
|
||||
assert appliance.start_latest[0] == 10 - 3
|
||||
|
||||
def test_each_cycle_gets_its_own_unconstrained_mask(self):
|
||||
appliance = make_appliance(prediction_hours=10, duration_h=2, num_cycles=2)
|
||||
max_start = 10 - 2
|
||||
assert appliance.start_allowed[0][: max_start + 1].all()
|
||||
assert appliance.start_allowed[1][: max_start + 1].all()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Allowed-start computation: explicit single-cycle window
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestExplicitCycleWindow:
|
||||
def test_only_hours_inside_window_allowed(self):
|
||||
appliance = make_appliance(
|
||||
prediction_hours=24,
|
||||
duration_h=2,
|
||||
num_cycles=1,
|
||||
time_windows=cycle_window(0, "10:00", "3 hours"),
|
||||
)
|
||||
allowed = appliance.start_allowed[0]
|
||||
# Window is 10:00-13:00, appliance needs 2h -> valid starts 10, 11.
|
||||
assert allowed[10] and allowed[11]
|
||||
assert not allowed[9]
|
||||
assert not allowed[12]
|
||||
|
||||
def test_earliest_latest_reflect_window(self):
|
||||
appliance = make_appliance(
|
||||
prediction_hours=24,
|
||||
duration_h=2,
|
||||
num_cycles=1,
|
||||
time_windows=cycle_window(0, "10:00", "3 hours"),
|
||||
)
|
||||
assert appliance.start_earliest[0] == 10
|
||||
assert appliance.start_latest[0] == 11
|
||||
|
||||
def test_window_with_no_valid_start_falls_back(self):
|
||||
# Window shorter than the appliance's own duration -> nothing fits.
|
||||
appliance = make_appliance(
|
||||
prediction_hours=24,
|
||||
duration_h=3,
|
||||
num_cycles=1,
|
||||
time_windows=cycle_window(0, "10:00", "1 hour"),
|
||||
)
|
||||
allowed = appliance.start_allowed[0]
|
||||
assert not allowed.any()
|
||||
assert appliance.start_earliest[0] == 0
|
||||
assert appliance.start_latest[0] == 24 - 3
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Allowed-start computation: mocked per-cycle windows (CycleTimeWindowSequence)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestCycleStartAllowed:
|
||||
def test_missing_cycle_row_is_unconstrained(self):
|
||||
# num_cycles=2 but the mock only provides a window for cycle 0.
|
||||
prediction_hours = 10
|
||||
duration_h = 2
|
||||
steps = np.zeros(prediction_hours)
|
||||
steps[2:6] = 1.0
|
||||
windows = mock_cycle_windows({0: steps})
|
||||
|
||||
appliance = make_appliance(
|
||||
prediction_hours=prediction_hours,
|
||||
duration_h=duration_h,
|
||||
num_cycles=2,
|
||||
time_windows=windows,
|
||||
)
|
||||
|
||||
max_start = prediction_hours - duration_h
|
||||
# Cycle 1 has no matrix row -> should be allowed everywhere it fits.
|
||||
assert appliance.start_allowed[1][: max_start + 1].all()
|
||||
|
||||
def test_duration_feasibility_uses_correct_window(self):
|
||||
# Steps 2,3,4,5 are inside the window (1.0); everything else is 0.
|
||||
# duration_h=2 -> valid starts are 2, 3, 4 (each 2h block fully inside).
|
||||
prediction_hours = 10
|
||||
duration_h = 2
|
||||
steps = np.zeros(prediction_hours)
|
||||
steps[2:6] = 1.0
|
||||
windows = mock_cycle_windows({0: steps})
|
||||
|
||||
appliance = make_appliance(
|
||||
prediction_hours=prediction_hours,
|
||||
duration_h=duration_h,
|
||||
num_cycles=1,
|
||||
time_windows=windows,
|
||||
)
|
||||
|
||||
allowed = appliance.start_allowed[0]
|
||||
expected = np.zeros(prediction_hours, dtype=bool)
|
||||
expected[2:5] = True # starts 2, 3, 4
|
||||
np.testing.assert_array_equal(allowed, expected)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# set_completed_cycles
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestSetCompletedCycles:
|
||||
def test_resets_start_hours_and_load_curve(self):
|
||||
appliance = make_appliance(num_cycles=2)
|
||||
appliance.start_hours = [1, 5]
|
||||
appliance.load_curve[0] = 999
|
||||
|
||||
appliance.set_completed_cycles(1)
|
||||
|
||||
assert appliance.start_hours == []
|
||||
assert (appliance.load_curve == 0).all()
|
||||
|
||||
def test_remaining_cycle_indices_updated(self):
|
||||
appliance = make_appliance(num_cycles=4)
|
||||
appliance.set_completed_cycles(2)
|
||||
assert appliance.remaining_cycle_indices == [2, 3]
|
||||
assert appliance.num_remaining_cycles == 2
|
||||
|
||||
def test_clamped_to_valid_range(self):
|
||||
appliance = make_appliance(num_cycles=3)
|
||||
appliance.set_completed_cycles(-5)
|
||||
assert appliance.completed_cycles == 0
|
||||
appliance.set_completed_cycles(99)
|
||||
assert appliance.completed_cycles == 3
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# set_starting_times -- the core scheduling / repair logic
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestSetStartingTimes:
|
||||
def test_single_cycle_schedule_returns_requested_start(self):
|
||||
appliance = make_appliance(prediction_hours=24, duration_h=2, num_cycles=1)
|
||||
result = appliance.set_starting_times([5])
|
||||
assert result == [5]
|
||||
|
||||
def test_two_cycles_enforce_minimum_gap(self):
|
||||
appliance = make_appliance(
|
||||
prediction_hours=24, duration_h=2, num_cycles=2, min_cycle_gap_h=1
|
||||
)
|
||||
# Requested starts overlap; cycle 1 must be pushed to start >= 0+2+1=3.
|
||||
result = appliance.set_starting_times([0, 1])
|
||||
assert result[0] == 0
|
||||
assert result[1] >= 3
|
||||
|
||||
def test_three_cycles_are_all_gap_repaired(self):
|
||||
appliance = make_appliance(
|
||||
prediction_hours=24, duration_h=1, num_cycles=3, min_cycle_gap_h=0
|
||||
)
|
||||
result = appliance.set_starting_times([0, 0, 0])
|
||||
# Each cycle is 1h with no gap -> expect 0, 1, 2.
|
||||
assert result == [0, 1, 2]
|
||||
|
||||
def test_load_curve_reflects_final_start_hours(self):
|
||||
appliance = make_appliance(
|
||||
prediction_hours=10, duration_h=2, consumption_wh=2000, num_cycles=1
|
||||
)
|
||||
appliance.set_starting_times([3])
|
||||
expected = np.zeros(10)
|
||||
expected[3:5] = 1000 # 2000 Wh over 2h
|
||||
np.testing.assert_array_equal(appliance.get_load_curve(), expected)
|
||||
|
||||
def test_sorting_preserves_per_cycle_window_alignment(self):
|
||||
prediction_hours = 24
|
||||
duration_h = 1
|
||||
# Cycle 0 only allowed late (hour 20), cycle 1 only allowed early (hour 2).
|
||||
steps0 = np.zeros(prediction_hours)
|
||||
steps0[20] = 1.0
|
||||
steps1 = np.zeros(prediction_hours)
|
||||
steps1[2] = 1.0
|
||||
windows = mock_cycle_windows({0: steps0, 1: steps1})
|
||||
|
||||
appliance = make_appliance(
|
||||
prediction_hours=prediction_hours,
|
||||
duration_h=duration_h,
|
||||
num_cycles=2,
|
||||
time_windows=windows,
|
||||
)
|
||||
|
||||
result = appliance.set_starting_times([20, 2])
|
||||
# Cycle 0 must land at 20 (its only allowed hour), cycle 1 at 2,
|
||||
# regardless of chronological sorting during repair.
|
||||
assert 20 in result
|
||||
assert 2 in result
|
||||
|
||||
def test_raises_on_wrong_number_of_start_times(self):
|
||||
appliance = make_appliance(prediction_hours=24, duration_h=2, num_cycles=2)
|
||||
with pytest.raises(ValueError):
|
||||
appliance.set_starting_times([5])
|
||||
|
||||
def test_no_remaining_cycles_returns_empty_list(self):
|
||||
appliance = make_appliance(prediction_hours=24, duration_h=2, num_cycles=1)
|
||||
appliance.completed_cycles = 1
|
||||
result = appliance.set_starting_times([])
|
||||
assert result == []
|
||||
assert (appliance.load_curve == 0).all()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Backwards-compatible single-cycle interface
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestSetStartingTimeBackCompat:
|
||||
def test_single_cycle_wrapper_returns_int(self):
|
||||
appliance = make_appliance(prediction_hours=24, duration_h=2, num_cycles=1)
|
||||
result = appliance.set_starting_time(5)
|
||||
assert isinstance(result, int)
|
||||
assert result == 5
|
||||
|
||||
def test_no_remaining_cycles_returns_input_unchanged(self):
|
||||
appliance = make_appliance(prediction_hours=24, duration_h=2, num_cycles=1)
|
||||
appliance.completed_cycles = 1 # nothing left to schedule
|
||||
result = appliance.set_starting_time(7)
|
||||
assert result == 7
|
||||
assert (appliance.load_curve == 0).all()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Load curve utilities
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestLoadCurve:
|
||||
def test_reset_load_curve_zeros_array(self):
|
||||
appliance = make_appliance(prediction_hours=6)
|
||||
appliance.load_curve[:] = 42
|
||||
appliance.reset_load_curve()
|
||||
assert (appliance.load_curve == 0).all()
|
||||
assert len(appliance.load_curve) == 6
|
||||
|
||||
def test_get_load_for_hour_valid(self):
|
||||
appliance = make_appliance(prediction_hours=6)
|
||||
appliance.load_curve[2] = 123.0
|
||||
assert appliance.get_load_for_hour(2) == 123.0
|
||||
|
||||
@pytest.mark.parametrize("hour", [-1, 6, 100])
|
||||
def test_get_load_for_hour_out_of_range_raises(self, hour):
|
||||
appliance = make_appliance(prediction_hours=6)
|
||||
with pytest.raises(ValueError):
|
||||
appliance.get_load_for_hour(hour)
|
||||
@@ -83,11 +83,11 @@ async def test_optimize(
|
||||
},
|
||||
"devices": {
|
||||
"max_electric_vehicles": 1,
|
||||
"electric_vehicles": [
|
||||
"electric_vehicles": { "ev1":
|
||||
{
|
||||
"charge_rates": [0.0, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0],
|
||||
}
|
||||
],
|
||||
},
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
@@ -11,9 +11,8 @@ import numpy as np
|
||||
import pandas as pd
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.devices.genetic.inverter import Inverter
|
||||
from akkudoktoreos.devices.genetic.inverter import Inverter, InverterParameters
|
||||
from akkudoktoreos.optimization.genetic.genetic import GeneticSimulation
|
||||
from akkudoktoreos.optimization.genetic.geneticdevices import InverterParameters
|
||||
from akkudoktoreos.optimization.genetic.geneticparams import (
|
||||
GeneticOptimizationParameters,
|
||||
)
|
||||
|
||||
@@ -2,21 +2,24 @@ import numpy as np
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.config.configabc import TimeWindow, TimeWindowSequence
|
||||
from akkudoktoreos.devices.genetic.battery import Battery
|
||||
from akkudoktoreos.devices.genetic.homeappliance import HomeAppliance
|
||||
from akkudoktoreos.devices.genetic.inverter import Inverter
|
||||
from akkudoktoreos.optimization.genetic.genetic import GeneticSimulation
|
||||
from akkudoktoreos.optimization.genetic.geneticdevices import (
|
||||
from akkudoktoreos.devices.genetic.battery import (
|
||||
Battery,
|
||||
ElectricVehicleParameters,
|
||||
HomeApplianceParameters,
|
||||
InverterParameters,
|
||||
SolarPanelBatteryParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic.geneticparams import (
|
||||
from akkudoktoreos.devices.genetic.homeappliance import (
|
||||
HomeAppliance,
|
||||
HomeApplianceParameters,
|
||||
)
|
||||
from akkudoktoreos.devices.genetic.inverter import (
|
||||
Inverter,
|
||||
InverterParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic.genetic import (
|
||||
GeneticEnergyManagementParameters,
|
||||
GeneticOptimizationParameters,
|
||||
GeneticSimulation,
|
||||
GeneticSimulationResult,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic.geneticsolution import GeneticSimulationResult
|
||||
from akkudoktoreos.utils.datetimeutil import to_duration, to_time
|
||||
|
||||
start_hour = 1
|
||||
|
||||
@@ -2,21 +2,24 @@ import numpy as np
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.config.configabc import TimeWindow, TimeWindowSequence
|
||||
from akkudoktoreos.devices.genetic.battery import Battery
|
||||
from akkudoktoreos.devices.genetic.homeappliance import HomeAppliance
|
||||
from akkudoktoreos.devices.genetic.inverter import Inverter
|
||||
from akkudoktoreos.optimization.genetic.genetic import GeneticSimulation
|
||||
from akkudoktoreos.optimization.genetic.geneticdevices import (
|
||||
from akkudoktoreos.devices.genetic.battery import (
|
||||
Battery,
|
||||
ElectricVehicleParameters,
|
||||
HomeApplianceParameters,
|
||||
InverterParameters,
|
||||
SolarPanelBatteryParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic.geneticparams import (
|
||||
from akkudoktoreos.devices.genetic.homeappliance import (
|
||||
HomeAppliance,
|
||||
HomeApplianceParameters,
|
||||
)
|
||||
from akkudoktoreos.devices.genetic.inverter import (
|
||||
Inverter,
|
||||
InverterParameters,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic.genetic import (
|
||||
GeneticEnergyManagementParameters,
|
||||
GeneticOptimizationParameters,
|
||||
GeneticSimulation,
|
||||
GeneticSimulationResult,
|
||||
)
|
||||
from akkudoktoreos.optimization.genetic.geneticsolution import GeneticSimulationResult
|
||||
from akkudoktoreos.utils.datetimeutil import to_duration, to_time
|
||||
|
||||
start_hour = 0
|
||||
|
||||
@@ -17,12 +17,14 @@ from unittest.mock import Mock, patch
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from akkudoktoreos.devices.genetic.battery import Battery
|
||||
from akkudoktoreos.devices.genetic.inverter import Inverter
|
||||
from akkudoktoreos.optimization.genetic.geneticdevices import (
|
||||
InverterParameters,
|
||||
from akkudoktoreos.devices.genetic.battery import (
|
||||
Battery,
|
||||
SolarPanelBatteryParameters,
|
||||
)
|
||||
from akkudoktoreos.devices.genetic.inverter import (
|
||||
Inverter,
|
||||
InverterParameters,
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers / Fixtures
|
||||
|
||||
+95
-419
@@ -1,4 +1,9 @@
|
||||
## Base configuration for devices simulation settings
|
||||
## Configuration for all controllable devices in the simulation
|
||||
|
||||
Every device collection is a ``dict[str, <Settings>]`` keyed by
|
||||
``device_id``. This makes config paths stable regardless of
|
||||
declaration order and lets each device settings class build its own
|
||||
config path from ``self.device_id`` without needing an external index.
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
:::{table} devices
|
||||
@@ -7,15 +12,15 @@
|
||||
|
||||
| Name | Environment Variable | Type | Read-Only | Default | Description |
|
||||
| ---- | -------------------- | ---- | --------- | ------- | ----------- |
|
||||
| batteries | `EOS_DEVICES__BATTERIES` | `list[akkudoktoreos.devices.devices.BatteriesCommonSettings] | None` | `rw` | `None` | List of battery devices |
|
||||
| electric_vehicles | `EOS_DEVICES__ELECTRIC_VEHICLES` | `list[akkudoktoreos.devices.devices.BatteriesCommonSettings] | None` | `rw` | `None` | List of electric vehicle devices |
|
||||
| home_appliances | `EOS_DEVICES__HOME_APPLIANCES` | `list[akkudoktoreos.devices.devices.HomeApplianceCommonSettings] | None` | `rw` | `None` | List of home appliances |
|
||||
| inverters | `EOS_DEVICES__INVERTERS` | `list[akkudoktoreos.devices.devices.InverterCommonSettings] | None` | `rw` | `None` | List of inverters |
|
||||
| max_batteries | `EOS_DEVICES__MAX_BATTERIES` | `int | None` | `rw` | `None` | Maximum number of batteries that can be set |
|
||||
| max_electric_vehicles | `EOS_DEVICES__MAX_ELECTRIC_VEHICLES` | `int | None` | `rw` | `None` | Maximum number of electric vehicles that can be set |
|
||||
| max_home_appliances | `EOS_DEVICES__MAX_HOME_APPLIANCES` | `int | None` | `rw` | `None` | Maximum number of home_appliances that can be set |
|
||||
| max_inverters | `EOS_DEVICES__MAX_INVERTERS` | `int | None` | `rw` | `None` | Maximum number of inverters that can be set |
|
||||
| measurement_keys | | `list[str] | None` | `ro` | `N/A` | Return the measurement keys for the resource/ device stati that are measurements. |
|
||||
| batteries | `EOS_DEVICES__BATTERIES` | `dict[str, akkudoktoreos.devices.settings.batterysettings.BatteriesCommonSettings] | None` | `rw` | `None` | Stationary battery storage devices, keyed by device_id. |
|
||||
| electric_vehicles | `EOS_DEVICES__ELECTRIC_VEHICLES` | `dict[str, akkudoktoreos.devices.settings.batterysettings.BatteriesCommonSettings] | None` | `rw` | `None` | Electric vehicle battery packs, keyed by device_id. |
|
||||
| home_appliances | `EOS_DEVICES__HOME_APPLIANCES` | `dict[str, akkudoktoreos.devices.settings.homeappliancesettings.HomeApplianceCommonSettings]` | `rw` | `required` | Shiftable home appliance devices, keyed by device_id. |
|
||||
| inverters | `EOS_DEVICES__INVERTERS` | `dict[str, akkudoktoreos.devices.settings.invertersettings.InverterCommonSettings] | None` | `rw` | `None` | Inverter devices, keyed by device_id. |
|
||||
| max_batteries | `EOS_DEVICES__MAX_BATTERIES` | `int | None` | `rw` | `None` | Maximum number of batteries allowed. |
|
||||
| max_electric_vehicles | `EOS_DEVICES__MAX_ELECTRIC_VEHICLES` | `int | None` | `rw` | `None` | Maximum number of EVs allowed. |
|
||||
| max_home_appliances | `EOS_DEVICES__MAX_HOME_APPLIANCES` | `int | None` | `rw` | `None` | Maximum number of home appliances allowed. |
|
||||
| max_inverters | `EOS_DEVICES__MAX_INVERTERS` | `int | None` | `rw` | `None` | Maximum number of inverters allowed. |
|
||||
| measurement_keys | | `list[str]` | `ro` | `N/A` | All measurement keys across all configured devices. |
|
||||
:::
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
@@ -27,13 +32,13 @@
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"batteries": {
|
||||
"bat0": {
|
||||
"device_id": "bat0",
|
||||
"capacity_wh": 8000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"levelized_cost_of_storage_kwh": 0.0,
|
||||
"levelized_cost_of_storage_amt_kwh": 0.0,
|
||||
"max_charge_power_w": 5000,
|
||||
"min_charge_power_w": 50,
|
||||
"charge_rates": [
|
||||
@@ -52,15 +57,15 @@
|
||||
"min_soc_percentage": 0,
|
||||
"max_soc_percentage": 100
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_batteries": 1,
|
||||
"electric_vehicles": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"capacity_wh": 8000,
|
||||
"electric_vehicles": {
|
||||
"ev0": {
|
||||
"device_id": "ev0",
|
||||
"capacity_wh": 60000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"levelized_cost_of_storage_kwh": 0.0,
|
||||
"levelized_cost_of_storage_amt_kwh": 0.0,
|
||||
"max_charge_power_w": 5000,
|
||||
"min_charge_power_w": 50,
|
||||
"charge_rates": [
|
||||
@@ -79,12 +84,22 @@
|
||||
"min_soc_percentage": 0,
|
||||
"max_soc_percentage": 100
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_electric_vehicles": 1,
|
||||
"inverters": [],
|
||||
"inverters": {},
|
||||
"max_inverters": 1,
|
||||
"home_appliances": [],
|
||||
"max_home_appliances": 1
|
||||
"home_appliances": {
|
||||
"dishwasher": {
|
||||
"device_id": "dishwasher",
|
||||
"consumption_wh": 1500,
|
||||
"duration_h": 2,
|
||||
"num_cycles": 1,
|
||||
"cycle_time_windows": null,
|
||||
"min_cycle_gap_h": 0,
|
||||
"cycles_completed_measurement_key": null
|
||||
}
|
||||
},
|
||||
"max_home_appliances": 3
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -98,13 +113,13 @@
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"batteries": {
|
||||
"bat0": {
|
||||
"device_id": "bat0",
|
||||
"capacity_wh": 8000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"levelized_cost_of_storage_kwh": 0.0,
|
||||
"levelized_cost_of_storage_amt_kwh": 0.0,
|
||||
"max_charge_power_w": 5000,
|
||||
"min_charge_power_w": 50,
|
||||
"charge_rates": [
|
||||
@@ -122,28 +137,28 @@
|
||||
],
|
||||
"min_soc_percentage": 0,
|
||||
"max_soc_percentage": 100,
|
||||
"measurement_key_soc_factor": "battery1-soc-factor",
|
||||
"measurement_key_power_l1_w": "battery1-power-l1-w",
|
||||
"measurement_key_power_l2_w": "battery1-power-l2-w",
|
||||
"measurement_key_power_l3_w": "battery1-power-l3-w",
|
||||
"measurement_key_power_3_phase_sym_w": "battery1-power-3-phase-sym-w",
|
||||
"measurement_key_soc_factor": "bat0-soc-factor",
|
||||
"measurement_key_power_l1_w": "bat0-power-l1-w",
|
||||
"measurement_key_power_l2_w": "bat0-power-l2-w",
|
||||
"measurement_key_power_l3_w": "bat0-power-l3-w",
|
||||
"measurement_key_power_3_phase_sym_w": "bat0-power-3-phase-sym-w",
|
||||
"measurement_keys": [
|
||||
"battery1-soc-factor",
|
||||
"battery1-power-l1-w",
|
||||
"battery1-power-l2-w",
|
||||
"battery1-power-l3-w",
|
||||
"battery1-power-3-phase-sym-w"
|
||||
"bat0-soc-factor",
|
||||
"bat0-power-l1-w",
|
||||
"bat0-power-l2-w",
|
||||
"bat0-power-l3-w",
|
||||
"bat0-power-3-phase-sym-w"
|
||||
]
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_batteries": 1,
|
||||
"electric_vehicles": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"capacity_wh": 8000,
|
||||
"electric_vehicles": {
|
||||
"ev0": {
|
||||
"device_id": "ev0",
|
||||
"capacity_wh": 60000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"levelized_cost_of_storage_kwh": 0.0,
|
||||
"levelized_cost_of_storage_amt_kwh": 0.0,
|
||||
"max_charge_power_w": 5000,
|
||||
"min_charge_power_w": 50,
|
||||
"charge_rates": [
|
||||
@@ -161,387 +176,48 @@
|
||||
],
|
||||
"min_soc_percentage": 0,
|
||||
"max_soc_percentage": 100,
|
||||
"measurement_key_soc_factor": "battery1-soc-factor",
|
||||
"measurement_key_power_l1_w": "battery1-power-l1-w",
|
||||
"measurement_key_power_l2_w": "battery1-power-l2-w",
|
||||
"measurement_key_power_l3_w": "battery1-power-l3-w",
|
||||
"measurement_key_power_3_phase_sym_w": "battery1-power-3-phase-sym-w",
|
||||
"measurement_key_soc_factor": "ev0-soc-factor",
|
||||
"measurement_key_power_l1_w": "ev0-power-l1-w",
|
||||
"measurement_key_power_l2_w": "ev0-power-l2-w",
|
||||
"measurement_key_power_l3_w": "ev0-power-l3-w",
|
||||
"measurement_key_power_3_phase_sym_w": "ev0-power-3-phase-sym-w",
|
||||
"measurement_keys": [
|
||||
"battery1-soc-factor",
|
||||
"battery1-power-l1-w",
|
||||
"battery1-power-l2-w",
|
||||
"battery1-power-l3-w",
|
||||
"battery1-power-3-phase-sym-w"
|
||||
"ev0-soc-factor",
|
||||
"ev0-power-l1-w",
|
||||
"ev0-power-l2-w",
|
||||
"ev0-power-l3-w",
|
||||
"ev0-power-3-phase-sym-w"
|
||||
]
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_electric_vehicles": 1,
|
||||
"inverters": [],
|
||||
"inverters": {},
|
||||
"max_inverters": 1,
|
||||
"home_appliances": [],
|
||||
"max_home_appliances": 1,
|
||||
"home_appliances": {
|
||||
"dishwasher": {
|
||||
"device_id": "dishwasher",
|
||||
"consumption_wh": 1500,
|
||||
"duration_h": 2,
|
||||
"num_cycles": 1,
|
||||
"cycle_time_windows": null,
|
||||
"min_cycle_gap_h": 0,
|
||||
"cycles_completed_measurement_key": null,
|
||||
"effective_num_cycles": 1,
|
||||
"measurement_keys": []
|
||||
}
|
||||
},
|
||||
"max_home_appliances": 3,
|
||||
"measurement_keys": [
|
||||
"battery1-soc-factor",
|
||||
"battery1-power-l1-w",
|
||||
"battery1-power-l2-w",
|
||||
"battery1-power-l3-w",
|
||||
"battery1-power-3-phase-sym-w",
|
||||
"battery1-soc-factor",
|
||||
"battery1-power-l1-w",
|
||||
"battery1-power-l2-w",
|
||||
"battery1-power-l3-w",
|
||||
"battery1-power-3-phase-sym-w"
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
### Inverter devices base settings
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
:::{table} devices::inverters::list
|
||||
:widths: 10 10 5 5 30
|
||||
:align: left
|
||||
|
||||
| Name | Type | Read-Only | Default | Description |
|
||||
| ---- | ---- | --------- | ------- | ----------- |
|
||||
| ac_to_dc_efficiency | `float` | `rw` | `1.0` | Efficiency of AC to DC conversion for grid-to-battery AC charging (0-1). Set to 0 to disable AC charging. Default 1.0 (no additional inverter loss). |
|
||||
| battery_id | `str | None` | `rw` | `None` | ID of battery controlled by this inverter. |
|
||||
| dc_to_ac_efficiency | `float` | `rw` | `1.0` | Efficiency of DC to AC conversion for battery discharging to AC load/grid (0-1). Default 1.0 (no additional inverter loss). |
|
||||
| device_id | `str` | `rw` | `required` | ID of device |
|
||||
| max_ac_charge_power_w | `float | None` | `rw` | `None` | Maximum AC charging power in watts. null means no additional limit. Set to 0 to disable AC charging. |
|
||||
| max_power_w | `float | None` | `rw` | `None` | Maximum power [W]. |
|
||||
| measurement_keys | `list[str] | None` | `ro` | `N/A` | Measurement keys for the inverter stati that are measurements. |
|
||||
:::
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Input**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"inverters": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"max_power_w": 10000.0,
|
||||
"battery_id": null,
|
||||
"ac_to_dc_efficiency": 0.95,
|
||||
"dc_to_ac_efficiency": 0.95,
|
||||
"max_ac_charge_power_w": null
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Output**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"inverters": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"max_power_w": 10000.0,
|
||||
"battery_id": null,
|
||||
"ac_to_dc_efficiency": 0.95,
|
||||
"dc_to_ac_efficiency": 0.95,
|
||||
"max_ac_charge_power_w": null,
|
||||
"measurement_keys": []
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
### Model defining a daily or date time window with optional localization support
|
||||
|
||||
Represents a time interval starting at `start_time` and lasting for `duration`.
|
||||
Can restrict applicability to a specific day of the week or a specific calendar date.
|
||||
Supports day names in multiple languages via locale-aware parsing.
|
||||
|
||||
Timezone contract:
|
||||
|
||||
``start_time`` is always **naive** (no ``tzinfo``). It is interpreted as a
|
||||
local wall-clock time in whatever timezone the caller's ``date_time`` or
|
||||
``reference_date`` carries. When those arguments are timezone-aware the
|
||||
window boundaries are evaluated in that timezone; when they are naive,
|
||||
arithmetic is performed as-is (no timezone conversion occurs).
|
||||
|
||||
``date``, being a calendar ``Date`` object, is inherently timezone-free.
|
||||
|
||||
This design avoids the ambiguity that arises when a stored ``start_time``
|
||||
carries its own timezone that differs from the caller's timezone, and keeps
|
||||
the model serialisable without timezone state.
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
:::{table} devices::home_appliances::list::time_windows::windows::list
|
||||
:widths: 10 10 5 5 30
|
||||
:align: left
|
||||
|
||||
| Name | Type | Read-Only | Default | Description |
|
||||
| ---- | ---- | --------- | ------- | ----------- |
|
||||
| date | `pydantic_extra_types.pendulum_dt.Date | None` | `rw` | `None` | Optional specific calendar date for the time window. Naive — matched against the local date of the datetime passed to contains(). Overrides `day_of_week` if set. |
|
||||
| day_of_week | `int | str | None` | `rw` | `None` | Optional day of the week restriction. Can be specified as integer (0=Monday to 6=Sunday) or localized weekday name. If None, applies every day unless `date` is set. |
|
||||
| duration | `Duration` | `rw` | `required` | Duration of the time window starting from `start_time`. |
|
||||
| locale | `str | None` | `rw` | `None` | Locale used to parse weekday names in `day_of_week` when given as string. If not set, Pendulum's default locale is used. Examples: 'en', 'de', 'fr', etc. |
|
||||
| start_time | `Time` | `rw` | `required` | Naive start time of the time window (time of day, no timezone). Interpreted in the timezone of the datetime passed to contains() or earliest_start_time(). |
|
||||
:::
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Input/Output**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"home_appliances": [
|
||||
{
|
||||
"time_windows": {
|
||||
"windows": [
|
||||
{
|
||||
"start_time": "00:00:00.000000",
|
||||
"duration": "2 hours",
|
||||
"day_of_week": null,
|
||||
"date": null,
|
||||
"locale": null
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
### Model representing a sequence of time windows with collective operations
|
||||
|
||||
Manages multiple TimeWindow objects and provides methods to work with them
|
||||
as a cohesive unit for scheduling and availability checking.
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
:::{table} devices::home_appliances::list::time_windows
|
||||
:widths: 10 10 5 5 30
|
||||
:align: left
|
||||
|
||||
| Name | Type | Read-Only | Default | Description |
|
||||
| ---- | ---- | --------- | ------- | ----------- |
|
||||
| windows | `list[akkudoktoreos.config.configabc.TimeWindow]` | `rw` | `required` | List of TimeWindow objects that make up this sequence. |
|
||||
:::
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Input/Output**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"home_appliances": [
|
||||
{
|
||||
"time_windows": {
|
||||
"windows": []
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
### Home Appliance devices base settings
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
:::{table} devices::home_appliances::list
|
||||
:widths: 10 10 5 5 30
|
||||
:align: left
|
||||
|
||||
| Name | Type | Read-Only | Default | Description |
|
||||
| ---- | ---- | --------- | ------- | ----------- |
|
||||
| consumption_wh | `int` | `rw` | `required` | Energy consumption [Wh]. |
|
||||
| device_id | `str` | `rw` | `required` | ID of device |
|
||||
| duration_h | `int` | `rw` | `required` | Usage duration in hours [0 ... 24]. |
|
||||
| measurement_keys | `list[str] | None` | `ro` | `N/A` | Measurement keys for the home appliance stati that are measurements. |
|
||||
| time_windows | `akkudoktoreos.config.configabc.TimeWindowSequence | None` | `rw` | `None` | Sequence of allowed time windows. Defaults to optimization general time window. |
|
||||
:::
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Input**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"home_appliances": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"consumption_wh": 2000,
|
||||
"duration_h": 1,
|
||||
"time_windows": {
|
||||
"windows": [
|
||||
{
|
||||
"start_time": "10:00:00.000000",
|
||||
"duration": "2 hours",
|
||||
"day_of_week": null,
|
||||
"date": null,
|
||||
"locale": null
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Output**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"home_appliances": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"consumption_wh": 2000,
|
||||
"duration_h": 1,
|
||||
"time_windows": {
|
||||
"windows": [
|
||||
{
|
||||
"start_time": "10:00:00.000000",
|
||||
"duration": "2 hours",
|
||||
"day_of_week": null,
|
||||
"date": null,
|
||||
"locale": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"measurement_keys": []
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
### Battery devices base settings
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
:::{table} devices::batteries::list
|
||||
:widths: 10 10 5 5 30
|
||||
:align: left
|
||||
|
||||
| Name | Type | Read-Only | Default | Description |
|
||||
| ---- | ---- | --------- | ------- | ----------- |
|
||||
| capacity_wh | `int` | `rw` | `8000` | Capacity [Wh]. |
|
||||
| charge_rates | `list[float] | None` | `rw` | `[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]` | Charge rates as factor of maximum charging power [0.00 ... 1.00]. None triggers fallback to default charge-rates. |
|
||||
| charging_efficiency | `float` | `rw` | `0.88` | Charging efficiency [0.01 ... 1.00]. |
|
||||
| device_id | `str` | `rw` | `required` | ID of device |
|
||||
| discharging_efficiency | `float` | `rw` | `0.88` | Discharge efficiency [0.01 ... 1.00]. |
|
||||
| levelized_cost_of_storage_kwh | `float` | `rw` | `0.0` | Levelized cost of storage (LCOS), the average lifetime cost of delivering one kWh [amount/kWh]. |
|
||||
| max_charge_power_w | `float | None` | `rw` | `5000` | Maximum charging power [W]. |
|
||||
| max_soc_percentage | `int` | `rw` | `100` | Maximum state of charge (SOC) as percentage of capacity [%]. |
|
||||
| measurement_key_power_3_phase_sym_w | `str` | `ro` | `N/A` | Measurement key for the symmetric 3 phase power the battery is charged or discharged with [W]. |
|
||||
| measurement_key_power_l1_w | `str` | `ro` | `N/A` | Measurement key for the L1 power the battery is charged or discharged with [W]. |
|
||||
| measurement_key_power_l2_w | `str` | `ro` | `N/A` | Measurement key for the L2 power the battery is charged or discharged with [W]. |
|
||||
| measurement_key_power_l3_w | `str` | `ro` | `N/A` | Measurement key for the L3 power the battery is charged or discharged with [W]. |
|
||||
| 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]. |
|
||||
| measurement_keys | `list[str] | None` | `ro` | `N/A` | Measurement keys for the battery stati that are measurements. |
|
||||
| min_charge_power_w | `float | None` | `rw` | `50` | Minimum charging power [W]. |
|
||||
| min_soc_percentage | `int` | `rw` | `0` | Minimum state of charge (SOC) as percentage of capacity [%]. This is the target SoC for charging |
|
||||
:::
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Input**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"capacity_wh": 8000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"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
|
||||
],
|
||||
"min_soc_percentage": 10,
|
||||
"max_soc_percentage": 100
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
<!-- pyml enable line-length -->
|
||||
|
||||
<!-- pyml disable no-emphasis-as-heading -->
|
||||
**Example Output**
|
||||
<!-- pyml enable no-emphasis-as-heading -->
|
||||
|
||||
<!-- pyml disable line-length -->
|
||||
```json
|
||||
{
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"capacity_wh": 8000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"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
|
||||
],
|
||||
"min_soc_percentage": 10,
|
||||
"max_soc_percentage": 100,
|
||||
"measurement_key_soc_factor": "battery1-soc-factor",
|
||||
"measurement_key_power_l1_w": "battery1-power-l1-w",
|
||||
"measurement_key_power_l2_w": "battery1-power-l2-w",
|
||||
"measurement_key_power_l3_w": "battery1-power-l3-w",
|
||||
"measurement_key_power_3_phase_sym_w": "battery1-power-3-phase-sym-w",
|
||||
"measurement_keys": [
|
||||
"battery1-soc-factor",
|
||||
"battery1-power-l1-w",
|
||||
"battery1-power-l2-w",
|
||||
"battery1-power-l3-w",
|
||||
"battery1-power-3-phase-sym-w"
|
||||
]
|
||||
}
|
||||
"bat0-soc-factor",
|
||||
"bat0-power-l1-w",
|
||||
"bat0-power-l2-w",
|
||||
"bat0-power-l3-w",
|
||||
"bat0-power-3-phase-sym-w",
|
||||
"ev0-soc-factor",
|
||||
"ev0-power-l1-w",
|
||||
"ev0-power-l2-w",
|
||||
"ev0-power-l3-w",
|
||||
"ev0-power-3-phase-sym-w"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
+24
-14
@@ -36,13 +36,13 @@
|
||||
"batch_size": 100
|
||||
},
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"batteries": {
|
||||
"bat0": {
|
||||
"device_id": "bat0",
|
||||
"capacity_wh": 8000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"levelized_cost_of_storage_kwh": 0.0,
|
||||
"levelized_cost_of_storage_amt_kwh": 0.0,
|
||||
"max_charge_power_w": 5000,
|
||||
"min_charge_power_w": 50,
|
||||
"charge_rates": [
|
||||
@@ -61,15 +61,15 @@
|
||||
"min_soc_percentage": 0,
|
||||
"max_soc_percentage": 100
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_batteries": 1,
|
||||
"electric_vehicles": [
|
||||
{
|
||||
"device_id": "battery1",
|
||||
"capacity_wh": 8000,
|
||||
"electric_vehicles": {
|
||||
"ev0": {
|
||||
"device_id": "ev0",
|
||||
"capacity_wh": 60000,
|
||||
"charging_efficiency": 0.88,
|
||||
"discharging_efficiency": 0.88,
|
||||
"levelized_cost_of_storage_kwh": 0.0,
|
||||
"levelized_cost_of_storage_amt_kwh": 0.0,
|
||||
"max_charge_power_w": 5000,
|
||||
"min_charge_power_w": 50,
|
||||
"charge_rates": [
|
||||
@@ -88,12 +88,22 @@
|
||||
"min_soc_percentage": 0,
|
||||
"max_soc_percentage": 100
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_electric_vehicles": 1,
|
||||
"inverters": [],
|
||||
"inverters": {},
|
||||
"max_inverters": 1,
|
||||
"home_appliances": [],
|
||||
"max_home_appliances": 1
|
||||
"home_appliances": {
|
||||
"dishwasher": {
|
||||
"device_id": "dishwasher",
|
||||
"consumption_wh": 1500,
|
||||
"duration_h": 2,
|
||||
"num_cycles": 1,
|
||||
"cycle_time_windows": null,
|
||||
"min_cycle_gap_h": 0,
|
||||
"cycles_completed_measurement_key": null
|
||||
}
|
||||
},
|
||||
"max_home_appliances": 3
|
||||
},
|
||||
"elecfee": {
|
||||
"provider": "ElecFeeFixed",
|
||||
|
||||
+7
-6
@@ -12,14 +12,15 @@
|
||||
"console_level": "INFO"
|
||||
},
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"batteries": {
|
||||
"pv_akku": {
|
||||
"device_id": "pv_akku",
|
||||
"capacity_wh": 30000
|
||||
}
|
||||
],
|
||||
"electric_vehicles": [
|
||||
{
|
||||
},
|
||||
"electric_vehicles": {
|
||||
"ev0": {
|
||||
"device_id": "ev0",
|
||||
"charge_rates": [
|
||||
0.0,
|
||||
0.375,
|
||||
@@ -30,7 +31,7 @@
|
||||
1.0
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"measurement": {
|
||||
"load_emr_keys": [
|
||||
|
||||
+26
-28
@@ -10,54 +10,52 @@
|
||||
"mode": "OPTIMIZATION"
|
||||
},
|
||||
"devices": {
|
||||
"batteries": [
|
||||
{
|
||||
"batteries": {
|
||||
"battery1": {
|
||||
"device_id": "battery1"
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_batteries": 1,
|
||||
"electric_vehicles": [
|
||||
{
|
||||
"electric_vehicles": {
|
||||
"ev11": {
|
||||
"device_id": "ev11",
|
||||
"capacity_wh": 50000,
|
||||
"min_soc_percentage": 70
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_electric_vehicles": 1,
|
||||
"inverters": [
|
||||
{
|
||||
"inverters": {
|
||||
"inverter1": {
|
||||
"device_id": "inverter1",
|
||||
"max_power_w": 10000.0,
|
||||
"battery_id": "battery1"
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_inverters": 1,
|
||||
"home_appliances": [
|
||||
{
|
||||
"home_appliances": {
|
||||
"dishwasher1": {
|
||||
"device_id": "dishwasher1",
|
||||
"consumption_wh": 2000,
|
||||
"duration_h": 3,
|
||||
"time_windows": {
|
||||
"windows": [
|
||||
{
|
||||
"start_time": "08:00:00.000000",
|
||||
"duration": "5 hours"
|
||||
},
|
||||
{
|
||||
"start_time": "15:00:00.000000",
|
||||
"duration": "3 hours"
|
||||
}
|
||||
]
|
||||
}
|
||||
"consumption_wh": 2000
|
||||
}
|
||||
],
|
||||
},
|
||||
"max_home_appliances": 1
|
||||
},
|
||||
"elecprice": {
|
||||
"provider": "ElecPriceAkkudoktor"
|
||||
},
|
||||
"feedintariff": {
|
||||
"provider": "FeedInTariffFixed"
|
||||
"provider": "FeedInTariffFixed",
|
||||
"feedintarifffixed": {
|
||||
"feed_in_tariff_amt_kwh": {
|
||||
"windows": [
|
||||
{
|
||||
"start_time": "00:00:00.000000",
|
||||
"duration": "1 day",
|
||||
"value": 0.078
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"load": {
|
||||
"provider": "LoadAkkudoktorAdjusted",
|
||||
@@ -122,4 +120,4 @@
|
||||
"weather": {
|
||||
"provider": "BrightSky"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user