# ImplicitComponent¶

Implicit variables are those that are computed as an implicit function of other variables. For instance, \(y\) would be an implicit variable, given that it is computed by solving \(cos(x⋅y)−z⋅y=0\). In OpenMDAO, implicit variables are defined as the outputs of components that inherit from ImplicitComponent.

In the above implicit expression, \(y\) is the implicit variable while \(x\) and \(z\) would be considered inputs.

## ImplicitComponent Methods¶

The implementation of each method will be illustrated using a simple implicit component that computes the output \(x\) implicitly via a quadratic equation, \(ax^2+bx+c=0\), where \(a\), \(b\), and \(c\) are inputs to the component.

```
import openmdao.api as om
class QuadraticComp(om.ImplicitComponent):
"""
A Simple Implicit Component representing a Quadratic Equation.
R(a, b, c, x) = ax^2 + bx + c
Solution via Quadratic Formula:
x = (-b + sqrt(b^2 - 4ac)) / 2a
"""
```

`setup()`

:

Declare input and output variables via `add_input`

and `add_output`

. Information like variable names, sizes, units, and bounds are declared. Also, declare partial derivatives that this component provides. Here we use the wild card to say that this component provides derivatives of all implicit residuals with respect to all inputs and outputs.

```
def setup(self):
self.add_input('a', val=1., tags=['tag_a'])
self.add_input('b', val=1.)
self.add_input('c', val=1.)
self.add_output('x', val=0., tags=['tag_x'])
```

`setup_partials()`

:

Declare partial derivatives that this component provides. Here we use the wild card to say that this component provides derivatives of all implicit residuals with respect to all inputs and outputs.

```
def setup_partials(self):
self.declare_partials(of='*', wrt='*')
```

`apply_nonlinear(inputs, outputs, residuals)`

:

Compute the `residuals`

, given the `inputs`

and `outputs`

.

```
def apply_nonlinear(self, inputs, outputs, residuals):
a = inputs['a']
b = inputs['b']
c = inputs['c']
x = outputs['x']
residuals['x'] = a * x ** 2 + b * x + c
```

`solve_nonlinear(inputs, outputs)`

:

[Optional] Compute the `outputs`

, given the `inputs`

.

```
def solve_nonlinear(self, inputs, outputs):
a = inputs['a']
b = inputs['b']
c = inputs['c']
outputs['x'] = (-b + (b ** 2 - 4 * a * c) ** 0.5) / (2 * a)
```

`linearize(inputs, outputs, partials)`

:

[Optional] The component’s partial derivatives of interest are those of the `residuals`

with respect to the `inputs`

and the `outputs`

. If the user computes the partial derivatives explicitly, they are provided here. If the user wants to implement partial derivatives in a matrix-free way, this method provides a place to perform any necessary assembly or pre-processing for the matrix-vector products. Regardless of how the partial derivatives are computed, this method provides a place to perform any relevant factorizations for directly solving or preconditioning the linear system.

```
def linearize(self, inputs, outputs, partials):
a = inputs['a']
b = inputs['b']
c = inputs['c']
x = outputs['x']
partials['x', 'a'] = x ** 2
partials['x', 'b'] = x
partials['x', 'c'] = 1.0
partials['x', 'x'] = 2 * a * x + b
self.inv_jac = 1.0 / (2 * a * x + b)
```

`apply_linear(inputs, outputs, d_inputs, d_outputs, d_residuals, mode)`

:

[Optional] If the user wants to implement partial derivatives in a matrix-free way, this method performs the matrix-vector product. If `mode`

is ‘fwd’, this method computes \(d\_residuals=J⋅[d\_inputs \ d\_outputs]^T\)
. If `mode`

is ‘rev’, this method computes \([d\_inputs \ d\_outputs]^T=J^T⋅d\_residuals\).

