Augmented Lagrangian Alternating Direction Inexact Newton (ALADIN) Pseudocode-to-Code Traceability

This page maps each step of the ALADIN pseudocode to the implementing classes and methods in the codebase.

Highlighted lines are linked to the implementation. Hover or click to see the implementing classes/methods, then click through to the full API documentation.

Algorithm 4 Augmented Lagrangian Alternating Direction Inexact Newton (ALADIN)

Require: hyperparameters $\nu$, \({}^{i}\Sigma\), \({}^{i}_{j}s \;\; \forall\; j \in {}^{i}N,\; i \in M\)

Require: initial \(\Delta{}^{i}d\) in interface storage \(i \leftrightarrow \text{Controller} \;\; \forall\; i \in M\)

Require: initial \({}^{i}\lambda^{(0)} \;\; \forall\; i \in M\)

 

\(k \leftarrow 0\) ▷ initialize outerloop iterator

repeat

\(l \leftarrow 0\) ▷ initialize innerloop iterator

repeat

 

for every \(i \in M\) in parallel do

Copy \(\Delta{}^{i}d\) from interface storage \(i \leftrightarrow \text{Controller}\)

Copy \({}^{i}_{j}h,\; {}^{j}_{i}z\) from interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

\[ {}^{i}\hat{d}^{(k,\,l+1)} \leftarrow {}^{i}d^{(k,\,l)} + \Delta{}^{i}d \]

\[\begin{aligned} {}^{i}d^{(k,\,l+1)} \leftarrow{} & \argmin_{{}^{i}d} \;\; {}^{i}v_f\!\left({}^{i}r\right) + \sum_{j \in {}^{i}N} \left( \left({}^{i}_{j}\lambda\right)^{T} \begin{bmatrix} {}^{i}_{j}H\!\left({}^{i}r\right) \\ {}^{i}_{j}S_{z}\,{}^{i}d \end{bmatrix} + \left({}^{j}_{i}\lambda\right)^{T} \begin{bmatrix} - {}^{j}_{i}S_{h}\,{}^{i}d \\ - {}^{i}_{j}S_{z}\,{}^{i}d \end{bmatrix} \right) \\ & + \frac{\nu}{2} \left\| {}^{i}d - {}^{i}\hat{d}^{(k,\,l+1)} \right\|_{{}^{i}\Sigma}^{2} \\ & \text{s.t.} \;\; {}^{i}v_g\!\left({}^{i}r\right) \leq 0 \quad | \; {}^{i}\kappa_g \\ & \phantom{\text{s.t.}} \;\; {}^{i}v_h\!\left({}^{i}r\right) = 0 \quad | \; {}^{i}\kappa_h \\ & \phantom{\text{s.t.}} \;\; {}^{i}v_D\!\left({}^{i}d\right) \leq 0 \quad | \; {}^{i}\kappa_d \end{aligned}\]

Copy \({}^{i}B,\; \nabla_{{}^{i}d}{}^{i}v_f,\; {}^{i}v_g,\; \nabla_{{}^{i}d}{}^{i}v_g,\; \nabla_{{}^{i}d}{}^{i}v_h,\; {}^{i}v_D,\; \nabla_{{}^{i}d}{}^{i}v_D,\; \nabla^{2}_{{}^{i}d\,{}^{i}d}{}^{i}_{j}H,\; \nabla_{{}^{i}d}{}^{i}_{j}H,\; {}^{i}_{j}H\),

\({}^{j}_{i}h,\; {}^{i}_{j}z,\; {}^{j}_{i}S_{h},\; {}^{i}_{j}S_{z},\; {}^{i}_{j}\lambda,\; {}^{i}_{j}s \;\; \forall\; j \in {}^{i}N\) to interface storage \(i \leftrightarrow \text{Controller}\)

Copy \({}^{i}_{j}H,\; {}^{j}_{i}h,\; {}^{i}_{j}z\) to interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

end for

 

for Controller do

Copy \({}^{i}B,\; \nabla_{{}^{i}d}{}^{i}v_f,\; {}^{i}v_g,\; \nabla_{{}^{i}d}{}^{i}v_g,\; \nabla_{{}^{i}d}{}^{i}v_h,\; {}^{i}v_D,\; \nabla_{{}^{i}d}{}^{i}v_D,\; \nabla^{2}_{{}^{i}d\,{}^{i}d}{}^{i}_{j}H,\; \nabla_{{}^{i}d}{}^{i}_{j}H,\; {}^{i}_{j}H\),

