Structural and Multidisciplinary Optimization (2019) 59:1075–1104

https://doi.org/10.1007/s00158-019-02211-z

RESEARCH PAPER

OpenMDAO: an open-source framework

for multidisciplinary design, analysis, and optimization
Justin S. Gray1 · John T. Hwang2 · Joaquim R. R. A. Martins3 · Kenneth T. Moore4 · Bret A. Naylor4

Received: 24 October 2018 / Revised: 15 January 2019 / Accepted: 27 January 2019 / Published online: 1 March 2019
© The Author(s) 2019

Abstract
Multidisciplinary design optimization (MDO) is concerned with solving design problems involving coupled numerical
models of complex engineering systems. While various MDO software frameworks exist, none of them take full advantage
of state-of-the-art algorithms to solve coupled models efficiently. Furthermore, there is a need to facilitate the computation
of the derivatives of these coupled models for use with gradient-based optimization algorithms to enable design with
respect to large numbers of variables. In this paper, we present the theory and architecture of OpenMDAO, an open-source
MDO framework that uses Newton-type algorithms to solve coupled systems and exploits problem structure through new
hierarchical strategies to achieve high computational efficiency. OpenMDAO also provides a framework for computing
coupled derivatives efficiently and in a way that exploits problem sparsity. We demonstrate the framework’s efficiency by
benchmarking scalable test problems. We also summarize a number of OpenMDAO applications previously reported in the
literature, which include trajectory optimization, wing design, and structural topology optimization, demonstrating that the
framework is effective in both coupling existing models and developing new multidisciplinary models from the ground up.
Given the potential of the OpenMDAO framework, we expect the number of users and developers to continue growing,
enabling even more diverse applications in engineering analysis and design.

Keywords Multidisciplinary design optimization · Coupled systems · Complex systems · Sensitivity analysis ·
Derivative computation · Adjoint methods · Python

1 Introduction need in two ways. First, it performs the coupled simulation

of the engineering system, taking into account all the
Numerical simulations of engineering systems have been interdisciplinary interactions. Second, it performs the
widely developed and used in industry and academia. simultaneous optimization of all design variables, taking
Simulations are often used within an engineering design into account the coupling and the interdisciplinary design
cycle to inform design choices. Design optimization—the trade-offs. MDO is sometimes referred to as MDAO
use of numerical optimization techniques with engineering (multidisciplinary analysis and optimization) to emphasize
simulation—has emerged as a way of incorporating that the coupled analysis is useful on its own. MDO was
simulation into the design cycle. first conceived to solve aircraft design problems, where
Multidisciplinary design optimization (MDO) arose from disciplines such as aerodynamics, structures, and controls
the need to simulate and design complex engineering are tightly coupled and require design trade-offs (Haftka
systems involving multiple disciplines. MDO serves this 1977). Since then, numerical simulations have advanced
in all disciplines, and the power of computer hardware
has increased dramatically. These developments make it
possible to advance the state-of-the-art in MDO, but other
Responsible Editor: Jose Herskovits
more specific developments are needed.
There are two important factors when evaluating MDO
 Justin S. Gray strategies: implementation effort and the computational
[email protected]
efficiency. The implementation effort is arguably the most
important because if the work required to implement a
Extended author information available on the last page of the article. multidisciplinary model is too large, the model will simply

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1076 J. S. Gray et al.

never be built. One of the main MDO implementation The difficulty of implementing MDO techniques with
challenges is that each analysis code consists of a analytic derivatives creates a significant barrier to their
specialized solver that is typically not designed to be adoption by the wider engineering community. The
coupled to other codes or to be used for numerical OpenMDAO framework aims to lower this barrier and enable
optimization. Additionally, these solvers are often coded the widespread use of analytic derivatives in MDO applications.
in different programming languages and use different Like other frameworks, OpenMDAO provides a modular
interfaces. These difficulties motivated much of the early environment to more easily integrate discipline analyses into
development of MDO frameworks, which provided simpler a larger multidisciplinary model. However, OpenMDAO V2
and more efficient ways to link discipline analyses together. improves upon other MDO frameworks by integrating
While these MDO frameworks introduce important inno- discipline analyses as implicit functions, which enables it
vations in software design, modular model construction, to compute derivatives for the resulting coupled model via
and user interface design, they treat each discipline analy- the unified derivatives equation (Martins and Hwang 2013).
sis as an explicit function evaluation; that is, they assume The computed derivatives are coupled in that they take
that each discipline is an explicit mapping between inputs into account the full interaction between the disciplines
and outputs. This limits the efficiency of the nonlinear solu- in the system. Furthermore, OpenMDAO is designed to
tion algorithms that could be used to find a solution to work efficiently in both serial and parallel computing
the coupled multidisciplinary system. Furthermore, these environments. Thus, OpenMDAO provides a means for
MDO frameworks also present the combined multidisci- users to leverage the most efficient techniques, regardless
plinary model as an explicit function to the optimizer, of problem size and computing architecture, without having
which limits the efficiency when computing derivatives for to incur the significant implementation difficulty typically
gradient-based optimization of higher-dimensional design associated with gradient-based MDO.
spaces. Therefore, while these first framework develop- This paper presents the design and algorithmic features
ments addressed the most pressing issue by significantly of OpenMDAO V2 and is structured to cater to different
lowering the implementation effort for multidisciplinary types of readers. For readers wishing to just get a quick
analysis, they did not provide a means for applying the most overview of what OpenMDAO is and what it does, reading
efficient MDO techniques. this introduction, the overview of applications (Section 7,
The computational efficiency of an MDO implementa- especially Fig. 13), and the conclusions (Section 8) will
tion is governed by the efficiency of the coupled (multidis- suffice. Potential OpenMDAO users should also read
ciplinary) analysis and the efficiency of the optimization. Section 3, which explains the basic usage and features
The coupled analysis method that is easiest to implement through a simple example. The remainder of the paper
is a fixed-point iteration (also known as nonlinear block provides a background on MDO frameworks and the
Gauss–Seidel iteration), but for strongly coupled models, history of OpenMDAO development (Section 2), the theory
Newton-type methods are potentially more efficient (Haftka behind OpenMDAO (Section 4), and the details of the
et al. 1992; Heil et al. 2008; Keyes et al. 2013; Chauhan major new contributions in OpenMDAO V2 in terms of
et al. 2018). When it comes to numerical optimization, multidisciplinary solvers (Section 5) and coupled derivative
gradient-based optimization algorithms scale much better computation (Section 6).
with the number of design variables than gradient-free
methods. The computational efficiency of both Newton-
type analysis methods and gradient-based optimization is, 2 Background
in large part, dependent on the cost and accuracy with which
the necessary derivatives are computed. The need for frameworks that facilitate the implementation
One can always compute derivatives using finite differ- of MDO problems and their solution was identified soon
ences, but analytic derivative methods are much more effi- after MDO emerged as a field. Various requirements have
cient and accurate. Despite the extensive research into ana- been identified over the years. Early on, Salas and Townsend
lytic derivatives and their demonstrated benefits, they have (1998) detailed a large number of requirements that they
not been widely supported in MDO frameworks because categorized under software design, problem formulation,
their implementation is complex and requires deeper access problem execution, and data access. Later, Padula and
to the analysis code than can be achieved through an Gillian (2006) more succinctly cited modularity, data
approach that treats all analyses as explicit functions. There- handling, parallel processing, and user interface as the most
fore, users of MDO frameworks that follow this approach important requirements. While frameworks that fulfill these
are typically restricted to gradient-free optimization methods, or requirements to various degrees have emerged, the issue
gradient-based optimization with derivatives computed via of computational efficiency and scalability has not been
finite differences. sufficiently highlighted or addressed.

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1077

The development of commercial MDO frameworks dates OpenMDAO (V0.1). An early aircraft design application
back to the late 1990s with iSIGHT (Golovidov et al. 1998), using OpenMDAO to implement gradient-free efficient
which is now owned by Dassault Systèmes and renamed global optimization was presented by Heath and Gray
Isight/SEE. Various other commercial frameworks have (2012). Gray et al. (2013) later presented benchmarking
been developed, such as Phoenix Integration’s ModelCen- results for various MDO architectures using gradient-based
ter/CenterLink, Esteco’s modeFRONTIER, TechnoSoft’s optimization with analytic derivatives in OpenMDAO.
AML suite, Noesis Solutions’ Optimus, SORCER (Kolonay As the pyMDO and OpenMDAO frameworks pro-
and Sobolewski 2011), and Vanderplaats’ VisualDOC (Bal- gressed, it became apparent that the computation of deriva-
abanov et al. 2002). These frameworks have focused on tives for MDO presented a previously unforeseen implemen-
making it easy for users to couple multiple disciplines and tation barrier.
to use the optimization algorithms through graphical user The methods available for computing derivatives are
interfaces (GUIs). They have also been providing wrappers finite-differencing, complex-step, algorithmic differentia-
to popular commercial engineering tools. While this focus tion, and analytic methods. The finite-difference method is
has made it convenient for users to implement and solve popular because it is easy to implement and can always be
MDO problems, the numerical methods used to converge used, even without any access to source code, but it is sub-
the multidisciplinary analysis (MDA) and the optimization ject to large inaccuracies. The complex-step method (Squire
problem are usually not state-of-the-art. For example, these and Trapp 1998; Martins et al. 2003) is not subject to these
frameworks often use fixed-point iteration to converge the inaccuracies, but it requires access to the source code to
MDA. When derivatives are needed for a gradient-based implement. Both finite-difference and complex-step meth-
optimizer, finite-difference approximations are used rather ods become prohibitively costly as the number of design
than more accurate analytic derivatives. variables increases because they require rerunning the sim-
When solving MDO problems, we have to consider how ulation for each additional design variable.
to organize the discipline analysis models, the problem Algorithmic differentiation (AD) uses a software tool
formulation, and the optimization algorithm in order to to parse the code of an analysis tool to produce new
obtain the optimum design with the lowest computational code that computes derivatives of that analysis (Griewank
cost possible. The combination of the problem formulation 2000; Naumann 2011). Although AD can be efficient, even
and organizational strategy is called the MDO architecture. for large numbers of design variables, it does not handle
MDO architectures can be either monolithic (where a iterative simulations efficiently in general.
single optimization problem is solved) or distributed (where Analytic methods are the most desirable because
the problem is partitioned into multiple optimization they are both accurate and efficient even for iterative
subproblems). Martins and Lambe (2013) describe this simulations (Martins and Hwang 2013). However, they
classification in more detail and present all known MDO require significant implementation effort.
architectures. Analytic methods can be implemented in two different
To facilitate the exploration of the various MDO archi- forms: the direct method and the adjoint method. The choice
tectures, Tedford and Martins (2006) developed pyMDO. between these two methods depends on how the number
This was the first object-oriented framework that focused of functions that we want to differentiate compares to the
on automating the implementation of different MDO number of design variables. In practice, the adjoint method
architectures (Martins et al. 2009). In pyMDO, the user tends to be the more commonly used method.
defined the general MDO problem once, and the frame- Early development of the adjoint derivative computation
work would reformulate the problem in any architecture was undertaken by the optimal control community in the
with no further user effort. Tedford and Martins (2010) 1960s and 1970s (Bryson and Ho 1975), and the struc-
used this framework to compare the performance of vari- tural optimization community adapted those developments
ous MDO architectures, concluding that monolithic archi- throughout the 1970s and 1980s (Arora and Haug 1979).
tectures vastly outperform the distributed ones. Marriage This was followed by the development of adjoint methods
and Martins (2008) integrated a semi-analytic method for for computational fluid dynamics (Jameson 1988), and aero-
computing derivatives based on a combination of finite- dynamic shape optimization became a prime example of
differencing and analytic methods, showing that the semi- an application where the adjoint method has been particu-
analytic method outperformed the traditional black-box larly successful (Peter and Dwight 2010; Carrier et al. 2014;
finite-difference approach. Chen et al. 2016).
The origins of OpenMDAO began in 2008, when Moore When computing the derivatives of coupled sys-
et al. (2008) identified the need for a new MDO framework tems, the same methods that are used for single
to address aircraft design challenges at NASA. Two years disciplines apply. Sobieszczanski-Sobieski (1990) pre-
later, Gray et al. (2010) implemented the first version of sented the first derivation of the direct method for

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1078 J. S. Gray et al.

coupled systems, and Martins et al. (2005) derived the cou- design optimization problem constructed in Open-
pled adjoint method. One of the first applications of the MDAO V1 that combined a high-fidelity aerodynamics
coupled adjoint method was in high-fidelity aerostructural model with a low-fidelity propulsion model, executed in par-
optimization (Martins et al. 2004). The results from the allel. One of the central features of the MAUD architecture,
work on coupled derivatives highlighted the promise of dra- enabling the usage of parallel computing and high-fidelity
matic computational cost reductions, but also showed that analyses, was the use of hierarchical, matrix-free linear solver
existing frameworks were not able to handle these methods. design. While advantageous for large parallel models, this
Their implementation required linear solvers and support feature was inefficient for smaller serial models. The need
for distributed memory parallelism that no framework had to support both serial and parallel computing architectures
at the time. led to the development of OpenMDAO V2, a second rewrite
In an effort to unify the theory for the various methods for of the framework, which is presented in this paper.
computing derivatives, Martins and Hwang (2013) derived Recently, the value of analytic derivatives has also motivated
the unified derivatives equation. This new generalization the development of another MDO framework, GEMS, which
showed that all the methods for computing derivatives can is designed to implement bi-level distributed MDO architec-
be derived from a common equation. It also showed that tures that might be more useful in some industrial settings
when there are both implicitly and explicitly defined disci- (Gallard et al. 2017). This stands in contrast to OpenMDAO,
plines, the adjoint method and chain rule can be combined which is focused mostly on the monolithic MDO architec-
in a hybrid approach. Hwang et al. (2014) then realized tures for best possible computational efficiency.
that this theoretical insight provided a sound and convenient
mathematical basis for a new software design paradigm
and set of numerical solver algorithms for MDO frame- 3 Overview of OpenMDAO V2
works. Using a prototype implementation built around the
unified derivatives equation (Martins and Hwang 2016), In this section, we introduce OpenMDAO V2, present
they solved a large-scale satellite optimization problem with its overall approach, and discuss its most important
25,000 design variables and over 2 million state variables feature—efficient derivative computation. To help with the
(Hwang et al. 2014). Later, Gray et al. (2014) developed explanations, we introduce a simple model and optimization
OpenMDAO V1, a complete rewrite of the OpenMDAO problem that we use throughout Sections 3 and 4.
framework based on the prototype work of Hwang et al.
with the added ability to exploit sparsity in a coupled multi- 3.1 Basic description
disciplinary model to further reduce computational cost.
Collectively, the work cited above represented a signif- OpenMDAO is an open-source software framework for mul-
icant advancement of the state-of-the-art for MDO frame- tidisciplinary design, analysis, and optimization (MDAO),
works. The unified derivatives equation, combined with also known as MDO. It is primarily designed for gradient-
the new algorithms and framework design, enabled the based optimization; its most useful and unique features
solution of significantly larger and more complex MDO relate to the efficient and accurate computation of the
problems than had been previously attempted. In addition, model derivatives. We chose the Python programming lan-
OpenMDAO had now integrated three different methods guage to develop OpenMDAO because it makes scripting
for computing total derivatives into a single framework: convenient, it provides many options for interfacing to com-
finite-difference, analytic, and semi-analytic. However, this piled languages (e.g., SWIG and Cython for C and C++,
work was all done using serial discipline analyses and run and F2PY for Fortran), and it is an open-source language.
on a serial computing environment. The serial computing OpenMDAO facilitates the solution of MDO problems using
environment presented a significant limitation, because it distributed-memory parallelism and high-performance com-
precluded the integration of high-fidelity analyses into the puting (HPC) resources by leveraging MPI and the PETSc
coupled models. library (Balay et al. 2018).
To overcome the serial computing limitation, Hwang and
Martins (2018) parallelized the data structures and solver 3.2 A simple example
algorithms from their prototype framework, which led
to the modular analysis and unified derivatives (MAUD) This example consists of a model with one scalar input, x,
architecture. Hwang and Martins (2015) used the new two “disciplines” that define state variables (y1 , y2 ), and one
MAUD prototype to solve a coupled aircraft allocation- scalar output, f . The equations for the disciplines are
mission-design optimization problem. OpenMDAO V1 was
then modified to incorporate the ideas from the MAUD (Discipline 1) y1 = y22 (1)
architecture. Gray et al. (2018a) presented an aeropropulsive (Discipline 2) exp(−y1 y2 ) − xy2 = 0, (2)

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1079

