Performance Evaluation of MDO Architectures within a Variable Complexity Problem

Though quite a number of multidisciplinary design optimization (MDO) architectures have been proposed for the optimal design of large-scale multidisciplinary systems, how their performance changes with the complexity of MDO problem varied is not well studied. In order to solve this problem, this paper presents a variable complexity problem which allows people to obtain a MDO problem with arbitrary complexity by specifying its changeable parameters, such as the number of disciplines and the numbers of design variables. Then four investigations are performed to evaluate how the performance of different MDO architectures changes with the number of disciplines, global variables, local variables, and coupling variables varied, respectively. Finally, the results supply guidance for the selection of MDO architectures in solving practical engineering problems with different complexity.


Introduction
Multidisciplinary design optimization (MDO) is a growing field of research in the design of large-scale engineering systems that consist of a number of interacting subsystems.The main motivation for using MDO is that the performance of a multidisciplinary system is driven not only by the individual disciplines but also by their interactions.By coordinating each discipline and decoupling their interaction reasonably in the design cycle, designers can improve the design and reduce the time and cost simultaneously.
Until now, many MDO architectures have been proposed for the optimal design of large-scale engineering systems.Generally, the architectures can be divided into two classes: monolithic architectures and distributed architectures.Monolithic architectures solve the MDO problem by casting it as a single optimization problem, which is easy to be implemented for small MDO problems.But for complicated engineering systems where people in charge of each discipline work independently of one another, these architectures may encounter big difficulty in integrating all the disciplines together.The monolithic architectures commonly include multidisciplinary feasible (MDF) [1][2][3], Individual Discipline Feasible (IDF) [1,2,4], and Simultaneous Analysis and Design (SAND) [1,5].However, the distributed architectures solve the MDO problems by decomposing it into smaller and more manageable discipline optimization problems that have the same solution when reassembled.One big advantage of these architectures is that they promote discipline autonomy and make people in different groups and teams just be in charge of their own fields and use their own discipline legacy.The distributed architectures usually include Concurrent Subspace Optimization (CSSO) [6,7], Collaborative Optimization (CO) [8][9][10], Bilevel Integrated Systems Synthesis (BLISS) [11], Bilevel Integrated Systems Synthesis 2000 (BLISS-2000) [12,13], Analytical Target Cascading (ATC) [14,15], and MDO based on independent subspaces (MDOIS) [16].
Though many MDO architectures are available, the big challenge is to determine which architecture is the most efficient for a given MDO problem.To solve the problem, a benchmarking study of different MDO architectures needs to be carried out.Though many researches [17][18][19][20][21][22][23] have done excellent work in comparing the performances of different MDO architectures and Martins et al. [24] have made an initial exploration in assessing the computational complexity of MDO architectures, there are still some limitations of them.Firstly, many of the test MDO problems are of low 2 Mathematical Problems in Engineering dimensionality with few disciplines and variables.They lack the ability to test the performance of different MDO architectures for the practical engineering problems which are often composed of hundreds of design variables, constraints, and coupling variables.Secondly, the MDO architectures may perform differently when the test problem has different number of disciplines, design variables, constraints, or coupling variables.How the performance of MDO architectures changes with the complexity of MDO problem varied is not well studied.
In order to deal with the problems above, two works will be done in this paper.The first one is to present a variable complexity problem which is a nonseparable nonlinear problem that allows people to specify its complexity, such as the number of disciplines, design variables, and coupling variables.This makes it feasible to test the performance of different MDO architectures not only for high complexity problem, but also for problem with arbitrary complexity.The second one is to implement different MDO architectures to solve the variable complexity problem in four cases to evaluate how the performance of MDO architectures changes with the complexity of MDO problem varied.
The remainder of this paper is organized as follows.In Section 2, we state the terminology and mathematical notation that will be used throughout this paper.In Section 3, we present a variable complexity problem whose complexity can be varied by the changeable parameters.In Section 4, we give the specific formulations of four MDO architectures associated with the variable complexity problem.In Section 5, we evaluate how the performance of MDO architectures changes with the complexity of MDO problem varied.Finally, some conclusions are presented in the last section.