\({}^{j}_{i}h,\; {}^{i}_{j}z,\; {}^{j}_{i}S_{h},\; {}^{i}_{j}S_{z},\; {}^{i}_{j}\lambda,\; {}^{i}_{j}s \;\; \forall\; j \in {}^{i}N\) from interface storage \(i \leftrightarrow \text{Controller} \;\; \forall\; i \in M\)

\[\begin{aligned} \left\{\Delta{}^{i}d\right\}_{i \in M} \leftarrow{} & \argmin_{\Delta{}^{i}d \;\forall\; i \in M} \;\; \sum_{i \in M} \left( \nabla_{{}^{i}d}^{T}{}^{i}v_f\,\Delta{}^{i}d + \frac{1}{2} \Delta{}^{i}d^{T}\,{}^{i}B\,\Delta{}^{i}d \right) \\ & + \sum_{i \in M} \sum_{j \in {}^{i}N} \left( \left({}^{i}_{j}\lambda\right)^{T} \begin{bmatrix} \nabla_{{}^{i}d}{}^{i}_{j}H\,\Delta{}^{i}d - {}^{i}_{j}S_{h}\,\Delta{}^{j}d \\ {}^{i}_{j}S_{z}\,\Delta{}^{i}d - {}^{j}_{i}S_{z}\,\Delta{}^{j}d \end{bmatrix} + \frac{1}{2} \Delta{}^{i}d^{T} \left( \sum_{q=1}^{{}^{i}_{j}n_h} \left({}^{i}_{j}\lambda_{h}\right)_{q} \nabla^{2}_{{}^{i}d\,{}^{i}d} \left({}^{i}_{j}H\right)_{q} \right) \Delta{}^{i}d \right) \\ & + \sum_{i \in M} \sum_{j \in {}^{i}N} \left( 2 \left( {}^{i}_{j}s^{2} \circ \begin{bmatrix} {}^{i}_{j}H\!\left({}^{i}r\right) - {}^{i}_{j}h \\ {}^{i}_{j}z - {}^{j}_{i}z \end{bmatrix} \right)^{T} \begin{bmatrix} \nabla_{{}^{i}d}{}^{i}_{j}H\,\Delta{}^{i}d - {}^{i}_{j}S_{h}\,\Delta{}^{j}d \\ {}^{i}_{j}S_{z}\,\Delta{}^{i}d - {}^{j}_{i}S_{z}\,\Delta{}^{j}d \end{bmatrix} \right. \\ & \quad\quad\quad\quad\quad\;\; + \begin{bmatrix} \nabla_{{}^{i}d}{}^{i}_{j}H\,\Delta{}^{i}d - {}^{i}_{j}S_{h}\,\Delta{}^{j}d \\ {}^{i}_{j}S_{z}\,\Delta{}^{i}d - {}^{j}_{i}S_{z}\,\Delta{}^{j}d \end{bmatrix}^{T} \operatorname{diag}\!\left({}^{i}_{j}s\right)^{2} \begin{bmatrix} \nabla_{{}^{i}d}{}^{i}_{j}H\,\Delta{}^{i}d - {}^{i}_{j}S_{h}\,\Delta{}^{j}d \\ {}^{i}_{j}S_{z}\,\Delta{}^{i}d - {}^{j}_{i}S_{z}\,\Delta{}^{j}d \end{bmatrix} \\ & \left. \quad\quad\quad\quad\quad\;\; + \sum_{q=1}^{{}^{i}_{j}n_h} \left( {}^{i}_{j}s_{h}^{2} \circ \left( {}^{i}_{j}H\!\left({}^{i}r\right) - {}^{i}_{j}h \right) \right)_{q} \Delta{}^{i}d^{T} \nabla^{2}_{{}^{i}d\,{}^{i}d} \left( \left({}^{i}_{j}H\right)_{q} \right) \Delta{}^{i}d \right) \\ & \text{s.t.} \;\; {}^{i}v_g + \nabla_{{}^{i}d}{}^{i}v_g\,\Delta{}^{i}d \leq 0 \quad \forall\; i \in M \\ & \phantom{\text{s.t.}} \;\; \nabla_{{}^{i}d}{}^{i}v_h\,\Delta{}^{i}d = 0 \quad \forall\; i \in M \\ & \phantom{\text{s.t.}} \;\; {}^{i}v_D + \nabla_{{}^{i}d}{}^{i}v_D\,\Delta{}^{i}d \leq 0 \quad \forall\; i \in M \end{aligned}\]

