Structural and Multidisciplinary Optimization (2018) 57:83–94

https://doi.org/10.1007/s00158-017-1872-4

RESEARCH PAPER

Multiobjective optimization of modular design concepts

for a collection of interacting systems
Alparslan Emrah Bayrak1 · Arianne X. Collopy2 · Panos Y. Papalambros1 · Bogdan I. Epureanu1

Received: 12 July 2017 / Revised: 24 October 2017 / Accepted: 17 November 2017 / Published online: 2 December 2017
© Springer-Verlag GmbH Germany, part of Springer Nature 2017

Abstract
A collection of interacting systems, such as a fleet of military vehicles, can have a life-cycle benefit from sharing
interoperable modules. Defining the modules that maximize such benefits must be addressed at the early stages of
system design. We present a multi-objective optimization framework for conceptual modular design. We use a functional
representation of the supersystem, i.e., the interacting systems collection, to make module design decisions informed by
supersystem requirements and life-cycle objectives. The resultant modules are configured into a variety of architectures and
form a set of systems with distinct capabilities that meet supersystem requirements. We apply this approach on a fleet of
military vehicles. Computational results quantify the intuition that designing a large number of smaller modules reduces
overall fleet weight and increases required personnel resources because of larger demand for vehicle reconfiguration.

Keywords Modularity · Functional synthesis · Design concept development · Decomposition-based design · System
partitioning · Multi-objective optimization

1 Introduction Gu and Sosale 1999; Dahmus et al. 2001; Gershenson et al.