Terminology and Mathematical Notation
Before introducing the variable complexity problem, we need to describe the terminology and mathematical notation that will be used throughout this paper.
Firstly, we define and clarify several terms that are specific to the field of MDO.Discipline analysis is usually a simulation that models the performance of one discipline in a multidisciplinary system.Global variables are the design variables that are shared by multiple disciplines.Local design variables are the design variables that only apply to one discipline.Coupling variables are the outputs that one discipline passes to other disciplines.Local constraints are the constraints that are only decided by one discipline.Global constraints are the constraints that are determined by multiple disciplines.
Then the common mathematical notation that will be used in the following sections is listed as follows.Note that all vectors in this paper are assumed to be column vectors unless indicated otherwise.

Mathematical Notation for MDO Problem
x 0 : the vector of global variables shared by more than one discipline  0 : the th element of x 0 x  : the vector of local design variables included in discipline    : the th element of x  y  : the vector of coupling variables included in discipline    : the th element of y  c  : the vector of local constraints included in discipline    : the th element of c  c 0 : the vector of global constraints depending on the variables of multiple disciplines  0 : the th element of c 0

Variable Complexity Problem
In this section, a variable complexity problem is proposed to allow the investigation that how the performance of MDO architectures changes with its complexity varied.It is a nonseparable nonlinear MDO problem which provides the ability to specify the changeable parameters in the following.Those parameters can be used to change the problem complexity as the user desires.The remaining part of this section is laid out as follows to introduce the variable complexity problem.Firstly, the discipline analysis, constraint functions, and objective function of the variable complexity problem are described in detail, respectively.Then the monolithic mathematical model of the variable complexity problem is built and a simple example consisting of three disciplines is given for a more vivid description.

Discipline Analysis.
A discipline analysis is a simulation that models the behavior of one discipline.Generally, performing a discipline analysis is to solve an equation group, such as the Navier-Stokes equation in fluid mechanics, the static equilibrium equation in structural mechanics, or the equations of motion in control simulations.So a set of equations are created to represent the analysis of discipline  in the variable complexity problem as follows.
For ( 2), it is obvious that different disciplines are coupled with each other through the global variables and the coupling variables.In order to make it more clearly, a simple example consisting of three disciplines is described in Figure 1 by the extended design structure matrix (XDSM) method [25] which makes the description of MDO problems and architectures very convenient and legible.
Another important thing is to determine the coefficient matrices in (2).As for C  and D  , they both can be generated randomly or customized by user prior to the start of the optimization.As for B  , because the discipline analysis needs to be individual disciplinary feasible, which means (2) needs a feasible solution, B  needs to be nonsingular.As for B  , because the whole multidisciplinary analysis which is composed of multiple discipline analyses needs to be multidisciplinary feasible, which means the combined equations composed of multiple equations (2) need a feasible solution, the combined matrix B shown in (3) needs to be nonsingular ] . (3)

Constraint Functions.
As stated in Section 2, there are two kinds of constraints in the MDO problem.One is the local constraints which depend on only one discipline variables.The other one is the global constraints which depend on multiple discipline variables.
Note that all of the coefficient vectors and positive scalars in ( 4) and ( 5) can be generated randomly or customized by user prior to the start of the optimization.

Objective Function.
For the objective function of MDO problem, it usually can be divided into two types.One is called the separable objective whose expression is a sum of the local objectives, each of which is formulated just by the variables included in one discipline.The other is called the nonseparable objective whose expression cannot be divided into a sum of local objectives.Because the separable objective unintentionally is preferred to some distributed architectures [16,26,27] and the objectives of most engineering problems are nonseparable, the objective of the variable complexity problem is built by a nonseparable function below to show the objectivity and generality f = ( 3.4.Monolithic Model.Based on (2), ( 4), (5), and ( 6), the monolithic mathematical model of the variable complexity problem can be obtained as follows by assuming there are  disciplines: minimize:  (x 0 , x, y) where ] T , and c  = [ 1 ,  2 , . . .,     ] T .The presented variable complexity problem is composed of the design variables, local constraints, global constraints, and nonseparable objective function.So it is a credible MDO problem to benchmark different MDO architectures without loss of generality.In order to make this problem be easily understood, one simple example consisting of three disciplines is represented in Figure 2 by the XDSM method.

MDO Architectures Associated with the Variable Complexity Problem
There are a wide range of MDO architectures, each of which formulates a given problem in a different manner.In this section, four common MDO architectures are introduced to formulate the variable complexity problem.Though only four MDO architectures are included, they serve as templates for future researchers to work from for other MDO architectures.For each architecture above, we firstly make a brief overview of it and then give its specific formulation associated with the variable complexity problem in the remaining section.

