An Algorithmic Approach to System Modularization ...

17th INTERNATIONAL DEPENDENCY AND STRUCTURE MODELING CONFERENCE, DSM 2017 ESPOO, FINLAND, SEPTEMBER 11 - 13, 2017

An Algorithmic Approach Modularization under Constraints

to

System

Roozbeh Sanaei1, Kevin N. Otto2, Katja Hölttä-Otto2, Kristin L. Wood1 1

2

SUTD - MIT International Design Center, Singapore Mechanical Engineering Department, Aalto University, Espoo, Finland

Abstract: In this paper, we introduce a principled method for product modularization that incorporates embodiment constraints due to different levels of fields in the product. In particular, we introduce the concept of a constraints matrix that determines which elements should and which elements should not to be placed together in a same module. Entries of this matrix can be determined based on architectural guidelines, and then a modified version of the IGTA+ clustering algorithm can be used to explore the space of feasible architectures under restraints imposed by the constraints matrix. We demonstrate this method through a case study of controller board of a three phase AC motor. Keywords: Product Modularization, DSM Clustering, Field Effects, Constraint Matrix,

1 Introduction Partitioning systems into several simpler modules is a widely used approach for simplifying complex systems. Such simplifications makes it easier for individual designers to comprehend their complex systems through multiple layers of abstraction. This also leads to higher level of innovation through within-module developments or through the mix-and-match of new module combinations (Baldwin and Clark 2000). Modularity also reduces overall lead time as separate teams can design different modules independently and at the same time. Modular Product families enable companies to produce verity of products with distinct overall functions with more or less same set of modules (Patrick James Newcomb, Bras, and Rosen 1998; Arnheiter and Harren 2006; Simpson, Maier, and Mistree 2001; Blees et al. 2010; Suh 2005). From a single-system point of view (Gershenson, Prasad, and Zhang 2004), a well-defined module, in terms of simple interfaces, can ease project management by decoupling of tasks and providing design freedom within a module so different design teams can work in parallel on separate modules leading to lower development time (Ulrich 1994; O’Grady 1999). Modularity can also make understanding a complex product architecture simpler and it facilitates innovation through within-module autonomous improvements and also mix-and-match of new module combinations in this way(Baldwin and Clark 2000). On the downside, a poorly designed modular architecture can lead to products and systems that cost more than their integral (non-modular) counterparts due to over design (Krishnan and Gupta 2001; Gupta and Krishnan 1999). A poorly designer modular product or system can also have inefficient performance (Ethiraj and Levinthal 2004) compared to more performance optimized integral systems(Whitney and others 2004). Further, too many common modules may result in loss of brand identity and cannibalization (Ulrich 1994; Arnheiter and Harren 2006; Kim and Chhajed 2000).

An Algorithmic approach to System Modularization under Constraints

In many products and systems, however, a key consideration is the placement of critical functions within or outside of extreme values of fields. Fields are often a driving factor during product architecture synthesis decisions. In medical device design, a key architectural consideration is how to place functionality within or outside of the sterile field. In laser xerography, a key architectural consideration is how to place functionality around high temperature or high electrostatic modules. In general, field effects often place strong constraints on where functionality can be located within a product architecture. Matrices and graphical networks approaches are two commonly used data-types for system representation in product modularization. Graphical function network-based approaches pioneered by Stone and Wood (Stone and Wood 2000) using function structures are mainly based on heuristics that suggest combinations of components and functions as modules. The selection and application of the heuristics is an interactive manual process and hence the designer is not bounded to a particular scheme and can take into account many criteria and the compliance of components with each other. Further, Otto and Hölttä-Otto (Otto and Hölttä-Otto 2010) develop methods to incorporate field effect constraints in the function structure based architecting methods. While the interactive nature of the approach allows for multiple criteria and constraints, it also offers limited assurance of optimality. This interactive nature of the function structure based approaches contrasts with the design-structure-matrix based approaches which apply algorithms over a space of architectures to search for an optimal scheme based upon a heuristically selected modularity metric. The matrix-based approaches provide a more principled methodology and convenience compared with the interactive methods using the graphical-function networks. This is particularly true when the system of interest has a large number of elements and becomes unwieldy for interactive consideration. While the DSM matrix methodology is useful for large systems, unlike function structure networks thus far there has been no systematic approach suggested for taking partitioning constraints into account in the DSM algorithms. In this paper, we purpose a principled modularization approach based on a constrained clustering algorithm on the top of the conventional IGTA+ algorithm. and we show the implementation of this algorithm through a detail example. The structure of the paper is as following: First different approaches for product modularization are reviewed. Next, we introduce the concept of field effects in product modularization, and present the idea of field separation, where different functions are placed in different field values. This decision is often a significant consideration in product modularization. Afterwards, we describe our approach to translate field constraints into a matrix form and our algorithm to search the space of feasible architectures without crossing the constraints. Lastly, we present application of our algorithm in an example in power electronics, a motor controller which high and low voltage levels restrict placement of different elements.

