implicitcomponent.py

Define the ImplicitComponent class.

class openmdao.core.implicitcomponent.ImplicitComponent(**kwargs)

Bases: Component

Class to inherit from when all output variables are implicit.

Parameters:

**kwargsdict of keyword arguments

Keyword arguments that will be mapped into the Component options.

Attributes:

_declared_residualsdict

Contains local residual names mapped to metadata.

_has_solve_nlbool

If True, this component has a solve_nonlinear method that overrides the ImplicitComponent class method.

_has_solve_linearbool

If True, this component has a solve_linear method that overrides the ImplicitComponent class method.

_has_linearizebool

If True, this component has a linearize method that overrides the ImplicitComponent class method.

_vjp_hashint or None

Hash value for the last set of inputs to the compute_primal function.

_vjp_funfunction or None

The vector-Jacobian product function.

Methods

abs_meta_iter(iotype[, local, cont, discrete])	Iterate over absolute variable names and their metadata for this System.
add_constraint(name[, lower, upper, equals, ...])	Add a constraint variable to this system.
add_design_var(name[, lower, upper, ref, ...])	Add a design variable to this system.
add_discrete_input(name, val[, desc, tags, ...])	Add a discrete input variable to the component.
add_discrete_output(name, val[, desc, tags, ...])	Add an output variable to the component.
add_input(name[, val, shape, units, desc, ...])	Add an input variable to the component.
add_objective(name[, ref, ref0, index, ...])	Add a response variable to this system.
add_output(name[, val])	Add an output variable to the component.
add_recorder(recorder[, recurse])	Add a recorder to the system.
add_residual(name[, shape, units, desc, ref])	Add a residual variable to the component.
add_response(name, type_[, lower, upper, ...])	Add a response variable to this system.
apply_linear(inputs, outputs, d_inputs, ...)	Compute jac-vector product.
apply_nonlinear(inputs, outputs, residuals)	Compute residuals given inputs and outputs.
best_partial_deriv_direction()	Return the best direction for partial deriv calculations based on input and output sizes.
check_config(logger)	Perform optional error checks.
check_partials([out_stream, compact_print, ...])	Check partial derivatives comprehensively for this component.
check_sparsity([method, max_nz, out_stream])	Check the sparsity of the computed jacobian against the declared sparsity.
cleanup()	Clean up resources prior to exit.
comm_info_iter()	Yield comm size for this system and all subsystems.
compute_fd_jac(jac[, method])	Force the use of finite difference to compute a jacobian.
compute_fd_sparsity([method, num_full_jacs, ...])	Use finite difference to compute a sparsity matrix.
compute_sparsity([direction, num_iters, ...])	Compute the sparsity of the partial jacobian.
convert2units(name, val, units)	Convert the given value to the specified units.
convert_from_units(name, val, units)	Convert the given value from the specified units to those of the named variable.
convert_units(name, val, units_from, units_to)	Wrap the utility convert_units and give a good error message.
declare_coloring([wrt, method, form, step, ...])	Set options for deriv coloring of a set of wrt vars matching the given pattern(s).
declare_partials(of, wrt[, dependent, rows, ...])	Declare information about this component's subjacobians.
dist_size_iter(io, top_comm)	Yield names and distributed ranges of all local and remote variables in this system.
get_coloring_fname(mode)	Return the full pathname to a coloring file.
get_conn_graph()	Return the model connection graph.
get_constraints([recurse, get_sizes, ...])	Get the Constraint settings from this system.
get_declare_partials_calls([sparsity])	Return a string containing declare_partials() calls based on the subjac sparsity.
get_design_vars([recurse, get_sizes, ...])	Get the DesignVariable settings from this system.
get_io_metadata([iotypes, metadata_keys, ...])	Retrieve metadata for a filtered list of variables.
get_linear_vectors()	Return the linear inputs, outputs, and residuals vectors.
get_nonlinear_vectors()	Return the inputs, outputs, and residuals vectors.
get_objectives([recurse, get_sizes, ...])	Get the Objective settings from this system.
get_outputs_dir(*subdirs[, mkdir])	Get the path under which all output files of this system are to be placed.
get_promotions([inprom, outprom])	Return all promotions for the given promoted variable(s).
get_reports_dir()	Get the path to the directory where the report files should go.
get_responses([recurse, get_sizes, use_prom_ivc])	Get the response variable settings from this system.
get_self_statics()	Override this in derived classes if compute_primal references static values.
get_source(name)	Return the source variable connected to the given named variable.
get_val(name[, units, indices, get_remote, ...])	Get an output/input/residual variable.
get_var_dup_info(name, io)	Return information about how the given variable is duplicated across MPI processes.
get_var_sizes(name, io)	Return the sizes of the given variable on all procs.
guess_nonlinear(inputs, outputs, residuals)	Provide initial guess for states.
has_vectors()	Check if the system vectors have been initialized.
initialize()	Perform any one-time initialization run at instantiation.
is_explicit([is_comp])	Return True if this is an explicit component.
linearize(inputs, outputs, jacobian[, ...])	Compute sub-jacobian parts and any applicable matrix factorizations.
list_inputs([val, prom_name, units, shape, ...])	Write a list of input names and other optional information to a specified stream.
list_options([include_default, ...])	Write a list of output names and other optional information to a specified stream.
list_outputs([explicit, implicit, val, ...])	Write a list of output names and other optional information to a specified stream.
list_vars([val, prom_name, residuals, ...])	Write a list of inputs and outputs sorted by component in execution order.
load_case(case)	Pull all input and output variables from a Case into this System.
load_model_options()	Load the relevant model options from Problem._metadata['model_options'].
override_method(name, method)	Dynamically add a method to this component instance.
record_iteration()	Record an iteration of the current System.
run_apply_linear(mode[, scope_out, scope_in])	Compute jac-vec product.
run_apply_nonlinear()	Compute residuals.
run_linearize([sub_do_ln])	Compute jacobian / factorization.
run_solve_linear(mode)	Apply inverse jac product.
run_solve_nonlinear()	Compute outputs.
run_validation()	Run validate method on all systems below this system.
set_check_partial_options(wrt[, method, ...])	Set options that will be used for checking partial derivatives.
set_constraint_options(name[, ref, ref0, ...])	Set options for constraints in the model.
set_design_var_options(name[, lower, upper, ...])	Set options for design vars in the model.
set_objective_options(name[, ref, ref0, ...])	Set options for objectives in the model.
set_output_solver_options(name[, lower, ...])	Set solver output options.
set_solver_print([level, depth, type_, ...])	Control printing for solvers and subsolvers in the model.
set_val(name, val[, units, indices])	Set an input or output variable.
setup()	Declare inputs and outputs.
setup_partials()	Declare partials.
setup_residuals()	User hook for adding named residuals to this component.
solve_linear(d_outputs, d_residuals, mode)	Apply inverse jac product.
solve_nonlinear(inputs, outputs)	Compute outputs given inputs.
sparsity_matches_fd([direction, outstream])	Compare the sparsity computed by this system vs.
subjac_sparsity_iter(sparsity[, wrt_matches])	Iterate over sparsity for each subjac in the jacobian.
system_iter([include_self, recurse, typ, ...])	Yield a generator of local subsystems of this system.
total_local_size(io)	Return the total local size of the given variable.
use_fixed_coloring([coloring, recurse])	Use a precomputed coloring for this System.
uses_approx()	Return True if the system uses approximations to compute derivatives.
validate(inputs, outputs[, discrete_inputs, ...])	Check any final input / output values after a run.