Multidisciplinary Feasible.
The multidisciplinary feasible architecture is a traditional MDO approach.Its main idea is to simply place an optimizer over a multidisciplinary analysis (MDA) module that takes in the design variables of the optimizer and iterates between the discipline analyses until all the coupling variables have converged.Because the solution of MDA module is required at each iteration of the optimizer, MDF architecture grantees that the MDO problem is multidisciplinary feasible at each optimization iterations.An obvious advantage of MDF architecture is that it is easy to be implemented since it is a monolithic architecture where the design variables, objective function, and design constraints are directly under the control of optimizer.
Another advantage is that MDF architecture always returns a feasible design even if the optimization is terminated early.This is particularly meaningful in some engineering problems if the goal is just to obtain an improved design that is unnecessary to be strictly mathematically optimal because of the computation difficulty.
The main disadvantage of MDF architecture is that the architecture requires a full MDA to be performed at each optimization iteration, which can be very time-consuming sometimes.Particularly when the gradient-based optimization method is adopted in the optimizer, the gradient calculations are more difficult for MDF architecture because the gradient information in MDF needs to be feasible with all disciplines.
With regard to the variable complexity problem, the specific formulation of MDF architecture can be stated as follows: minimize:  (x 0 , x, y)

Individual Discipline Feasible. The Individual Discipline
Feasible architecture removes the need for MDA procedure in MDF architecture that guarantees the multidisciplinary feasibility.This architecture enables the discipline analyses to be carried out in parallel by introducing the copies of coupling variables in each discipline and the corresponding consistency constraints.The copies of coupling variables are applied to decouple the discipline analyses so that they no longer depend on the coupling variables generated by other disciplines.The consistency constraints are introduced to make sure a multidisciplinary feasible solution is obtained at the optimal points by constraining the copies of coupling variables to match the actual coupling variables gradually.An obvious advantage of IDF architecture is that the discipline analyses are decoupled so that they can be performed in parallel, which will greatly increase the optimization efficiency.In addition, IDF architecture is also more robust than MDF architecture in the success rate of optimization because MDF involves a MDA procedure and solving the MDA module may sometimes be prone to error [24].
However, there are also some disadvantages about the IDF architecture.The first one is that the multidisciplinary feasibility is ensured at the last iteration of the optimization, which means the optimization cannot be terminated early for obtaining the optimal design.Another is that the introduction of consistency constraints increases the scale of the optimization problem.In particular, when the number of coupling variables is large, the optimization problem might be too large to solve efficiently.

Simultaneous Analysis and Design. The Simultaneous
Analysis and Design architecture treats the entire multidisciplinary design problem as a single large optimization problem, which is accomplished by converting the discipline analysis equations into equality constraints and adding the coupling variables and state variables into optimization variables.In this case, the task of the optimizer is to solve the discipline analysis and the optimization problem simultaneously.This approach is also referred to as All-at-Once (AAO) in some literature.The primary advantage of SAND architecture is that the costly solving of discipline analysis is eliminated at each optimization iteration, which can make the optimal solution of MDO problem found at a lower expense by letting the optimizer explore regions that are infeasible with respect to the discipline analysis equations.In addition, the parallel computing can be performed not only between different disciplines, but also within each disciplines.This character makes it possible to further improve the optimization efficiency by making full use of the parallelism of MDO problem.
In spite of having the benefits above, the SAND architecture has some major weaknesses in practice.The first one is that the discipline feasibility is not guaranteed until the last iteration of the optimization process.Therefore, if the optimization is interrupted, the resulting design may not be physically feasible.The second one is that SAND architecture does require all coupling variables, state variables, and discipline analysis equations.But in practical engineering problem, the discipline analysis is mostly computed by specialized software which often operates in a black-box form, so the SAND architecture cannot be implemented in this case.The last one is that the SAND architecture can greatly increase the dimensionality of the optimization problem by converting the discipline analysis equations into equality constraints and adding the coupling variables and state variables into optimization variables.Some gradientfree optimization methods might be prohibitive because the iterations of them show exponential growth with the optimization variables increasing.
With regard to the variable complexity problem, the specific formulation of SAND architecture can be stated as follows: minimize:  (x 0 , x, y) design variable: x 0 , x, y constraints: c 0 (x 0 , x, y) ≤ 0 As a bilevel architecture, there are many advantages about CO.The main one is that it accomplishes the discipline autonomy.This allows the discipline design groups just to be control of and responsible for their own discipline.The people are given the freedom to solve each subproblem optimization using any efficient methods based on the characters of each discipline.In addition, the autonomy also allows each subproblem optimization to be carried out in parallel, which can greatly improve the optimization efficiency.
But CO architecture has major drawback in its mathematical formulation which results in its poor performance in practice.DeMiguel and Murray (2000) [28] and Alexandrov and Lewis (2002) [2] show that there is a breakdown in the constraint qualification of the KKT optimality conditions in the master problem of CO architecture, which slows down the convergence rate for most gradient-based optimization methods and may prevent the CO architecture from converging in the worst case.A linear and a quadratic programming problem given by Alexandrow and lewis (2000) demonstrates that the CO architecture failed to converge to optimal solution even from starting points close to the optimal solution.
With regard to the variable complexity problem, the specific formulation of CO architecture can be stated as follows.
The master problem is as follows: minimize:  (x 0 , x, ŷ) where where p is the copy of x 0 in discipline  and ŷ ̸ = are the nonlocal coupling variables which are passed from the master problem.

