With underlying mathematical algorithms of OpenMDAO, based on the MAUD framework, solve_nonlinear computes the values of the output values only (does not set residuals). First, I'll address the details of solve_nonlinear vs apply_nonlinear. There are a couple of different aspects to your question. So another way of putting this is: why do we need the self._run_apply() in each iteration when doing Gauss-Seidel convergence? (And could this be turned off?) (This is actually the existing implementation that I have for convergence of these components in MATLAB and that works as expected, hence it finds the same converged design, but with half the amount of component runs.) Of course this means that we need at least two iterations to assess convergence, but it saves one component run per iteration.

Instead of having this second run inside the iteration, wouldn't it be more efficient to directly continue to the next iteration? In that iteration we can use the new values of the feedback variables and do another self._iter_execute() with the update of feedforward data and then assess the convergence based on the difference between the results between those two iterations.

If I'm not mistaken, this information is then (only) used to assess the convergence of that iteration ( self._iter_get_norm()). But then the second component run ( self._run_apply()) runs the components again with the updated feedback variables that resulted from the first run while keeping the feedforwards as they were in that first run. This is the step I would expect for Gauss-Seidel. It seems the first component run ( er_execute()) uses an initial guess for the feedback variables that need to be converged and then runs the components sequentially while updating any feedforward data. My main question is, are two runs per iteration really required, and if so, why? These runs originate from the self._iter_execute() and the self._run_apply() in the _run_iterator() method of the solver (class Solver in file solver.py). That's when I noticed that the NonLinearBlockGS solver actually needs to run the tools in the coupled system two times per iteration. First I was using this with simple mathematical functions (hence runtime << 1s), but now I'm also implementing a system with multiple explicit components that have runtimes of around one minute or more.

I've been using the the NonLinearBlockGS as nonlinear_solver for my MDO system consisting of ExplicitComponents and this works as expected.

Mdp gauss seidel python