gemseo / mda

newton_raphson module¶

The Newton-Raphson algorithm for solving MDAs.

class gemseo.mda.newton_raphson.MDANewtonRaphson(disciplines, max_mda_iter=10, relax_factor=None, name=None, grammar_type=GrammarType.JSON, linear_solver='DEFAULT', tolerance=1e-06, linear_solver_tolerance=1e-12, warm_start=False, use_lu_fact=False, coupling_structure=None, log_convergence=False, linear_solver_options=None, newton_linear_solver_name='DEFAULT', newton_linear_solver_options=None, parallel=False, use_threading=True, n_processes=2, acceleration_method=AccelerationMethod.NONE, over_relaxation_factor=0.99)[source]

Bases: BaseMDARoot

Newton solver for MDA.

The Newton-Raphson method is an iterative method to solve general equations of the form,

\[F(x) = 0, \quad \text{where} \quad F: \mathbb{R}^n \rightarrow \mathbb{R}^n.\]

Beginning with \(x_0 \in \mathbb{R}^n\) the successive iterates are given by:

\[x_{k+1} = x_k - J_f(x_k)^{-1} f(x_k),\]

where \(J_f(x_k)\) denotes the Jacobian of \(f\) at \(x_k\).

Initialize self. See help(type(self)) for accurate signature.

Parameters:

disciplines (Sequence[MDODiscipline]) – The disciplines from which to compute the MDA.
max_mda_iter (int) –
The maximum iterations number for the MDA algorithm.

By default it is set to 10.
relax_factor (float | None) – The relaxation factor.
name (str | None) – The name to be given to the MDA. If None, use the name of the class.
grammar_type (MDODiscipline.GrammarType) –
The type of the input and output grammars.

By default it is set to “JSONGrammar”.
linear_solver (str) –
The name of the linear solver.

By default it is set to “DEFAULT”.
tolerance (float) –
The tolerance of the iterative direct coupling solver; the norm of the current residuals divided by initial residuals norm shall be lower than the tolerance to stop iterating.

By default it is set to 1e-06.
linear_solver_tolerance (float) –
The tolerance of the linear solver in the adjoint equation.

By default it is set to 1e-12.
warm_start (bool) –
Whether the second iteration and ongoing start from the previous coupling solution.

By default it is set to False.
use_lu_fact (bool) –
Whether to store a LU factorization of the matrix when using adjoint/forward differentiation. to solve faster multiple RHS problem.

By default it is set to False.
coupling_structure (MDOCouplingStructure | None) – The coupling structure to be used by the MDA. If None, it is created from disciplines.
log_convergence (bool) –
Whether to log the MDA convergence, expressed in terms of normed residuals.

By default it is set to False.
linear_solver_options (Mapping[str, Any] | None) – The options passed to the linear solver factory.
newton_linear_solver_name (str) –
The name of the linear solver for the Newton method.

By default it is set to “DEFAULT”.
newton_linear_solver_options (Mapping[str, Any] | None) – The options for the Newton linear solver.
parallel (bool) –
Whether to execute and linearize the disciplines in parallel.

By default it is set to False.
use_threading (bool) –
Whether to use threads instead of processes to parallelize the execution. Processes will copy (serialize) all the disciplines, while threads will share all the memory. If one wants to execute the same discipline multiple times then multiprocessing should be preferred.

By default it is set to True.
n_processes (int) –
The maximum simultaneous number of threads if use_threading is set to True, otherwise processes, used to parallelize the execution.

By default it is set to 2.
acceleration_method (AccelerationMethod) –
The acceleration method to be used to improve the convergence rate of the fixed point iteration method.

By default it is set to “NoTransformation”.
over_relaxation_factor (float) –
The over-relaxation factor.

By default it is set to 0.99.

Raises:

ValueError – When there are no coupling variables, or when there are weakly coupled disciplines. In these cases, use MDAChain.

all_couplings: list[str]: The names of all the coupling variables.

assembly: JacobianAssembly

cache: AbstractCache | None: The cache containing one or several executions of the discipline according to the cache policy.

coupling_structure: MDOCouplingStructure: The coupling structure to be used by the MDA.

data_processor: DataProcessor: A tool to pre- and post-process discipline data.

exec_for_lin: bool: Whether the last execution was due to a linearization.

input_grammar: BaseGrammar: The input grammar.

jac: MutableMapping[str, MutableMapping[str, ndarray | csr_array | JacobianOperator]]

The Jacobians of the outputs wrt inputs.

The structure is {output: {input: matrix}}.

lin_cache_tol_fact: float: The tolerance factor to cache the Jacobian.

linear_solver: str: The name of the linear solver.

linear_solver_options: Mapping[str, Any]: The options of the linear solver.

linear_solver_tolerance: float: The tolerance of the linear solver in the adjoint equation.

matrix_type: JacobianAssembly.JacobianType: The type of the matrix.

n_processes: int: The maximum number of simultaneous threads, if use_threading is True, or processes otherwise, used to parallelize the execution.

name: str: The name of the discipline.

norm0: float | None: The reference residual, if any.

normed_residual: float: The normed residual.

output_grammar: BaseGrammar: The output grammar.

re_exec_policy: ReExecutionPolicy: The policy to re-execute the same discipline.

property relax_factor: float: The over-relaxation factor.

reset_history_each_run: bool: Whether to reset the history of MDA residuals before each run.

residual_history: list[float]: The history of the MDA residuals.

residual_variables: dict[str, str]: The output variables mapping to their inputs, to be considered as residuals; they shall be equal to zero.

run_solves_residuals: bool: Whether the run method shall solve the residuals.

scaling: ResidualScaling: The scaling method applied to MDA residuals for convergence monitoring.

strong_couplings: list[str]: The names of the strong coupling variables.

tolerance: float: The tolerance of the iterative direct coupling solver.

use_lu_fact: bool: Whether to store a LU factorization of the matrix.

use_threading: bool: Whether to use threads instead of processes to parallelize the execution.

warm_start: bool: Whether the second iteration and ongoing start from the previous solution.

Examples using MDANewtonRaphson¶

Newton-Raphson MDA