where Discipline 1 computes y1 explicitly and Discipline 2 to be integrated to form a larger model. This modular
computes y2 implicitly. The equation for the model output approach allows OpenMDAO to automate tasks that
f is are performed repeatedly when building multidisciplinary
models. Instances of the Component class provide the
f = y12 − y2 + 3. (3)
lowest-level functionality representing basic calculations.
Figure 1 visualizes the variable dependencies in this model Each component instance maps input values to output values
using a design structure matrix. We show components that via some calculation. A component could be a simple
compute variables on the diagonal and dependencies on the explicit function, such as y = sin(x); it could involve a long
off-diagonals. From Fig. 1, we can easily see the feedback sequence of code; or it could call an external code that is
loop between the two disciplines, as well as the overall potentially written in another language. In multidisciplinary
sequential structure with the model input, the coupled models, each component can encapsulate just a part of one
disciplines, and the model output. We will refer back to this discipline, a whole discipline, or even multiple disciplines.
model and optimization problem periodically throughout In our simple example, visualized in Fig. 1, there are
Sections 3 and 4. four components: Discipline 1 and the model output are
To minimize f with respect to x using gradient- components that compute explicit functions, Discipline 2
based optimization, we need the total derivative df/dx. is a component that computes an implicit function, and
In Section 3.4, we use this example to demonstrate how the model input is a special type of component with only
OpenMDAO computes the derivative. outputs and no inputs.
Another fundamental class in OpenMDAO is Group,
3.3 Approach and nomenclature which contains components, other groups, or a mix of
both. The containment relationships between groups and
OpenMDAO uses an object-oriented programming components form a hierarchy tree, where a top-level group
paradigm and an object composition design pattern. Spe- contains other groups, which contain other groups, and so
cific functionalities via narrowly focused classes are on, until we reach the bottom of the tree, which is composed
combined to achieve the desired functionality during only of components. Group instances serve three purposes:
execution. In this section, we introduce the four most fun- (1) they help to package sets of components together,
damental types of classes in OpenMDAO: Component, e.g., the components for a given discipline; (2) they help
Group, Driver, and Problem. Note that for the Compo- create better-organized namespaces (since all components
nent class, the end user actually works with one of its two and variables are named based on their ancestors in the tree);
derived classes, ExplicitComponent or ImplicitComponent, and (3) they facilitate the use of hierarchical nonlinear and
which we describe later in this section. linear solvers. In our simple example, the obvious choice is
MDO has traditionally considered multiple “disciplines” to create a group containing Discipline 1 and Discipline 2,
as the units that need to be coupled through coupling because these two form a coupled pair that needs to be
variables. In OpenMDAO, we consider more general converged for any given value of the model input. The
components, which can represent a whole discipline hierarchy of groups and components collectively form the
analysis or can perform a smaller subset of calculations model.
representing only a portion of a whole discipline model. Children of the Driver base class define algorithms
Components share a common interface that allows them that iteratively call the model. For example, a subclass

Fig. 1 Extended design structure matrix (XDSM) (Lambe and Mar- where an entry above the diagonal indicates a forward dependence and
tins 2012) for the simple model. Components that compute variables vice versa. Blue indicates an independent variable, green indicates an
are on the diagonal, and dependencies are shown on the off-diagonals, explicit function, and red indicates an implicit function

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1080 J. S. Gray et al.

of Driver might implement an optimization algorithm or because the way it is done in OpenMDAO is unique among
execute design of experiments (DOE). In the case of an computational modeling frameworks. The mathematical
optimization algorithm, the design variables are a subset of and algorithmic details of total derivative computation are
the model inputs, and the objective and constraint functions described in Section 4.
are a subset of the model outputs. Total derivatives are difficult and expensive to compute
Instances of the Problem class perform as a top-level directly, especially in the context of a framework that
container, holding all other objects. A problem instance must deal with user-defined models of various types. As
contains both the groups and components that constitute the mentioned in the introduction, there are various options
model hierarchy and also contains a single driver instance. for computing derivatives: finite-differencing, complex-
In addition to serving as a container, a Problem also step, algorithmic differentiation, and analytic methods.
provides the user interface for model setup and execution. The finite-difference method can always be used because
Figure 2 illustrates the relationships between instances of it just requires rerunning the model with a perturbation
the Component, Group, and Driver classes and introduces applied to the input. However, the accuracy of the result
the nomenclature for derivatives. The Driver repeatedly depends heavily on the magnitude of the perturbation,
calls model (i.e., the top-level instance of Group, which in and the errors can be large. The complex-step method
turn contains groups that contain other groups that contain yields accurate results, but it requires modifications to
the component instances). The derivatives of the model the model source code to work with complex numbers.
outputs with respect to the model inputs are considered to The computational cost of these methods scales with the
be total derivatives, while the derivatives of the component number of input variables, since the model needs to be rerun
outputs with respect to the component inputs are considered for a perturbation in each input. OpenMDAO provides an
to be partial derivatives. This is not the only way to option to use either of these methods, but their use is only
define the difference between partial and total derivatives, recommended when the ease of implementation justifies the
but this is a definition that suits the present context and increase in computational cost and loss of accuracy.
is consistent with previous work on the computation of As described in the introduction, analytic methods have
coupled derivatives (Martins et al. 2005). In the next the advantage that they are both efficient and accurate.
section, we provide a brief explanation of how OpenMDAO OpenMDAO facilitates the derivative computation for
computes derivatives. coupled systems using analytic methods, including the
direct and adjoint variants. To use analytic derivative
3.4 Derivative computation methods in OpenMDAO, the model must be built such
that any internal implicit calculations are exposed to
As previously mentioned, one of the major advantages the framework. This means that the model must be
of OpenMDAO is that it has the ability to compute cast as an implicit function of design variables and
total derivatives for complex multidisciplinary models very implicit variables with associated residuals that must be
efficiently via a number of different techniques. Total converged. For explicit calculations, OpenMDAO performs
derivatives are derivatives of model outputs with respect to the implicit transformation automatically, as discussed in
model inputs. In the example problem from Section 3.2, the Section 4.3. When integrating external analysis tools with
total derivative needed to minimize the objective function built-in solvers, this means exposing the residuals and
is just the scalar df/dx. Here, we provide a high-level the corresponding state variable vector. Then, the total
overview of the process for total derivative computation derivatives are computed in a two-step process: (1) compute

Fig. 2 Relationship between Driver, Group, and Component classes. Group and Component instances. The derivatives of a model are total
An instance of Problem contains a Driver instance, and the Group derivatives, and the derivatives of a component are partial derivatives
instance named “model.” The model instance holds a hierarchy of

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1081

the partial derivatives of each component and (2) solve Finally, we also need the partial derivatives of the objective
a linear system of equations that computes the total function component:
derivatives. The linear system in step 2 can be solved in a
∂f ∂f
forward (direct) or a reverse (adjoint) form. As mentioned = 2y1 , = −1. (8)
∂y1 ∂y2
in the introduction, the cost of the forward method scales
linearly with the number of inputs, while the reverse method When using the semi-analytic technique, OpenMDAO
scales linearly with the number of outputs. Therefore, the automatically computes the partial derivatives for each
choice of which form to use depends on the ratio of the component using either the finite-difference or complex-
number of outputs to the number of inputs. The details of the step methods. This is different from applying these methods
linear systems are derived and discussed in Section 4. For to the whole model because it is done component by
the purposes of this section, it is sufficient to understand that component, and therefore it does not require the re-
the total derivatives are computed by solving these linear convergence of the coupled system. For instances of an
systems, and that the terms in these linear systems are partial ImplicitComponent, only partial derivatives of the residual
derivatives that need to be provided. functions are needed (e.g., (5), (6), and (7) in the example).
In the context of OpenMDAO, partial derivatives Since residual evaluations do not involve any nonlinear
are defined as the derivatives of the outputs of each solver iterations, approximating their partial derivatives is
component with respect to the component inputs. For much less expensive and more accurate. The technique is
an ExplicitComponent, which is used when outputs can called “semi-analytic” because while the partial derivatives
be computed as an analytic function of the inputs, the are computed numerically, the total derivatives are still
partial derivatives are the derivatives of these outputs with computed analytically by solving a linear system.
respect to the component inputs. For an ImplicitComponent, In the mixed-technique, some components provide
which is used when a component provides OpenMDAO analytic partial derivatives, while others approximate the
with residual equations that need to be solved, the partial partials with finite-difference or complex-step methods.
derivatives are derivatives of these residuals with respect to The mixed-technique offers great flexibility and is a good
the component input and output variables. Partial derivatives option for building models that combine less costly analyses
can be computed much more simply and with lower without analytic derivatives and computationally expensive
computational cost than total derivatives. OpenMDAO analyses that do provide them. If the complex-step method
supports three techniques for computing partial derivatives: is used for some of the partial derivatives, the net result
full-analytic, semi-analytic, and mixed-analytic. is effectively identical to the fully-analytic method. If
When using the full-analytic technique, OpenMDAO finite differences are used to compute some of the partial
expects each and every component in the model to derivatives, then some accuracy is lost, but overall the net
provide partial derivatives. These partial derivatives can be result is still better than either the semi-analytic approach or
computed either by hand differentiation or via algorithmic finite differencing the coupled model to compute the total
differentiation. For the example model in Section 3.2, the derivatives.
partial derivatives can easily be hand-derived. Discipline 1
is an ExplicitComponent defined as y1 = y22 (one input and 3.5 Implementation of the simple example
one output), so we only need the single partial derivative:
We now illustrate the use of the OpenMDAO basic classes
∂y1 by showing the code implementation of the simple model
= 2y2 . (4) we presented in Section 3.2.
∂y2
The run script is listed in Fig. 3. In Block 1, we import
several classes from the OpenMDAO API, as well as the
Discipline 2 is an ImplicitComponent, so it is defined as a
components for Discipline 1 and Discipline 2, which we
residual that needs to be driven to zero, R = exp(−y1 y2 ) −
show later in this section. In Block 2, we instantiate the
xy2 = 0. In this case, we need the partial derivatives of this
four components shown in Fig. 1, as well as a group that
residual function with respect to all the variables:
combines the two disciplines, called states group. In
this group, we connect the output of Discipline 1 to the
∂R input of Discipline 2 and vice versa. Since there is coupling
= −y2 exp(−y1 y2 ), (5)
∂y1 within this group, we also assign a Newton solver to be used
∂R when running the model and a direct (LU) solver to be used
= −y1 exp(−y1 y2 ) − x, (6)
∂y2 for the linear solutions required for the Newton iterations
∂R and the total derivative computation. For the model output,
= −y2 . (7)
∂x we define a component “inline,” using a convenience class

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1082 J. S. Gray et al.

Fig. 3 Run script for the simple

example. This script depends on
a disciplines file that
defines the components for
disciplines 1 and 2 (see Fig. 4)

