RWE: Quantum Optimization for Renewable Energy Portfolio

The Challenge

RWE operates one of Europe’s largest renewable energy portfolios, with more than 10 GW of wind and solar capacity spread across Germany, the Netherlands, the UK, and several other markets. Managing dispatch decisions across this portfolio involves solving a large-scale binary optimization problem every 15 minutes: which generation assets to commit, how much stored energy to release from battery installations, and when to curtail excess generation to avoid grid penalties.

The problem is a variant of the unit commitment problem, one of the canonical hard optimization problems in power systems. For a portfolio of RWE’s scale, the full problem has thousands of binary variables and a complex constraint structure reflecting grid codes, ramp rate limits, balancing market rules, and intraday price signals. Classical MILP solvers handle this well when the problem fits within their time budget, but as renewable penetration increases and grid conditions become more volatile, solution quality under tight time constraints degrades.

RWE’s energy management technology team began investigating QAOA as a potential path to faster, higher-quality solutions for the hardest dispatch subproblems, particularly those arising in volatile balancing market conditions where solution windows shrink to minutes.

The Quantum Approach

The team formulated a 50-variable dispatch subproblem as a QUBO and implemented QAOA using Qiskit on IBM Quantum hardware. The QAOA circuit alternates between a cost Hamiltonian encoding the dispatch objective and a mixing Hamiltonian driving exploration of the solution space. Classical optimization of the QAOA variational parameters was handled by COBYLA, with parameter initialization using a warm-start strategy seeded from classical solver hints.

Problem instances were drawn from real RWE historical dispatch scenarios, allowing direct comparison of QAOA solution quality against the incumbent MILP baseline using identical problem data.

from qiskit.circuit.library import QAOAAnsatz
from qiskit.quantum_info import SparsePauliOp
from qiskit_algorithms.minimum_eigensolvers import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
import numpy as np

def build_dispatch_cost_operator(n_assets: int, prices: list, ramp_penalties: dict):
    """
    Build a cost Hamiltonian for the renewable dispatch problem.
    Each qubit represents whether an asset is committed (1) or curtailed (0).
    Minimize negative revenue minus ramp penalties.
    """
    pauli_list = []

    # Revenue terms: ZI...I for each asset (diagonal, single-qubit)
    for i, price in enumerate(prices):
        pauli_str = "I" * i + "Z" + "I" * (n_assets - i - 1)
        pauli_list.append((pauli_str, -price / 2))  # Z = 2*x - 1 encoding

    # Ramp penalty terms: correlated ZZ terms for adjacent assets
    for (i, j), penalty in ramp_penalties.items():
        pauli_str = list("I" * n_assets)
        pauli_str[i] = "Z"
        pauli_str[j] = "Z"
        pauli_list.append(("".join(pauli_str), penalty))

    return SparsePauliOp.from_list(pauli_list)

# Example: 6-asset dispatch problem
n_assets = 6
prices = [42.5, 38.0, 55.3, 49.1, 33.7, 61.2]  # EUR/MWh marginal revenue
ramp_penalties = {(0, 1): 5.0, (1, 2): 3.5, (3, 4): 4.0, (4, 5): 6.5}

cost_op = build_dispatch_cost_operator(n_assets, prices, ramp_penalties)

# Run QAOA with p=2 layers
sampler = Sampler()
optimizer = COBYLA(maxiter=500)
qaoa = QAOA(sampler, optimizer, reps=2)

result = qaoa.compute_minimum_eigenvalue(cost_op)
best_bitstring = max(result.eigenvalue_results, key=lambda x: x.shots)
print(f"QAOA minimum eigenvalue: {result.eigenvalue:.4f}")
print(f"Best dispatch solution: {result.best_measurement['bitstring']}")
print(f"Optimal parameters: {np.round(result.optimal_point, 3)}")

Results and Implications

On the 50-variable portfolio instances drawn from real RWE historical scenarios, QAOA with p=3 circuit layers matched or exceeded MILP solution quality in 73% of test cases, with the remaining cases within 1.2% of optimal. Critically, QAOA solution time was consistent and predictable (bounded by the circuit execution and classical optimization loop), whereas MILP solution time varied widely and occasionally exceeded the 5-minute dispatch window under hard instances.

The result represents a significant milestone for energy sector quantum computing. The 50-variable instance size is not yet at full commercial scale, but the quantum readiness of the problem formulation is clearly established. RWE’s team noted that hardware improvements between IBM Quantum’s Eagle and Heron processors meaningfully improved result quality, suggesting the trajectory is favorable.

RWE has committed to scaling the evaluation to 100-variable instances in 2025 using next-generation IBM hardware, with a pathway toward integration into their live energy management system for balancing market operations within three years.