__init__(**kwargs)

Store some bound methods so we can detect runtime overrides.

add_output(name, val=1.0, **kwargs)

Add an output variable to the component.

Parameters:

namestr

Name of the variable in this component’s namespace.

valfloat or list or tuple or ndarray

The initial value of the variable being added in user-defined units. Default is 1.0.

**kwargsdict

Keyword args to store. The value corresponding to each key is a dict containing the metadata for the input name that matches that key.

Returns:

dict

Metadata for added variable.

add_residual(name, shape=(1,), units=None, desc='', ref=None)

Add a residual variable to the component.

Note that the total size of the residual vector must match the total size of the outputs vector for this component.

Parameters:

namestr

Name of the residual in this component’s namespace.

shapeint or tuple

Shape of this residual.

unitsstr or None

Units in which this residual will be given to the user when requested. Default is None, which means it has no units.

descstr

Description of the residual.

reffloat or ndarray or None

Scaling parameter. The value in the user-defined units of this residual when the scaled value is 1. Default is 1.

Returns:

dict

Metadata for the added residual.

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

Compute jac-vector product. The model is assumed to be in an unscaled state.

If mode is:

‘fwd’: (d_inputs, d_outputs) |-> d_residuals

‘rev’: d_residuals |-> (d_inputs, d_outputs)