Performance Evaluation
The main work of this section is to evaluate how the performance of MDO architectures in Section 4 changes when the changeable parameters in Section 3 are varied.In order to achieve this purpose, some implementation tools, which are used to solve problems (( 8)-( 12)), are firstly introduced to describe the test environment and then a comprehensive performance analysis is carried out to give an indication of each architecture's performance.

Implementation Tools.
Python [29][30][31] is selected as the programming language to solve problems (( 8)-( 12)) because it has the following advantages in the scientific computing area.Firstly, Python is an interpreted language and can be run in interactive mode, which makes it easy for learning and debugging.Secondly, Python supports object-oriented programming and the raising and catching of exceptions defined by user, which make it convenient for scripting and error handling.Thirdly, Python has many useful packages, such as Numpy, Scipy, and pyMPI, which greatly reduce the difficulty in realizing optimization, parallel computing, and so on.
Python Optimization Framework (pyOpt) [32] is a Python-based package for formulating and solving nonlinear constrained optimization problems, which was inspired by a Python wrapper script for the Sparse Nonlinear Optimizer (SNOPT) created by Professor Joaquim Martins in 2000.
Different types of open-source and licensed optimizers that solve the general nonlinear optimization problem have been integrated into the package, such as SNOPT, SLSQP, and ALPSO.Because pyOpt can solve the nonlinear constrained optimization problems in an efficient, reusable, and portable manner, it is introduced to provide all the required optimizers for implementing different MDO architectures.
SciPy [33][34][35] is a collection of mathematical algorithms and convenience functions built on the Numpy extension of Python.It adds significant power to the interactive Python session by providing the user with high-level commands and classes for manipulating and visualizing data.Specifically, the scipy.optimizepackage provides several commonly used root finding algorithms, such as Broyden, Exicitingmixing, and Krylov.In this paper, these root finding algorithms are used to solve the MDA module in MDF architectures.

