ExplicitComponent

Explicit variables are those that are computed as an explicit function of other variables. For instance, \(z\) would be an explicit variable, given \(z=sin(y)\), while \(y\) would not be, given that it is defined implicitly by the nonlinear equation \(cos(x⋅y)−z⋅y=0\).

In OpenMDAO, explicit variables are defined by writing a class that inherits from the ExplicitComponent class. The explicit variables would be considered outputs while the variables on which they depend would be considered inputs (e.g., \(y\) in \(z=sin(y)\)).

ExplicitComponent Methods

The implementation of each method will be illustrated using a simple explicit component that computes the output area as a function of inputs length and width.

import openmdao.api as om


class RectangleComp(om.ExplicitComponent):
    """
    A simple Explicit Component that computes the area of a rectangle.
    """
  • setup() :

Declare input and output variables via add_input and add_output. Information such as variable names, sizes, units, and bounds are declared here.

def setup(self):
    self.add_input('length', val=1.)
    self.add_input('width', val=1.)
    self.add_output('area', val=1.)
  • setup_partials() :

Declare partial derivatives that this component provides, using wild cards to say that this component provides derivatives of all outputs with respect to all inputs.

def setup_partials(self):
    self.declare_partials('*', '*')
  • compute(inputs, outputs) :

Compute the outputs given the inputs.

def compute(self, inputs, outputs):
    outputs['area'] = inputs['length'] * inputs['width']
  • compute_partials(inputs, partials) :

Note

[Optional] Compute the partials (partial derivatives) given the inputs.

def compute_partials(self, inputs, partials):
    partials['area', 'length'] = inputs['width']
    partials['area', 'width'] = inputs['length']
  • compute_jacvec_product(inputs, d_inputs, d_outputs, mode) :

Note

[Optional] Provide the partial derivatives as a matrix-vector product. If mode is ‘fwd’, this method must compute \(d\_outputs=J⋅d\_inputs\), where J is the partial derivative Jacobian. If mode is ‘rev’, this method must compute \(d\_inputs=J^T⋅d\_outputs\).

def compute_jacvec_product(self, inputs, d_inputs, d_outputs, mode):
    if mode == 'fwd':
        if 'area' in d_outputs:
            if 'length' in d_inputs:
                d_outputs['area'] += inputs['width'] * d_inputs['length']
            if 'width' in d_inputs:
                d_outputs['area'] += inputs['length'] * d_inputs['width']
    elif mode == 'rev':
        if 'area' in d_outputs:
            if 'length' in d_inputs:
                d_inputs['length'] += inputs['width'] * d_outputs['area']
            if 'width' in d_inputs:
                d_inputs['width'] += inputs['length'] * d_outputs['area']

Note that the last two are optional, because the class can implement compute_partials and/or compute_jacvec_product, or neither if the user wants to use the finite-difference or complex-step method.