Modularity is a design approach that provides benefits throu-
ghout a system’s life cycle including design, manufacturing,
operation, and retirement; modularity enables decoupling of
design work, improving system integration, manufacturing
process parallelization, lower-cost product variety, and
adaptable product architectures for changing and uncertain
environments (Baldwin and Clark 2000; Jain et al. 2008;
This work was supported in part by the US TARDEC Automotive
Research Center at the University of Michigan thanks to the
Vehicle Agnostic Modularity program at the Office of Naval
Research. An earlier version of this article was presented
at WCSMO-12 held in Braunschweig, Germany 2017.
See Bayrak et al. 2017.
 Alparslan Emrah Bayrak
bayrak@umich.edu
1 Mechanical Engineering, University of Michigan, 500 S State
St, Ann Arbor, MI 48109, USA
2 Integrative Systems + Design, University of Michigan, 500 S
State St, Ann Arbor, MI 48109, USA
2004; Dasch and Gorsich 2016). Modularity principles have
been used for the design of single products and systems
(Gu and Sosale 1999; Huang and Kusiak 1998), families of
products (Jiao et al. 2007; Simpson et al. 2014), and sets
of interacting systems working to achieve a common goal
such as distributed systems, federated systems, or systems
of systems (D’Souza et al. 2016; Heydari and Dalili 2015;
Brown and Eremenko 2006).
Modularity requires the ability to partition a system into
separable, decomposable elements with standardized inter-
faces (Huang and Kusiak 1998; Parnas 1972; Ulrich and
Eppinger 2004). Decomposition-based design optimization
strategies are top-down approaches that proceed from
partitioning the system into elements to coordination of
those elements to achieve overall system functionality and
objectives (Wagner and Papalambros 1993; Krishnamachari
and Papalambros 1997). Bottom-up design synthesis
methods for new concept generation combine elements
from a library to create a system that satisfies functional
requirements (Ulrich and Eppinger 2004; Otto and Wood
2001; Chakrabarti and Bligh 1996).
84
Identifying the right modules is a key early decision
in conceptual design of interacting systems that can share
interoperable modules throughout their life cycles. In this
paper we approach this decision problem by first making
partitioning decisions to identify an appropriate set of
functional system elements, then using a synthesis strategy
to combine these elements into complete modular design
concepts.
1.1 Modular design approaches
A system can be represented as a collection of functions that
depend on the design variables and are embodied in a set
of elements. A functional dependency table (FDT) (Wagner
and Papalambros 1993) represents the dependence of
functions on variables and a design structure matrix (DSM)
(Steward 1981) represents the dependence of functions
on each other (Steward 1981; Eppinger et al. 1994; Sosa
et al. 2003; Browning 2016). A matrix representation of a
system has an equivalent graph or network representation,
where system elements are vertices and dependencies are
edges (Newman 2006).
Defining modules requires some system partitioning, for
example to reduce couplings, i.e., functional and physical
interdependencies between modules, by gathering highly
interdependent functions or components within the modules
(Baldwin and Clark 2000; Parnas 1972; Steward 1981).
Such approaches differ in their treatment of dependencies.
Matrix manipulations can be used to rearrange rows and
columns to group elements within a DSM based on their
connectivity (Steward 1981; Eppinger et al. 1994; Browning
2016). Highly connected functions or components may be
separated as integrative linking elements through design
rules (Baldwin and Clark 2000). Clustering algorithms
can be used to group functions or components based on
functional similarity, alluding to embodiment or shared
life-cycle objectives (Gu and Sosale 1999; Erixon 1998;
Borjesson and Hölttä-Otto 2013).
Modular design tends to take place at the system embo-
diment design phase rather than at the conceptual design.
Since the mapping between a functional representation of a
design and its embodiment is unlikely to be unique, defining
modules at the functional level may offer more opportunities
for innovation. At the same time, such modules may have no
physical embodiment at least within our current technology
or imagination.
1.2 Modularity for interacting systems
A collection of systems is characterized differently based
on how those systems interact. For example, a system
of systems is typically described as a set of systems
A. E. Bayrak et al.
that work to achieve a common goal by interacting at
several stages of their life cycle but without central
oversight (Maier 1998). Fractionated systems may be
centrally controlled during their operation, but similarly
require the interaction of multiple systems to achieve
collective functionality (Brown and Eremenko 2006).
Modularity for physical systems (Lafleur and Saleh 2009)
and software systems (Incremona et al. 2015) has been
studied for various applications of interacting systems.
Approaches have been developed to quantify the costs
and benefits of modularity targeting particular applications
(D’Souza et al. 2016; Lafleur and Saleh 2009; Bayrak et al.
2016b; Mosleh et al. 2016).
A product family is a type of interacting system where
interaction occurs only at the design and manufacturing
stages. Modularity is used in the product family design
(PFD) to meet a variety of product requirements while
keeping manufacturing time and cost low (Jiao et al.
2007). The key problem in PFD is to identify the set of
common elements that can be shared across the product
family and the set of elements that can differentiate
the products to satisfy diverse product requirements.
Common elements form a platform shared by multiple
products onto which unique modules are added for product
differentiation (Simpson 2004), or modules with specific
functionality are shared among different products as needed.
Product architecture design and product variety design
are two distinct aspects of modular PFD. Architecture
is determined by the boundaries between functions or
components to identify modules and platforms. Variety
is achieved by different configuration of modules into
products with distinct functionalities or by using different
instantiations of a module to obtain products with distinct
capabilities (Fujita 2002).
Decisions for product architecture and variety design
are linked but making them together is challenging (Fujita
2002). PFD studies typically base design decisions on
marketing (e.g., profit and performance) and manufacturing
objectives (e.g., cost and lead-time) (Jiao et al. 2007).
Sequential design optimization approaches make design
decisions on the product architecture first, and then
design individual products within the family based on
a common architecture (Fujita 2002; Fellini et al. 2006;
Gonzalez-Zugasti et al. 2000; Ferguson et al. 2009).
Decomposition-based design optimization approaches
partition the problem into two subproblems, product
architecture and product variety, and then coordinate these
subproblems iteratively until convergence (Khajavirad et al.
2008; Fujita and Yoshida 2004; de Weck et al. 2003; Pate
et al. 2012). A common assumption in these studies is that
the number of products in a family is given at the outset.
This assumption stems from a given market segmentation
Multiobjective optimization of modular design concepts
where a dedicated product is assigned to each segment.
Another typical assumption is to impose a common
architecture across the product family, as it simplifies the
design and manufacturing processes.
In this paper we extend the PFD modularity concept
motivated by manufacturing and marketing to the more
general problem of how to modularize a collection of
interacting systems. This problem starts with a set of
requirements to be met collectively, and the number
of systems needed to satisfy these requirements is not
necessarily known a priori. Furthermore, the impact of
modularity on the supersystem design and its life-cycle
operation must be addressed. A general quantitative
approach to address these issues is the main contribution of
the work presented here.
We employ a bottom-up approach to the combined
architecture and variety problem. This approach starts with
partitioning the functional requirements for the supersystem
in order to define a design space representing all possible
module designs. The design decisions for the modules that
form individual systems are made without prior assumptions
on the number of systems to be designed or on a common
architecture across all systems.
An earlier study examined supersystem-level per-
formance trade-offs with changing module designs
without a formal methodology to select modular concept
designs (Bayrak et al. 2016a). We build on this previous
work to extend and formalize the optimal module design
process combining architecture and variety decisions.
We propose a multi-objective optimization formulation
comprising three nested optimization subproblems to
determine the supersystem functions and variables that
define modules, the number of variants needed for
each module definition, and the variant definitions for
each, respectively, based on supersystem-level life-cycle
performance measures. The proposed formulation can be
classified as multidisciplinary feasible (MDF) (Cramer
et al. 1994) implemented for modular design of interacting
systems. As noted by Martins and Lambe (2013), MDF is a
fitting approach for this problem due to its variable number
of design decisions. The problem formulation is discussed
further in Section 3 and then applied to the design of a
modular plug-and-play vehicle fleet where modules can be
readily shared between systems during operation (Bayrak
et al. 2016b).
The proposed approach is suitable for modular concept
generation at the early design stages. Design decisions
are made with respect to a set of life-cycle performance
objectives, which we illustrate with operational
performance objectives in the vehicle fleet application.
Performance is determined based on a predefined operation
management (control) strategy. A separate problem could
85
be formulated to optimize the operation strategy of the
supersystem accounting for the coupling between design
and management problem, but this problem is not addressed
in the present study.
In the remainder, Section 2 describes partitioning the
supersystem requirements and generation of different
modular concept alternatives. Section 3 formulates the
design optimization problem to select modular concepts.
The vehicle fleet application is described in Section 4.
Results for the application and conclusions are presented in
Sections 5 and 6.
2 Concept generation
We discuss a function-based approach to generate modular
concepts that maximize a system-level performance. When
multiple systems interact with each other, we define a
supersystem containing all interacting systems and apply the
concept generation approach to this supersystem. We use
functions and associated variables to represent modules in
a supersystem abstractly and avoid the need for a mapping
between supersystem functions and embodied elements.
Following the approach presented by Bayrak et al.
(2016a), we define modules by two properties: type and
variant. Module type is a qualitative description that
defines the group of functions and variables constituting
a module. For example, a module type can be defined
by a communication function and a variable determining
the range of communication. Variants are different
instantiations of a module type distinguished by the values
assigned to the variables in that module type. While
the design of module types determines the range of
possible system architectures that can be formed using these
modules, the design of module variants determines the
distinct capabilities of these systems, i.e., system variety.
Based on these definitions, the overall problem is to find
the optimal set of module types and variants to maximize a
supersystem-level objective. We represent the supersystem
by an FDT that identifies the dependency of the supersystem
functions to the variables. We assume that the objective is
obtained by the performance of the supersystem under a
predefined set of tasks.
2.1 Module type assignment
Creating module types from a supersystem represented by
an FDT corresponds to grouping functions and variables
based on some criteria. When multiple functions depend on
the same variable, we may group these functions together.
We partition a given FDT into connected subgraphs such
that each subgraph is formed by functions that have at least
86
one common variable (Wagner and Papalambros 1993). We
can use several algorithms including breadth-first search
and depth-first search to perform this partitioning (Hopcroft
and Tarjan 1973; Reghbati and Corneil 1978). In this paper
we use the conncomp function in MATLAB which is based
on depth-first search (Mathworks 2016a). Figure 1a–c show
an example in which six functions and five variables are
partitioned into three subgraphs. In this example, functions
f1 , f2 and f5 are grouped together since they have variables
v1 and v3 in common. If a function does not have any
common variable with other functions, a subgraph with only
one function is formed such as f6 . We refer to each of these
subgraphs as submodules, i.e., building blocks for module
type definition based on evaluation of system performance.
We can further group these submodules into modules
by assigning links between them. Formally, we define a
symmetric submodule adjacency matrix L whose element
Lij is 1 when there is a link between submodules i
and j , and 0 otherwise. Figure 1d–e depict an example
of this link assignment procedure. In this figure, the
three submodules formed in Fig. 1c, i.e., SM1 , SM2 , and
SM3 , are grouped into two module types by assigning
a link between SM2 and SM3 . The link assignment
among submodules is a design decision that is made
based on the supersystem performance. Note that the
binary representation of design alternatives based on an
adjacency matrix can create multiple identical designs. For
example, for three submodules given in Fig. 1c, x =
[L12 , L13 , L23 ] = [1, 0, 1] (i.e., linking SM1 to SM2 , and
SM2 to SM3 ) and x = [1, 1, 1] (i.e., linking SM1 to SM2 ,
SM2 to SM3 , and SM1 to SM3 ) correspond to the same
module type assignment since both cases produce a module
type that contains all three submodules. In this example,
linking SM1 and SM3 directly is redundant since they are
already linked through SM2 . If the number of submodules
obtained from an FDT is nSM , then the number of possible
module type assignments is 2p where p = (n2SM −
nSM )/2 in this representation. However, the number of
unique module type assignments is given by the Bell num-
ber corresponding to the number of submodules (Rota 1964).
Fig. 1 Example FDT partitioning and link assignment to create modules
A. E. Bayrak et al.
It is possible to have an FDT that cannot be partitioned
into multiple disjoint subgraphs, i.e., the FDT forms a single
subgraph. There are several ways to form disjoint partitions
in that case. One way is to exclude a group of variables
(and/or functions) from partitioning (Krishnamachari and
Papalambros 1997) and can be made available to all
modules in the system as in bus modularity (Salvador et al.
2002). Another way is to duplicate some of the shared
variables (and/or functions) and treat them as separate
variables (functions) during partitioning. This is analogous
to the practice of code cloning in software systems (Kapser
2009), where different modules have their own dedicated
copy of a system functionality. An example in vehicle
systems is of multiple functionalities that require auxiliary
power. This process of cloning would create multiple
modules each with dedicated auxiliary power, in contrast
to a single module grouping all functionalities that rely on
auxiliary power together. An extension of this approach
could completely ignore variable dependencies and treat all
functions as building blocks, i.e. submodules, on their own,
each with a dedicated set of variables. In the rest of this
paper we assume, without loss of generality, the FDT allows
partitioning into multiple disjoint subgraphs.
2.2 Module variant assignment
Module variants can be created by assigning different
values to the variables defined by a particular module type.
When designing modular systems that interact throughout
their lifecycle, the number of variants needed for each
module type to maximize the supersystem performance is
not usually known a priori. We assume that the number
of variants per module type is a design decision while
the total number of variants for all module types is
bounded from above due to various considerations including
manufacturing cost and time, inventory management, and
maintenance.
Given a number of variants for each module type
definition, the variable values are assigned based on
supersystem performance evaluation. Figure 2 shows the
Multiobjective optimization of modular design concepts
Fig. 2 Example variant
assignment for given module
definitions
variant assignment process for the two module types created
in Fig. 1. The number of variants per module types y1 and
y2 are assigned first, considering the maximum number of
variants allowed ymax . Next, 3y1 variable values for the first
module type and 2y2 variable values for the second module
type are assigned to create y1 + y2 module variants in total.
Both module type assignment and variant assignment
might be subject to a set of design constraints that can
be defined at the module level. For instance, certain
functions can be constrained to be in separate modules
in module type assignment. Another possibility is that the
variable values to specify variants for a given module type
may be subject to supersystem-level design requirements
formulated as a function of those variables. Such constraints
can be included in the concept generation process to
eliminate designs that would be considered infeasible
during operation. Section 3 discusses a design optimization
formulation without such constraints, which we refer to as
the basic form. It is also possible to have design constraints
that can be evaluated only at the supersystem level. For
example, a feasibility constraint on certain combination of
modules cannot be imposed at the concept generation stage.
In that case, these constraints can be augmented to the
supersystem performance as penalty functions to prevent
designs violating these constraints from being selected in a
design process.
3 Design optimization
Module type and variant design are coupled problems that
must be solved together to achieve an optimal supersystem
design. However, a simultaneous design formulation is
difficult because the number of design variables in this
problem representation is not constant. Design decisions on
the module types impact the number of design variables
used to represent the variant design problem. Also, design
decisions on the number of variants for each module type
change the number of variables for each module type in
the variant design problem. We propose a nested design
formulation with three levels: 1) an outer-level problem to
87
design module types, 2) a middle-level problem to design
the number of variants for each given module type, and 3) an
inner-level problem to design variants, i.e. assign variable
values for each variant of a given module type. Section 3.1
describes the outer-level problem and Section 3.2 describes
the middle and inner-level optimization problems.
3.1 Module types
At the outer-level, we formulate the problem of designing
module types by grouping submodules together to
maximize a set of supersystem-level performance functions.
For generality, we assume that the design problem has N
objective functions, denoted by z1 , z2 , . . . , zN . Following
the submodule representation described in Section 2.1, this
optimization problem can be formulated using a vector
of binary design variables x corresponding to the upper
(or lower) triangular elements in the submodule adjacency
matrix L. In the basic form, the optimization problem is
written as
min {z1 , z2 , . . . zN }
with respect to x = {Lij | 1 ≤ i < j ≤ nSM }
subject to x is binary, (1)
where nSM is the number of submodules obtained from
the supersystem FDT. This basic form can be extended
by adding problem-specific constraints that apply to
the module type design as discussed in Section 2.2.
Evaluation of the objective functions requires information
from the module variant design problem, i.e., the
solution of middle and inner-level problems. A nested
optimization formulation ensures that each design candidate
corresponding to a set of module types is evaluated with its
best instantiation.
3.2 Module variants
Middle and inner-levels describe the module variant design
problem for a given set of module types. We assume that
these two levels are defined as single-objective optimization
problems with the same objective function zm . In general,
88 A. E. Bayrak et al.