Performance Analysis.
In order to evaluate how the performance of MDO architectures changes with the complexity of MDO problem varied, four investigations are performed for the variable complexity problem.In the first one, the number of disciplines is varied while keeping all the other changeable parameters of the variable complexity problem unchanged.In the second one, the number of global variables is varied and similarly keeping the other changeable parameters constant.In the third investigation, only the number of local variables included in each discipline is varied.In the fourth one, the number of coupling variables included in each discipline is varied.In order to specify the four investigations above, an initial variable complexity problem is given by setting (,   0 ,    ,    ,    ,   0 ) at (2, 1, 2, 2, 2, 1) and all the investigations are carried out on it.What is more, for every specific variable complexity problem, the coefficient matrices in Section 3.1, B  , B  , C  , and D  , are randomly generated between −5 and 5 while keeping B  and the combined matrix B nonsingular.The coefficient vectors in Section 3.2, E  , F  , G  , H  , I  , and J  , are randomly generated between −5 and 5.The positive scalars in Section 3.2,   and   , are randomly generated between 1 and 5.
When implementing the four MDO architectures in Section 4 for the four investigations above, the SLSQP in pyOpt is selected as the optimizer wherever there is a need for solving optimization problem and all of its parameters are left at the default values resulting in the convergence tolerance on the objective and constraints having to be satisfied with 10 −6 .The Broyden method in scipy.optimizepackage is chosen to solve the MDA module in MDF architecture and all its parameters are similarly left at the default values.In addition, the processor of the computer used to perform the optimization is Intel(R)Core(TM) 2 Duo CPU E7500 @ 2.93 GHz × 2 and the memory is 1.9 GiB.
Due to the different structures of each MDO architecture in Section 4, the total optimization time is the most meaningful and effective quantity to compare their performances.Figures 3-6 show the results of the four MDO architectures associated with the four investigations, respectively.In the first investigation, the number of disciplines is specifically varied from 1 to 100.In the second investigation, the number of global variables is varied from 1 to 100.In the third investigation, the number of local variables included in each discipline is varied from 1 to 100.In the fourth investigation, the number of coupling variables outputted from each discipline is similarly varied from 1 to 100.
From these figures, we can see that CO is always the most expensive architecture and it spends significantly more time than the other three architectures.SAND and IDF are the second and third expensive architectures, respectively.MDF is typically the most computationally efficient architecture.In Figures 4 and 5, with the number of global variables and the number of local variables included in each discipline increasing, the gaps between SAND, IDF, and MDF architectures remain about the same, which means the number of global variables and local variables almost has the same effect on the SAND, IDF, and MDF architectures.
In Figures 3 and 6, with the number of disciplines and the number of coupling variables included in each discipline increasing, the gaps between SAND, IDF, and MDF architectures are becoming gradually larger.It means SAND architecture performs gradually worse than the IDF and MDF architectures and IDF architecture performs gradually worse than MDF architecture with the number of disciplines and coupling variables increasing, respectively.In addition, the number of disciplines has less effect than the number of coupling variables.
For CO architecture, the number of disciplines and coupling variables has the same effect on it and SAND architectures based on Figures 3 and 6.However, its performance becomes gradually worse than SAND architecture with the

Conclusions
In this paper, two works have mainly been done to evaluate how the performance of MDO architectures changes with the complexity of MDO varied.Firstly, we present a variable complexity problem which is a nonseparable nonlinear problem that allows people to specify its complexity as needed.Secondly, we evaluate the performance of different MDO architectures through implementing four MDO architectures to solve the variable complexity problem under four investigations.
For the first work, the presented variable complexity problem is composed of the design variables, local constraints, global constraints, and nonseparable objective functions and allows people to obtain the MDO problem with arbitrary complexity by varying its complexity.It is more general to represent the practical engineering problems and make it possible to examine the effects of problem complexity on different MDO architecture.
For the second work, the architectures of MDF, IDF, SAND, and CO are implemented to solve the variable complexity problem through programming in Python language in the same computer environment and four investigations are performed for the variable complexity problem by varying its variable parameters which are, respectively, the number of disciplines, the number of global variables, the number of local variables, and the number of coupling variables.The results supply a reference for the selection of MDO architectures in solving practical engineering problems.Though only four common MDO architectures and four investigations are included, they can be regarded as templates for future researchers to benchmark other MDO architectures under other investigations.

1 Figure 2 :
Figure 2: The variable complexity problem consisting of three disciplines.
is the vector of coupling variables of discipline , B  is a coefficient matrix of size    ×   , C  is a coefficient matrix of size    ×   0 , and D  is a coefficient matrix of size    ×    .In addition, all elements of B  , C  , and D  are real values.If we denote (1) by R  = 0 in residual form as follows, the values of y  can be obtained by solving the equation R  = 0 and they are the solution of the discipline analysis 2, . . .,    ) are the coefficient vectors of x 0 , F  ( = 1, 2, . . .,    ) are the coefficient vectors of x  , G  ( = 1, 2, . . .,    ) are the coefficient vectors of y  , and ( = 1, 2, . . .,    ) are positive scalars.Its global constraints are built as follows: The aim of the master problem is to minimize the design objective function while making the compatibility function of each subproblem zero.The variables in master problem are composed of global variables, copies of local variables, and copies of coupling variables that explicitly affect the design objective function.
level variables and the values obtained by optimizing the subproblem while satisfying the local constraints.The variables in each subproblem consist of local variables and copies of global variables.Any nonlocal coupling variables needed by the discipline analysis are passed from the master problem and kept constant throughout the entire subproblem optimization.
ŷT  ] T and ŷ is the copy of y  , and  *  is obtained by solving the following optimization subproblem of discipline design variable: p , x  constraints: c  (p  , x  , y  ) ≤ 0 residual: R  (p  , x  , y  , ŷ ̸ =