Reference: Real-Time Streaming Constraints

This reference sheet captures the core real-time inputs and the optimizer model changes required when restrictions arrive as a stream (for example from Kafka).

Core real-time inputs

• max_charge_mw[t] — maximum available charging power at hour t.
• max_discharge_mw[t] — maximum available discharge power at hour t.
• allow_charge[t] — boolean flag enabling charging at hour t.
• allow_discharge[t] — boolean flag enabling discharging at hour t.
• reserved_energy_mwh[t] — energy reserved and unavailable for arbitrage at hour t.
• soc_min_pct[t] — minimum state of charge percentage at hour t.
• soc_max_pct[t] — maximum state of charge percentage at hour t.
• valid_from / valid_until — the event window when the restriction is active.

Data layer contract

class RealtimeConstraintSnapshot:
    def __init__(self, horizon_hours: int):
        self.max_charge_mw = [p_max] * horizon_hours
        self.max_discharge_mw = [p_max] * horizon_hours
        self.soc_min_pct = [soc_min] * horizon_hours
        self.soc_max_pct = [soc_max] * horizon_hours
        self.reserved_energy_mwh = [0.0] * horizon_hours

    def apply_restriction(self, restriction):
        for t in range(restriction.relative_start, restriction.relative_end):
            self.max_charge_mw[t] = min(self.max_charge_mw[t], restriction.max_charge_mw)
            self.max_discharge_mw[t] = min(self.max_discharge_mw[t], restriction.max_discharge_mw)
            self.soc_min_pct[t] = max(self.soc_min_pct[t], restriction.soc_min_pct)
            self.soc_max_pct[t] = min(self.soc_max_pct[t], restriction.soc_max_pct)
            self.reserved_energy_mwh[t] = max(self.reserved_energy_mwh[t], restriction.reserved_energy_mwh)

Optimizer parameter mapping

model.p_charge_max = pyo.Param(model.T, initialize=p_charge_max, mutable=True)
model.p_discharge_max = pyo.Param(model.T, initialize=p_discharge_max, mutable=True)
model.soc_min_pct = pyo.Param(model.T, initialize=soc_min_pct, mutable=True)
model.soc_max_pct = pyo.Param(model.T, initialize=soc_max_pct, mutable=True)
model.reserved_energy_mwh = pyo.Param(model.T, initialize=reserved_energy_mwh, mutable=True)

model.p_c = pyo.Var(model.T, bounds=(0, p.p_max))
model.p_d = pyo.Var(model.T, bounds=(0, p.p_max))
model.soc = pyo.Var(model.T, bounds=(0, p.e_max))

model.charge_limit = pyo.Constraint(model.T,
    rule=lambda m, t: m.p_c[t] <= m.p_charge_max[t])
model.discharge_limit = pyo.Constraint(model.T,
    rule=lambda m, t: m.p_d[t] <= m.p_discharge_max[t])
model.soc_min_con = pyo.Constraint(model.T,
    rule=lambda m, t: m.soc[t] >= m.soc_min_pct[t] * p.e_max + m.reserved_energy_mwh[t])
model.soc_max_con = pyo.Constraint(model.T,
    rule=lambda m, t: m.soc[t] <= m.soc_max_pct[t] * p.e_max)

Key design rules

• Always treat streaming restrictions as hard constraints in the optimization model.
• Prefer event-driven reoptimization for hard restrictions; use periodic reopt for forecast updates.
• Keep the active snapshot in-memory and rebuild it incrementally when new events arrive.
• Use a safe fallback (idle or last known feasible schedule) if the solver fails.

What stays the same

• The core decision variables are still p_charge[t], p_discharge[t], and soc[t].
• The objective is still revenue minus degradation cost.
• Energy balance and the charge/discharge mutual exclusion logic remain unchanged.

Rechtliches: Impressum