these problems can have multiple objectives, but a nested
optimization formulation requires a single solution to be
passed to the outer-level. In such a case, we assume
that a single objective function can be created by either
linearly weighting multiple objectives or selecting one of
the objectives and defining the rest as constraints.
In the middle level, we formulate the design of the
number of variants for each module type. Let nM be
the number of module types corresponding to the design
candidate x̄ coming from the outer-level problem. The
middle level problem in the basic form can be formulated as
min zm
with respect to y = {yi | 1 ≤ i ≤ nM }
subject to 1T y ≤ ymax
y is integer. (2)
In the most general case, the objective function is a
nonlinear function, and the size of this problem depends
on the dimension of the design candidate x̄. Evaluation of
each design candidate requires the solution of the inner-level
problem in which the variable values are designed for each
variant.
Let nV be the number of variables defined in the
supersystem FDT. For given x̄ and a design candidate ȳ, the
problem of variant design becomes
obtained through simulation of fleet operations. Figure 3
shows an overview of the modular fleet design problem
with three nested optimization problems following the
process described in Section 3. The objective of the middle-
and inner-level optimization problems is to minimize the
expected total convoy weight, an estimate that can be
calculated without running the entire fleet simulation.
Since the overall computational cost is a major concern
in nested optimization problems, it is important to keep
the computation time required to solve the middle and
inner-levels low. The outer-level optimization minimizes
both fleet weight and personnel time obtained from a fleet
simulation model.
A specific fleet definition depends on the input, i.e.,
an input FDT indicating fleet functions and corresponding
variables. We classify the functions in the FDT as essential
or nonessential. Essential functions are required to exist
in all vehicles in the fleet, such as providing motive
power or ability to steer. Nonessential functions, such as
containing offensive devices or ability to communicate
with the base, are not required to be available in all
vehicles. We illustrate our module design methodology
using the same fleet definition as described in Bayrak
et al. (2016a). This past work demonstrated a tradeoff
between two fleet measures, total fleet weight to perform