provided by the OpenMDAO standard library. In Block 3, whether to use finite differences to compute them).
we create the top-level group, which we appropriately name In Discipline 1, compute maps inputs to outputs,
as model, and we add the relevant subsystems to it and and compute partials is responsible for providing
make the necessary connections between inputs and outputs. partial derivatives of the outputs with respect to inputs.
In Block 4, we specify the model inputs and model In Discipline 2, apply nonlinear maps inputs and
outputs, which in this case correspond to the design variable outputs to residuals, and linearize computes the partial
and objective function, respectively, since we are setting derivatives of the residuals with respect to inputs and
up the model to solve an optimization problem. In Block outputs. More details regarding the API can be found in the
5, we create the problem, assign the model and driver, documentation on the OpenMDAO website.1
and run setup to signal to OpenMDAO that the problem The component that computes the objective func-
construction is complete so it can perform the necessary tion is built using the inline ExecComp. ExecComp
initialization. In Block 6, we illustrate how to set a model is a helper class in the OpenMDAO standard library
input, run the model, and read the value of a model output, that provides a convenient shortcut for implementing an
and in Block 7, we run the optimization algorithm and print ExplicitComponent for simple and inexpensive cal-
the results. culations. This provides the user a quick mechanism for
In Fig. 4, we define the actual computations and partial adding basic calculations like summing values or subtract-
derivatives for the components for the two disciplines. ing quantities. However, ExecComp uses the complex-step
Both classes inherit from OpenMDAO base classes and method to compute the derivatives, so it should not be used
implement methods in the component API, but they are for expensive calculations or where there is a large input
different because Discipline 1 is explicit while Discipline 2 array.
is implicit. For both, setup is where the component
declares its inputs and outputs, as well as information
about the partial derivatives (e.g., sparsity structure and 1 http://www.openmdao.org/docs

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1083

Fig. 4 Definition of the

components for Discipline 1 and
Discipline 2 for the simple
example, including the
computation of the partial
derivatives

Figure 5 shows a visualization of the model generated derivatives are just explicit derivatives of a function (Hwang
automatically by OpenMDAO. The hierarchy structure and Martins 2018). The only derivative in the right-hand
of the groups and components is shown on the left, side of (9) that is not partial is dy/dx, which captures the
and the dependency graph is shown on the right. This change in the converged values for y with respect to x.
diagram is useful for understanding how data is exchanged Noting the implicit dependence by R(x, y) = 0, we can
between components in the model. Any connections above differentiate it with respect to x to obtain
the diagonal indicate feed-forward data relationships, and
connections below the diagonal show feedback relationships dr ∂R ∂R dy
= + = 0. (10)
that require a nonlinear solver. dx ∂x ∂y dx

Re-arranging this equation, we get the linear system

4 Theory    
∂R dy ∂R
=− . (11)
∂y dx ∂x
As previously mentioned, one of the main goals in       
OpenMDAO is to efficiently compute the total derivatives m×m m×n m×n
of the model outputs (f ) with respect to model inputs (x),
and we stated that we could do this using partial derivatives Now dy/dx can be computed by solving this linear system,
computed with analytic methods. For models consisting which is constructed using only partial derivatives. This
purely of explicit functions, the basic chain rule can be used linear system needs to be solved n times, once for each
to achieve this goal. However, when implicit functions are component of x, with the column of ∂R/∂x that corresponds
present in the model (i.e., any functions that require iterative to the element of x as the right-hand side. Then, dy/dx
nonlinear solvers), the chain rule is not sufficient. In this can be used in (9) to compute the total derivatives. This
section, we start by deriving these methods and then explain approach is known as the direct method.
how they are implemented in OpenMDAO. There is another way to compute the total derivatives
based on these equations. If we substitute the linear
4.1 Analytic methods: direct and adjoint system (11) into the total derivative (9), we obtain

m×m
    
Given a function F (x, y), where x is a vector n inputs, and y 1×m

is a vector of m variables that depends implicitly on x, then df ∂F ∂F ∂R −1 ∂R
= − . (12)
df ∂F ∂F dy dx ∂x ∂y ∂y ∂x
= + , (9)   
dx ∂x ∂y dx ψT
where we distinguish the quantity f from the function
F that computes it using lowercase and uppercase, By grouping the terms [∂R/∂y]−1 and ∂F /∂y, we get an
respectively. Using this notation, total derivatives account m-vector, ψ, which is the adjoint vector. Instead of solving
for the implicit relation between variables, while the partial for dy/dx with (11) (the direct method), we can instead

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1084 J. S. Gray et al.

Fig. 5 Visualization of the

simple model generated
automatically by OpenMDAO.
In the hierarchy tree on the left,
the darker blue blocks are
groups, the lighter blue blocks
are components, pink blocks are
component inputs, and gray
blocks are component outputs

solve a linear system with [∂F /∂y]T as the right-hand side direct, and adjoint methods into a single implementation
to compute ψ: that works even when using models that utilize distributed-
    memory parallelism, such as computational fluid dynamics
∂R T ∂F T
ψ = . (13) (CFD) and finite element analysis (FEA) codes.
∂y  ∂y
   m×1   
m×m m×1 4.2 Nonlinear problem formulation
This linear system needs to be solved once for each function
of interest f . If f is a vector variable, then the right-hand OpenMDAO V1 and V2 were designed based on the
side for each solution is the corresponding row of ∂F /∂y. algorithms and data structures of MAUD, but V2 includes
The transpose of the adjoint vector, ψ T , can then be used to several additions to the theory and algorithms to enable
compute the total derivative, more efficient execution for serial models. In this section,
df ∂F ∂R we summarize the key MAUD concepts and present the new
= − ψT . (14) additions in OpenMDAO V2 that make the framework more
dx ∂x ∂x
efficient for serial models. The core idea of MAUD is to
This is the adjoint method, and the derivation above shows formulate any model (including multidisciplinary models)
why the computational cost of this method is proportional as a single nonlinear system of equations. This means that
to the number of outputs and independent of the number we concatenate all variables—model inputs and outputs,
of inputs. Therefore, if the number of inputs exceeds the and both explicit and implicit component variables—into a
number of outputs, the adjoint method is advantageous, single vector of unknowns, u. Thus, in all problems, we can
while if the opposite is true, then the direct method has the represent the model as R(u) = 0, where R is a residual
advantage. The main idea of these analytic methods is to function defined in such a way that this system is equivalent
compute total derivatives (which account for the solution to the original model.
of the models) using only partial derivatives (which do not For the simple example from Section 3.2, our vector of
require the solution of the models). unknowns would be u = (x, y1 , y2 , f ), and the correct
As mentioned in Section 2, these analytic methods residual function is
have been extended to MDO applications (Sobieszczanski-
Sobieski 1990; Martins et al. 2005; Martins and Hwang ⎡ ⎤ ⎡ ⎤
2013). All of these methods have been used in MDO rx x − x∗
⎢ ry ⎥ ⎢ y1 − y22 ⎥
applications, but as was discussed in Section 2, the R(u) = ⎢ 1 ⎥
= ⎢ ⎥
⎣ ry ⎦ ⎣ exp(−y1 y2 ) − xy2 ⎦ = 0. (15)
implementations tend to be highly application specific and 2

not easily integrated into an MDO framework. rf f − (y12 − y2 + 3)

To overcome the challenge of application-specific deriva-
tive computations, Hwang and Martins (2018) developed Although the variable x is not an “unknown” (it has a value
the MAUD architecture, which provides the mathemati- that is set explicitly), we reformulate it into an implicit form
cal and algorithmic framework to combine the chain rule, by treating it as an unknown and adding a residual that

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1085

forces it to the expected value of x ∗ . Using this approach, solution for each input, while the the reverse mode requires
any computational model can be written as a nonlinear a linear solution for each output.
system of equations such that the solution of the system Although the full matrix du/dr is shown in (17), we
yields the same outputs and intermediate values as running do not actually need to solve for the whole matrix; the
the original computational model. optimizer only needs the derivatives of the model outputs
Users do not actually need to reformulate their problems with respect to model inputs. The needed derivatives
in this fully implicit form because OpenMDAO handles the are computed by solving for the appropriate columns
translation automatically via the ExplicitComponent class, (forward mode) or rows (reverse mode) one at a time using
as shown in the code snippet in Fig. 4. However, the OpenMDAO’s linear solver functionality.
framework does rely on the fully implicit formulation for its
internal representation. 4.3 API for group and component classes
The key benefit of representing the whole model as a
single monolithic nonlinear system is that we can use the To recast the entire model as a single nonlinear system, the
unified derivatives equation (Martins and Hwang 2013; Component and Group classes both define the following
Hwang and Martins 2018), which generalizes all analytic five API methods:
derivative methods. The unified derivatives equation can be
– apply nonlinear(p, u, r): Compute the residuals
written as
       (r) given the inputs (p) and outputs (u) of the
∂R du ∂R T du T component or group.
=I= , (16)
∂u dr ∂u dr – solve nonlinear(p, u): Compute the converged
where u is a vector containing inputs, implicitly defined values for the outputs given the inputs.
variables, and outputs, and R represents the corresponding – linearize(p, u): Perform any one-time linearization
residual functions. The matrix du/dr contains a block operations, e.g., computing partial derivatives of the
with the total derivatives that we ultimately want (i.e., residuals or approximating them via finite differences.
the derivatives of the model outputs with respect to the – apply linear(du, dr): Compute a Jacobian-vector
inputs, df/dx). Again, we use lowercase and uppercase product, and place the result in the storage vector. For
to distinguish between quantities and functions, as well as the forward mode, this product is
 
the convention for total and partial derivatives introduced ∂R
dr = du , (18)
earlier. For the simple example in Section 3.2, the total ∂u
derivative matrix is and for the reverse mode, it is
⎡ ⎤ ⎡ ⎤  
dx dx dx dx
drx dry1 dry2 drf 1 0 0 0 ∂R T
  ⎢ ⎥
⎢ dy1 dy1 dy1 dy1 ⎥ ⎢ dy1 dy1 dy1 ⎥ du = dr . (19)
du ⎢ drx dry1 dry2 drf ⎥ ⎢ dx dry1 dry2 0 ⎥ ∂u
⎢
= ⎢ dy2 dy2 dy2 dy2 ⎥ = ⎢ dy2 dy2 dy2 ⎥ ,
dr ⎢ dr dr dr dr ⎥ ⎣ dx dry dry 0 ⎥ ⎦ – solve linear(du, dr): Multiply the inverse of the
⎣ x y1 y2 f ⎦ 1 2
df df df df df df df Jacobian with the provided right-hand side vector (or
drx dry1 dry2 drf dx dry dry 1 1 2 solve a linear system to compute the product without
(17) explicitly computing the inverse), and place the result
where the middle term shows the expanded total derivative in the storage vector. For the forward mode,
 
matrix and the right-most term simplifies these deriva- ∂R −1
tives. The middle term is obtained by inserting u = du = dr , (20)
∂u
[x, y1 , y2 , f ]T and r = [rx , ry1 , ry2 , rf ]T . The simplifica-
while for the reverse mode,
tion in the right-most term is possible because from (15), we   −1
know that for example, ∂R T
    dr = du . (21)
dx dx ∂u
= 1, = 0.
drx dry
Up to this point, we have commonly referred to the unknown
In this example, the left equality of the unified derivatives vector (u) and the residual vector (r), but the API methods
(16) corresponds to the forward form, which is equivalent above introduce several new vectors that have not been
to the direct method, while the right equality corresponds to previously discussed. The input vector (p) contains values
the reverse form, which is equivalent to the adjoint method. for any variables that are constant relative to a given location
Solving the forward form solves for one column of the total in the model hierarchy. For any given component, the set of
derivative matrix at a time, while the reverse mode solves for inputs is clear. For a group, the inputs are composed of the
one row at a time. Thus, the forward mode requires a linear set of any variables that do not have an associated output

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1086 J. S. Gray et al.

owned by one of the children of that group. For example, to call the specialized nonlinear solver built into that
referring back to Fig. 5, the states group has the variable x analysis code.
in its input vector, and the output group has the variables y1 In the following section, we discuss the practical matter
and y2 in its input vector. At the top level of that model, the of using the API methods to accomplish the nonlinear and
input vector is empty, and all variables are contained within linear solutions required to execute OpenMDAO models. In
the unknown vector. There are also the du and dr vectors, both the nonlinear and linear cases, there are two strategies
which are used to contain the source and product for matrix- employed, depending on the details of the underlying model
vector-product methods. For a detailed description of the being worked with: monolithic and hierarchical. While
relationship between the p and u vectors, and how the API in our discussion we recommend using each strategy for
methods as well as the du and dr vectors enable efficient certain types of models, in actual models, the choice does
solution of the unified derivatives equations, see the original not need to be purely one or the other. Different strategies
MAUD paper (Hwang and Martins 2018). can be employed at different levels of the model hierarchy
Both Group and Component classes must implement to match the particular needs of any specific model.
these five methods, but default implementations are In addition, the usage of one strategy for the nonlinear
provided in many cases. All five methods are implemented solution does not prescribe that same strategy for the
in the Group class in OpenMDAO’s standard library, linear solution. In fact, it is often the case that a model
which is used to construct the model hierarchy. For using the hierarchical nonlinear strategy would also use the
subclasses of ExplicitComponent, such as Discipline1 in monolithic linear strategy. The converse is also true: Models
Fig. 4, the user does not directly implement any of the that use the monolithic nonlinear strategy will often use the
five basic API methods. Instead, the user implements hierarchical linear strategy. This asymmetry of nonlinear
the compute and compute partials methods that and linear solution strategies is one of the central features in
the ExplicitComponent base class uses to implement the OpenMDAO that enables the framework to work efficiently
necessary lower level methods, as shown in Algorithm 1. with a range or models that have vastly different structures
The negative sign in line 8 of Algorithm 1 indicates that and computational needs.
the partial derivatives for the implicit transformation are the
negative of the partial derivatives for the original explicit
function. As shown in (15), the implicit transformation for 5 Monolithic and hierarchical solution
the explicit output f is given by strategies

rf = f − (y12 − y2 + 3) , (22) OpenMDAO uses a hierarchical arrangement of groups and

components to organize models, define execution order, and
which explains the negative sign. control data passing. This hierarchical structure can also
be used to define nonlinear and linear solver hierarchies
Algorithm 1 ExplicitComponent API. for models. While in some cases it is better to match the
1: function apply nonlinear ( , , ) solver hierarchy closely to that of the model structure, in
2: − compute most cases, better performance is achieved when the solver
3: return r structure is more monolithic than the associated model. The
4: function solve nonlinear ( ) framework provides options for both nonlinear and linear
5: compute solvers and allows the user to mix them at the various levels
6: return of the model hierarchy to customize the solver strategy for
7: function linearize ( ) any given model.
8: compute partials The hierarchical model structure and solver structure
9: return used in OpenMDAO were first proposed as part of
the MAUD architecture (Hwang and Martins 2018). In
For subclasses of ImplicitComponent, such as addition, MAUD also included several algorithms that
Discipline2 in Fig. 4, only apply nonlinear is implement monolithic and hierarchical solvers in the
strictly required, and solve nonlinear is optional. model hierarchy that OpenMDAO also adopted: monolithic
(The base class implements a method that does not perform Newton’s method, along with hierarchical versions of
any operations.) For many models, such as the example in nonlinear block Gauss–Seidel, nonlinear block Jacobi,
Fig. 3, it is sufficient to rely on one of the nonlinear solvers linear block Gauss–Seidel, and linear block Jacobi. In
in OpenMDAO’s standard library to converge the implicit addition to these solvers, OpenMDAO V2 implements a new
portions of a model. Alternatively, a component that wraps hierarchical nonlinear solver that improves performance for
a complex discipline analysis can use solve nonlinear very tightly coupled models (e.g., hierarchical Newton’s

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1087

method). It also includes a monolithic linear solver strategy even outputs of an ExplicitComponent—have their values
that enables much greater efficiency for serial models. directly set by their respective components. When the pure
This section describes the new contributions in Open- Newton’s method works, as is the case for the states group
MDAO, along with a summary of the relevant strategies and in the example model shown in Fig. 5, it is a highly efficient
solver algorithms adopted from the MAUD architecture. algorithm for solving a nonlinear system. The challenge
with pure Newton’s method is that even with added global-
5.1 Nonlinear solution strategy ization techniques, it still may not converge for especially
complex models with large numbers of states. Pure New-
Although the user may still implement any explicit ton’s method is particularly challenging to apply to large
analyses in the traditional form using ExplicitComponent, multidisciplinary models built from components that wrap
OpenMDAO internally transforms all models into the disciplinary analyses with their own highly customized
implicit form defined by MAUD, i.e., R(u) = 0. nonlinear solver algorithms. This is because some special-
For the simple example problem from Section 3.2, this ized disciplinary solvers include customized globalization
transformation is given by (15). While the transformation schemes (e.g., pseudo time continuation) and linear solver
is what makes it possible to leverage the unified derivatives preconditioners that a pure Newton’s method applied at the
equation to compute total derivatives, it also yields a top level of the model cannot directly take advantage of.
much larger implicit system that now represents the
complete multidisciplinary model including all intermediate Algorithm 2 Pure Newton’s method.
variables. The larger system is more challenging to converge 1: apply nonlinear
and may not be solvable in monolithic form. OpenMDAO 2: while do
provides a hierarchical nonlinear strategy that allows 3: linearize
individual subsystems in the model to be solved first, which 4: solve linear
makes the overall problem more tractable. The hierarchical 5:
nonlinear strategy represents a trade-off between solution 6: apply nonlinear
robustness and solution efficiency because it is typically
more robust and more expensive.
5.1.2 Hierarchical nonlinear strategy
5.1.1 Monolithic nonlinear strategy
For some models, the monolithic nonlinear strategy may
In some cases, treating the entire model as a single be numerically unstable and fail to converge on a solution.
monolithic block provides a simple and efficient solution In those cases, the hierarchical strategy may provide more
strategy. This is accomplished with a pure Newton’s method robust solver behavior. Consider that each level of the
that iteratively applies updates to the full u vector until the model hierarchy, from the top-level model group all the
residual vector is sufficiently close to zero, via way down to the individual components, contains a subset
  of the unknowns vector, uchild , and the corresponding
∂R residual equations, Rchild (uchild ) = 0. For any level of the
u = −r . (23)
∂u hierarchy, a given subsystem (which can be a component
or group of components) is a self-contained nonlinear
In practice, pure Newton’s method is usually used together system, where any variables from external components
with a globalization technique, such as a line search, or groups are inputs that are held constant for that
to improve robustness for a range of initial guesses. subsystem’s solve nonlinear. Therefore, we can apply
OpenMDAO’s Newton solver uses these methods in a nonlinear solver to any subsystem in the hierarchy
its actual implementation. For simplicity, we omit the to converge that specific subset of the nonlinear model.
globalization techniques from the following descriptions. The hierarchical nonlinear strategy takes advantage of this
Since these techniques do not change the fundamentals of subsystem property to enable more robust top-level solvers.
Newton’s method, we can do this without loss of generality. OpenMDAO implements a number of nonlinear solution
Algorithm 2 shows the pseudocode for a pure New- algorithms that employ a hierarchical strategy. The most
ton’s method implemented using the OpenMDAO API. All basic two algorithms are the nonlinear block Gauss–Seidel
variables are treated as implicit and updated in line 4, and nonlinear block Jacobi algorithms used by Hwang and
which uses solve linear to implement (23). Note that Martins (2018). Both of these algorithms use simple itera-
solve nonlinear is never called anywhere in Algo- tive strategies that repetitively call solve nonlinear for
rithm 2; only apply nonlinear is called to compute all the child subsystems in sequence, until the residuals are
the residual vector, r. This means that no variables—not sufficiently converged.

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1088 J. S. Gray et al.

OpenMDAO V2 introduces a new hierarchical Newton’s by the current system and not by any of the solvers from its
method solver that extends the use of this strategy to multi- children.
disciplinary models composed of a set of more tightly cou- While perfect sub-convergence is necessary to satisfy
pled subsystems. Compared to the pure Newton’s method the conditions of the proof, in practice, it is not necessary
of Algorithm 2, the hierarchical Newton algorithm adds an to fully converge the child subsystems for every top-level
additional step that recursively calls solve nonlinear hierarchical Newton iteration. Once the nonlinear system
on all child subsystems of the parent system, as shown in has reached a sufficient level of convergence, the recursion
Algorithm 3. can be turned off, reverting the solver to the more efficient
monolithic strategy.
Algorithm 3 Hierarchical Newton’s methods. A hybrid strategy that switches between monolithic and
1: for all child in subsystems do hierarchical strategies was investigated by Chauhan et al.
2: child child.solve nonlinear child child
(2018) in a study where they found that the best performing
3: apply nonlinear nonlinear solver algorithm changes with the strength of
4: while do the multidisciplinary coupling. Their results underscore
5: linearize the need for OpenMDAO to support both hierarchical
6: solve linear and monolithic nonlinear solver architectures, because they
7:
show that different problems require different treatments.
8: for all child in subsystems do The mixture of the two often yields the best compromise
9: child.solve nonlinear between stability and performance.
child child child
In addition to the hierarchical Newton’s method solver,
10: apply nonlinear
OpenMDAO also provides a gradient-free hierarchical
Broyden solver that may offer faster convergence than
We refer to Algorithm 3 as the hierarchical Newton’s the nonlinear Gauss–Seidel or nonlinear Jacobi solvers.
method, because although each child subsystem solves for In Appendix 3, we also prove that the Broyden solver
its own unknowns (uchild ), the parent groups are responsible exhibits the same equivalence between the hierarchical and
for those same unknowns as well. Since each level of the reduced-space formulations.
hierarchy sees the set of residuals from all of its children,
the size of the Newton system (the number of state variables 5.2 Linear solution strategy
it is converging) increases as one moves higher up the
hierarchy, making it increasingly challenging to converge. As discussed above, some nonlinear solvers require their
The recursive solution of subsystems acts as a form of own linear solvers to compute updates for each iteration.
nonlinear preconditioning or globalization to help stabilize OpenMDAO also uses a linear solver to compute total
the solver, but fundamentally, the top-level Newton solver is derivatives via (16). The inclusion of linear solvers in the
dealing with the complete set of all residual equations from framework, and the manner in which they can be combined,
the entire model. is one of the unique features of OpenMDAO.
There is another, arguably more common, formulation There are two API methods that are useful for
for applying Newton’s method to nested models where the implementing linear solvers: apply linear and
solver at any level of the model hierarchy sees only the solve linear. In an analogous fashion to the nonlinear
subset of the implicit variables that it alone is responsible solvers, the linear solvers can employ either a monolithic or
for. In this formulation, the Newton system at any level hierarchical strategy. In this context, a monolithic strategy
is much smaller because it does not inherit the states is one that works with the entire partial derivatives Jacobian
and residuals from any child systems. Instead, it treats (∂R/∂u) as a single block in-memory. A hierarchical linear
any child calculations as if they were purely explicit. We strategy is one that leverages a matrix-free approach.
refer to this formulation as the “reduced-space Newton’s
method.” In Appendix 2, we prove that the application of 5.2.1 Hierarchical linear strategy
the hierarchical Newton’s method yields the exact same
solution path as that of a reduced-space Newton’s method. The hierarchical linear solver strategy is an approach
The proof demonstrates that exact recursive solutions for that relies on the use of the apply linear and
uchild (i.e., Rchild (uchild ) = 0) (lines 1, 2, 8, and 9 in solve linear methods in the OpenMDAO API. As
Algorithm 3) reduce the search space for the parent solver such, it is a matrix-free strategy. This strategy was originally
to only the subset of the u vector that is owned exclusively proposed by Hwang and Martins (2018), and we refer the

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1089

reader to that work for a more detailed presentation of hierarchy. While recursion is generally expensive in and
these concepts, including an extensive treatment of how of itself, the cost is exacerbated because OpenMDAO is
parallel data passing is integrated into this linear strategy. written in Python, an interpreted language where loops
OpenMDAO implements the hierarchical linear solver are especially costly. For many models, it is feasible to
strategy proposed by MAUD to support integration with assemble the entire partial derivative Jacobian matrix in
computationally expensive analyses, i.e., parallel distributed memory, which then allows the use of a direct factorization
memory analyses such as CFD and FEA. Models that to solve the linear system more efficiently. As long as
benefit from this strategy tend to have fewer than ten the cost of computing the factorization is reasonable, this
components that are computationally expensive, with at approach is by far the simplest and most efficient way to
least one component having on the order of a hundred implement the solve linear method. This represents
thousand unknowns. The linear block Gauss–Seidel and a significant extension from the previously developed
linear block Jacobi solvers are the two solvers in the hierarchical formulation (Hwang and Martins 2018), and
OpenMDAO standard library that use the hierarchical as we will show in Section 5.3, this approach is crucial
strategy. Algorithms 4 and 5 detail the forward (direct) for good computational performance on models with many
formulation of the two hierarchical linear solvers. There components.
are also separate reverse (adjoint) formulations for these The matrix assembly can be done using either a dense
solvers, which are explained in more detail by Hwang matrix or a sparse matrix. In the sparse case, OpenMDAO
and Martins (2018). For integration with PDE solvers, relies on the components to declare the nonzero partial
the forward and reverse forms of these algorithms allow derivatives, as shown in Fig. 4. Broadly speaking, at the
OpenMDAO to leverage existing, highly specialized linear model level, the partial derivative Jacobian is almost always
solvers used by discipline analyses as part of a recursive very sparse, even for simple models. Figure 5, which
preconditioner for a top-level OpenMDAO Krylov subspace includes a visualization of [∂R/∂u]T , shows that even a
solver in a coupled multidisciplinary model (Hwang and small model has a very sparse partial derivative Jacobian. In
Martins 2018). the vast majority of cases, the factorization is more efficient
when using a sparse matrix assembly.
Algorithm 4 Linear block Gauss–Seidel (forward mode). The monolithic linear solver strategy is primarily
1: while do designed to be used with a direct linear solver. A direct
2: for all child in subsystems do factorization is often the fastest, and certainly the simplest
3: for all child in subsystems : do type of linear solver to apply. However, this strategy can
4: d d child .apply linear child j also be used with a Krylov subspace solver, assuming
we either do not need to use a preconditioner or want
5: d child child .solve linear
to use a preconditioner that is also compatible with the
monolithic strategy (e.g., incomplete LU factorization).
Algorithm 5 Linear block Jacobi (forward mode). Krylov subspace solvers are unique because they can be
1: while do used with both the hierarchical and monolithic linear solver
2: for all child in subsystems do strategies, depending on what type of preconditioner is
3: d child child .solve linear d applied.
Monolithic and hierarchical linear solver strategies can
4: for all child in subsystems do
be used in conjunction with each other as part of a larger
5: for all child in subsystems : do
model. At any level of the model hierarchy, a monolithic
6: d d − child .apply linear d child
strategy can be used, which causes all components
below that level to store their partial derivatives in the
5.2.2 Monolithic linear strategy assembled Jacobian matrix. Above that level, however, a
hierarchical linear solver strategy can still be used. This
Although the hierarchical linear solver strategy is an mixed linear solver strategy is crucial for achieving good
efficient approach for models composed of computationally computational efficiency for larger models. Aeropropulsive
expensive analyses, it can introduce significant overhead design optimization is a good example where this is
for models composed of hundreds or thousands of necessary. Gray et al. (2018a) coupled a RANS CFD
computationally simple components. The hierarchical linear analysis to a 1-D propulsion model using OpenMDAO with
solver strategy relies on the use of the apply linear a hierarchical linear solver strategy to combine the matrix-
and solve linear methods, which only provide linear free Krylov subspace from the CFD with the monolithic
operators that must be recursively called on the entire model direct solver used for the propulsion analysis.

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1090 J. S. Gray et al.

5.3 Performance study for mixed linear solver Direct

strategy

The specific combination of hierarchical and monolithic

linear solvers that will give the best performance is very
Design
model-specific, which is why OpenMDAO’s flexibility to
Vars
allow different combinations is valuable.
Wing
This sensitivity of computational performance to solver Geometry
strategy can be easily demonstrated using an example model
built using the OpenAeroStruct (Jasa et al. 2018b) library. 0
OpenAeroStruct is a modular, lower-fidelity, coupled

Model
Multi-case
aerostructural modeling tool which is built on top of 0

Group
OpenMDAO V2. Consider a notional model that computes
the average drag coefficient for a set of aerostructural wing 0
models at different angles of attack, as shown in Fig. 6.
The derivatives of average drag with respect to the shape 0

design variables can be computed via a single reverse model Average

linear solution. This reverse mode solution was tested with Drag
two separate solver strategies: (1) pure monolithic with a
direct solver at the top of the model hierarchy and (2) mixed
hierarchical/monolithic with a linear block Gauss–Seidel
solver at the top and direct solver angle of attack case. Linear Block Gauss-Seidel
Figure 7 compares the computational costs of these two
linear solver strategies and examines how the computational
Direct Direct Direct Direct
cost scales with increasing number of components. For this
problem, the scaling is achieved by increasing the number Design
of angle of attack conditions included in the average. Vars
As the number of angle of attack cases increases, the Wing
number of components and number of variables goes up Geometry
as well, since each case requires its own aerostructural
0
analysis group. The data in Fig. 7 shows that both linear
Model

solver strategies scale nearly linearly with an increasing

Multi-case

0
Group

number of variables, which indicates very good scaling

for the direct solver. This solver relies on the sparse 0
LU factorization in SciPy (Oliphant 2007). However, the
difference between the purely monolithic and the mixed 0
hierarchical/monolithic linear solver strategies is 1.5 to
Average
2 orders of magnitude in total computation time. This
Drag
difference in computational cost is roughly independent of
problem size, which demonstrates that the mixed strategy is
fundamentally more efficient than the pure monolithic one.
Fig. 6 Model hierarchy, data connectivity, and linear solver strategy
for an OpenAeroStruct model with four flight conditions

6 Efficient methods for computing total

derivatives of sparse models matrix using fewer linear solutions than the number of
model inputs or model outputs. Furthermore, when properly
As discussed in Section 4, when using the unified derivative exploited, these sparsity structures can also change the
equation to analytically compute the total derivative preferred solution mode (forward or reverse) from what
Jacobian, one linear solution is required for each model would normally be expected. In this section, we present
input in forward mode; alternatively, in reverse mode, one two specific types of sparsity structure and discuss how
linear solution is required for each model output. However, OpenMDAO exploits them to reduce the computational cost
when the model exhibits certain types of sparsity patterns, it of computing derivatives for models where they are present.
is possible to compute the complete total derivative Jacobian The first sparsity pattern arises from separable model

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1091

multiple model inputs or multiple model outputs into a sin-

gle linear solution. This reduces the cost for computing the
total derivative Jacobian. Consider a notional problem with
seven model inputs (a, b, c0 , c1 , c2 , c3 , c4 ) and six model
outputs (g0 , g1 , g2 , g3 , g4 , f ) with the total derivative Jaco-
bian structure illustrated in Fig. 8. Since there are more
model inputs than outputs, the reverse mode would normally
be faster.
However, as we can infer from Fig. 8, the five ci
inputs affect the six outputs (g0 ,...,g4 , f ) independently.
Therefore, these inputs can share a single color, and the
linear system only requires a single forward solution.
Combining multiple linear solutions is accomplished by
combining multiple columns of the identity matrix from
(16) into a single right-hand side, as shown in Fig. 9.
Fig. 7 Scaling of computational cost for a single linear solution Normally, a combined right-hand side would yield sums
versus number of components in the model. Two solver strategies are
compared: pure monolithic (orange) and mixed (blue). The average
of total derivatives, but if we know that certain terms are
slope of the two data sets indicates nearly linear scaling for both, but guaranteed to be zero (e.g., dg0 /dc1 = 0, dg1 /dc2 = 0), we
there is a two-order-of-magnitude difference in actual cost can safely combine the right-hand side vectors.
In this case, using forward mode would require two
separate linear solutions for a and b, and then a single
variables and allows for the multiple linear solutions to additional combined linear solution for the set (c0 , . . . , c4 ),
be computed simultaneously using a single right-hand-side as illustrated in Figs. 8a and 9b. Since this case is colored
vector; thus, it requires only one linear solution. The second in forward mode, the subscripts (i, j, k) in Fig. 9b are
sparsity pattern arises from models where one component associated with the denominator of the total derivatives,
output provides the input to many downstream components indicating that each solution yields derivatives of all the
that do not depend on each other. This enables multiple outputs with respect to a single input. In Fig. 9a, du/dri|j |k
linear solutions to be computed in parallel via multiple indicates the need to use three separate linear solutions. In
parallel linear solutions on multiple right-hand sides. Fig. 9b, du/dri+j +k indicates that the three right-hand
sides can be added as
6.1 Combining multiple linear solutions using graph        
du du du du
coloring = + + , (24)
dri+j +k dri drj drk
Typically, a single linear solution corresponds to a single to form a single linear system that can compute all three sets
model input (forward/direct mode) or a single model out- of total derivatives.
put (reverse/adjoint mode). When a portion of the total Using coloring, the complete total derivative Jacobian
derivative Jacobian has a block-diagonal structure, a color- can be constructed using only three linear solutions in
ing technique can be applied to combine linear solutions for a colored forward mode. The original uncolored solution

Fig. 8 Total derivative Jacobian

structure for a notional model
where the model outputs are all
separable with respect to the ci
inputs. a The full Jacobian
structure with coloring to
indicate the potential for
simultaneous solutions. b The
collapsed Jacobian structure that
takes advantage of the coloring

(a) Seven individual solutions (b) Two individual solutions and

one simultaneous solution

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1092 J. S. Gray et al.

Fig. 10 Comparison of total derivatives computation time computed

with (blue) and without (orange) the combined linear solution feature

OpenMDAO uses an algorithm developed by Coleman and

Verma (1998) to perform coloring, and it uses a novel
approach to computing the total derivative sparsity. More
details are included in Appendix 1.

6.1.1 Computational savings from combined linear

solutions

The combined linear solution feature is leveraged by

the Dymos optimal control library, which is built using
OpenMDAO. To date, Dymos has been used to solve a
range of optimal control problems (Falck et al. 2019),
Fig. 9 Combining multiple linear solutions
including canonical problems such as Bryson’s minimum
time to climb problem (Bryson 1999), as well as the classic
method would require six linear solutions in reverse mode. brachistochrone problem posed by Bernoulli (1696). It has
Therefore, the colored forward mode is faster than using the also been used to solve more complex optimal trajectory
uncolored reverse mode. problems for electric aircraft (Falck et al. 2017; Schnulo
There is a well-known class of optimal control problems et al. 2018).
To demonstrate the computational improvement, we
that is specifically formulated to create total derivative
present results showing how the cost of solving for the total
Jacobians that can be efficiently colored. Betts and Huffman
derivatives Jacobian scales with and without the combined
(1991) describe their “sparse finite-differencing” method,
linear solutions feature for Bryson’s minimum time to
where multiple model inputs are perturbed simultaneously
climb problem implemented in the Dymos example problem
to approximate total derivatives with respect to more than library. Figure 10 shows the variation of the total derivatives
one input at the same time. Sparse finite-differencing computation time as a function of the number of time steps
is applicable only to forward separable problems, but used in the model. The greater the number of time steps,
OpenMDAO can leverage coloring in both forward and the greater the number of constraints in the optimization
reverse directions because analytic derivatives are computed problem for which we need total derivatives. We can see that
with linear solutions rather than a numerical approximations the combined linear solution offers significant reductions in
of the nonlinear analysis. The ability to leverage both the total derivative computation time, and more importantly,
forward and reverse modes for coloring gives the analytic shows superior computational scaling.
derivatives approach greater flexibility than the traditional
sparse finite-differencing and makes it applicable to a wider 6.2 Sparsity from quasi-decoupled parallel models
range of problems.
Although the notional example used in this section Combining multiple linear solutions offers significant
provides a very obvious coloring pattern, in general coloring computational savings with no requirement for additional
a total derivative Jacobian is extremely challenging. memory allocation; thus, it is a highly efficient technique

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1093

A quasi-decoupled model is one with an inexpensive

serial calculation bottleneck at the beginning, followed by
a more computationally costly set of parallel calculations
for independent model outputs. The data passing in this
model is such that one set of outputs gets passed to
multiple downstream components that can run in parallel. A
typical example of this structure can be found in multipoint
models, where the same analysis is run at several different
points, e.g., multiple CFD analyses that are run for the
same geometry, but at different flow conditions (Reuther
et al. 1999; Kenway and Martins 2016; Gallard et al.
2013). In these cases, the geometric calculations that
translate the model inputs to the computational grid are the
serial bottleneck, and the multiple CFD analyses are the
decoupled parallel computations, which can be solved in
an embarrassingly parallel fashion. This model can be run
efficiently in the forward direction for nonlinear solutions—
making it practically forward decoupled—but the linear
reverse mode solutions to compute total derivatives can no
longer be run in parallel.
One possible solution to address this challenge is to
employ a constraint aggregation approach (Kreisselmeier
and Steinhauser 1979; Lambe et al. 2017). This approach
allows the adjoint method to work efficiently because it
collapses many constraint values into a single scalar, hence
recovering the adjoint method efficiency. Though this may
work in some cases, constraint aggregation is not well-
suited to problems where the majority of the constraints
being aggregated are active at the optimal solution, as
is the case for equality constraints. In these situations,
the conservative nature of the aggregations function is
problematic because it prevents the optimizer from tightly
satisfying all the equalities. Kennedy and Hicken (2015)
developed improved aggregation methods that offer a less
conservative and more numerically stable formulation,
Fig. 11 Parallel derivative computation for a reverse mode solu- but despite the improvements, aggregation is still not
tion (Hwang and Martins 2015). Group 1 contains components 2, 3, appropriate for all applications. In these cases, an alternate
and 4, and group 2 contains components 5, 6, and 7. We assume approach is needed to maintain efficient parallel reverse
groups 1 and 2 are allocated on different processors. Without the
ability to solve multiple right-hand sides simultaneously, processor 2
mode (adjoint) linear solutions.
would be idling in a, and processor 1 would be idling in b. In c, each When aggregation cannot be used, OpenMDAO uses a
processor can solve for the derivatives of its own group simultaneously solution technique that retains the parallel efficiency at the
cost of a slight increase in required memory. First, the mem-
ory allocated for the serial bottleneck calculations in the
for reducing the computational cost of solving for total
right-hand side and solution vectors is duplicated across
derivatives, even when running in serial. However, it is not
possible to use that approach for all models. In particular, all processors. Only the variables associated with the bot-
a common model structure that relies on parallel execution tleneck calculation are duplicated, and the variables in the
for computational efficiency, which we refer to as “quasi- computationally expensive parallel calculations remain the
decoupled,” prevents the use of combined linear solutions same. This duplication is acceptable because the bottleneck
and demands a different approach to exploit its sparsity. In calculation requires an insignificant amount of memory
this section, we present a method for performing efficient compared to the parallel calculations. The duplication of
linear solutions for derivatives of quasi-decoupled systems the memory effectively decouples the portions of the model
that enables the efficient use of parallel computing resources that require more memory and computational effort, so
for reverse mode linear solutions. OpenMDAO can then perform multiple linear solutions

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1094 J. S. Gray et al.

in parallel across multiple processors. This approach for portions of the vectors, indicating that memory is not
parallel reverse derivative solutions was first proposed by allocated for those variables on that particular processor.
Hwang and Martins (2015) and has been adapted into the
OpenMDAO framework. It is described below for com- 6.2.1 Computational savings from parallel reverse mode
pleteness and to provide context for the performance results
presented. We now demonstrate the performance of parallel reverse
Figure 11 compares the reverse mode linear solution mode derivatives computation using the combined
between a basic reverse mode solution and a parallel reverse allocation-mission-design (AMD) problem developed by
mode solution. Note that the left-hand side matrices in Hwang and Martins (2015). In this problem, an airline with
Fig. 11 are upper triangular because the reverse mode four existing aircraft and one new aircraft design allocates
solutions use [∂R/∂u]T . In this notional model, the first
these aircraft for 128 individual routes to maximize opera-
component on the diagonal is the inexpensive serial
tional profit. This model was executed on a parallel cluster
bottleneck that all following calculations depend on. Then,
with 140 cores, ensuring that the mission constraints are
there are two parallel expensive computational groups
handled in parallel. A number of the constraints exhibit the
represented by components (2,3,4) and (5,6,7), each of
which computes a model output. We assume that group 1 quasi-decoupled structure because there are separate sets
is allocated in processor 1, and group 2 is allocated in related to each of the 128 missions which can all be com-
processor 2. puted in parallel, but they all depend on a single upstream
Using the basic reverse mode requires two sequential calculation that creates the reverse mode bottleneck.
linear solutions. During the first solution, illustrated in In Fig. 12, we show the total derivatives computation
Fig. 11a, processor 1 solves for the derivative of the output time with and without parallel reverse mode for a range
of group 1, while processor 2 idles. Similarly, during the of different model sizes. The models were scaled up by
second solution, illustrated in Fig. 11b, processor 2 solves refining the time discretization of the mission integration,
for the derivatives of the outputs of group 2, while processor which also created more physical constraints for each
1 idles. mission. The calculation is significantly faster with parallel
Using the parallel reverse mode, both processors reverse mode, but more importantly, the parallel reverse
independently loop over the two right-hand sides to compute mode makes the cost to compute total derivatives nearly
two linear solutions, as shown in Fig. 11c. For processor 1, independent of the size of the problem.
the first right-hand side computes derivatives of the group 1
model output, while the second performs no operations.
For processor 2, the first right-hand side does not require 7 Applications
any operations, and the second computes derivatives of
the group 2 model output. Therefore, the parallel reverse The usefulness and efficiency of OpenMDAO has already
mode of Fig. 11c takes advantage of embarrassingly parallel been demonstrated in a variety of applications. All of these
execution. Note that in Fig. 11c, there are grayed out applications have been the subject of previous publications
and will not be detailed here. Instead, we present an
overview of these applications to illustrate the wide range
of model fidelities, problem structures, and disciplines that
can be handled by OpenMDAO. For each application, we
highlight the computational performance and OpenMDAO
features that were used. The applications are listed in
Fig. 13, where we show the extended design structure matrix
(XDSM) (Lambe and Martins 2012) for each problem
and list the design variables, objective functions, and
constraints.
One of the first practical engineering problems, and
the first example of an optimal control problem, solved
with OpenMDAO V2 was a satellite MDO problem that
maximized the data downloaded by varying satellite design
parameters (related to solar panels, antenna, and radiators)
as well as time dependent variables (power distribution,
trajectory, and solar panel controls) (Gray et al. 2014).
This problem was originally implemented using a bare-
Fig. 12 Comparison of total derivatives computation time calculated
with and without parallel reverse mode bones implementation of MAUD (Hwang et al. 2014). The

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1095

Fig. 13 Summary of applications of OpenMDAO to engineering design optimization problems

modeled disciplines consisted of orbit dynamics, attitude involved over 25,000 design variables and 2.2 million
dynamics, cell illumination, temperature, solar power, state variables and required 100 CPU-h to converge to
energy storage, and communication. The optimization the optimum result in a serial computation (Hwang et al.

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1096 J. S. Gray et al.

2014). The satellite model is broken down into around solver strategy to the framework, and coupling that
100 different components, which greatly simplified the task model to the high-fidelity aerodynamic solver required the
of deriving the analytic partial derivatives by hand. This implementation of a mixed hierarchical-monolithic linear
problem exhibits the quasi-decoupled structure discussed in solver strategy in the coupled model.
Section 6.2, and in OpenMDAO V2, the model was able to Jasa et al. (2018b) developed OpenAeroStruct, a low-
run in around 6 h of wall time, running in on 6 CPUs using order wing aerostructural library whose development was
parallel derivative computation. motivated by the absence of a tool for fast wing design
The first integration of a specialized high-fidelity optimization. OpenAeroStruct implements a vortex lat-
solver in OpenMDAO was done to perform the design tice model for the aerodynamic analysis and a beam
optimization of an aircraft considering allocation, trajectory finite-element model for structural analysis. These anal-
optimization, and aerodynamic performance with the yses are coupled, enabling the aerostructural analysis of
lifting surfaces. Each of the models was implemented
objective of maximizing airline profit (Hwang et al.
in OpenMDAO from the ground up, making use of
2019). The aerodynamics were modeled using the ADflow
the hierarchical representation and solvers for the best
CFD solver (Lyu et al. 2013), which has an adjoint
possible coupled solution efficiency, as demonstrated in
implementation to efficiently compute derivatives of the
Fig. 7. As a result, OpenAeroStruct efficiently com-
aerodynamic force coefficients with respect to hundreds putes aerostructural derivatives through the coupled-adjoint
of wing shape variables. In this work, the ADflow method, enabling fast aerostructural analysis (solutions
solver was integrated into the overall model in an in seconds) and optimizations (converged results in min-
explicit form, which greatly simplified the integration utes). OpenAeroStruct has already been used in a number of
and reduced the number of variables that OpenMDAO applications (Friedman et al. 2017; Chaudhuri et al.
needed to track. The optimization problem consisted of 2017; Palar and Shimoyama 2017; Cook et al. 2017a, b;
over 6000 design variables and 23,000 constraints, and Bons et al. 2019; Lam et al. 2018; Tracey and Wolpert
it was solved in about 10 h using 128 processors. This 2018; Cook 2018; Baptista and Poloczek 2018; Peherstor-
work relied heavily on OpenMDAO’s support for parallel fer et al. 2018; Chauhan and Martins 2018). Significant
computing to efficiently evaluate multiple aerodynamic computational efficiency was achieved for OpenAeroStruct
points simultaneously. Related work on this problem by by using the sparse-assembled Jacobian matrix feature with
Roy et al. (2018a) expanded the problem to a mixed integer a monolithic linear solver strategy, thanks to the highly
optimization that considered the airline allocation portion sparse nature of many of the underlying calculations.
of the problem in a more correct discrete form, which Chung et al. (2018) developed a framework for
demonstrated the flexibility of the framework to expand setting up structural topology optimization problems and
beyond purely gradient-based optimization. formulations. Using this platform, they implemented
The OpenMDAO interface to ADflow, first developed three popular topology optimization approaches. Even
in the work mentioned above, was later reworked into an though structural topology optimization involves only one
implicit form that exposed the full state vector of the flow discipline, they found that the framework benefited from the
solution to the framework. The new wrapper was then used modularity and the more automated derivative computation.
in a series of propulsion-airframe integration optimization The increased modularity made it easier to restructure and
studies that were the first to demonstrate the framework’s extend the code, allowing the authors to quickly change
ability to compute high-fidelity coupled derivatives. A CFD the order of operations in the process to demonstrate the
model of a tightly integrated fuselage and propulsor was importance of correct sequencing. This structural topology
coupled to a one-dimensional engine cycle model to build optimization framework is expected to facilitate future
an aeropropulsive model, which enabled the detailed study developments in multiscale and multidisciplinary topology
of boundary layer ingestion (BLI) effects (Gray et al. optimization. This work, in addition to OpenAeroStruct,
2018a) and the simultaneous design of aerodynamic shape provides an excellent example of using OpenMDAO as
and propulsor sizing for BLI configurations (Gray and a low-level software layer to develop new disciplinary
Martins 2018; Gray et al. 2018b). The thermodynamic analysis solvers.
cycle analysis tool was developed using OpenMDAO Hwang and Ning (2018) developed and integrated low-
as a standalone propulsion modeling library based on fidelity propeller, aerodynamic, structural, and mission
a chemical-equilibrium analysis technique (Gray et al. analysis models using OpenMDAO for NASA’s X-57
2017). This new modeling library was the first engine Maxwell research aircraft, which features distributed
cycle analysis capability that included analytic derivative electric propulsion. They solved MDO problems with up to
computation (Hearn et al. 2016). The development of 101 design variables and 74 constraints that converged in
the cycle analysis tool in OpenMDAO was ultimately a few hundred model evaluations. Numerical experiments
what motivated the addition of the new monolithic linear showed the scaling of the optimization time with the number

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1097

of mission points was, at worst, linear. The inclusion of To compute total coupled derivatives efficiently in
a fully transient mission analysis model of the aircraft a scalable way, OpenMDAO uses analytic methods in
performance was shown to offer significantly different two modes: forward and reverse. The forward mode is
results from a basic multipoint optimization formulation. equivalent to the coupled direct method, and its cost scales
The need to include the transient analysis is an example linearly with the number of design variables. The reverse
of why analytic derivatives are needed for these types of mode is equivalent to the coupled-adjoint method, and
problems: They offer the required computational efficiency its cost scales linearly with the number of functions of
and accuracy that could not be achieved using monolithic interest—but it is independent of the number of design
finite differencing. variables. This last characteristic is particularly desirable
Other work that used OpenMDAO V2 includes a because many problems have a number of design variables
framework for the solution of ordinary differential equa-
that is larger than the number of functions of interest
tions (Hwang and Munster 2018), a conceptual design
(objective and constraints). Furthermore, in cases with large
model for aircraft electric propulsion (Brelje and Mar-
numbers of constraints, these can often be aggregated.
tins 2018), and a mission planning tool for the X-57
Problem sparsity was also exploited in the coupled
aircraft (Schnulo et al. 2018).
Application-focused work has included the design derivative computation by a new approach we developed
of a next-generation airliner considering operations and that uses graph coloring. We also discussed a few
economics (Roy et al. 2018b), design and trajectory other techniques to increase the efficiency of derivative
optimization of a morphing wing aircraft (Jasa et al. 2018a), computations using the hierarchical problem representation.
and trajectory optimization of an aircraft with a fuel thermal The algorithms in OpenMDAO work best if the residuals
management system (Jasa et al. 2018c). OpenMDAO is of the systems involved are available, but when they are not
also being used extensively by the wind energy community available, it is possible to formulate the models solely in
for wind turbine design (Ning and Petch 2016; Barrett terms of their inputs and outputs.
and Ning 2018; Zahle et al. 2016, 2018; McWilliam et al. The efficiency and scalability of OpenMDAO were
2018; Graf et al. 2018; Dykes et al. 2018) and wind farm demonstrated in several examples. We also presented an
layouts (Thomas et al. 2017; Stanley and Ning 2018). overview of various previously published applications of
OpenMDAO to engineering design problems, including
satellite, wing, and aircraft design. Some of these problems
8 Conclusions involved tens of thousands of design variables and similar
number of constraints. Other problems involved costly high-
The OpenMDAO framework was developed to facilitate fidelity models, such as CFD and finite element structural
the multidisciplinary analysis and design optimization of analysis with millions of degrees of freedom. While the
complex engineering systems. While other frameworks solution of the problems in these applications would
exist for the same purpose, OpenMDAO has evolved in the have been possible with single purpose implementations,
last few years to incorporate state-of-the-art algorithms that OpenMDAO made it possible to use state-of-the-art
enable it to address optimization problems of unprecedented methods with a much lower development effort.
scale and complexity. Based on the experience of these applications, we
Two main areas of development made this possible: conclude that while OpenMDAO can handle traditional
algorithms for the solution of coupled systems and methods disciplinary analysis models effectively, it is most efficient
for the computation of derivatives. The development of when these models are developed from the ground up using
efficient derivative computation was motivated by the fact OpenMDAO with a fine-grained modularity to take full
that gradient-based optimization is our only hope for advantage of the problem sparsity, lower implementation
solving large-scale problems that involve computationally effort, and built-in derivative computation.
expensive models; thus, efficient gradient computations that
are scalable are required. Because most models and coupled
systems exhibit some degree of sparsity in their problem 9 Replication of results
structure, OpenMDAO takes advantage of the sparsity for
both storage and computation. Most of the codes required to replicate the results in this
To achieve the efficient solution of coupled systems, paper are available under open-source licenses and are
OpenMDAO implements known state-of-the-art monolithic maintained in version control repositories. The Open-
methods and has developed a flexible hierarchical approach MDAO framework is available from GitHub (github.com/
that enables users to group models according to the problem OpenMDAO). The OpenMDAO website (openmdao.org)
structure so that computations can be nested, parallelized, provides installation instructions and a number of examples.
or both. The code for the simple example of Section 3 is listed in

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1098 J. S. Gray et al.

Figs. 3 and 4 and can be run once OpenMDAO is installed now also applicable for coloring total derivative Jacobian
as is. The scripts used to produce the scaling plots in calculations based on the unified derivatives (16).
Figs. 7 and 10 are available as supplemental material in this To apply a coloring algorithm, we need to know the
paper. In addition to requiring OpenMDAO to be installed, total derivative Jacobian sparsity pattern a priori, but this
these scripts require OpenAeroStruct (github.com/mdolab/ information is not easily available. However, the sparsity
OpenAeroStruct) and Dymos (github.com/OpenMDAO/ pattern of the partial derivative Jacobian matrix, ∂R/∂u,
dymos). The scaling plots for the AMD problem (Fig. 12) is known to OpenMDAO a priori from the combination
involve a complex framework that includes code that is not of user-declared partial derivatives and the connections
open source, and therefore, we are not able to provide scripts made during model construction. Therefore, we developed
for these results. Finally, although no results are shown in a method in OpenMDAO that computes the total derivative
the applications mentioned in Section 7, the code for two of sparsity given the partial derivative Jacobian sparsity.
these applications—OpenAeroStruct (github.com/mdolab/ To determine the total Jacobian sparsity pattern for a
OpenAeroStruct) and the satellite MDO (github.com/Open given state, OpenMDAO computes a randomized partial
MDAO/CADRE)—is also available. derivative matrix using linear solutions of (16) with ran-
Acknowledgements The authors would like to thank the NASA domized values for ∂R/∂u. Intuitively, one can understand
ARMD Transformational Tools and Technologies project for their how using randomized partial derivatives would yield a
support of the OpenMDAO development effort. Joaquim Martins was relatively robust estimate of the total derivative sparsity pat-
partially supported by the National Science Foundation (award number tern, but we provide a more detailed logical argument for
1435188). We would like to acknowledge the invaluable advice from
Gaetan Kenway and Charles Mader on efficient implementation of why this approach is appropriate here. A single random-
OpenMDAO for high-fidelity work. Also invaluable was the extensive ized total derivative Jacobian is likely to give the correct
feedback provided by Eric Hendricks, Rob Falck, and Andrew Ning. sparsity pattern, but we can reduce the likelihood of errors
Finally, we would also like to thank Nicolas Bons, Benjamin Brelje, in the sparsity by summing the absolute value of multiple
Anil Yildirim, and Shamsheer Chauhan for their review of this
manuscript and their helpful suggestions. randomly generated total derivative Jacobians.
Once we have the total derivative sparsity pattern,
Compliance with ethical standards OpenMDAO applies a coloring algorithm based on the work
of Coleman and Verma (1998) to identify the reduced set
Conflict of interest The authors declare that there is no conflict of
interest.
of linear solutions needed to compute the total derivative
Jacobian. As we demonstrate in Section 5.3, coloring can
Open Access This article is distributed under the terms of the Creative offer significant performance improvements for problems
Commons Attribution 4.0 International License (http://creativecommons. that have sparse total derivative Jacobians.
org/licenses/by/4.0/), which permits unrestricted use, distribution, and
reproduction in any medium, provided you give appropriate credit to
the original author(s) and the source, provide a link to the Creative 1.2 Justification for coloring with randomized total
Commons license, and indicate if changes were made. derivative Jacobians

In theory, it would be possible to color the total derivative

Appendix 1: Coloring of total derivative Jacobian based on the actual Jacobian computed around the
Jacobians initial condition of the model. There is a risk, however, that
the initial condition of the model will happen to be at a point
1.1 Determining total derivative coloring where some of the total derivatives in the model are incidentally
zero, although they will take nonzero values elsewhere in the
In the simple problem illustrated in Fig. 8, the forward design space. The incidental zero would potentially result in
coloring of the model inputs is obvious. However, for a an incorrect coloring, and so it is to be avoided if possible.
large problem with an unordered total Jacobian matrix, it is Instead of using the actual Jacobian values, we generate
not easy to identify coloring. There are a wide variety of a randomized total derivative Jacobian that is statistically
serial coloring algorithms (Welsh and Powell 1967; Karp highly unlikely to create any incidental zero values.
and Wigderson 1985; Jones and Plassmann 1993; Coleman From (16), we know that the total derivative Jacobian
and Verma 1998; Gebremedhin et al. 2005), originally matrix, du/dr, is equal to the inverse of the partial derivative
developed for coloring partial derivative Jacobians. There Jacobian matrix, ∂R/∂u. Our task reduces to the general
are also a set of parallel coloring algorithms that have been mathematical problem of determining the sparsity structure
developed for parallel distributed-memory applications, of a matrix inverse given the sparsity structure of the matrix
such as CFD (Jones and Plassmann 1993; Nielsen and Kleb itself, assuming that the matrix is large. First, we note that
2006; Mader et al. 2008; Lyu et al. 2013; He et al. 2018). we do not need the sparsity structure of all of du/dr; we
What we propose here is that these coloring algorithms are only need the rows and columns corresponding to df/dx,

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1099

which is almost always a much smaller matrix because Expanding ∂Rx /∂x to account for the intermediate calcula-
du/dr contains all the intermediate model variables as well tion of y gives
as the model inputs and model outputs. From Cramer’s rule,  
∂C ∂C dy
we know that + x = −rx . (29)
  ∂x ∂y dx
∂R −1 adj(∂R/∂u)ij
= , (25) By differentiating (27) with respect to x, we find that
∂u det(∂R/∂u)
ij
dRy ∂Ry ∂Ry dy
= + = 0, (30)
which is to say that the (i, j )th entry of the inverse of the dx ∂x ∂y dx
 
Jacobian is the quotient of the (i, j )th entry of the adjugate dy ∂D −1 ∂D
of the Jacobian and the determinant of the Jacobian. =− . (31)
dx ∂y ∂x
The Jacobian is invertible for well-posed models, so the
determinant is always nonzero. Thus, only the numerator in Combining (29) and (31) gives a formula for the Newton
(25) determines if a particular term is nonzero. If the matrix update of the reduced-space function as
is n × n, where n is large, each term in the adjugate and,    
thus, the inverse is the sum of a large number of terms that ∂C ∂C ∂D −1 ∂D
− x = −rx . (32)
are products of n − 1 partial derivatives. ∂x ∂y ∂y ∂x
If we produce a partial derivative Jacobian matrix with
random values for all nonzero terms, it would be highly Now, instead of the reduced-space form of (26), consider a
improbable that this sum of a large number of terms would full-space form that deals with both x and y simultaneously
be incidentally zero. Therefore, we assume that each entry as one vector:
   
of the inverse of the random partial derivative Jacobian that C(x, y) r
Ru (u) = R(x, y) = = ru = x . (33)
is zero is actually a zero in the sparsity structure of the true D(x, y) ry
total derivative Jacobian.
This full-space form is the mathematical representation
used by OpenMDAO for any system—or subsystem, as
Appendix 2: Equivalence between demonstrated in (15). The Newton update for the flattened
hierarchical and reduced-space Newton’s system must be solved for via a linear system of size (n+m):
methods  
∂Ru
u = −ru . (34)
OpenMDAO introduces a new hierarchical Newton’s ∂u
method formulation for the sake of improved numerical If we apply the hierarchical Newton algorithm to the full-
flexibility; however, this proof shows that the new full-space space formulation, then we can assume that any time (34)
method can be made mathematically identical to the more is solved, y has first been found such that that ry = 0.
traditional reduced-space Newton’s method if one always Expanding ∂Ru /∂u and setting ry = 0 in (34) yields
fully converges the internal nonlinear system associated  
∂C ∂C   
with Ry . Consider the residual of an arbitrary implicit x rx
function, Rx (x) = rx , at some non-converged value of x. If
∂x ∂y
∂D ∂D = − . (35)
∂x ∂y
y 0
rx is actually a function of the nonlinear system Ry (x, y) =
0, converged for a specific value of x: Solving (35) for y and back substituting yields
   
Rx (x) = C(x, y) = rx (26) ∂C ∂C ∂D −1 ∂D
− x = −rx . (36)
Ry (y) = D(x, y) = 0, (27) ∂x ∂y ∂y ∂x

then we call Rx the reduced-space residual function, with Now note that (32) and (36) are identical, and therefore
the full space composed of the vectors x and y of lengths n applying the hierarchical Newton algorithm to the full-
and m, respectively. space model (size n + m) gives the exact same x as
Our ultimate goal is to solve for x such that Rx (x) = 0, the reduced-space Newton algorithm applied to the smaller,
using Newton’s method. The traditional Newton’s method reduced-space model (size n). Since the updates to x are
iteration consists in computing x by solving a linear the same, then assuming complete convergence of all child
system of size n: subsystems, the path that the hierarchical Newton’s method
  takes on the size (n + m) formulation will be identical to
∂Rx the path the reduced-space Newton’s method takes on the
x = −rx . (28)
∂x smaller size n formulation.

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1100 J. S. Gray et al.

Appendix 3: Equivalence between recursive We use the closed form solution for the block inverse of a
and hierarchical Broyden’s methods 2 × 2 matrix to obtain
 −1
∂C ∂C
Broyden’s second method computes an approximate update −1
Jn−1 = ∂x
∂D
∂y
∂D =
of the inverse Jacobian via ⎡
∂x ∂y
 −1  −1 ⎤
∂C ∂D −1 ∂D −1 ∂C ∂D ∂C −1 ∂C
∂x − ∂y ∂y − ∂C −
∂C ∂D
 −1 −1 ⎢ ∂x ∂x ∂y ∂y ∂x ∂x ∂y ⎥
∂Rx xn − Jn−1 rn T ⎣ 
−1 ∂D ∂C ∂C ∂D −1 ∂D
−1 
∂D ∂C −1 ∂C
−1 ⎦(45)
= Jn−1 ∼ −1 − ∂D ∂x − ∂y ∂y −
∂D
= Jn−1 + rn . (37) ∂y ∂x ∂x ∂y ∂x ∂x ∂y .
∂x n rn 2

We can simplify this by substituting (40) into (45), which

Then, the Newton update is applied using the approximate yields
inverse Jacobian via ⎡  −1 ⎤
∂C −1 ∂C ∂D ∂D ∂C −1 ∂C
⎢ β − ∂x ∂y ∂y − ∂x ∂x ∂y ⎥
x = −Jn−1 rx . (38) −1
Jn−1 =⎣  −1 ⎦
−1 ∂D ∂C −1 ∂C
− ∂y
∂D ∂D
∂x β ∂D
∂y − ∂x ∂x ∂y .
3.1 Reduced-space Broyden
(46)
Consider the same composite model structure given in (26) To further simplify, we define one more new variable, γ :
and (27). From (32), we know that  −1
∂D ∂D ∂C −1 ∂C
    γ = − (47)
∂Rx ∂C ∂C ∂D −1 ∂D ∂y ∂x ∂x ∂y
= − . (39)
∂x n ∂x ∂y ∂y ∂x and then,
n  −1 ∂C 
−1 β − ∂C ∂y γ
To simplify the algebra, we now define a new variable, β, as Jn−1 = −1 ∂D
∂x
. (48)
− ∂D
∂y ∂x β γ
 −1  −1
∂Rx ∂C ∂C ∂D −1 ∂D Now, returning to (44), we can compute each of the
β= = − . (40) terms:
∂x n−1 ∂x ∂y ∂y ∂x  
n−1  
−1 −1 r x βr x
Jn−1 rn = Jn−1 = −1 ∂D (49)
Now we can substitute this into (37) to calculate the 0 n − ∂D
∂y ∂x βrx .
Broyden update to the inverse Jacobian as
Since the residual ry is zero,
x − βrx T ru  = rx .
Jn−1 =β+ rx . (41) (50)
rx 2
Putting it all together, we get
Finally, if we substitute this into (38), we get the update to  −1 ∂C 
−1 β − ∂C ∂y γ
the state value: Jn = ∂D −1 ∂D
∂x

  − ∂y ∂x β γ
x − βrx T    
xn = − β + r x rx . (42) x βrx
rx 2 − −1 ∂D
y − ∂D
∂y ∂x βrx 
2
 T 
+ rx 0 . (51)
3.2 Full-space Broyden rx 2
Performing the outer product and reducing yields
To apply Broyden’s method to the full-space formulation, ⎡ ⎤
∂C −1 ∂C
we start from (35) for the Newton update of the full-space β + x−βr
rx  2
1
r T
x ∂x ∂y γ
system, but now instead of an exact inverse Jacobian, we use Jn−1 = ⎣ −1 ∂D −1 ∂D
⎦.
∂D ∂D x− ∂y ∂x βrx
the approximate inverse Jacobian, Jn−1 , i.e., β r T γ
∂y ∂x r 2 x x

    (52)
x rx
[u] = = −Jn−1 = −Jn−1 [ru ] . (43) Now we substitute this into (23) to get the update to the state
y 0
value:
The full-space Broyden’s method gives ⎡ ⎤
  x−βrx ∂C −1 ∂C  
β+ rxT ∂y γ
 −1 −1
x
= −⎣
rx2 ∂x
⎦ rx
∂Ru un − Jn−1 rn T y ∂D −1 ∂D y− ∂D
−1 ∂D
∂x βrx 0 n
= Jn−1 ∼ −1 + rxT γ
∂y
= Jn−1 + rn . (44) n
∂y ∂x β rx 2
∂u n rn 2
(53)

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1101

⎡  ⎤
  β + x−βr x
r T r
x
optimization with the elsA software. In: 52nd aerospace sciences
x ⎢ rx  2 x
 ⎥ meeting. https://doi.org/10.2514/6.2014-0568
=− ⎢
⎣ ∂D ∂D
∂D −1 ∂D ⎥.
y n −1
β +
y− ∂y ∂x βrx
r T r ⎦ Chaudhuri A, Lam R, Willcox K (2017) Multifidelity uncertainty
∂y ∂x r  2 x x propagation via adaptive surrogates in coupled multidisciplinary
x
systems. AIAA J, 235–249. https://doi.org/10.2514/1.J055678
(54) Chauhan SS, Martins JRRA (2018) Low-fidelity aerostructural opti-
mization of aircraft wings with a simplified wingbox model using
Finally, we can solve for the Broyden updated x to obtain: OpenAeroStruct. In: Proceedings of the 6th international confer-
  ence on engineering optimization, EngOpt 2018. Springer, Lisbon,
x − βrx T
xn = − β + r x rx . (55) pp 418–431. https://doi.org/10.1007/978-3-319-97773-7 38
rx 2 Chauhan SS, Hwang JT, Martins JRRA (2018) An automated selection
algorithm for nonlinear solvers in MDO. Struct Multidiscip Optim
This matches the result from recursive Broyden in (42). We 58(2):349–377. https://doi.org/10.1007/s00158-018-2004-5
also end up with an update to y, but since we have assumed Chen S, Lyu Z, Kenway GKW, Martins JRRA (2016) Aerodynamic
that a sub-solver will always drive Ry to zero, this update to shape optimization of the Common Research Model wing-body-
y does not affect the path taken by the top-level full-space tail configuration. J Aircr 53(1):276–293. https://doi.org/10.2514
/1.C033328
solver. Chung H, Hwang JT, Gray JS, Kim HA (2018) Implementa-
tion of topology optimization using OpenMDAO. In: 2018
Publisher’s note Springer Nature remains neutral with regard to AIAA/ASCE/AHS/ASC structures, structural dynamics, and
jurisdictional claims in published maps and institutional affiliations. materials conference. AIAA AIAA, Kissimmee. https://doi.org/
10.2514/6.2018-0653
Coleman TF, Verma A (1998) The efficient computation of sparse
References Jacobian matrices using automatic differentiation. SIAM J Sci
Comput 19(4):1210–1233
Cook LW (2018) Effective formulations of optimization under
Arora J, Haug EJ (1979) Methods of design sensitivity anal- uncertainty for aerospace design. PhD thesis, University of
ysis in structural optimization. AIAA J 17(9):970–974. Cambridge. https://doi.org/10.17863/CAM.23427
https://doi.org/10.2514/3.61260 Cook LW, Jarrett JP, Willcox KE (2017a) Extending horsetail match-
Balabanov V, Charpentier C, Ghosh DK, Quinn G, Vanderplaats G, ing for optimization under probabilistic, interval, and mixed uncer-
Venter G (2002) Visualdoc: a software system for general purpose tainties. AIAA J 56(2):849–861. https://doi.org/10.2514/1.J05
integration and design optimization. In: 9th AIAA/ISSMO 6371
symposium on multidisciplinary analysis and optimization. Cook LW, Jarrett JP, Willcox KE (2017b) Horsetail matching for
Atlanta optimization under probabilistic, interval and mixed uncertainties.
Balay S, Abhyankar S, Adams M, Brown J, Buschelman K, Dalcin L, In: 19th AIAA non-deterministic approaches conference, p 0590.
Dener A, Eijkhout V, Gropp W, Karpeyev D, Kaushik D, Knepley https://doi.org/10.2514/6.2017-0590
M, May D, McInnes LC, Mills R, Munson T, Rupp K, Sanan P, Dykes K, Damiani R, Roberts O, Lantz E (2018) Analysis Of
Smith B, Zampini S, Zhang H (2018) PETSc users manual. Tech. ideal towers for tall wind applications. In: 2018 wind energy
Rep. ANL-95/11 - Revision 3.10, Argonne National Laboratory symposium. AIAA. https://doi.org/10.2514/6.2018-0999
Baptista R, Poloczek M (2018) Bayesian optimization of combi- Falck RD, Chin JC, Schnulo SL, Burt JM, Gray JS (2017) Trajectory
natorial structures. In: Dy J, Krause A (eds) Proceedings of optimization of electric aircraft subject to subsystem thermal
the 35th international conference on machine learning, PMLR, constraints. In: 18th AIAA/ISSMO multidisciplinary analysis and
Stockholmsmässan, Stockholm Sweden, Proceedings of Machine optimization conference. Denver
Learning Research, vol 80. pp 462–471. http://proceedings.mlr. Falck RD, Gray JS, Naylor B (2019) Optimal control within the
press/v80/baptista18a.html context of multidisciplinary design, analysis, and optimization.
Barrett R, Ning A (2018) Integrated free-form method for aerostruc- In: AIAA SciTech forum, AIAA. https://doi.org/10.2514/6.2019-
tural optimization of wind turbine blades. Wind Energy 0976
21(8):663–675. https://doi.org/10.1002/we.2186 Friedman S, Ghoreishi SF, Allaire DL (2017) Quantifying the impact
Bernoulli J (1696) A new problem to whose solution mathematicians of different model discrepancy formulations in coupled multidis-
are invited. Acta Eruditorum 18:269 ciplinary systems. In: 19th AIAA non-deterministic approaches
Betts JT, Huffman WP (1991) Trajectory optimization on a conference, p 1950. https://doi.org/10.2514/6.2017-1950
parallel processor. J Guid Control Dyn 14(2):431–439. Gallard F, Meaux M, Montagnac M, Mohammadi B (2013) Aero-
https://doi.org/10.2514/3.20656 dynamic aircraft design for mission performance by multipoint
Bons N, He X, Mader CA, Martins JRRA (2019) Multimodal- optimization. In: 21st AIAA computational fluid dynamics con-
ity in aerodynamic wing design optimization. AIAA Journal ference. American Institute of Aeronautics and Astronautics.
https://doi.org/10.2514/1.J057294, (In press) https://doi.org/10.2514/6.2013-2582
Brelje BJ, Martins JRRA (2018) Development of a conceptual design Gallard F, Lafage R, Vanaret C, Pauwels B, Guénot D, Barjhoux
model for aircraft electric propulsion with efficient gradients. PJ, Gachelin V, Gazaix A (2017) GEMS: a Python library
In: Proceedings of the AIAA/IEEE electric aircraft technologies for automation of multidisciplinary design optimization process
symposium. Cincinnati. https://doi.org/10.2514/6.2018-4979 generation. In: 18th AIAA/ISSMO multidisciplinary analysis and
Bryson AE (1999) Dynamic optimization. Addison Wesley Longman, optimization conference
Menlo Park Gebremedhin AH, Manne F, Pothen A (2005) What color is your
Bryson AE, Ho YC (1975) Applied optimal control: optimization, Jacobian? Graph coloring for computing derivatives. SIAM Rev
estimation, and control. Wiley, Hoboken 47(4):629–705
Carrier G, Destarac D, Dumont A, Méheut M, Din ISE, Peter J, Khelil Golovidov O, Kodiyalam S, Marineau P, Wang L, Rohl P
SB, Brezillon J, Pestana M (2014) Gradient-based aerodynamic (1998) Flexible implementation of approximation concepts

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1102 J. S. Gray et al.

in an MDO framework. In: 7th AIAA/USAF/NASA/ISSMO Hwang JT, Martins JRRA (2015) Parallel allocation-mission opti-
symposium on multidisciplinary analysis and optimiza- mization of a 128-route network. In: Proceedings of the 16th
tion. American Institute of Aeronautics and Astronautics. AIAA/ISSMO multidisciplinary analysis and optimization confer-
https://doi.org/10.2514/6.1998-4959 ence. Dallas. https://doi.org/10.2514/6.2015-2321
Graf P, Dykes K, Damiani R, Jonkman J, Veers P (2018) Adaptive Hwang JT, Martins JRRA (2018) A computational architecture
stratified importance sampling: hybridization of extrapolation and for coupling heterogeneous numerical models and comput-
importance sampling Monte Carlo methods for estimation of ing coupled derivatives. ACM Trans Math Softw 44(4):37.
wind turbine extreme loads. Wind Energy Science (Online) 3(2). https://doi.org/10.1145/3182393
https://doi.org/10.5194/wes-3-475-2018 Hwang JT, Munster DW (2018) Solution of ordinary differen-
Gray J, Moore KT, Naylor BA (2010) OpenMDAO: an open tial equations in gradient-based multidisciplinary design opti-
source framework for multidisciplinary analysis and optimization. mization. In: 2018 AIAA/ASCE/AHS/ASC structures, struc-
In: Proceedings of the 13th AIAA/ISSMO multidisciplinary tural dynamics, and materials conference. Kissimmee, FL.
analysis optimization conference, Fort Worth, TX, AIAA, 2010- https://doi.org/10.2514/6.2018-1646
9101 Hwang JT, Ning A (2018) Large-scale multidisciplinary opti-
Gray J, Moore KT, Hearn TA, Naylor BA (2013) Standard mization of an electric aircraft for on-demand mobility.
platform for benchmarking multidisciplinary design analysis In: 2018 AIAA/ASCE/AHS/ASC structures, structural dynam-
and optimization architectures. AIAA J 51(10):2380–2394. ics, and materials conference. AIAA AIAA, Kissimmee.
https://doi.org/10.2514/1.J052160 https://doi.org/10.2514/6.2018-1384
Gray J, Hearn T, Moore K, Hwang JT, Martins JRRA, Ning Hwang JT, Lee DY, Cutler JW, Martins JRRA (2014) Large-
A (2014) Automatic evaluation of multidisciplinary derivatives scale multidisciplinary optimization of a small satellite’s
using a graph-based problem formulation in OpenMDAO. In: design and operation. J Spacecr Rocket 51(5):1648–1663.
Proceedings of the 15th AIAA/ISSMO multidisciplinary analysis https://doi.org/10.2514/1.A32751
and optimization conference, Atlanta. https://doi.org/10.2514/ Hwang JT, Jasa J, Martins JRRA (2019) High-fidelity design-
6.2014-2042 allocation optimization of a commercial aircraft maximizing air-
Gray J, Mader CA, Kenway GKW, Martins JRRA (2018a) Modeling line profit. Journal of Aircraft. https://doi.org/10.2514/1.C035082,
boundary layer ingestion using a coupled aeropropulsive analysis. (In press)
J Aircr 55(3):1191–1199. https://doi.org/10.2514/1.C034601 Jameson A (1988) Aerodynamic design via control theory. J Sci
Gray JS, Martins JRRA (2018) Coupled aeropropulsive design Comput 3(3):233–260
optimization of a boundary layer ingestion propulsor. The Jasa JP, Hwang JT, Martins JRRA (2018a) Design and trajectory
Aeronautical Journal. https://doi.org/10.1017/aer.2018.120, (In optimization of a morphing wing aircraft. In: 2018 AIAA/
press) ASCE/AHS/ASC structures, structural dynamics, and materials
Gray JS, Chin J, Hearn T, Hendricks E, Lavelle T, Martins JRRA conference. AIAA SciTech Forum, Orlando. https://doi.org/10.
(2017) Chemical equilibrium analysis with adjoint derivatives 2514/6.2018-1382
for propulsion cycle analysis. J Propuls Power 33(5):1041–1052. Jasa JP, Hwang JT, Martins JRRA (2018b) Open-source coupled
https://doi.org/10.2514/1.B36215 aerostructural optimization using Python. Struct Multidiscip
Gray JS, Kenway GKW, Mader CA, Martins JRRA (2018b) Aero- Optim 57:1815–1827. https://doi.org/10.1007/s00158-018-1912-8
propulsive design optimization of a turboelectric boundary layer Jasa JP, Mader CA, Martins JRRA (2018c) Trajectory optimization
ingestion propulsion. In: AIAA aviation technology, integra- of supersonic air vehicle with thermal fuel management system.
tion and operations conference. Atlanta. https://doi.org/10.25 In: AIAA/ISSMO multidisciplinary analysis and optimization
14/6.2018-3976 conference. Atlanta. https://doi.org/10.2514/6.2018-3884
Griewank A (2000) Evaluating derivatives. SIAM, Philadelphia Jones M, Plassmann P (1993) A parallel graph coloring heuristic.
Haftka RT (1977) Optimization of flexible wing structures subject to SIAM J Sci Comput 14(3):654–669. https://doi.org/10.1137/
strength and induced drag constraints. AIAA J 15(8):1101–1106. 0914041
https://doi.org/10.2514/3.7400 Karp RM, Wigderson A (1985) A fast parallel algorithm for
Haftka RT, Sobieszczanski-Sobieski J, Padula SL (1992) On options the maximal independent set problem. J Assoc Comput Mach
for interdisciplinary analysis and design optimization. Struct 32(4):762–773
Optim 4:65–74. https://doi.org/10.1007/BF01759919 Kenway GKW, Martins JRRA (2016) Multipoint aerodynamic shape
He P, Mader CA, Martins JRRA, Maki KJ (2018) An aero- optimization investigations of the Common Research Model wing.
dynamic design optimization framework using a discrete AIAA J 54(1):113–128. https://doi.org/10.2514/1.J054154
adjoint approach with OpenFOAM. Comput Fluids 168:285–303. Kennedy GJ, Hicken JE (2015) Improved constraint-aggregation
https://doi.org/10.1016/j.compfluid.2018.04.012 methods. Comput Methods Appl Mech Eng 289:332–354.
Hearn DT, Hendricks E, Chin J, Gray JS, Moore DKT (2016) https://doi.org/10.1016/j.cma.2015.02.017
Optimization of turbine engine cycle analysis with analytic Keyes DE, McInnes LC, Woodward C, Gropp W, Myra E, Pernice
derivatives. In: 17th AIAA/ISSMO multidisciplinary analysis M, Bell J, Brown J, Clo A, Connors J, Constantinescu E, Estep
and optimization conference, part of AIAA Aviation 2016 D, Evans K, Farhat C, Hakim A, Hammond G, Hansen G, Hill
(Washington, DC). https://doi.org/10.2514/6.2016-4297 J, Isaac T, Jiao X, Jordan K, Kaushik D, Kaxiras E, Koniges A,
Heath C, Gray J (2012) OpenMDAO: framework for flexible Lee K, Lott A, Lu Q, Magerlein J, Maxwell R, McCourt M, Mehl
multidisciplinary design, analysis and optimization methods. In: M, Pawlowski R, Randles AP, Reynolds D, Riviere B, Rude U,
Proceedings of the 53rd AIAA structures, structural dynamics and Scheibe T, Shadid J, Sheehan B, Shephard M, Siegel A, Smith B,
materials conference, Honolulu, HI, AIAA-2012-1673 Tang X, Wilson C, Wohlmuth B (2013) Multiphysics simulations:
Heil M, Hazel AL, Boyle J (2008) Solvers for large-displacement challenges and opportunities. Int J High Perform Comput Appl
fluid–structure interaction problems: segregated versus monolithic 27(1):4–83. https://doi.org/10.1177/1094342012468181
approaches. Comput Mech 43(1):91–101. https://doi.org/10.1007 Kolonay RM, Sobolewski M (2011) Service oriented computing
/s00466-008-0270-6 environment (SORCER) for large scale, distributed, dynamic

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

