unit_comp.py

Class definition for UnitComp, a component that explicitly converts units.

class openmdao.components.unit_comp.UnitComp(shape, param_name, out_name, units)

Bases: openmdao.core.component.Component

A Component that converts the input into the requested units.

Args:

shape : tuple or int

A tuple (or int if one-dimensional) that describes the shape of the input and output.

param_name : str

A string containing the name for the input parameter.

out_name : str

A string containing the name for the output variable.

units : str

A string containing the units to which inputs are converted.

Options:

deriv_options[‘type’] : str(‘user’)

Derivative calculation type (‘user’, ‘fd’, ‘cs’) Default is ‘user’, where derivative is calculated from user-supplied derivatives. Set to ‘fd’ to finite difference this system. Set to ‘cs’ to perform the complex step if your components support it.

deriv_options[‘form’] : str(‘forward’)

Finite difference mode. (forward, backward, central)

deriv_options[‘step_size’] : float(1e-06)

Default finite difference stepsize

deriv_options[‘step_calc’] : str(‘absolute’)

Set to absolute, relative

deriv_options[‘check_type’] : str(‘fd’)

Type of derivative check for check_partial_derivatives. Set to ‘fd’ to finite difference this system. Set to ‘cs’ to perform the complex step method if your components support it.

deriv_options[‘check_form’] : str(‘forward’)

Finite difference mode: (“forward”, “backward”, “central”) During check_partial_derivatives, the difference form that is used for the check.

deriv_options[‘check_step_calc’] : str(‘absolute’,)

Set to ‘absolute’ or ‘relative’. Default finite difference step calculation for the finite difference check in check_partial_derivatives.

deriv_options[‘check_step_size’] : float(1e-06)

Default finite difference stepsize for the finite difference check in check_partial_derivatives”

deriv_options[‘linearize’] : bool(False)

Set to True if you want linearize to be called even though you are using FD.

apply_linear(params, unknowns, dparams, dunknowns, dresids, mode)

Multiplies incoming vector by the Jacobian (fwd mode) or the transpose Jacobian (rev mode).

Args:

params : VecWrapper

VecWrapper containing parameters. (p)

unknowns : VecWrapper

VecWrapper containing outputs and states. (u)

dparams : VecWrapper

VecWrapper containing either the incoming vector in forward mode or the outgoing result in reverse mode. (dp)

dunknowns : VecWrapper

In forward mode, this VecWrapper contains the incoming vector for the states. In reverse mode, it contains the outgoing vector for the states. (du)

dresids : VecWrapper

VecWrapper containing either the outgoing result in forward mode or the incoming vector in reverse mode. (dr)

mode : string

Derivative mode, can be ‘fwd’ or ‘rev’.

solve_nonlinear(params, unknowns, resids)

For UnitComp, just pass on the incoming values.

Args:

params : VecWrapper

VecWrapper containing parameters. (p)

unknowns : VecWrapper

VecWrapper containing outputs and states. (u)

resids : VecWrapper, optional

VecWrapper containing residuals. (r)