min zm
with respect to v = {vk | 1 ≤ k ≤ nV }
where vk = {akt | 1 ≤ t ≤ yi }
subject to vkmin ≤ vk ≤ vkmax ∀k ∈ {1, . . . nV }, (3)

where yi is the number of variants for the module type

that contains the variable vk , vkmin and vkmax are the lower
and upper bounds for the variable vector vk , respectively.
Depending on the application, some of the variables in v
may be discrete.
We discuss the solution of these problems in Section 5
for the particular application described in Section 4.

4 Application to modular vehicle fleet design

We demonstrate the application of the proposed design

approach to a modular vehicle fleet required to perform a
set of convoy operations over time. A generic fleet consists
of a finite number of convoys formed by vehicles that are
assembled from modules. Thus a convoy is a collection
of vehicles that carry out a mission; a fleet is defined
as the set of all convoys. Convoys may share vehicles
or modules depending on functions needed to carry out
a mission. The design approach presented here addresses Fig. 3 Overview of the modular fleet design with three nested
module definition by minimization of fleet-level measures optimization problems
Multiobjective optimization of modular design concepts
all required operations, and total personnel time spent
for vehicle assembly, maintenance, and repair operations.
This analysis indicates that minimizing fleet weight favors
a higher degree of modularity, i.e., a larger number
of modules, while minimizing personnel time favors a
lower degree of modularity, the extreme case of which
is a single module being equivalent to a vehicle. The
focus of the following discussion is to build on previous
demonstration of the tradeoff between the two selected fleet
performance measures, total fleet weight for all required
convoy operations, and total personnel time for vehicle
assembly, maintenance, and repair operations.
Each convoy in the fleet is defined by its operation
frequency, its operation duration, and its set of requirements
determined by variable values in the FDT. There are
two types of convoy requirements used in the current
study: 1) requirements to be satisfied by all vehicles
such as engine power, terrain capability, and armor
level, and 2) operation-specific requirements, such as
communication range, cargo volume, and lethality power.
Convoy definitions determine the frequency of specific
functionalities during operation as well as any constraints on
specific module variant decisions. In this study, we define
ten sets of convoy requirements.
Vehicles are assembled from a set of modules, giving
some functional capability, and are mapped to convoys
based on these convoy requirements.
Recall that module types determine the possible modular
vehicle architectures and variable values assigned to module
variants determine the capabilities of these vehicles. If there
are
nMnM nMdifferent
 module types, it is possible to create