OpenMDAO: An open-source framework for multidisciplinary design, analysis, and optimization 1103

fidelity aeroelastic analysis. In: Optimization, international Proceedings of the 10th AIAA/ISSMO multidisciplinary analysis
forum on aeroelasticity and structural dynamics, IFASD 2011, and optimization conference. Victoria, BC, Canada, AIAA 2008-
26-30 6069
Kreisselmeier G, Steinhauser R (1979) Systematic control design Naumann U (2011) The art of differentiating computer programs—an
by optimizing a vector performance index. In: International introduction to algorithmic differentiation. SIAM
federation of active controls symposium on computer-aided Nielsen EJ, Kleb WL (2006) Efficient construction of discrete adjoint
design of control systems. Zurich. https://doi.org/10.1016/S14 operators on unstructured grids using complex variables. AIAA J
74-6670(17)65584-8 44(4):827–836. https://doi.org/10.2514/1.15830
Lam R, Poloczek M, Frazier P, Willcox KE (2018) Advances in Ning A, Petch D (2016) Integrated design of downwind land-based
Bayesian optimization with applications in aerospace engineering. wind turbines using analytic gradients. Wing Energy 19(12):2137–
In: 2018 AIAA non-deterministic approaches conference, p 1656. 2152. https://doi.org/10.1002/we.1972
https://doi.org/10.2514/6.2018-1656 Oliphant TE (2007) Python for scientific computing. Comput Sci Eng
Lambe AB, Martins JRRA (2012) Extensions to the design structure 9(3):10. https://doi.org/10.1109/MCSE.2007.58
matrix for the description of multidisciplinary design, analysis, Padula SL, Gillian RE (2006) Multidisciplinary environments: a his-
and optimization processes. Struct Multidiscip Optim 46:273–284. tory of engineering framework development. In: Proceedings
https://doi.org/10.1007/s00158-012-0763-y of the 11th AIAA/ISSMO multidisciplinary analysis and opti-
Lambe AB, Martins JRRA, Kennedy GJ (2017) An evaluation of mization conference, AIAA 2006-7083. https://doi.org/10.2514/6.
constraint aggregation strategies for wing box mass minimization. 2006-7083
Struct Multidiscip Optim 55(1):257–277. https://doi.org/10.1007 Palar PS, Shimoyama K (2017) Polynomial-chaos-kriging-assisted
/s00158-016-1495-1 efficient global optimization. In: 2017 IEEE symposium series on
Lyu Z, Kenway GK, Paige C, Martins JRRA (2013) Auto- computational intelligence (SSCI). IEEE, pp 1–8. https://doi.org/
matic differentiation adjoint of the Reynolds-averaged 10.1109/SSCI.2017.8280831
Navier–Stokes equations with a turbulence model. In: 21st Peherstorfer B, Beran PS, Willcox KE (2018) Multifidelity Monte
AIAA computational fluid dynamics conference. San Diego. Carlo estimation for large-scale uncertainty propagation. In:
https://doi.org/10.2514/6.2013-2581 2018 AIAA non-deterministic approaches conference, p 1660.
Mader CA, Martins JRRA, Alonso JJ, van der Weide E (2008) https://doi.org/10.2514/6.2018-1660
ADJoint: an approach for the rapid development of discrete Peter JEV, Dwight RP (2010) Numerical sensitivity analysis for
adjoint solvers. AIAA J 46(4):863–873. https://doi.org/10.2514/ aerodynamic optimization: a survey of approaches. Comput Fluids
1.29123 39(3):373–391. https://doi.org/10.1016/j.compfluid.2009.09.013
Marriage CJ, Martins JRRA (2008) Reconfigurable semi-analytic Reuther JJ, Jameson A, Alonso JJ, Rimlinger MJ, Saunders D (1999)
sensitivity methods and MDO architectures within the πMDO Constrained multipoint aerodynamic shape optimization using
framework. In: Proceedings of the 12th AIAA/ISSMO multidis- an adjoint formulation and parallel computers, part 1. J Aircr
ciplinary analysis and optimizaton conference Victoria. British 36(1):51–60. https://doi.org/10.2514/2.2413
Columbia. https://doi.org/10.2514/6.2008-5956 Roy S, Crossley WA, Moore KT, Gray JS, Martins JRRA (2018a)
Martins JRRA, Hwang JT (2013) Review and unification of meth- Next generation aircraft design considering airline operations
ods for computing derivatives of multidisciplinary computa- and economics. In: 2018 AIAA/ASCE/AHS/ASC structures,
tional models. AIAA J 51(11):2582–2599. https://doi.org/10.25 structural dynamics, and materials conference. Kissimmee, FL.
14/1.J052184 https://doi.org/10.2514/6.2018-1647
Martins JRRA, Hwang JT (2016) Multidisciplinary design optimiza- Roy S, Crossley WA, Moore KT, Gray JS, Martins JRRA
tion of aircraft configurations—part 1: a modular coupled adjoint (2018b) Next generation aircraft design considering airline
approach. Lecture series, Von Karman Institute for Fluid Dynam- operations and economics. In: AIAA/ASCE/AHS/ASC struc-
ics, Rode Saint Genèse, Belgium, ISSN0377-8312 tures, structural dynamics and materials conference. Kissimmee.
Martins JRRA, Lambe AB (2013) Multidisciplinary design opti-
https://doi.org/10.2514/6.2018-1647
mization: a survey of architectures. AIAA J 51(9):2049–2075.
Salas AO, Townsend JC (1998) Framework requirements for MDO
https://doi.org/10.2514/1.J051895
application development. In: 7th AIAA/USAF/NASA/ISSMO
Martins JRRA, Sturdza P, Alonso JJ (2003) The complex-step
symposium on multidisciplinary analysis and optimization, pp
derivative approximation. ACM Trans Math Softw 29(3):245–262.
98–4740
https://doi.org/10.1145/838250.838251
Martins JRRA, Alonso JJ, Reuther JJ (2004) High-fidelity aerostruc- Schnulo SL, Jeff Chin RDF, Gray JS, Papathakis KV, Clarke
tural design optimization of a supersonic business jet. J Aircr SC, Reid N, Borer NK (2018) Development of a multi-
41(3):523–530. https://doi.org/10.2514/1.11478 segment mission planning tool for SCEPTOR X-57. In: 2018
Martins JRRA, Alonso JJ, Reuther JJ (2005) A coupled-adjoint multidisciplinary analysis and optimization conference AIAA.
sensitivity analysis method for high-fidelity aero-structural Atlanta. https://doi.org/10.2514/6.2018-3738
design. Optim Eng 6(1):33–62. https://doi.org/10.1023/B:OPTE. Sobieszczanski-Sobieski J (1990) Sensitivity of complex, internally
0000048536.47956.62 coupled systems. AIAA J 28(1):153–160. https://doi.org/10.251
Martins JRRA, Marriage C, Tedford NP (2009) pyMDO: an object- 4/3.10366
oriented framework for multidisciplinary design optimization. Squire W, Trapp G (1998) Using complex variables to estimate
ACM Trans Math Softw 36(4):20:1–20:25. https://doi.org/10.11 derivatives of real functions. SIAM Rev 40(1):110–112
45/1555386.1555389 Stanley APJ, Ning A (2018) Coupled wind turbine design and layout
McWilliam MK, Zahle F, Dicholkar A, Verelst D, Kim T (2018) optimization with non-homogeneous wind turbines. Wind Energy
Optimal aero-elastic design of a rotor with bend-twist coupling. Science. https://doi.org/10.5194/wes-2018-54
J Phys Conf Ser 1037(4):042009. http://stacks.iop.org/1742-6596/ Tedford NP, Martins JRRA (2006) On the common structure of MDO
1037/i=4/a=042009 problems: a comparison of architectures. In: Proceedings of the
Moore K, Naylor B, Gray J (2008) The development of an open-source 11th AIAA/ISSMO multidisciplinary analysis and optimization
framework for multidisciplinary analysis and optimization. In: conference. Portsmouth, VA, AIAA 2006-7080

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