2 Related Work Variety of methods have been developed to define modules (Gershenson, Prasad, and Zhang 2004) most revolve around a chunk with a unique function and well defined interfaces. Module can be defined either by applying manual heuristic rules on graphical DSM 2017

Roozbeh Sanaei, Kevin N. Otto

functional models or computer clustering algorithms on design structure matrices (DSM) or through Modular function deployment (MFD) based on product usage and other strategic aspects. Design Structure Matrix (DSM) (Steward 1981; Eppinger et al. 1994) mapping of system elements and their interactions and the clustering algorithms (e.g. Blackenfelt 2001; Thebeau 2001; Sosa, Eppinger, and Rowles 2007) attempt to maximize the connectivity within a module and minimize it outside the module by clustering tightly connected element into a module. Many modularity metrics reinforce this by rewarding for inner module connectivity and/or punishing for inter module connectivity (e.g Newcomb, Rosen, and Bras 2003; Steward 1981; Eppinger et al. 1994; Martin and Ishii 2002). In the case when the number of desired modules is specified, the modularization can be defined as grouping the vertices of the graph in a way that optimizes modularity (Pothen 1997). In most cases, the number of modules in the optimal architecture is not known, and so hierarchical clustering algorithms are the common approach (Thebeau 2001). In such algorithms, an agglomerative or divisive strategy is followed to construct the hierarchy. Agglomerative algorithms start with modules each of which contains a single vertex, and pairs of modules with maximal similarity are combined iteratively. Divisive algorithms on the other hand are up-to-bottom procedures, starting with a module containing the whole graph and iteratively splitting it into a pair of modules with minimal similarity (Pothen 1997). Another possible strategy is to move vertices form one module into another when optimality of architecture is improved. IGTA is one such a strategy. We use IGTA as our base algorithm for constrained clustering, working principle of IGTA is explained in section 3. Beside connectivity of components and modules, In many designs, the external force fields such as electric, magnetic, or pressure fields drive the partitioning of the functionality. For example, with power electronics, there are AC power functions that operate on high voltages and there are logic functions that operate on low voltages. Optical interconnects or transformers are required between the two sides of the voltage field. We call this design synthesis approach field separation, where functionality is partitioned within a product according to values of a field. That is, each function is assigned a particular value of the field. Typically, a field is used to separate product functions into zones, each zone divided by a field effect boundary. Sometimes there are multiple zones, each with an individual level of the field. In this paper we address this issue by developing an algorithm which explores the space of possible architectures given multiple constraints With respect to consideration of constraints on architecture decisions, Otto and HölttäOtto (Otto and Hölttä-Otto 2010) develop methods to incorporate field effect constraints in the function structure based architecting methods. Field levels can be represented easily with separation lines on the function block diagram. Part of the product architecting process is to locate this boundary. This involves selecting functions to place on the high side of the field, and selecting functions to place on the low side. Yassine et. al. (Yassine, Chidiac, and Osman 2013; Yu, Yassine, and Goldberg 2007) and in a separate work Jason E. Bartolomei et al (Bartolomei et al. 2012) have also used the notion of multi-domain optimization to integrate the effect of several domains on the optimization of the product architecture. However, in both of these approaches each domain of product development is associated with a separate matrix and overall cost is optimized through an multi-domain optimization algorithm. However, in our algorithm DSM 2017