k=1 k = 2 nM − 1 different vehicle architectures
by considering all possible modular combinations. Among
these combinations, we define the architectures that
contain all essential functions as feasible architectures
and remove the infeasible architectures from consideration
when forming convoys. If there are nM module types
that contain at least one of the essential functions,
then the number of feasible architectures we create for
analysis reduces to 2(nM −nM +1) − 1. For a given set of
module variants, we identify the set of vehicles from all
possible vehicle designs that satisfy the convoy operation
requirements with minimum convoy weight. We assume
that there is a monotonic relationship between module
variable values and module weight, and use a simple linear
relationship to estimate the weight. We estimate the linear
coefficients used to calculate the weight of modules based
on known weights of existing vehicle parts corresponding to
similar functionality. Therefore, we can estimate the convoy
weight as the sum of the weights of all modules used in the
convoy. The objectives of the middle and inner-level design
problems are evaluated by calculating the expected value of
the sum of convoy weights. Since convoy definitions include
89
the frequency of each convoy operation, this calculation can
be done without simulating the entire fleet operation over
time.
We evaluate the design candidates for modular concepts
based on total fleet weight denoted by w F LT and total
personnel time denoted by t P RS obtained from a fleet
simulation model. We use a time-marching simulation
model that operates the fleet over a period of time
by performing convoy operations, vehicle assembly,
maintenance, and repair operations, based on the study
presented in Bayrak et al. (2016a). The personnel
time is calculated based on time required for vehicle
reconfiguration and module maintenance. These values
depend on the number of modules assembled into vehicles
and the frequency of their use in convoy operations.
Modules are assumed to require maintenance after a fixed
period of usage. As a result of the fleet operation over
a given time period, we calculate w F LT by using the
history of inventory levels and t P RS using the history of
maintenance, repair and assembly operations to evaluate
design candidates for the outer-level problem.
5 Results and discussion
We now discuss the design optimization results. We
partition the FDT provided in Table 1 based on the variable
dependencies in Tables 2 and 3 (Bayrak et al. 2016a)
using the graph partitioning method conncomp available
in MATLAB (Mathworks 2016a). This partitioning gives
nSM = 12 submodules as shown in Table 4. Underlined
functions in the table are the essential functions that every
vehicle must contain. Underlined submodules, i.e., essential
submodules, contain at least one essential function. The
partitioned FDT whose rows and columns are re-arranged
based on these submodules is shown in Table 5. Using
these submodules, the size of the design variable vector
x that represents module types becomes p = 66. The
number of unique module types that can be created, i.e.,
12th Bell number, is B12 ≈ 4.2million. For the variant
optimization, the upper bound for the total number of
module variants is ymax = 28, and the lower and upper
bounds for the values of the variables in the FDT are
shown in Table 2. The outer-level bi-objective binary
optimization problem that designs the module types can be
solved using a multi-objective genetic algorithm (Marler
and Arora 2004). We use the implementation of an elitist
Non-dominated Sorting Genetic Algorithm-II (NSGA-II)
(Deb et al. 2002) available in MATLAB (Mathworks 2016).
We use a randomly generated initial population of size
200 and perform the optimization for 15 generations. We
experimentally find the number of generations to achieve
convergence. In this particular case study, we observe that
90 A. E. Bayrak et al.

Table 1 Functional
dependency table for a vehicle
fleet

Table 2 List of Variables and Bounds

No. Variable (Bounds), unit No. Variable (Bounds), unit No. Variable (Bounds), unit

1 Suspension rating (9,11) 9 Highest gear ratio (4,6.9) 17 Dump volume (5,10), cu-yd
2 Brake type (1,2), type 10 Lowest gear ratio (0.65,0.8) 18 Number of driver seats (2,3)
3 Wheel height (1.18,1.35), m 11 Steering ratio (12,20) 19 Number of troop seats (4,10)
4 Wheel width (0.39,0.41), m 12 Number of batteries (1,2), pairs 20 Body armor level (1,3)
5 Number of axles (2,4), number 13 APU power (55,300), kW 21 Underbody armor level (1,3)
6 Engine power (200,600), hp 14 Antenna range (1,2), level 22 Patient capacity (2,4), people
7 Fuel tank capacity (50,150), gal 15 Liquid tank volume (1000,2500), gal 23 Weapon caliber level (1,3)
8 Final drive ratio (5.4,7.8) 16 Dry cargo volume (1150,2300), cu-ft

Table 3 List of Functions

No. Function (Requirement) No. Function (Requirement) No. Function (Requirement)

1 Traverse terrain (E) 9 Steering (E) 17 Protect against IED damage (E)
2 Provide motive power (E) 10 Contain driver (E) 18 Protect against ballistic damage (E)
3 Stop vehicle (E) 11 Contain co-driver (E) 19 Contain lethality devices (NE)
4 Provide high speed (E) 12 Provide comfortable ride (E) 20 Contain lethality operator (NE)
5 Contain liquid (NE) 13 Provide electrical power (E) 21 Contain aid kits (NE)
6 Contain dry cargo (NE) 14 Store electrical energy (E) 22 Contain aid personnel (NE)
7 Contain dump (NE) 15 Communicate with vehicles (E)
8 Contain personnel (NE) 16 Communicate with base (NE)
Multiobjective optimization of modular design concepts 91

Table 4 List of Submodules Since f (y) is a non-increasing (weakly decreasing) and