1104 J. S. Gray et al.

Tedford NP, Martins JRRA (2010) Benchmarking multidisciplinary problems. Comput J 10(1):85–86. https://doi.org/10.1093/comjnl/
design optimization algorithms. Optim Eng 11(1):159–183. 10.1.85
https://doi.org/10.1007/s11081-009-9082-6 Zahle F, Tibaldi C, Pavese C, McWilliam MK, Blasques JPAA, Hansen
Thomas J, Gebraad P, Ning A (2017) Improving the FLORIS MH (2016) Design of an aeroelastically tailored 10 MW wind
wind plant model for compatibility with gradient-based opti- turbine rotor. J Phys Conf Ser 753(6):062008. http://stacks.iop.
mization. Wind Eng 41(5):313–329. https://doi.org/10.1177/030 org/1742-6596/753/i=6/a=062008
9524X17722000 Zahle F, Sørensen NN, McWilliam MK, Barlas A (2018) Com-
Tracey BD, Wolpert D (2018) Upgrading from Gaussian processes putational fluid dynamics-based surrogate optimization of a
to student’s-T processes. In: 2018 AIAA non-deterministic wind turbine blade tip extension for maximising energy pro-
approaches conference, p 1659. https://doi.org/10.2514/6.20 duction. In: Journal of Physics: Conference Series, The Sci-
18-1659 ence of Making Torque from Wind, vol 1037. Milano.
Welsh DJA, Powell MB (1967) An upper bound for the chro- https://doi.org/10.1088/1742-6596/1037/4/042013
matic number of a graph and its application to timetabling