we do not allow field-effect to be violated at any-cost and strictly force search to remain within architectures that follow the constraints. Similarly to the function structure approach to considering field effect constraints, we can modify current design structure matrix approaches to also consider field effects. Conventional DSM algorithms cannot be applied to the entire product matrix, for then some functions which must be at a high field value might be bundled with functions that must be at low field values. Further, simply applying a DSM separately to the elements in each field domain is also sub-optimal, since there can be elements which can be placed in any field levels. Putting these neutral elements into a separate field-indifferent region may result into sub-optimal architectures. In an optimal architecture these elements may construct new field-indifferent modules or incorporated into modules placed in particular filed level. In this paper we address this issue by developing an algorithm which explores the space of possible architectures given multiple constraints.

3 Methodology The schematic outline of our methodology is illustrated in Figure 1. It begins with the definition of a system schematic diagram consisting of linked elements, an element being the functional building blocks or the components of the system (Step 1). A DSM is constructed as the adjacency matrix of the schematic diagram. If there is a flow of energy, material or information between the elements, the entry corresponding to this couple will be set to one in the matrix, otherwise it it will be set to zero (Step 2). Once these elements are set, next the different fields that are affecting the product can be defined. Define schematic diagram Step 1

Analyze the results Step 6

Create DSM Step 2

Run constrained IGTA+ Step 5

Highlight fields Step 3

Create constraints matrix Step 4

Figure 1. Schematic outline for modularization under constraints through DSM clustering

Architectural guidelines to define such fields are provided in our earlier paper (Otto and Hölttä-Otto 2010) (Step 3). To represent a field, each element is labeled with field levels, such as high or low temperature. If one of the elements has be placed in high-level and one has to be in the low level of any of the fields affecting the product, the two elements cannot be placed in the same module; in any other case there is no rule to stop the placement of the elements. The next step is putting field effects constraints into a matrix referred to as the constraints matrix. The constraints matrix is a square matrix with identically labeled rows and columns, where each row/column denotes one of product elements. To create the constraints matrix, we iterate through all feasible couples of elements, and if the two elements must be located at different field levels then the entry is set to zero (incompatible), otherwise, one (compatible). One advantage of using a constraints matrix is that effects associated with different fields can be element-wise DSM 2017


multiplied together into one constraints matrix (Step 4). Once the constraints matrix is constructed, a modified version of IGTA+ algorithm can be used to modularize the product by taking the constraints into account (Step 5). Constraints will be satisfied through modification to the implementation of the “cluster bid'' algorithm within IGTA+. The IGTA+ algorithm pseudo-code is shown in Figure 2, the algorithms begins with an identity matrix of size n, representing n modules each containing only one element. In each iteration, the algorithm takes one element randomly and computes cluster bid of that against all modules, and the module with the highest cluster bid will be chosen. The cluster bid shows the degree of fit between a selected component and each of the existing modules. We take field related constraints into account by redefining cluster bid, where if an element and any element of a module are not allowed to be placed in the same module according to contraints matrix, then their corresponding cluster bid will be zero; otherwise it will

𝑝𝑝𝑜𝑤_𝑑𝑒𝑝 𝑞 𝑝𝑜𝑤_𝑏𝑖𝑑

as before defined by IGTA+. Here p is the number of connections between

the chosen element and elements of that module, q is the size of the module, and 𝑝𝑝𝑜𝑤_𝑑𝑒𝑝 and 𝑞 𝑝𝑜𝑤_𝑏𝑖𝑑 are strategic parameters of algorithm which are set by user as before with IGTA+.

Figure 2. Restricted IGTA+ algorithm for modularization under constraints