Parameters:

inputsVector

Unscaled, dimensional input variables read via inputs[key].

outputsVector

Unscaled, dimensional output variables read via outputs[key].

d_inputsVector

See inputs; product must be computed only if var_name in d_inputs.

d_outputsVector

See outputs; product must be computed only if var_name in d_outputs.

d_residualsVector

See outputs.

modestr

Either ‘fwd’ or ‘rev’.

apply_nonlinear(inputs, outputs, residuals, discrete_inputs=None, discrete_outputs=None)

Compute residuals given inputs and outputs.

The model is assumed to be in an unscaled state.

Parameters:

inputsVector

Unscaled, dimensional input variables read via inputs[key].

outputsVector

Unscaled, dimensional output variables read via outputs[key].

residualsVector

Unscaled, dimensional residuals written to via residuals[key].

discrete_inputsdict or None

If not None, dict containing discrete input values.

discrete_outputsdict or None

If not None, dict containing discrete output values.

compute_fd_sparsity(method='fd', num_full_jacs=2, perturb_size=1e-09)

Use finite difference to compute a sparsity matrix.

Parameters:

methodstr

The type of finite difference to perform. Valid options are ‘fd’ for forward difference, or ‘cs’ for complex step.

num_full_jacsint

Number of times to repeat jacobian computation using random perturbations.

perturb_sizefloat

Size of the random perturbation.

Returns:

coo_matrix

The sparsity matrix.

guess_nonlinear(inputs, outputs, residuals, discrete_inputs=None, discrete_outputs=None)

Provide initial guess for states.

Override this method to set the initial guess for states.

Parameters:

inputsVector

Unscaled, dimensional input variables read via inputs[key].

outputsVector

Unscaled, dimensional output variables read via outputs[key].

residualsVector

Unscaled, dimensional residuals written to via residuals[key].

discrete_inputsdict or None

If not None, dict containing discrete input values.

discrete_outputsdict or None

If not None, dict containing discrete output values.

linearize(inputs, outputs, jacobian, discrete_inputs=None, discrete_outputs=None)

Compute sub-jacobian parts and any applicable matrix factorizations.

The model is assumed to be in an unscaled state.

Parameters:

inputsVector

Unscaled, dimensional input variables read via inputs[key].

outputsVector

Unscaled, dimensional output variables read via outputs[key].

jacobianJacobian

Sub-jac components written to jacobian[output_name, input_name].

discrete_inputsdict or None

If not None, dict containing discrete input values.

discrete_outputsdict or None

If not None, dict containing discrete output values.

override_method(name, method)

Dynamically add a method to this component instance.

This allows users to create an ImplicitComponent that uses optional methods like linearize, guess_nonlinear, etc. that aren’t defined statically, but instead are dynamically created during setup. The motivating use case is the omjlcomps library, where the optional methods are implemented in the Julia programming language (see omjlcomps.JuliaImplicitComp in byuflowlab/OpenMDAO.jl).

Parameters:

namestr

The name of the method to add. Must be one of: ‘solve_nonlinear’, ‘linearize’, ‘apply_linear’, ‘solve_linear’, or ‘guess_nonlinear’.

methodfunction

The function to add as a method. Will be converted to a MethodType if necessary.

Raises:

ValueError

If name is not one of the allowed method names.

setup_residuals()

User hook for adding named residuals to this component.

solve_linear(d_outputs, d_residuals, mode)

Apply inverse jac product. The model is assumed to be in an unscaled state.

If mode is:

‘fwd’: d_residuals |-> d_outputs

‘rev’: d_outputs |-> d_residuals

Note : this is not the linear solution for the implicit component. We use identity so that simple implicit components can function in a preconditioner under linear gauss-seidel. To correctly solve this component, you should slot a solver in linear_solver or override this method.

Parameters:

d_outputsVector

Unscaled, dimensional quantities read via d_outputs[key].

d_residualsVector

Unscaled, dimensional quantities read via d_residuals[key].

modestr

Either ‘fwd’ or ‘rev’.

solve_nonlinear(inputs, outputs)

Compute outputs given inputs. The model is assumed to be in an unscaled state.

Parameters:

inputsVector

Unscaled, dimensional input variables read via inputs[key].

outputsVector

Unscaled, dimensional output variables read via outputs[key].