bounded function, ∃y∗ that is the solution of the relaxed
Submodules Functions Variables
problem
1 {f1 , f2 , f4 , f12 } {v1 , v3 , v4 , v5 , v6 , v7 , v8 , v9 , v10 } min f (y)
2 {f3 } {v2 } y

3 {f5 } {v15 } subject to ylb ≤ y ≤ yub

4 {f6 } {v16 } y is discrete. (5)
5 {f7 } {v17 }
The search for solutions to the problem in (4) starts
6 {f8 , f19 , f20 } {v19 , v23 }
from the point y∗ , the unconstrained minimum. Define the
7 {f9 , f10 , f11 } {v11 , v18 }
following linearization around the point yk in iteration k
8 {f13 , f14 } {v12 , v13 }
with respect to the discrete variables
9 {f15 , f16 } {v14 }
10 {f17 } {v21 } f (yk ) ≈ (g(yk ))T y, (6)
11 {f18 } {v20 } with
12 {f21 , f22 } {v22 }
gi (yk ) = f (yk ) − f (yk − ei ),
g(yk ) = [g1 (yk ), g2 (yk ), ...gn (yk )]T , (7)

increasing the number of generations above 15 does not where ei is the unit vector in i th
dimension. Then, the
improve the results. optimization problem defined in (4) is solved as follows
We solve the middle-level integer nonlinear optimization (i) Start from yk = y∗ for k = 0.
problem that designs the number of variants for each module (ii) Check if cT yk ≤ b is satisfied. Stop if true. Continue
type using the custom algorithm below. to (iii) if false.
(iii) Solve the following optimization problem
Module Variant Optimization Algorithm The discrete opti- min f (yk )
mization problem is stated as, y
subject to ylb ≤ yk + y ≤ yub
min f (y)
y y ∈ {−e1 , ... − en }. (8)
subject to cT y ≤ b (iv) Set yk+1 = yk + y∗ where y∗ is the solution to the
ylb ≤ y ≤ yub problem given in (8).
y is discrete, (4) (v) Go to (ii).