```
def apply_linear(self, inputs, outputs,
d_inputs, d_outputs, d_residuals, mode):
a = inputs['a']
b = inputs['b']
c = inputs['c']
x = outputs['x']
if mode == 'fwd':
if 'x' in d_residuals:
if 'x' in d_outputs:
d_residuals['x'] += (2 * a * x + b) * d_outputs['x']
if 'a' in d_inputs:
d_residuals['x'] += x ** 2 * d_inputs['a']
if 'b' in d_inputs:
d_residuals['x'] += x * d_inputs['b']
if 'c' in d_inputs:
d_residuals['x'] += d_inputs['c']
elif mode == 'rev':
if 'x' in d_residuals:
if 'x' in d_outputs:
d_outputs['x'] += (2 * a * x + b) * d_residuals['x']
if 'a' in d_inputs:
d_inputs['a'] += x ** 2 * d_residuals['x']
if 'b' in d_inputs:
d_inputs['b'] += x * d_residuals['x']
if 'c' in d_inputs:
d_inputs['c'] += d_residuals['x']
```

`solve_linear(d_outputs, d_residuals, mode)`

:

[Optional] Solves a linear system where the matrix is \(d\_residuals/d\_outputs\)
or its transpose. If `mode`

is ‘fwd’, the right-hand side vector is \(d\_residuals\) and the solution vector is \(d\_outputs\). If `mode`

is ‘rev’, the right-hand side vector is \(d\_outputs\) and the solution vector is \(d\_residuals\).

```
def solve_linear(self, d_outputs, d_residuals, mode):
if mode == 'fwd':
d_outputs['x'] = self.inv_jac * d_residuals['x']
elif mode == 'rev':
d_residuals['x'] = self.inv_jac * d_outputs['x']
```

`guess_nonlinear(self, inputs, outputs, residuals)`

:

[Optional] This method allows the user to calculate and specify an initial guess for implicit states. It is called at the start of the solve loop from certain nonlinear solvers (i.e. NewtonSolver and BroydenSolver), so it is useful for when you would like to “reset” the initial conditions on an inner-nested solve whenever an outer loop solver or driver changes other values. However if you include this function without checking the residuals, you will be starting the solvers from scratch during each *run_model* during an optimization. Add a check of your residuals and you can skip it when the system is converged.

Since it is a hook for custom code, you could also use it to monitor variables in the input, output, or residual vectors and change the initial guess when some condition is met.

Here is a simple example where we use NewtonSolver to find one of the roots of a second-order quadratic equation. Which root you get depends on the initial guess.

```
import openmdao.api as om
import numpy as np
class ImpWithInitial(om.ImplicitComponent):
"""
An implicit component to solve the quadratic equation: x^2 - 4x + 3
(solutions at x=1 and x=3)
"""
def setup(self):
self.add_input('a', val=1.)
self.add_input('b', val=-4.)
self.add_input('c', val=3.)
self.add_output('x', val=0.)
self.declare_partials(of='*', wrt='*')
def apply_nonlinear(self, inputs, outputs, residuals):
a = inputs['a']
b = inputs['b']
c = inputs['c']
x = outputs['x']
residuals['x'] = a * x ** 2 + b * x + c
def linearize(self, inputs, outputs, partials):
a = inputs['a']
b = inputs['b']
c = inputs['c']
x = outputs['x']
partials['x', 'a'] = x ** 2
partials['x', 'b'] = x
partials['x', 'c'] = 1.0
partials['x', 'x'] = 2 * a * x + b
def guess_nonlinear(self, inputs, outputs, resids):
# Check residuals
if np.abs(resids['x']) > 1.0E-2:
# Default initial state of zero for x takes us to x=1 solution.
# Here we set it to a value that will take us to the x=3 solution.
outputs['x'] = 5.0
prob = om.Problem()
model = prob.model
model.add_subsystem('comp', ImpWithInitial())
model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False)
model.linear_solver = om.ScipyKrylov()
prob.setup()
prob.run_model()
print(prob.get_val('comp.x'))
```

```
NL: Newton Converged in 6 iterations
[3.]
```