Copy \(\Delta{}^{i}d\) to interface storage \(i \leftrightarrow \text{Controller} \;\; \forall\; i \in M\)

end for

 

Compute innerloop convergence criterion (e.g., [@dewitUnifiedApproach2009a; @tosseramsDistributedOptimization2008; @guoDistributedAugmented2025])

\(l \leftarrow l + 1\)

until innerloop convergence criterion is met

 

\({}^{i}d^{(k+1)} \leftarrow {}^{i}d^{(k,\,l)} \;\; \forall\; i \in M\)

 

for every \(i \in M\) do

Copy \(\Delta{}^{i}d\) from interface storage \(i \leftrightarrow \text{Controller}\)

Copy \({}^{j}_{i}H\!\left({}^{j}r\right),\; {}^{i}_{j}h,\; {}^{j}_{i}z\) from interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

\[ {}^{i}\hat{d}^{(k+1)} \leftarrow {}^{i}d^{(k+1)} + \Delta{}^{i}d \]

Copy \({}^{i}_{j}H,\; {}^{j}_{i}h,\; {}^{i}_{j}z\) to interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

Copy \({}^{i}_{j}\hat{H},\; {}^{j}_{i}\hat{h},\; {}^{i}_{j}\hat{z}\) to interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

end for

 

for every \(i \in M\) do ▷ decentralized Dual Update

Copy \({}^{j}_{i}\hat{H}\!\left({}^{j}r\right),\; {}^{i}_{j}\hat{h},\; {}^{j}_{i}\hat{z}\) from interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

Copy \({}^{j}_{i}H\!\left({}^{j}r\right),\; {}^{i}_{j}h,\; {}^{j}_{i}z\) from interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N\)

\[\begin{aligned} {}^{i}_{j}\hat{c}^{(k+1)} &\leftarrow \begin{bmatrix} {}^{i}_{j}\hat{H}\!\left({}^{i}r\right) - {}^{i}_{j}\hat{h} \\ {}^{i}_{j}S_{z}\,{}^{i}\hat{d}^{(k+1)} - {}^{j}_{i}\hat{z} \end{bmatrix}, \quad {}^{j}_{i}\hat{c}^{(k+1)} \leftarrow \begin{bmatrix} {}^{j}_{i}\hat{H}\!\left({}^{j}r\right) - {}^{j}_{i}S_{h}\,{}^{i}\hat{d}^{(k+1)} \\ {}^{j}_{i}\hat{z} - {}^{i}_{j}S_{z}\,{}^{i}\hat{d}^{(k+1)} \end{bmatrix} \end{aligned}\]

\[\begin{aligned} {}^{i}_{j}\lambda^{(k+1)} &\leftarrow \operatorname{DualUpdate}\!\left( {}^{i}_{j}\lambda^{(k)},\; {}^{i}_{j}s^{(k)},\; {}^{i}_{j}\hat{c}^{(k+1)} \right) \quad \forall\; j \in {}^{i}N \\ {}^{j}_{i}\lambda^{(k+1)} &\leftarrow \operatorname{DualUpdate}\!\left( {}^{j}_{i}\lambda^{(k)},\; {}^{j}_{i}s^{(k)},\; {}^{j}_{i}\hat{c}^{(k+1)} \right) \quad \forall\; j \in {}^{i}N \end{aligned}\]

end for

 

Compute outerloop convergence criterion (e.g., [@dewitUnifiedApproach2009a; @tosseramsDistributedOptimization2008])

\(k \leftarrow k + 1\)

until outerloop convergence criterion is met

return \(\left\{{}^{i}d^{(k)}\right\}_{i \in M}\)

×

CouplingParameters and MiddleLevel

Algorithm Options / Hyperparameters

The ALADIN coordination method is selected and configured in the use case InputFile.py by assigning an ALADIN instance to self._coordinationmethod. All algorithmic behaviour is wired through four constructor arguments:

self._coordinationmethod: CoordinationMethodInterface = ALADIN(
    convergence_indicator_innerloop=ConvergenceIndicator_Innerloop_DeWit(
        tolerancetotalobjective=1000.0),
    convergence_indicator_outerloop=ConvergenceIndicator_Outerloop_DeWit(
        toleranceconsistency=1E-4),
    updatecouplingparametermethod_outerloop=UpdateCouplingParameterMethod_AugLagMultipliersFixedWeights(
        initialweight=0.01,
        initialmultiplier=0.0),
    iterationscheme=ParallelLocal_SequentialController())

