def test_charging_station_solver_day_2(target_soc, charging_station_name):
"""Starting with a state of charge 1 kWh, within 2 hours we should be able to reach
any state of charge in the range [1, 5] kWh for a unidirectional station,
or [0, 5] for a bidirectional station."""
soc_at_start = 1
duration_until_target = timedelta(hours=2)
epex_da = Market.query.filter(Market.name == "epex_da").one_or_none()
charging_station = Asset.query.filter(
Asset.name == charging_station_name).one_or_none()
start = as_server_time(datetime(2015, 1, 2))
end = as_server_time(datetime(2015, 1, 3))
resolution = timedelta(minutes=15)
target_soc_datetime = start + duration_until_target
soc_targets = pd.Series(np.nan,
index=pd.date_range(start,
end,
freq=resolution,
closed="right"))
soc_targets.loc[target_soc_datetime] = target_soc
consumption_schedule = schedule_charging_station(charging_station, epex_da,
start, end, resolution,
soc_at_start, soc_targets)
soc_schedule = integrate_time_series(consumption_schedule,
soc_at_start,
decimal_precision=6)
# Check if constraints were met
assert min(
consumption_schedule.values) >= charging_station.capacity_in_mw * -1
assert max(consumption_schedule.values) <= charging_station.capacity_in_mw
print(consumption_schedule.head(12))
print(soc_schedule.head(12))
assert abs(soc_schedule.loc[target_soc_datetime] - target_soc) < 0.00001
def test_fallback_to_unsolvable_problem(target_soc, charging_station_name):
"""Starting with a state of charge 10 kWh, within 2 hours we should be able to reach
any state of charge in the range [10, 14] kWh for a unidirectional station,
or [6, 14] for a bidirectional station, given a charging capacity of 2 kW.
Here we test target states of charge outside that range, ones that we should be able
to get as close to as 1 kWh difference.
We want our scheduler to handle unsolvable problems like these with a sensible fallback policy.
"""
soc_at_start = 10
duration_until_target = timedelta(hours=2)
expected_gap = 1
epex_da = Sensor.query.filter(Sensor.name == "epex_da").one_or_none()
charging_station = Sensor.query.filter(
Sensor.name == charging_station_name).one_or_none()
assert charging_station.get_attribute("capacity_in_mw") == 2
assert Sensor.query.get(
charging_station.get_attribute("market_id")) == epex_da
start = as_server_time(datetime(2015, 1, 2))
end = as_server_time(datetime(2015, 1, 3))
resolution = timedelta(minutes=15)
target_soc_datetime = start + duration_until_target
soc_targets = pd.Series(np.nan,
index=pd.date_range(start,
end,
freq=resolution,
closed="right"))
soc_targets.loc[target_soc_datetime] = target_soc
consumption_schedule = schedule_charging_station(charging_station, start,
end, resolution,
soc_at_start, soc_targets)
soc_schedule = integrate_time_series(consumption_schedule,
soc_at_start,
decimal_precision=6)
# Check if constraints were met
assert (min(consumption_schedule.values) >=
charging_station.get_attribute("capacity_in_mw") * -1)
assert max(consumption_schedule.values) <= charging_station.get_attribute(
"capacity_in_mw")
print(consumption_schedule.head(12))
print(soc_schedule.head(12))
assert (abs(
abs(soc_schedule.loc[target_soc_datetime] - target_soc) - expected_gap)
< TOLERANCE)
def make_schedule(
sensor_id: int,
start: datetime,
end: datetime,
belief_time: datetime,
resolution: timedelta,
soc_at_start: Optional[float] = None,
soc_targets: Optional[pd.Series] = None,
soc_min: Optional[float] = None,
soc_max: Optional[float] = None,
roundtrip_efficiency: Optional[float] = None,
price_sensor: Optional[Sensor] = None,
) -> bool:
"""Preferably, a starting soc is given.
Otherwise, we try to retrieve the current state of charge from the asset (if that is the valid one at the start).
Otherwise, we set the starting soc to 0 (some assets don't use the concept of a state of charge,
and without soc targets and limits the starting soc doesn't matter).
"""
# https://docs.sqlalchemy.org/en/13/faq/connections.html#how-do-i-use-engines-connections-sessions-with-python-multiprocessing-or-os-fork
db.engine.dispose()
rq_job = get_current_job()
# find sensor
sensor = Sensor.query.filter_by(id=sensor_id).one_or_none()
if rq_job:
click.echo("Running Scheduling Job %s: %s, from %s to %s" %
(rq_job.id, sensor, start, end))
if soc_at_start is None:
if (start == sensor.get_attribute("soc_datetime")
and sensor.get_attribute("soc_in_mwh") is not None):
soc_at_start = sensor.get_attribute("soc_in_mwh")
else:
soc_at_start = 0
if soc_targets is None:
soc_targets = pd.Series(np.nan,
index=pd.date_range(start,
end,
freq=resolution,
closed="right"))
if sensor.generic_asset.generic_asset_type.name == "battery":
consumption_schedule = schedule_battery(
sensor,
start,
end,
resolution,
soc_at_start,
soc_targets,
soc_min,
soc_max,
roundtrip_efficiency,
price_sensor=price_sensor,
)
elif sensor.generic_asset.generic_asset_type.name in (
"one-way_evse",
"two-way_evse",
):
consumption_schedule = schedule_charging_station(
sensor,
start,
end,
resolution,
soc_at_start,
soc_targets,
soc_min,
soc_max,
roundtrip_efficiency,
price_sensor=price_sensor,
)
else:
raise ValueError(
"Scheduling is not (yet) supported for asset type %s." %
sensor.generic_asset.generic_asset_type)
data_source = get_data_source(
data_source_name="Seita",
data_source_type="scheduling script",
)
if rq_job:
click.echo("Job %s made schedule." % rq_job.id)
ts_value_schedule = [
TimedBelief(
event_start=dt,
belief_time=belief_time,
event_value=-value,
sensor=sensor,
source=data_source,
) for dt, value in consumption_schedule.items()
] # For consumption schedules, positive values denote consumption. For the db, consumption is negative
bdf = tb.BeliefsDataFrame(ts_value_schedule)
save_to_db(bdf)
db.session.commit()
return True
def make_schedule(
asset_id: int,
start: datetime,
end: datetime,
belief_time: datetime,
resolution: timedelta,
soc_at_start: Optional[float] = None,
soc_targets: Optional[pd.Series] = None,
) -> bool:
"""Preferably, a starting soc is given.
Otherwise, we try to retrieve the current state of charge from the asset (if that is the valid one at the start).
Otherwise, we set the starting soc to 0 (some assets don't use the concept of a state of charge,
and without soc targets and limits the starting soc doesn't matter).
"""
# https://docs.sqlalchemy.org/en/13/faq/connections.html#how-do-i-use-engines-connections-sessions-with-python-multiprocessing-or-os-fork
db.engine.dispose()
rq_job = get_current_job()
# find asset
asset = Asset.query.filter_by(id=asset_id).one_or_none()
click.echo(
"Running Scheduling Job %s: %s, from %s to %s" % (rq_job.id, asset, start, end)
)
if soc_at_start is None:
if start == asset.soc_datetime and asset.soc_in_mwh is not None:
soc_at_start = asset.soc_in_mwh
else:
soc_at_start = 0
if soc_targets is None:
soc_targets = pd.Series(
np.nan, index=pd.date_range(start, end, freq=resolution, closed="right")
)
if asset.asset_type_name == "battery":
consumption_schedule = schedule_battery(
asset, asset.market, start, end, resolution, soc_at_start, soc_targets
)
elif asset.asset_type_name in (
"one-way_evse",
"two-way_evse",
):
consumption_schedule = schedule_charging_station(
asset, asset.market, start, end, resolution, soc_at_start, soc_targets
)
else:
raise ValueError(
"Scheduling is not supported for asset type %s." % asset.asset_type
)
data_source = get_data_source(
data_source_name="Seita",
data_source_type="scheduling script",
)
click.echo("Job %s made schedule." % rq_job.id)
ts_value_schedule = [
Power(
datetime=dt,
horizon=dt.astimezone(pytz.utc) - belief_time.astimezone(pytz.utc),
value=-value,
asset_id=asset_id,
data_source_id=data_source.id,
)
for dt, value in consumption_schedule.items()
] # For consumption schedules, positive values denote consumption. For the db, consumption is negative
try:
save_to_session(ts_value_schedule)
except IntegrityError as e:
current_app.logger.warning(e)
click.echo("Rolling back due to IntegrityError")
db.session.rollback()
if current_app.config.get("FLEXMEASURES_MODE", "") == "play":
click.echo("Saving again, with overwrite=True")
save_to_session(ts_value_schedule, overwrite=True)
db.session.commit()
return True