With this change, the standard IGTA+ algorithm can be used. Following a stochastic hillclimbing approach to avoid convergence of the algorithm into a local optima, the algorithm does not always choose the highest bid, but rather randomly with a specified probability selects the module with second-highest cluster bid. The elements will be relocated to a new module only if the new clustering solution has a lower ``total cost'' compared with the best total cost obtained so far. Total cost is a weighted summation of the intra-cluster cost and the extra-cluster cost. Intra-cluster cost is defined as the number of interactions within individual modules weighted by the sizes of the modules, and extracluster cost is defined as the total number of interactions between different modules together weighted by the size of DSM. Once the total cost is calculated, the replacement DSM 2017


will take place with some probability even when the total cost turns out not to be lower. The entire process will be repeated for a number of iterations equal to multiple times of DSM size, and the entire loop will be repeated until the cost remain invariable for several rounds of iteration. We discuss here using the IGTA+ algorithm, a modified version of the IGTA algorithm. To improve the computation efficiency of the IGTA algorithm, Börjesson et al (Borjesson and Hölttä-Otto 2012) developed the IGTA+ algorithm, by making two modifications to the original IGTA algorithm. The first is to constrain each component to be assigned to only one module, makes it possible for costs to be expressed in matrix form which can be computed faster. The second option offered is to terminate the algorithm once all components were tried once, also resulting in considerable improvement in computation speed. Here we adapt with non-overlapping clusters assumption and use matrix form of costs for computation but we do not use the latter option.

4 Case Study – 3 Phase AC Motor Controller Consider the design of an electronic controllers for three phase AC motors. An embedded microprocessor control offers higher performance. The microprocessor itself operates at 5 Volts, whereas the motors operate at 110-240 Volts, depending on the country of sell. One question is how to provide the 5 Volts (Hauenstein 2000). The typical solution is to transform the power down and operate the low voltage electronics at +5 Volts relative to ground. An alternative is to transform the power relative to the high voltage side and operate at -5V relative to the high voltage side. Depending on costs of components and breadth of applications, this may prove a better functional layout. Alternatives can be defined on where the functional should be placed, relative to the voltage field. Two alternatives are shown in Figures 3 and 4, the obvious traditional design calls for minimizing the number of CPUs, since these were historically expensive. This requires transferring two analog signals across the high voltage boundary down to the low voltage CPU signal processing, and such linear opto-couplers are not inexpensive. An alternative is to process these analog signals with a CPU on the high voltage side, and communicate to another CPU on the low voltage side with simple digital opto-couplers. With modern microprocessor costs, this alternative performed better at a lower cost. The design was generated through careful formulation of where to put the different functionality relative to the voltage boundary. Dashed blue lines in Figures 3 and 4 demonstrate modules without taking field-related constrained into account. As visible, the micro/process controller and the convertor attached to it, the analog to digital convertor, the signal conditioner, and the output signal fault and display status display would be all located in the same module. However, the micro/process controller can function in High-voltage zone with the rest placed in lowvoltage region. Furthermore, the convertor and the multiplexor can both be placed in the same high-voltage module, whereas the multiplexor is not able to function in the highvoltage zone. These issues can be elevated by implementing constrained modularization algorithm shown in Figures 5 and 6. This algorithm follows the constrictions in price of cutting more interfaces or more modules. For the motor controller with one CPU, number of cut interfaces among components increase from 7 to 10. For the motor controller with

DSM 2017


two CPUs number of cut interfaces remain unchanged but number of modules increase from 3 to 4.

Figure 3. Motor Controller logic partitioning and voltage field boundary with one CPU at high voltage. Modularized with non-constrained IGTA+

Figure 4. Motor Controller logic partitioning and voltage field boundary with two CPUs, one in low voltage and one in high voltage. Modularized with non-constrained IGTA+

DSM 2017


Figure 5. Motor Controller logic partitioning and voltage field boundary with one CPU at high voltage. Modularized with constrained IGTA+

Figure 6. Motor Controller logic partitioning and voltage field boundary with two CPUs, one in low voltage and one in high voltage. Modularized with constrained IGTA+

DSM 2017