Convergence criteria

ALADIN uses a nested inner/outer loop (Algorithm 2 in ALADIN), so two convergence indicators are configured:

• Inner loop — convergence_indicator_innerloop, evaluated by SubSystemBasis.evaluate_InnerLoopConvergenceIndicator. The recommended choice is ConvergenceIndicator_Innerloop_DeWit, which converges on the relative change of the total objective, \(\text{error} = |v_f^{\text{new}} - v_f^{\text{old}}| / (1 + |v_f^{\text{new}}|) \le\) tolerancetotalobjective. A smaller tolerancetotalobjective forces more inner iterations (tighter local/controller QP resolution per outer step); a larger value (e.g. 1000.0) lets the inner loop terminate quickly and shifts most of the work onto the outer dual updates.

• Outer loop — convergence_indicator_outerloop, evaluated by SubSystemBasis.evaluate_OuterLoopConvergenceIndicator. The recommended choice is ConvergenceIndicator_Outerloop_DeWit, which terminates once all coupling inconsistencies \(\left({}^{i}_{j}H({}^{i}r) - {}^{i}_{j}h,\; {}^{i}_{j}z - {}^{j}_{i}z,\ldots\right)\) and their step-to-step changes fall within toleranceconsistency. A smaller toleranceconsistency (e.g. 1E-4) enforces tighter consensus between coupled subsystems at the cost of more outer iterations.

An AlwaysConverged inner-loop indicator is also available when a single inner pass per outer iteration is desired.

Update method (dual update)

updatecouplingparametermethod_outerloop implements the ALADIN dual update (pseudocode lines 25–27). ALADIN requires the fixed-weight augmented-Lagrangian multiplier update UpdateCouplingParameterMethod_AugLagMultipliersFixedWeights, which updates each multiplier as \(\lambda \leftarrow \lambda + 2\,s^{2}\,c(\cdot)\) using the coupling inconsistency \(c(\cdot)\):

• initialweight — the penalty scaling weight \(s\) (recommended \(0 < s \le 0.1\), e.g. 0.01). Larger initialweight produces larger multiplier steps and faster constraint enforcement, but risks oscillation/divergence; smaller values give gentler, more stable but slower consensus. Unlike ALC's adaptive-weight methods, this weight stays fixed across outer iterations — a defining property of ALADIN.
• initialmultiplier — the initial Lagrange multiplier \({}^{i}_{j}\lambda^{(0)}\) (recommended 0.0).

Iteration scheme

iterationscheme controls how the inner-loop jobs are scheduled by the IterationSchemeInterface. Because ALADIN's controller QP couples all subsystems and must run after the local NLPs, the appropriate choice is ParallelLocal_SequentialController: the local subsystem problems (pseudocode line 11) are solved in parallel, followed by the sequential controller QP (pseudocode line 18).

Proximal hyperparameters ν, Σⁱ, s

The pseudocode "Require" block (Algorithm 2, lines 1–3) lists the penalty parameter \(\nu\), the positive-definite proximal scaling matrix \({}^{i}\)\(\Sigma\), and the coupling scaling weights \({}^{i}_{j}\)\(s\):

• \(\nu\) and \({}^{i}\)\(\Sigma\) weight the proximal term \(\tfrac{\nu}{2}\lVert {}^{i}d - {}^{i}\hat{d}\rVert_{{}^{i}\Sigma}^{2}\) in the local subproblem (see LocalSubSystemALADIN.evaluateCoordinationObjective, accessed via get_Nu/set_Nu and get_Sigma_i/set_Sigma_i). A larger \(\nu\) or larger diagonal entries of \({}^{i}\)\(\Sigma\) keep each local iterate closer to the controller prediction \({}^{i}\hat{d}\) (stronger regularization, better consistency, slower local progress); smaller values give the local NLP more freedom. Currently \({}^{i}\)\(\Sigma\) is initialized to the identity matrix in initializeCouplingParameters_before_CopyToMiddleLevel and \(\nu\) is set internally (not yet exposed through the InputFile).
• \({}^{i}_{j}\)\(s\) are the coupling scaling weights carried in the coordination QP and shared with the controller; they coincide with the initialweight \(s\) of the dual update above.