Sensitivity Based Distributed Programming (SBDP) Pseudocode-to-Code Traceability

This page maps each step of the Sensitivity Based Distributed Programming (SBDP) 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 5 Sensitivity Based Distributed Programming (SBDP)

Require: hyperparameter \(\epsilon_k\)

Require: initial \({}^{j}_{i}\lambda,\; {}^{i}_{j}h,\; {}^{j}_{i}z\) in interface storage \(i \leftrightarrow j \;\; \forall\; j \in {}^{i}N,\; i \in M\)

 

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

repeat

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

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

Determine \(\nabla_{{}^{i}d}{}^{j}L^{(k)} \;\; \forall\; j \in {}^{i}N\)

\[\begin{aligned} {}^{i}d^{(k+1)} \leftarrow{} & \argmin_{{}^{i}d \;\in\; {}^{i}\mathcal{D}} \;\; {}^{i}v_f\!\left({}^{i}r\right) + \sum_{j \in {}^{i}N} \left( \bigl(\nabla_{{}^{i}d}{}^{j}L^{(k)}\bigr)^{T} \left({}^{i}d - {}^{i}d^{(k)}\right) \right) \\ & \text{s.t.} \;\; {}^{i}v_g\!\left({}^{i}r\right) \leq 0, \\ & \phantom{\text{s.t.}} \;\; {}^{i}v_h\!\left({}^{i}r\right) = 0, \\ & \phantom{\text{s.t.}} \;\; \begin{bmatrix} {}^{i}_{j}H\!\left({}^{i}r\right) - {}^{i}_{j}h \\ {}^{i}_{j}S_{z}\,{}^{i}d - {}^{j}_{i}z \end{bmatrix} = 0 \quad | \; {}^{i}_{j}\lambda \quad \forall\; j \in {}^{i}N. \end{aligned}\]

Determine \({}^{i}_{j}\lambda \;\; \forall\; j \in {}^{i}N\)

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

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 SBDP coordination method is selected and configured in the use case InputFile.py by assigning an SBDP instance to self._coordinationmethod. All algorithmic behaviour is wired through four constructor arguments:

self._coordinationmethod: CoordinationMethodInterface = SBDP(
    convergence_indicator_innerloop=ConvergenceIndicator_Innerloop_AlwaysConverged(),
    convergence_indicator_outerloop=ConvergenceIndicator_Outerloop_DeWit(
        toleranceconsistency=1E-4),
    updatecouplingparametermethod_outerloop=UpdateCouplingParameterMethod_OnlyInitialMultipliers(
        initialmultiplier=0.0),
    iterationscheme=Parallel())

SBDP does not relax the coupling with an augmented-Lagrangian penalty. Instead it keeps the coordination equality as a hard constraint in each subsystem's local problem and couples subsystems through a first-order sensitivity correction \(\nabla_{{}^{i}d}{}^{j}L^{(k)}\) (Algorithm 3 in SBDP). Consequently there are no penalty weights \(s\) and no penalty-adaption hyperparameters \(\beta\), \(\gamma\); the coordination multipliers \(\lambda_h\) and \(\lambda_z\) are recovered directly from the KKT system of the local optimization rather than updated by a dual step.

Convergence criteria

SBDP runs a single decentralized pass per outer iteration (there is no inner fixed-point loop), so the two indicators play asymmetric roles:

• Inner loop — convergence_indicator_innerloop must be ConvergenceIndicator_Innerloop_AlwaysConverged. Because SBDP performs exactly one primal solve per outer step, the inner loop is required to report convergence immediately after that single pass; LocalSubSystemSBDP restricts the inner-loop indicator to this always-converged variant.

• Outer loop — convergence_indicator_outerloop, evaluated by SubSystemBasis.evaluate_OuterLoopConvergenceIndicator. SBDP requires ConvergenceIndicator_Outerloop_DeWit, which terminates once all coupling inconsistencies \(c = \left({}^{i}_{j}H({}^{i}r) - {}^{i}_{j}h,\; {}^{i}_{j}S_z\,{}^{i}d - {}^{j}_{i}z,\ldots\right)\) and their step-to-step changes fall within toleranceconsistency. This tolerance plays the role of the SBDP hyperparameter \(\epsilon_k\) (see the Hyperparameter ε_k section below).

Both indicators are validated in LocalSubSystemSBDP, which restricts SBDP to the always-converged inner indicator and the DeWit outer indicator.

Update method (multiplier recovery)

updatecouplingparametermethod_outerloop must be UpdateCouplingParameterMethod_OnlyInitialMultipliers. SBDP does not perform a dual/penalty update: the coordination-equality multipliers \(\lambda_h\) and \(\lambda_z\) are recovered from the KKT system of each local solve (pseudocode line 9, postprocess_Optimization / compute_KKT_multipliers on LocalSubSystemSBDP) and exchanged with neighbours through the interface storage. The update method therefore only seeds the multipliers before the first iteration:

• initialmultiplier — the initial coordination multipliers \({}^{i}_{j}\lambda_h^{(0)}\), \({}^{i}_{j}\lambda_z^{(0)}\) (recommended 0.0). From the first outer iteration onward the values are overwritten by the recovered KKT multipliers, so this argument only sets the starting point of the sensitivity correction.

The recovered multipliers and the coupling data are stored per coupling in CouplingParametersSBDP.

Iteration scheme

iterationscheme controls how the decentralized subsystem solves (pseudocode line 5) are scheduled by the IterationSchemeInterface. SBDP has no controller and each subsystem's local problem is independent within an outer step, so parallel execution is recommended:

• Parallel — a Jacobi sweep: all subsystem problems are solved simultaneously from the previous iterate (recommended for SBDP).
• SequentialForward / SequentialBackward — a Gauss–Seidel sweep: subsystems are solved one after another. These are allowed but not recommended, since the independent subproblems gain nothing from sequential execution.

Hyperparameter ε_k

The pseudocode "Require" block (Algorithm 3, lines 1–2) lists the single hyperparameter \(\epsilon_k\) alongside the initial multipliers \({}^{j}_{i}\lambda_h\), \({}^{j}_{i}\lambda_z\). In the implementation \(\epsilon_k\) is realised as the outer-loop consistency tolerance toleranceconsistency of ConvergenceIndicator_Outerloop_DeWit:

• \(\epsilon_k\) (toleranceconsistency) — the consensus tolerance on the coupling inconsistencies \(c\). A smaller \(\epsilon_k\) (e.g. 1E-4) enforces tighter agreement between coupled subsystems at the cost of more outer iterations; a larger value terminates the coordination earlier with looser consensus. Because SBDP has no penalty weights, \(\epsilon_k\) is the primary control on the accuracy/effort trade-off.