5 Conclusion In summary, we develop a new methodology combing the DSM partitioning approach with field effect constraints. We do this by constraining the IGTA+ algorithm to overcome current limitations which define modules merely based on functional connectivity. This constrained algorithm can be useful for applications that include thermal, sterile, magnetic, electric and other fields barriers that make the conventional methods difficult to apply. The algorithm takes in account modularity constraints (constructed based on architectural guidelines of our earlier paper) by referring to a constraints matrix as it transfers one element from one module into another during the calculations. Our approach is currently limited to constraints that disallow to components to be placed in the same module. Future work would be considering more general forms of the constraints or constrictions that may raise in later stages of product development. We demonstrated our IGTA+ based algorithm can resolve issues with impractical solutions with heuristics or other modularity methods that do not consider field effects. Including fields effects into architectural decisions thereby can result in overall better architectures. Further, including field effects explicitly in the architectural and layout considerations can be useful to help make explicit alternatives to generate new solutions.

References Baldwin, Carliss Young, and Kim B. Clark. 2000. Design Rules: The Power of Modularity. Vol. 1. MIT press. Bartolomei, Jason E., Daniel E. Hastings, Richard de Neufville, and Donna H. Rhodes. 2012. “Engineering Systems Multiple‐Domain Matrix: An Organizing Framework for Modeling Large‐scale Complex Systems.” Systems Engineering 15 (1): 41–61. Blackenfelt, Michael. 2001. “Managing Complexity by Product Modularisation.” Borjesson, Fredrik, and Katja Hölttä-Otto. 2012. “Improved Clustering Algorithm for Design Structure Matrix.” In ASME 2012 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, 921–30. American Society of Mechanical Engineers. Eppinger, Steven D, Daniel E Whitney, Robert P Smith, and David A Gebala. 1994. “A Model-Based Method for Organizing Tasks in Product Development.” Research in Engineering Design 6 (1): 1–13. Gershenson, John K, G Jagganath Prasad, and Ying Zhang. 2004. “Product Modularity: Measures and Design Methods.” Journal of Engineering Design 15 (1): 33–51. Hauenstein, Karl John. 2000. “Platform Design of a Motor Drive.” Massachusetts Institute of Technology. Martin, Mark V, and Kosuke Ishii. 2002. “Design for Variety: Developing Standardized and Modularized Product Platform Architectures.” Research in Engineering Design 13 (4): 213–235. Newcomb, N. J., David W. Rosen, and Bert Bras. 2003. "Life cycle modularity metrics for product design." Proceedings of Third International Symposium on Environmentally Conscious Design and Inverse Manufacturing, EcoDesign.

DSM 2017


Otto, Kevin, and Katja Hölttä-Otto. 2010. “Incorporating Field Effects into Modular Architecture Methods.” In ASME 2010 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference, 543–51. American Society of Mechanical Engineers. Pothen, Alex. 1997. “Graph Partitioning Algorithms with Applications to Scientific Computing.” In Parallel Numerical Algorithms, 323–368. Springer. Sosa, Manuel E, Steven D Eppinger, and Craig M Rowles. 2007. “A Network Approach to Define Modularity of Components in Complex Products.” Journal of Mechanical Design 129 (11): 1118–1129. Steward, Donald V. 1981. “The Design Structure System: A Method for Managing the Design of Complex Systems.” Engineering Management, IEEE Transactions On, no. 3: 71–74. Stone, Robert B., and Kristin L. Wood. 2000. “Development of a Functional Basis for Design.” Journal of Mechanical Design 122 (4): 359–70. Thebeau, Ronnie Emile. 2001. “Knowledge Management of System Interfaces and Interactions from Product Development Processes.” Massachusetts Institute of Technology. Yassine, Ali A., Rawia H. Chidiac, and Ibrahim H. Osman. 2013. “Simultaneous Optimisation of Products, Processes, and People in Development Projects.” Journal of Engineering Design 24 (4): 272–92. Yu, Tian-Li, Ali A. Yassine, and David E. Goldberg. 2007. “An Information Theoretic Method for Developing Modular Architectures Using Genetic Algorithms.” Research in Engineering Design 18 (2): 91–109.

DSM 2017