where f (y) is a nonlinear function, bounded from below
and known to be weakly decreasing with y, c is a vector of
linear coefficients, and b is a scalar.
Table 5 Partitioning for the FDT given in Table 1
Note that the solution to the problem (8) is trivial. y∗ =
{−ei | i = argmax{gj (yk )} ∀j, ylb ≤ yk − ej ≤ yub }
satisfies the bound constraints.
The algorithm above is based on linearization because
the objective function is non-increasing (weakly monotonic)
with respect to all design variables. Increasing the number
of module variants decreases the fleet weight until there
are enough variants available to dedicate a unique module
variant for each convoy requirement. Adding additional
module variants does not increase the fleet weight
since these additional variants will not be used in the
convoy creation process. Further, we can calculate the
unconstrained minimum by dedicating a module variant
for each convoy requirement. The search starts from the
unconstrained minimum and moves towards the direction
that leads to the least increase in the objective function
value. The search continues until the constraint on the
total number of module variants, ymax , is satisfied. We
can guarantee convergence if the algorithm starts from
the unconstrained minimum because every iteration moves
in the direction of a feasible solution, and the algorithm
92
Fig. 4 Pareto optimal designs
terminates when a feasible solution is found. However,
we do not have a proof showing that the solution found
is optimal. The same algorithm can be used for any
monotonic objective function. If the objective function is not
monotonic with respect to the number of module variants,
this algorithm must be replaced by mixed-integer nonlinear
solvers for which there is no guarantee of convergence.
At the inner-level, we design the variable values with a
mixed-integer nonlinear optimization problem. Even though
we model the module weights as a linear function of
variable values, the mapping between convoys and vehicles
makes the fleet weight a discontinuous function. Recall that
this mapping selects the vehicle combinations that satisfy
the convoy requirements with minimum weight. We solve
this problem in two steps: 1) We find the module variable
values that satisfies the corresponding convoy requirements
with minimum module weight using a mixed-integer linear
programming problem. For example, assume that three
convoys with equal operation frequencies require liquid
Fig. 5 Mapping between Pareto optimal designs and submodules
A. E. Bayrak et al.
capacities, i.e., v15 , of 1,000 gal, 2,000 gal, and 2,500
gal, and the module type containing that variable has
two variants determined by the middle level problem.
The optimal solution for that variable based on weight
minimization becomes v15∗ = [1, 000 gal, 2, 500 gal]T
for these two variants to satisfy all convoy requirements.
2) After finding the variable values, we create all
feasible vehicle architectures and solve an integer linear
optimization problem to map the vehicles to convoys with
minimum fleet weight. We solve both of these problems
with the existing mixed-integer linear optimization solver
intlinprog in MATLAB which uses the branch-and-bound
method (Mathworks 2016b). Figure 4 shows 10 Pareto
optimal designs for the overall optimization problem and
Fig. 5 shows a more detailed description of these designs.
It takes approximately one hour to obtain these results with
the solver parameters we use (population size of 200 for
15 generations) using parallel processing for NSGA-II on
a computer with Intel Xeon E5-2620V2 12-core processor
and 128GB of RAM. In Fig. 5, MID refers to the identifier
assigned to module types, consistent with the labels in
Fig. 4. y is the number of module variants for each module
type.
The designs x1 , . . . , x10 correspond to different degrees
of modularity, i.e., they have different number of modules.
At one extreme, x1 corresponds to a set of modules each of
which contains all functionality of a fleet with 10 variants.
In this case, a vehicle is made of a single module and each
convoy includes its dedicated vehicle variant. In reality,
such a design is not practical, but in this study we imposed
no constraint to eliminate such designs in the concept
generation process. At the other extreme, x10 has a module
type that groups seven submodules while the rest of the
submodules are defined as modules on their own. These
stand-alone submodules correspond to liquid cargo capacity
functionality, dump cargo capacity, dry cargo capacity,
lethality functions, and ambulance functions. These are all
nonessential submodules that are not required to exist in
Multiobjective optimization of modular design concepts
all vehicles. In this design, MID = 1 can be considered
as a core vehicle module with 9 variants where two out
of ten convoys share one variant, and MID ∈ {2, . . . , 6}
are mission-specific modules assembled to these platforms
only when needed. Note that the constraint on the maximum
number of module variants given in (2) is not active for these
optimal designs. Reducing the value of ymax is expected to
increase module sharing across vehicle convoys.
There is a general trend for decreasing fleet weight
and increasing personnel time as the degree of modularity
increases, see Fig. 4, consistent with expectations.
As functions are more spread across several modules,
redundancy in each convoy reduces and modules are
shared among multiple convoys. Therefore, the fleet
weight decreases. However, sharing modules among
convoys requires vehicle reconfiguration which increases
personnel time. These results show that we can generate
Pareto-optimal modular concepts, but further consideration
of physical constraints is required to select among the
nondominated solutions.
6 Conclusions and future work
We presented a multi-objective optimization framework to
generate modular concepts for a collection of interacting
systems combining architecture and variety design. We
used supersystem functions and variables to represent
the problem without limiting the concept generation
process by a predefined mapping between functionality and
embodiment. The framework has three nested problems
corresponding to the design of module types, number of
variants for each module type, and variable values for each
module variant, respectively. We made no assumptions on
common system architecture or fixed number of systems to
begin with. Results for an application to modular vehicle
fleet to minimize total fleet weight and personnel time
showed that we can generate modular solutions quantifying
trade-offs with respect to varying degrees of modularity.
However, physical realization of these modules remains a
follow-up task.
We considered only variable dependencies among
supersystem functions. We still need to account for required
interfaces among functions spread across several modules,
as well as emergent functions that can be created as a
combination of other functions. We did not address the
coupling between physical system design and management
strategy and left it to a future study. Introducing other
optimization objectives that capture key benefits attributed
to modularity, such as system resilience, system evolution
and capacity for future upgrades, may provide additional
insights. Obvious applications besides ground vehicles
include systems of spacecraft, drones, or ships. An
93
application such as design of reconfigurable manufacturing
systems exhibits a sequencing of required tasks that is
not considered in the present paper. Finally, including the
human constituents during system operation will likely
impact modularity decisions for practical implementations.
References
Baldwin C, Clark KB (2000) design rules: the power of modularity,
vol 1. MIT Press, Cambridge
Bayrak AE, Collopy AX, Epureanu BI, Papalambros PY (2016a) A
computational concept generation method for a modular vehicle
fleet design. In: Proceedings IEEE systems conference. IEEE,
Orlando, pp 1–8
Bayrak AE, Collopy AX, Epureanu BI, Papalambros PY (2017)
Modular design concept generation for a collection of interacting
systems with application to modular vehicle fleet design. In:
Presented at the world congress on structural and multidisciplinary
optimization, Braunschweig
Bayrak AE, Egilmez MM, Kaung H, Xingyu L, Park JM, Umpfenbach
E, Anderson E, Gorsich D, Hu J, Papalambros P, Epureanu B
(2016b) A system of systems approach to the strategic feasibility
of modular vehicle fleets. IEEE Transactions on Systems Man and
Cybernetics. to be published
Borjesson F, Hölttä-Otto K (2013) A module generation algorithm for
product architecture based on component interactions and strategic
drivers. Res Eng Des 25(1):31–51
Brown O, Eremenko P (2006) The value proposition for fractionated
space architectures. In: Space 2006. AIAA, San Jose
Browning TR (2016) Design structure matrix extensions and
innovations: a survey and new opportunities. IEEE Trans Eng
Manag 63(1):27–52
Chakrabarti A, Bligh TP (1996) An approach to functional
synthesis of mechanical design concepts: theory, applications,
and emerging research issues. Art Intell Eng Design Anal Manuf
10(04):313–331
Cramer EJ, Dennis Jr JE, Frank PD, Lewis RM, Shubin GR (1994)
Problem formulation for multidisciplinary optimization. SIAM J
Optim 4(4):754–776
Dahmus JB, Gonzalez-Zugasti JP, Otto KN (2001) Modular product
architecture. Des Stud 22(5):409–424
Dasch J, Gorsich DJ (2016) Survey of modular military vehicles:
Benefits and burdens. Defense Acquisition Research Journal
23(1):2–27
de Weck OL, Suh ES, Chang D (2003) Product family and platform
portfolio optimization. In: Proceedings international design
engineering technical conferences and computers and information
in engineering conference. ASME, Chicago, pp 175–185
Deb K, Pratap A, Agarwal S, Meyarivan T (2002) A fast and
elitist multiobjective genetic algorithm: Nsga-ii. IEEE Trans Evol
Comput 6(2):182–197
D’Souza K, Bayrak AE, Kang N, Wang H, Altin B, Barton K, Hu
J, Papalambros P, Epureanu B, Gerth R (2016) An integrated
design approach for evaluating the effectiveness and cost of a
conventional and modular fleet. Defense Journal on Modeling and
Simulation 13(4):381–397
Eppinger SD, Whitney DE, Smith RP, Gebala DA (1994) A
model-based method for organizing tasks in product development.
Res Eng Des 6(1):1–13
Erixon G (1998) Modular function deployment - a method for product
modularisation. PhD thesis, The Royal Institute of Technology,
Stockholm
94
Fellini R, Kokkolaras M, Papalambros PY (2006) Quantitative
platform selection in optimal design of product families, with
application to automotive engine design. J Eng Des 17(5):429–446
Ferguson S, Kasprzak E, Lewis K (2009) Designing a family of
reconfigurable vehicles using multilevel multidisciplinary design
optimization. Struct Multidiscip Optim 39(2):171–186
Fujita K (2002) Product variety optimization under modular
architecture. Comput Aided Des 34(12):953–965
Fujita K, Yoshida H (2004) Product variety optimization
simultaneously designing module combination and module
attributes. Concurr Eng 12(2):105–118
Gershenson J, Prasad G, Zhang Y (2004) Product modularity:
measures and methods. J Eng Des 15(1):33–51
Gonzalez-Zugasti JP, Otto KN, Baker JD (2000) A method for
architecting product platforms. Res Eng Des 12(2):61–72
Gu P, Sosale S (1999) Product modularization for life cycle
engineering. Robot Comput Integr Manuf 15(5):387–401
Heydari B, Dalili K (2015) Emergence of modularity in system of
systems: complex networks in heterogeneous environments. IEEE
Syst J 9(1):223–231
Hopcroft J, Tarjan R (1973) Algorithm 447: efficient algorithms for
graph manipulation. Commun ACM 16(6):372–378
Huang C-C, Kusiak A (1998) Modularity in design of products
and systems. IEEE Trans Syst Man Cybern Part A Syst Hum
28(1):66–77
Incremona GP, De Felici G, Ferrara A, Bassi E (2015) A supervisory
sliding mode control approach for cooperative robotic system of
systems. IEEE Syst J 9(1):263–272
Jain R, Chandrasekaran A, Elias G, Cloutier R (2008) Exploring
the impact of systems architecture and systems requirements on
systems integration complexity. IEEE Syst J 2(2):209–223
Jiao JR, Simpson TW, Siddique Z (2007) Product family design and
platform-based product development: a state-of-the-art review. J
Intell Manuf 18(1):5–29
Kapser CJ (2009) Toward an understanding of software code cloning
as a development practice. PhD thesis, University of Waterloo
Khajavirad A, Michalek JJ, Simpson TW (2008) An efficient
decomposed multiobjective genetic algorithm for solving the
joint product platform selection and product family design
problem with generalized commonality. Struct Multidiscip Optim
39(2):187–201
Krishnamachari RS, Papalambros PY (1997) Hierarchical
decomposition synthesis in optimal systems design. J Mech Des
119(4):448–457
Lafleur J, Saleh J (2009) Exploring the F6 fractionated spacecraft trade
space with GT-FAST. In: Space 2009. AIAA, Pasadena
Maier MW (1998) Architecting principles for systems-of-systems.
Syst Eng 1(4):267–284
A. E. Bayrak et al.
Marler RT, Arora JS (2004) Survey of multi-objective optimization
methods for engineering. Struct Multidiscip Optim 26(6):369–395
Martins JR, Lambe AB (2013) Multidisciplinary design optimization:
a survey of architectures. AIAA J 51(9):2049–2075
Mathworks (2016a) conncomp (biograph). Retrieved from https://
www.mathworks.com/help/bioinfo/ref/conncompbiograph.html
Mathworks (2016b) Mixed-integer linear programming algorithms.
Retrieved from https://www.mathworks.com/help/optim/ug/
mixed-integer-linear-programming-algorithms.html
Mathworks (2016) Multiobjective genetic algorithm options.Retrieved
from https://www.mathworks.com/help/gads/examples/multi
objective-genetic-algorithm-options.html
Mosleh M, Dalili K, Heydari B (2016) Distributed or monolithic?
A computational architecture decision framework. IEEE Systems
Journal 1–12. https://doi.org/10.1109/JSYST.2016.2594290
Newman MEJ (2006) Modularity and community structure in
networks. Proc Natl Acad Sci 103(23):8577–8582
Otto K, Wood KL (2001) Product design: techniques in reverse
engineering, systematic design, and new product development.
Prentice-Hall, New York
Parnas DL (1972) On the criteria to be used in decomposing systems
into modules. Commun ACM 15(12):1053–1058
Pate DJ, Patterson MD, German BJ (2012) Optimizing families
of reconfigurable aircraft for multiple missions. J Aircr
49(6):1988–2000
Reghbati E, Corneil DG (1978) Parallel computations in graph theory.
SIAM J Comput 7(2):230–237
Rota G-C (1964) The number of partitions of a set. Am Math Mon
71(5):498–504
Salvador F, Forza C, Rungtusanatham M (2002) Modularity, product
variety, production volume, and component sourcing: theorizing
beyond generic prescriptions. J Oper Manag 20(5):549–575
Simpson TW (2004) Product platform design and customization:
status and promise. Art Intell Eng Design Anal Manuf 18(1):3–
20
Simpson TW, Jiao JR, Siddique Z, Hölttä-Otto K (2014) Advances in
product family and product platform design. Springer, New York
Sosa ME, Eppinger SD, Rowles CM (2003) Identifying modular and
integrative systems and their impact on design team interactions. J
Mech Des 125(2):240–252
Steward DV (1981) The design structure system: a method for
managing the design of complex systems. IEEE Trans Eng Manag
EM-28(3):71–74
Ulrich KT, Eppinger SD (2004) Product design and development, 3rd
edn. McGraw-Hill/Irwin, Boston
Wagner TC, Papalambros PY (1993) A general framework for
decomposition analysis in optimal design. In: Gilmore BJ (ed)
Advances in design automation, vol 2. ASME, New York, pp 327–
335