Affiliations
Justin S. Gray1 · John T. Hwang2 · Joaquim R. R. A. Martins3 · Kenneth T. Moore4 · Bret A. Naylor4

John T. Hwang
[email protected]
Joaquim R. R. A. Martins
[email protected]
Kenneth T. Moore
[email protected]
Bret A. Naylor
[email protected]
1 NASA Glenn Research Center, Cleveland, OH, USA
2 University of California, San Diego, San Diego, CA, USA
3 Department of Aerospace Engineering, University of Michigan,
Ann Arbor, MI, USA
4 DB Consulting Group (NASA Glenn Research Center), Cleveland,
OH, USA

Content courtesy of Springer Nature, terms of use apply. Rights reserved.

Terms and Conditions
Springer Nature journal content, brought to you courtesy of Springer Nature Customer Service Center GmbH (“Springer Nature”).
Springer Nature supports a reasonable amount of sharing of research papers by authors, subscribers and authorised users (“Users”), for small-
scale personal, non-commercial use provided that all copyright, trade and service marks and other proprietary notices are maintained. By
accessing, sharing, receiving or otherwise using the Springer Nature journal content you agree to these terms of use (“Terms”). For these
purposes, Springer Nature considers academic use (by researchers and students) to be non-commercial.
These Terms are supplementary and will apply in addition to any applicable website terms and conditions, a relevant site licence or a personal
subscription. These Terms will prevail over any conflict or ambiguity with regards to the relevant terms, a site licence or a personal subscription
(to the extent of the conflict or ambiguity only). For Creative Commons-licensed articles, the terms of the Creative Commons license used will
apply.
We collect and use personal data to provide access to the Springer Nature journal content. We may also use these personal data internally within
ResearchGate and Springer Nature and as agreed share it, in an anonymised way, for purposes of tracking, analysis and reporting. We will not
otherwise disclose your personal data outside the ResearchGate or the Springer Nature group of companies unless we have your permission as
detailed in the Privacy Policy.
While Users may use the Springer Nature journal content for small scale, personal non-commercial use, it is important to note that Users may
not:

1. use such content for the purpose of providing other users with access on a regular or large scale basis or as a means to circumvent access
control;
2. use such content where to do so would be considered a criminal or statutory offence in any jurisdiction, or gives rise to civil liability, or is
otherwise unlawful;
3. falsely or misleadingly imply or suggest endorsement, approval , sponsorship, or association unless explicitly agreed to by Springer Nature in
writing;
4. use bots or other automated methods to access the content or redirect messages
5. override any security feature or exclusionary protocol; or
6. share the content in order to create substitute for Springer Nature products or services or a systematic database of Springer Nature journal
content.
In line with the restriction against commercial use, Springer Nature does not permit the creation of a product or service that creates revenue,
royalties, rent or income from our content or its inclusion as part of a paid for service or for other commercial gain. Springer Nature journal
content cannot be used for inter-library loans and librarians may not upload Springer Nature journal content on a large scale into their, or any
other, institutional repository.
These terms of use are reviewed regularly and may be amended at any time. Springer Nature is not obligated to publish any information or
content on this website and may remove it or features or functionality at our sole discretion, at any time with or without notice. Springer Nature
may revoke this licence to you at any time and remove access to any copies of the Springer Nature journal content which have been saved.
To the fullest extent permitted by law, Springer Nature makes no warranties, representations or guarantees to Users, either express or implied
with respect to the Springer nature journal content and all parties disclaim and waive any implied warranties or warranties imposed by law,
including merchantability or fitness for any particular purpose.
Please note that these rights do not automatically extend to content, data or other material published by Springer Nature that may be licensed
from third parties.
If you would like to use or distribute our Springer Nature journal content to a wider audience or on a regular basis or in any other manner not
expressly permitted by these Terms, please contact Springer Nature at

[email protected]