Airbus Quantum Optimization for Aircraft Loading and Weight Distribution

The aircraft loading problem combines a 3D bin-packing structure with continuous physics constraints. An A380 freighter conversion has a main deck and lower deck with defined unit load device (ULD) positions, each with weight capacity and dimensional constraints. Cargo containers arrive with known weights, volumes, and revenue values. The optimizer must assign containers to positions to maximize total revenue while keeping the aircraft center of gravity (CG) within the flight envelope for all fuel burn states from takeoff to landing. The CG constraint is particularly challenging: it is a continuous linear function of container positions (CG = sum_i w_i * x_i / W_total, where x_i is the longitudinal position of container i and W_total is total weight), but container placement decisions are binary, making the joint problem a mixed-integer program.

The QUBO formulation introduces binary variable y_{ic} = 1 if container i is placed in position c. The objective maximizes total revenue minus CG penalty. The constraints are: (1) each container assigned to at most one position; (2) each position holds at most one container; (3) CG at takeoff within [CG_min, CG_max]; (4) CG at landing (after fuel burn) also within limits. Constraints (1) and (2) enter as quadratic penalties. The CG constraint is linearized by discretizing the continuous CG range into bins and adding slack variables, then penalizing deviation from target. This discretization introduces approximation error but converts the continuous constraint into a form tractable for QUBO.

import dimod
import numpy as np
from dwave.system import LeapHybridSampler
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler

# A380 loading problem setup
N_CONTAINERS = 12    # containers to load
N_POSITIONS = 16     # available ULD positions on A380 main deck
CG_REF = 0.0        # reference datum (meters from nose)
CG_MIN, CG_MAX = -2.0, 2.0  # allowable CG range (% MAC)

np.random.seed(42)
revenues = np.random.uniform(1000, 5000, N_CONTAINERS)      # USD per container
weights = np.random.uniform(500, 3000, N_CONTAINERS)        # kg
cg_arms = np.linspace(-3.0, 3.0, N_POSITIONS)              # longitudinal CG arm per position
max_position_weight = 4000.0                                 # kg per ULD position

def build_loading_qubo(
    revenues: np.ndarray,
    weights: np.ndarray,
    cg_arms: np.ndarray,
    cg_min: float,
    cg_max: float,
    lambda_assign: float = 500.0,
    lambda_cg: float = 200.0,
) -> dimod.BinaryQuadraticModel:
    n_c = len(revenues)
    n_p = len(cg_arms)
    bqm = dimod.BinaryQuadraticModel(vartype="BINARY")

    # Variables: x_{i,j} = 1 if container i placed at position j
    def var(i, j):
        return f"x_{i}_{j}"

    # Revenue objective (maximize, so negate for minimization)
    for i in range(n_c):
        for j in range(n_p):
            bqm.add_variable(var(i, j), -revenues[i])

    # Constraint: each container assigned to at most one position
    for i in range(n_c):
        for j1 in range(n_p):
            for j2 in range(j1 + 1, n_p):
                bqm.add_interaction(var(i, j1), var(i, j2), lambda_assign)

    # Constraint: each position holds at most one container
    for j in range(n_p):
        for i1 in range(n_c):
            for i2 in range(i1 + 1, n_c):
                bqm.add_interaction(var(i1, j), var(i2, j), lambda_assign)

    # CG constraint: penalize CG deviation outside [cg_min, cg_max]
    # Approximate: add quadratic penalty for sum_ij weights[i]*cg_arms[j]*x_ij / total_weight
    total_w = weights.sum()
    cg_target = (cg_min + cg_max) / 2

    # Cross terms in CG penalty
    for i1 in range(n_c):
        for j1 in range(n_p):
            contrib1 = weights[i1] * cg_arms[j1] / total_w
            for i2 in range(n_c):
                for j2 in range(n_p):
                    contrib2 = weights[i2] * cg_arms[j2] / total_w
                    if (i1, j1) != (i2, j2):
                        bqm.add_interaction(
                            var(i1, j1), var(i2, j2),
                            lambda_cg * contrib1 * contrib2
                        )
            # Linear CG term (from -2 * cg_target * contrib)
            bqm.add_variable(
                var(i1, j1),
                lambda_cg * (contrib1 ** 2 - 2 * cg_target * contrib1)
            )

    return bqm

bqm = build_loading_qubo(revenues, weights, cg_arms, CG_MIN, CG_MAX)
print(f"BQM has {len(bqm.variables)} variables and {len(bqm.quadratic)} interactions")

# Solve with D-Wave Leap Hybrid (handles large BQMs via hybrid decomposition)
sampler = LeapHybridSampler()
result = sampler.sample(bqm, time_limit=2)
best = result.first

# Decode solution
loading_plan = {}
for i in range(N_CONTAINERS):
    for j in range(N_POSITIONS):
        if best.sample.get(f"x_{i}_{j}", 0) == 1:
            loading_plan[i] = j

total_revenue = sum(revenues[i] for i in loading_plan)
total_weight = sum(weights[i] for i in loading_plan)
cg = sum(weights[i] * cg_arms[j] for i, j in loading_plan.items()) / total_weight
print(f"Loaded {len(loading_plan)} containers, revenue: ${total_revenue:,.0f}")
print(f"Total weight: {total_weight:.0f} kg, CG: {cg:.3f} m (limit: {CG_MIN} to {CG_MAX})")
print(f"Energy: {best.energy:.2f}")

Airbus benchmarked three approaches on standardized 12-container scenarios derived from actual A380 freighter conversion flight manifests. The classical baseline used LP relaxation (Gurobi) followed by rounding, which produced CG-feasible solutions in roughly 8 seconds but missed revenue by 9% on average due to rounding cascades. IBM’s QAOA implementation on Eagle (127 qubits) required circuit transpilation that expanded the 192-variable QUBO to nearly 127 physical qubits with SWAP overhead, limiting circuit depth and solution quality in the NISQ regime. D-Wave’s LeapHybrid solver, which decomposes the full BQM and routes subproblems to Advantage hardware, returned feasible solutions within 2 seconds and matched or exceeded Gurobi optimal on 10 of 12 benchmark scenarios. The 7% revenue improvement over the current manual load planning process reflects both better container sequencing and more precise CG balancing that allows higher total load weight while staying within the flight envelope. Airbus plans to extend the problem to full A380 lower deck inclusion (32 positions) and real-time re-optimization for last-minute cargo swaps.