1. INTRODUCTION
“The task of an engineer is to find solutions for technical problems” (Pahl et al., Reference Pahl, Beitz, Feldhusen and Grote2007). A multitude of such design tasks that affect different aspects of a technical product arise along the process of product development. The overall task that has to be accomplished by an engineering team can be paraphrased as search over a set of realizable technical artifacts for alternatives that show the highest compliance with a set of objectives. This directly lends a general scheme for representing design decisions in terms of mathematical optimization (Marler & Arora, Reference Marler and Arora2004).
However, typically such problems are not fixed from the beginning. Multiple optimization problems evolve during design space exploration over consecutive design phases and reiterations. Consider the seminal work of Schon (Reference Schon1992), where he describes the act of exploring different design alternatives as a process of “seeing–moving–seeing.” From an abstract perspective, formulating and solving an optimization problem can be seen as a moving step, whereas interpreting the results and making conclusions about the formulation of the next optimization problem is considered seeing.
Although computer-aided methods for solving optimization problems have proven very valuable over the last decades (Marler & Arora, Reference Marler and Arora2004), most of these works solely address scattered and very specific moving steps. In order to automate design exploration over chains of seeing–moving–seeing and thus provide continuous support over several design phases, new approaches for formulating consecutive design problems are needed; that is, the seeing step has to be implemented.
Formulating an optimization problem usually requires design variables to be defined together with their ranges, constants (e.g., weights and other parameters), and functions over these elements used for setting objectives and constraints. In this paper, these tasks are paraphrased using the following notions of parameterization and configuration:
1. Multiple-objective design optimization problem: Given a vector of design variables x = (x 1, x 2, … , x n)T, a vector of constants c = (c 1, c 2, … , c m)T, a vector of objective functions f(x, c) = [f 1(x, c), f 2(x, c), … , f k(x, c)]T, a set of inequality constraint functions g i(x, c) with i = 1, 2, … , p, and a set of equality constraint functions h j(x, c) = 0 with j = 1, 2, … , q, then minxf(x, c) subject to g i(x, c) ≤ 0 and h j(x, c) = 0 is called a multiobjective optimization problem.
2. Parameterization: The preparatory act of defining the value of each constant within c is called parameterization.
3. Configuration: The act of specifying the ranges for each design variable within x together with the definition of functions f(x, c), g i(x, c), and h j(x, c) is called configuration.
The present work highlights promising methods that support automatic parameterization and configuration coming from the fields of machine learning (ML) and natural language processing (NLP). Special focus is made on approaches that integrate with the commonly used evolutionary optimization methods: genetic algorithms (GAs; Holland, Reference Holland1992) and genetic programming (GP; Koza, Reference Koza1992). Hence, information items that are needed for parameterizing and configuring GA and GP systems in different design phases are identified.
In this paper, reference is made to the VDI 2221 design method proposed by the Association of German Engineers (Verein Deutscher Ingenieure, 1993). It describes design processes in the context of product development that considerably builds on early editions of Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007). The general applicability of these processes spans a wide range of industries, for example, electrical design, mechanical design, and software design. In the following section procedure as to how the method's elements map to the definition of design exploration and evolutionary optimization is shown.
The paper is organized as follows: the basis is built for a common understanding of design exploration in light of the design phases of VDI 2221. On the basis of this, applications of evolutionary optimization within each phase of design exploration are reviewed. This is followed by a discussion of the effort for configuring and parameterizing these approaches. Given this, systems that integrate methods from the fields of ML and NLP for configuration and parameterization are further reviewed. The paper closes with a conclusion on the surveyed works.
2. PHASES OF DESIGN EXPLORATION
At this stage a series of definitions is provided that frame the above statement from Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007) more precisely. The following statements are mainly based on VDI 2221 and Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007).
The method defines multiple design phases (cf. Fig. 1 and Table 1), each of which has two aspects of problem solving. First, every design phase represents a task to achieve a process objective, that is, to transform one product description into another. The plans for doing so are given by the design method. Second, each phase addresses one or more problem-solving steps of the overall design problem/task, that is, the search for requirement-satisfying product designs.
Fig. 1. Phases of product development in the context of the product life cycle, based on Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007) and VDI 2221.
Table 1. Role of design phases in solving the overall design task
*The phases of design exploration.
Product development starts with the phase referred to as requirement modeling or task clarification. The process objective of this phase is to formulate a requirements specification according to the client's desired results of product development, where the latter is typically documented in the form of a design brief. Requirement modeling is also often revisited during later phases to change or add requirements that follow from intermediate design results.
Conceptual design consists of two phases, function modeling and principle modeling. Function modeling's process objective is to establish a more detailed requirement description by decomposing functional requirements into so-called function structures. These are models that provide a detailed description of the product's purpose by explaining how its subfunctions interact with each other. In VDI 2221 and Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007), these interactions are conceptualized as conversion processes of energy, material, and signal flows within the product. The next phase, principle modeling, searches for adequate solution principles that realize a function structure's subfunctions. Solution principles describe the physical effect for achieving a function together with properties of material and geometry. For instance, the solution principle “winch” can be used to achieve the function “lift weight.” The underlying physical effect is the mechanical advantage, which is applied in terms of the material and geometric properties of a rope, spool, and crank assembly. Finally, it has to be described how the solution principles are combined to work together as a whole. This kind of model is called a principle solution (also termed working structure or concept).
Defining properties of geometry, material, programming, and manufacturing is subject to configuration modeling. It comprises embodiment design and detail design. Embodiment design itself can be divided into three phases: modularization, preliminary embodiment design, and detailed embodiment design. First in line, modularization assigns the elements of the principle solution to structures of realizable modules, that is, the act of modeling systems and subsystems. Then preliminary embodiment design concentrates on defining the most important modules with respect to geometry, material, and/or programming in terms of preliminary layouts. In detailed embodiment design, the separately designed modules of a preliminary layout are integrated to form a definitive layout. The last phase then is to prepare and document all details needed for manufacturing.
The early design phases from function modeling to preliminary embodiment design require the generation of a set of alternatives as their desired state. These phases and the recurring phase of requirement modeling are considered to be phases of design exploration.
3. EVOLUTIONARY DESIGN EXPLORATION
This section provides an overview of the usage of GAs and GP for design exploration in light of the discussed design phases. On the basis of this review, the parameterization and configuration of such applications will be described later.
3.1. Requirement modeling
The main task of requirement modeling is to establish a definition of the overall design task. Therefore, the demands and wishes that are stated in a design brief first have to be translated from a customer-oriented perspective to concrete technical requirements. The resulting list of requirements is further refined in order to resolve contradictions, elaborate details, determine the priority of requirements, and match the interests of the engineering company.
To the authors' knowledge uses of GA/GP-based methods in the field of requirement modeling are sparse. Nonetheless, there is a growing interest in search-based requirements optimization (Zhang et al., Reference Zhang, Finkelstein, Harman, Paech and Rolland2008).
3.1.1. Quality function deployment (QFD)
QFD is a method that assists in the translation between customer-oriented and technology-oriented perspectives on the design problems. QFD considers the requirements to be formulated in the language of the customer. These customer requirements are then correlated with technical attributes of the solution (Mehrjerdi, Reference Mehrjerdi2010). The common model used for QFD is the house of quality (HoQ; see Fig. 2). Within this context, GAs have been used to maximize satisfaction with customer requirements along with further goals (cost, design time, market share). This is done by searching for optimal targets for technical attributes, that is, determine the degree of attainment for each technical attribute (Tang et al., Reference Tang, Fung, Xu and Wang2002), find target values for technical attributes (Bai & Kwong, Reference Bai and Kwong2003), determine importance weights for each technical attribute (Liu, Reference Liu2010), or choose target values under consideration of competing products (Kwong et al., Reference Kwong, Luo and Tang2011). In all cases simple decision variable vectors are used for representing individuals. Evaluation relies on preference weights for customer requirements and two correlation matrices. One traces requirements to technical attributes (center of HoQ). The other defines dependencies among technical attributes (roof of HoQ).
Fig. 2. House of quality model used for quality function deployment, based on Liu (Reference Liu2010).
3.1.2. Next release problem (NRP)
The NRP originates from software engineering. Software systems are typically deployed as a series of subsequent revisions. Given a set of customer requirements and a limited number of resources that a software company can invest in implementing requirements for the next revision, the NRP asks for the ideal allocation of resources to requirements (Bagnall et al., Reference Bagnall, Rayward-Smith and Whittley2001). Greer and Ruhe (Reference Greer and Ruhe2004) apply a GA to find an optimal schedule that determines which of the requirements will be realized and in what release they will be realized. Later, Zhang et al. (Reference Zhang, Harman and Mansouri2007) compared different GA variants on a multiple-objective formulation of the NRP, that is, minimizing cost while maximizing customer satisfaction (also called value). Like in QFD, decision variable vectors are used for representing individuals. Evaluation is also fairly simple because it mainly builds on attributes associated with requirements and customers.
3.1.3. Optimize specific requirement models
Over the span of different engineering disciplines, there also exist different and very specialized models for representing requirements. In the context of naval vessel design Sutcliffe et al. (Reference Sutcliffe, Chang and Neville2002) make use of so-called scenario task sequences (STS) for defining required interactions among human agents and computer equipment in a defined environment. A GA is employed to find optimal STS with respect to their influence on system reliability. In comparison to QFD and NRP, where decision variables could be readily used for defining genotypes, STS require a more complex chromosome representation. Sutcliffe et al. (Reference Sutcliffe, Chang and Neville2002) developed a mapping scheme, which encodes the sequence of tasks and the task–agent–equipment type combinations as binary string. For evaluation, a custom “performance interpreter” component models the expected influence of training, task complexity, operational time, quality, and utility on system reliability. Therefore, the interpreter component relies on attributes associated with agent and equipment types and rules that map these attributes to reliabilities.
Table 2 summarizes the evaluation criteria of the mentioned works, that is, the used objective and constraint functions.
Table 2. Evaluation criteria used for requirement modeling
3.2. Function modeling
The goal of function modeling is to clearly state the purpose of the design object, called primary function. This is done by delineating what subfunctions are needed to establish the primary function and how these functions must interoperate with each other, a process known as functional decomposition. Usually graph-based notations are used for describing function structures. In VDI 2221 and Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007), for instance, functions are represented as nodes of a graph. These nodes are connected by directed edges that represent energy, material, and signal flows. The resulting graph depicts how forms of energy, material, and signals are transformed along the paths in order to enable the contained functions.
However, few works addressed optimization in context of function modeling. This may be because these models are very abstract in nature and lack commonly agreed schemes for their evaluation.
3.2.1. Optimization of function structure
Nonetheless, Güroğlu (Reference Güroğlu2005), Jin and Li (Reference Jin and Li2006), and Sun and Yao (Reference Sun and Yao2012) applied GP for functional decomposition. The standard tree-based representation of GP individuals offers a way to capture topological information in function structures. Hence, different tree serializations of function structures have been developed (as an example, see Fig. 3). In order to evaluate the generated function structures a number of abstract criteria have been proposed that require further explanation (see Table 3).
Fig. 3. Exemplary function structure to genetic programming tree serialization (Func. = Function), based on Jin and Li (Reference Jin and Li2006).
Table 3. Evaluation criteria used for function modeling
3.2.2. Model consistency
The GP-generated function structures should be consistent in light of the underlying model of functional decomposition, for example, with respect to the one of Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007). Hence, a function structure must not be an arbitrary graph; it should rather correspond to the functional requirements for which it has been generated. For instance, the input and output flows of a function structure should match those of a more abstract black-box representation. Güroğlu (Reference Güroğlu2005) and Jin and Li (Reference Jin and Li2006) term this feasibility. Sun and Yao (Reference Sun and Yao2012) do not explicitly define such a measure. They require that their algorithm should include all resources that are mentioned in the requirements specification. However, these resources actually resemble the flows within the function structure.
3.2.3. Uniqueness of elements and function structure size
Sun and Yao (Reference Sun and Yao2012) define creativity as a matter of variety. Thus, GP trees with a relatively large amount of unique nodes are preferred. Jin and Li (Reference Jin and Li2006) adopt a similar variety measure as part of a compound desirability score. Desirability also includes function structure dimension. The latter aims at limiting the size of elements in a function structure. Güroğlu (Reference Güroğlu2005) also combines uniqueness of elements and function structure size. Their complexity measure is based on information entropy and promotes individuals with many unique elements.
3.2.4. Change from initial population
Both Güroğlu (Reference Güroğlu2005) and Jin and Li (Reference Jin and Li2006) compare generated function structures with individuals of the initial population. However, their assumptions on this comparison differ. Güroğlu (Reference Güroğlu2005) generates an initial population from existing function structures made by engineers. The goal is to produce new unseen solutions from this set. Therefore, a creativity score measures the probability of functions and flows occurring with respect to the initial population. Jin and Li (Reference Jin and Li2006), in turn, generate their initial population by means of a graph grammar. Hence, the generated graphs are per se artificial and do not have to correspond to existing products. The graph grammars rules follow the principles of functional decomposition and produce reasonable structures. Hence, the aim of Jin and Li (Reference Jin and Li2006) is to keep graph grammar-produced structures where possible.
3.2.5. Physical compatibility
With reference to the following design phase of principle modeling, Jin and Li (Reference Jin and Li2006) and Sun and Yao (Reference Sun and Yao2012) evaluate function structures by inspecting physical properties of their later realizations. As can be seen below, Jin and Li (Reference Jin and Li2006) also search means combinations that can be used for realizing a function structure. The degree of compatibility among these means serves as a performance indicator of function structures. Sun and Yao (Reference Sun and Yao2012) adopt principles from the theory of inventive problem solving (Altshuller, Reference Altshuller1999). Following the theory of inventive problem solving, a solution is inventive if physical contradictions have to be overcome. Hence, Sun and Yao (Reference Sun and Yao2012) introduce a score to determine inventive solutions based on the amount of physical contradictions being introduced by the function structure.
3.3. Principle modeling
Principle modeling is concerned with the search for ways to physically realize the defined functions. A rather abstract description of such means are the already mentioned solution principles (Pahl et al., Reference Pahl, Beitz, Feldhusen and Grote2007). As a result of the later design phases, solution principles will be implemented in concrete product components (e.g., in the context of ship design the solution principle “combustion engine” may be realized as a “four-stroke diesel engine”). Hence, especially in routine design tasks, it is also common to directly consider already realized product components at this stage of concept development.
Compared to requirement modeling and function modeling, more research has been done on using optimization for principle modeling. In this category three usage patterns for optimization can be identified.
3.3.1. Optimization of principle solution combination
Jin and Li (Reference Jin and Li2006) partly base their approach on the method of Pahl et al. (Reference Pahl, Beitz, Feldhusen and Grote2007) and search for solution principles that can be used for realizing a function structure and/or fit some given requirements. Jin and Li (Reference Jin and Li2006) used a GA to search for a working structure that fits a given function structure. The particular function structure is evolved in parallel making use of GP as mentioned earlier. While the topology is defined by the function structure, the combination of solution principles is built from a library of solution principles. It provides information on available principles, including possible functions that can be implemented with a principle and constraints for integrating principles with others. The evaluation of solution principles follows compatibility, performance, and preference measures. An early step in the same direction is the work of Pham and Yang (Reference Pham and Yang1993). Here, so-called building blocks are combined to produce principle solutions for transmission systems. These building blocks constitute abstract solution principles like “helical gear pairs” or “belt-wheels.” A GA performs the search over possible arrangements of building blocks considering their physical compatibility. Further, Campbell et al. (Reference Campbell, Cagan and Kotovsky1999) proposed a seminal agent-based method named A-design that uses a GA-like method to search for optimal conceptual designs. A-design takes a user-defined functional specification as input and builds a configuration of abstract component descriptions from it. For instance, “gear,” “shaft,” or “spring” are typical abstract components. Their descriptions hold information about their connectivity with other components, that is, how energy and signals are transformed and how energy variables relate to others. In a second step, these abstract versions are instantiated to concrete components from a catalog, for example, “Spring: ERS-A1-36 $0.93, K=16.0lb/in.”
3.3.2. Optimization of component combination
Other approaches skip this level of abstraction and directly search for adequate components, whose descriptions are usually stored in a product database. This avoids the need to model abstract solution principles and offers direct ways for evaluation, for example, by using the price, weight, and dimensions of components. Xu et al. (Reference Xu, Ong and Nee2006) used genetic search to find appropriate component combinations for so-called function groups. These are groups of similarly used functions from existing example products and constitute a product platform's functionality. Function groups are correlated with both requirements (via key characteristics) and concrete components of the example products. This trace offers a flexible way of ranking and constraining component configurations with respect to requirements (cost, weight, manufacturing time, etc.). Hutcheson et al. (Reference Hutcheson, Jordan, Stone, Terpenny and Chang2006) started from a manually designed function structure and defined relevant component families for each function. Genetic search has been used to search for optimal component combinations with respect to cost, performance, and stress factors.
3.3.3. Optimization of parametric product templates
A third pattern is to use domain-specific key parameters (e.g., number of engines for a plane). This approach is prevalent in domains where there is no need to consider the variability of custom-made function structures. To a great extent the kind of functions to be fulfilled, their topology, and the means used for realizing them are all considered to be well known. The remaining variability is bound to an enumerable set of predefined product templates. Special discrete variables are then used to choose from this set (e.g., wing type), while additional continuous variables (e.g., wing span) refine the concept. Several works from the field of aerospace design followed this approach to identify configurations for aircraft designs and space operations with respect to mission requirements (Roth & Crossley, Reference Roth and Crossley1998; Crossley, Reference Crossley1999; Blasi et al., Reference Blasi, Iuspa and Del Core2000; Perez & Behdinan, Reference Perez and Behdinan2002; Hassan & Crossley, Reference Hassan and Crossley2003). Further examples of this kind range from golf club design (Qiu et al., Reference Qiu, Fok, Chen and Xu2002) through hydropower systems (Parmee, Reference Parmee1998) to dynamics of bridge design (Wang & Tang, Reference Wang and Tang2011). A significantly different parameter-oriented approach is proposed by Wu et al. (Reference Wu, Campbell and Fernández2008). They start from a function structure and propose a method that yields a bond graph model representing the physical parameters of solution principles. Genetic search is used to determine the optimal parameters for this model.
Table 4 summarizes the criteria used for evaluation. These criteria heavily rely on attributes that are associated with solution principles or components. In simple cases, these attributes are directly matched against required key characteristics, most often in terms of constraint functions. Prevalent properties of this kind are cost, weight/mass, reliability/stress, and other indicators of quality, efficiency, or performance. In other cases, properties of the overall solution are computed from its solution principles or components, for example, by means of equations that take various properties of multiple parts of the solution into account. Examples for this are precision, respond speed, or domain-specific criteria like orbital altitude or the number of satellites (Crossley, Reference Crossley1999). A central point in principle modeling is that a chosen working structure is actually physically feasible. Wu et al. (Reference Wu, Campbell and Fernández2008), for instance, ensure this through behavioral equations of bond graphs. Further optimization goals mentioned are designer preference, grade level of technology, and manufacturing time.
Table 4. Evaluation criteria used for principle modeling
3.4. Modularization
In modularization working structures are split into interconnected subsystems that constitute the system architecture. Each of these so-called modules is defined by its specific set of attributes (e.g., nose/cabin/tail length of an aircraft's fuselage module). Preferably, modules are formed with respect to reoccurring patterns within the working structures of one or more products. Grouping these commonalities yields reusable modules that in turn enable product developers to increase variety, shorten lead times, and reduce costs (Simpson, Reference Simpson2004). Hence, modularization has received a lot of attention from the domain of product family design. Building on Fujita (Reference Fujita2002) and taking recent developments into account, three types of optimization problems can be distinguished in this field.
1. Optimization of module attributes: The task is to optimize attribute parameterizations for a given system architecture. This problem has already been discussed for single products in the previous section. Optimization can also be utilized to find design parameters that best suit all members of a set of products. Considering requirements that hold for the whole product family (e.g., manufacturing concerns), this may lead to different results than optimizing each product individually. In this sense, the goal of Ferguson et al. (Reference Ferguson, Kasprzak and Lewis2009) was to optimize multiple car configurations simultaneously by means of GAs. One of their goals was to determine the optimal degree of adaptability for each configuration while considering the cost and performance of the whole product platform.
2. Optimization of module combination: This problem is about finding an optimal combination of predefined modules whose attribute parameterizations are fixed. This has also been outlined in the previous section when choosing adequate existing components for a single product. In light of a product family, it is desirable to share components among products. Again, taking product family-wide requirements into account may have effects on the optimization results. Within this context, Li and Azarm (Reference Li and Azarm2002) generate alternatives for a cordless screwdriver, then select common components from these for a product platform. Wang et al. (Reference Wang, Zhu, Wang, Hu, Lin and Chen2011) provide a numerical example to demonstrate the feasibility of their GA-based approach for finding optimal module combinations.
3. Optimization of attribute-module assignment: Here, the goal is to find an optimal modularization scheme from given attribute parameterizations. After the parameters of each product have been determined, commonalities among the parameterizations can be identified and utilized to group identically parameterized product parts into modules. For this purpose, Simpson and D'Souza (Reference Simpson and D'Souza2004) and Lewis et al. (Reference Lewis, Murray and Mattson2011) used GAs to assign attributes to modules. They had a specific interest in identifying those attributes that should be part of a common product platform.
Figure 4 illustrates all three optimization problems with respect to a desired product architecture. The right-hand side shows the desired modularized product architecture in SysML notation (Object Management Group, 2012). The left-hand side depicts the different starting points of the mentioned optimization approaches. Besides this, Table 5 provides an overview of the evaluation criteria used in the above works.
Fig. 4. Exemplification of typical modularization optimization problems.
Table 5. Evaluation criteria used for modularization
3.5. Preliminary embodiment design
The following phase of preliminary embodiment design addresses the geometrical realization of the system architecture. The goal is to find geometrical structures that embed the previously defined modules. Kicinger et al. (Reference Kicinger, Arciszewski and De Jong2005a) provide a comprehensive survey on evolutionary structural design and categorize prevalent problems in this field as follows:
3.5.1. Topology optimization
Topology optimization is also known as layout optimization or topological optimum design. Although the principle topology has already been set through functional decomposition and modularization, it has to be clarified how the parts have to be connected geometrically, taking account of weight, structural stability, and further aspects. Chapman et al. (Reference Chapman, Saitou and Jakiela1994), Bentley and Kumar (Reference Bentley and Kumar1999), Jakiela et al. (Reference Jakiela, Chapman, Duda, Adewuya and Saitou2000), Wang and Tai (Reference Wang and Tai2005), and Chen and Chiou (Reference Chen and Chiou2013) consider a fixed geometrical grid defining the design space and employ a GA to determine which cells of the grid should be occupied by the product. Hamda et al. (Reference Hamda, Jouve, Lutton, Schoenauer and Sebag2002) in turn used Voronoi diagrams consisting of filled and empty cells to indicate what space should be occupied. Besides these Schoenauer (Reference Schoenauer1996) also takes so-called H-representations into account. These denote void by overlapping elementary shapes (e.g., rectangles) while all remaining parts of space are occupied by the product. Schoenauer (Reference Schoenauer1996) compares all three forms of representation using GAs. Tai and Akhtar (Reference Tai and Akhtar2005) propose a graph-based representation that is consecutively rendered as a geometrical fill/no-fill grid. This graph holds information about a b-spline-based line model and thickness values for these lines. Another distinct group of works builds topologies from truss and frame elements. Here, GAs (Koumousis & Georgiou, Reference Koumousis and Georgiou1994; Bohnenberger et al., Reference Bohnenberger, Hesser and Männer1995; Rajan, Reference Rajan1995; Nakanishi & Nakagiri, Reference Nakanishi and Nakagiri1996; Rajeev & Krishnamoorthy, Reference Rajeev and Krishnamoorthy1997; Azid et al., Reference Azid, Kwan and Seetharamu2002; Mahdavi & Hanna, Reference Mahdavi and Hanna2003; Kicinger et al., Reference Kicinger, Arciszewski and De Jong2005b) and GP (Soh & Yang, Reference Soh and Yang2000; Yang & Soh, Reference Yang and Soh2002) are utilized to search for optimal connections of such elements.
3.5.2. Shape optimization
After the topology has been set, the next step is to determine the product shape. With respect to the nodes of a layout, this means that connections between nodes remain fixed while their positions are adjusted. For this purpose, evolutionary optimization has been applied to find adequate shapes based on splines (Kita & Tanie, Reference Kita and Tanie1999; Cerrolaza et al., Reference Cerrolaza, Annicchiarico and Martinez2000; Annicchiarico & Cerrolaza, Reference Annicchiarico and Cerrolaza2001; Muc & Gurba, Reference Muc and Gurba2001), polygons (Grierson & Pak, Reference Grierson and Pak1993; Keane & Brown, Reference Keane and Brown1996; Soh & Yang, Reference Soh and Yang1996), boundary representations (Woon et al., Reference Woon, Querin and Steven2001; Namgoong et al., Reference Namgoong, Crossley and Lyrintzis2012), and constructive solid geometry (Bentley & Wakefield, Reference Bentley and Wakefield1996).
3.5.3. Sizing optimization
The last problem under consideration for design exploration is identifying optimal sizes of product parts. Specific dimensional aspects with strategic influence have already been in focus of modularization. The current stage takes account of more detailed matters of sizing. Just to mention a few exemplary works, sizing optimization with evolutionary algorithms has been addressed in context of determining sizes of basic elements like columns, beams, trusses, and rods (Hajela, Reference Hajela1990; Deb, Reference Deb1991; Rajeev & Krishnamoorthy, Reference Rajeev and Krishnamoorthy1997; Muc & Gurba, Reference Muc and Gurba2001; Kaveh & Kalatjari, Reference Kaveh and Kalatjari2002; Jármai et al., Reference Jármai, Snyman, Farkas and Gondos2003) or domain-specific sizing problems like cross-sectional dimensions in bridge design (Jenkins, Reference Jenkins1992), or bay and floor sizing in building design (Rafiq & Rustell, Reference Rafiq and Rustell2011).
3.5.4. Unified embodiment optimization
Some works combine the mentioned embodiment aspects in a unified process. Schnier and Gero (Reference Schnier, Gero, Gero and Sudweeks1996) “grow” floor plan layouts using a shape grammar. Here, all possible modifications are predefined by production rules. A GA then searches for application sequences of rules that result in solutions showing high similarity with a set of given design cases. Kicinger et al. (Reference Kicinger, Arciszewski and De Jong2005c) proposed another rule-based system that uses GAs to jointly search for the optimal topology and shape of a building's structural system, and Hornby (Reference Hornby2004) use a similar method for table design. Further, Turrin et al. (Reference Turrin, von Buelow and Stouffs2011) and Gerber and Lin (Reference Gerber and Lin2012) integrate parametric architectural design with a GA. Hence, topology, shape, and size may be jointly optimized with respect to the underlying parametric model. In addition to these works, a very different approach is taken by Shang et al. (Reference Shang, Huang and Zhang2009). They render conceptual design as a form of geometrical decomposition toward so-called functional surfaces. Initially, functional requirements are mapped to primitive geometric objects that form a prototype concept. After being codified as genotype, this concept is evolved to complex geometric structures using a genetic search. The engineer then performs an evaluation of generated solutions manually.
Despite the variety of approaches to preliminary embodiment design, the criteria used for evaluation show significant commonalities. Most often the goals are to achieve a design of minimum volume or mass while maintaining structural stability (in terms of stress, displacement, buckling, deflection, vibration, etc.). Another prevalent requirement is to satisfy certain geometrical affordances like symmetry (Kicinger et al., Reference Kicinger, Arciszewski and De Jong2005b) or boundary conditions (Annicchiarico & Cerrolaza, Reference Annicchiarico and Cerrolaza2001). Further, more domain-specific evaluation criteria comprise usable space (Rafiq & Rustell, Reference Rafiq and Rustell2011), material constraints (Mahdavi & Hanna, Reference Mahdavi and Hanna2003), light characteristics (Bentley & Wakefield, Reference Bentley and Wakefield1996), aerodynamic properties (Namgoong et al., Reference Namgoong, Crossley and Lyrintzis2012), and costs for manufacturing and operation (Deb, Reference Deb1991; Jenkins, Reference Jenkins1992; Rafiq & Rustell, Reference Rafiq and Rustell2011; Gerber & Lin, Reference Gerber and Lin2012; Namgoong et al., Reference Namgoong, Crossley and Lyrintzis2012).
4. CONFIGURATION AND PARAMETERIZATION
The reviewed works show how the design problems of a specific design phase can be formulated in such a way so that evolutionary optimization methods become applicable. In most cases, exemplary scenarios demonstrated how the methods could be applied. However, in order to be applied to any other practical problem instance, one has to prepare design variables x, constants c, and functions f(x, c), g i(x, c), h j(x, c) for the specific scenario at hand. In simple cases, only constants have to be adjusted (parameterization), while more complex adjustments require the preparation of variables and functions (configuration). Taking a closer look at the items used for parameterizing and configuring the above problems (cf. Table 6), four recurring patterns can be observed.
Table 6. Entities and relations from requirements (A) or design rationale (B) that are used for problem specification
Note: QFD, Quality function deployment; CR, customer requirements; TA, technical attributes; NRP, next release problem; STS, scenario task sequences; SP, solution principles.
In Pattern 1, the representation of individuals used for GA/GP is predominantly determined by the desired description of the design phase's process objective (e.g., to yield a function structure). At this point, the design variables have to be defined and subsequently transformed into the chromosome or GP tree representation of the particular approach. Typically, this requires the user to define the variable ranges under consideration (e.g., in case of function modeling, the variables may represent the available functions to choose from).
In Pattern 2, representation stands in close relation to the methods used for fitness evaluation. These methods require individuals to have certain attributes from which evaluation criteria may be calculated (e.g., cost or weight of a component). Hence, the design space has to be attributed beforehand, either by translating requirements to attributes, like in QFD, or by drawing upon experience from existing design rationale; that is, it is well known to the engineer what attributes typically need to be considered for the problem at hand. Conversely, the calculation of an individual's fitness is affected by the chosen definitions for design variables. Objective functions need to be configured to incorporate new design variables or modified variable ranges.
In Pattern 3, the fitness of individuals is further determined by the given descriptions of the preceding design phase (e.g., the chosen working principles should match the functions of a given function structure). Typically, method-specific objective functions need to be parameterized by setting constants (e.g., weights setting the relative importance of requirements). Nonetheless, often completely new objective functions need to be added to reflect custom requirements (e.g., a simulation model for estimating the range of an aircraft design, where the desired range has been determined by the preceding principle modeling phase). The same applies to constraint functions. In GA/GP-based optimization, these are often reflected as penalty objective functions. In this case, comparable actions need to be done for parameterization and configuration. Instead of using penalty functions, constraints can also be considered in advance during the generation of individuals. Here, the same parameterization and configuration steps apply.
In Pattern 4, some works also require specifying relations needed for the generation of individuals (e.g., rules that define feasible design decisions within functional decomposition). Though such relations are out of the scope of the optimization problem's definition, they are valuable for improving the problem-solving efficiency of evolutionary optimization methods. Here, the design space is restricted by integrating rules for production and/or validation into the mechanisms for generating individuals. This corresponds to the idea of using constraints to limit the individuals that are considered for evaluation to only feasible ones.
ML and NLP approaches offer a variety of ways to discover information entities and relations from available data. In case of ML, it is usually assumed that this data is already available in a formal format (e.g., as vector or graph representation), whereas NLP methods address the extraction of information entities and relations from naturally written texts. Principally, both fields provide methods to explore a space of possible hypotheses for models that best explain the available data. The next sections review literature where this characteristic has been employed to support parameterization and/or configuration of optimization problems. Moreover, reference is made to promising ML/NLP approaches that could contribute to this task. Therefore, symbols used for design variables and constants are both considered to be information entities. Among these entities, relations are defined. They represent range definitions, value assignments, objective functions, constraint functions, or relations used for generation. Table 6 lists the information entities and relations that were used for configuration and parameterization considering the reviewed works. They are further distinguished whether they originate from product specific requirements (A) or from existing knowledge for decision making in that phase, that is, the design rationale (B).
4.1. Methods supporting parameterization
Objectives and constraints are often formulated in a general sense and must be adapted to the concrete problem at hand before the optimization problem can be solved. For instance, imagine the task of finding an optimal bridge design. The original problem for that task could state that “the length of a bridge must be greater than the width of the river it spans.” Now, in order to find designs that suffice this constraint, the width of the river must be defined. Such concretizations of the problem are typically modeled by constants c that configure the objective functions f(x, c) = [f 1(x, c), f 2(x, c), … , f k(x, c)]T and/or constraint functions g i(x, c), h j(x, c).
Cluster-oriented genetic algorithms provide a method for dynamically parameterizing objective functions (Parmee & Bonham, Reference Parmee and Bonham1999; Parmee, Reference Parmee2002). They are a variant of GA that allows for exploring design spaces that have not been considered in the first place. This is supposed to support early design stages where the problem definition is uncertain and subject to frequent redefinition. A threshold constant on each objective function is introduced that determines which candidates will be considered in the solution set. The threshold can be adapted iteratively, where low values broaden the search while high values cause a more focused exploration of distinct regions of high performance. These regions are visually depicted so that the user can change the threshold in order to drive the problem definition toward a desired direction. Parmee and Bonham (Reference Parmee and Bonham1999) demonstrate this by showing the high-performance regions of three objective functions in a multiple-objective optimization problem. Two of the regions do overlap, which indicates that there is a subset of compromise solutions for the associated objectives. However, the high-performance region of the third objective is isolated from this. Relaxing the threshold for this objective is equivalent to a reduction of its relative importance and causes the associated region to expand. This ultimately leads to an overlapping of all three regions.
Ren and Papalambros (Reference Ren and Papalambros2011) tackle the problem of designer preference elicitation for design optimization by using a customized version of the efficient global optimization algorithm. It integrates a support vector machine (SVM) to iteratively refine constraints used for optimization. With each iteration of the efficient global optimization algorithm, the human designer chooses relatively suitable candidates from the generated solutions. From this response, the SVM classification mechanism produces a decision function that is used by a GA to sample new candidates from the design space. Completing the cycle, these samples are then presented to the designer to gather new feedback. Hence, the SVM decision function resembles a configurable constraint that is adapted over time in order to produce optimal solutions as desired by the designer.
4.2. Methods supporting configuration
Parameterization can be considered as choosing an instance from a rather narrow set of optimization problems that is defined by a known problem class. Configuration instead addresses the definition of that problem class. In the next sections different approaches are reviewed that help to determine all further elements of the problem definition beside constants, that is, design variables, objective functions, and constraint functions.
4.3. Product attribute extraction
Ghani et al. (Reference Ghani, Probst, Liu, Krema and Fano2006) characterized the term product attribute extraction. The idea of this NLP method is to produce formal representation of a product's attributes from semistructured or unstructured product descriptions (e.g., product recessions). Ideally, the extraction produces a variable description of each attribute found in the document corpus with its range defined by the written values. Each product description can then be represented by a data vector made up of the found attributes. This information can be directly used to define design variables x for product attributes. In contrast, product attribute extraction establishes the link between products/components and their attributes. In cases where design variables represent products/components, this relationship can be used to formulate objective functions f(x, c) and/or constraint functions g i(x, c), h j(x, c) that evaluate their characteristics.
Besides the original supervised method for extracting product attributes of Ghani et al. (Reference Ghani, Probst, Liu, Krema and Fano2006), semisupervised (Wu et al., Reference Wu, Cheng, Wang, Guo and Song2009) and unsupervised (Wong et al., Reference Wong, Lam and Wong2008) methods have been developed. These systems operate on semistructured product descriptions like websites, where additional context information is given by the structure of the HTML document. Raju et al. (Reference Raju, Shishtla and Varma2009) focused on unsupervised methods that can also be used for product attribute extraction from unstructured texts.
4.4. Clustering solutions with similar attributes
In product attribute extraction, the link between a variable (design object) and its range (characteristics of design object) is established by translating the information that is already explicit in documents into a formal representation. A different group of approaches targets the case where this information is not explicitly given. The starting point for these approaches is a set of solutions to a design problem. These solutions are then grouped with respect to the similarity of their characteristics using clustering methods. Each identified group is considered as the class of its contained instances. Having identified such class–instance relationships, the information can be used to express each class as a design variable x where the instances represent the variable's range.
Besides this, the inspection of discovered solution groups can provide hints for refining the optimization problem. Constraint functions g i(x, c), h j(x, c) may be defined that reflect the value boundaries of a specific group in order to formulate an optimization problem that specifically targets that region. Overlapping solution groups, in turn, suggest that more decisive optimization goals should be added to the set of objective functions f(x, c).
Xu et al. (Reference Xu, Ong and Nee2006) used a neural network to group components of similar products, called fan filter units, with respect to their functionality. Their work presents a way that design variables and their ranges can be defined automatically. Therefore, each component is described by means of a data vector that holds information about its material, signal, and energy flows. Using this as training data, the neural network is trained to group components that may be named differently but fulfill the same functionality; for example, components named “fan filter unit control,” “monitoring,” and “working condition control” are assigned to the group “control.” The resulting groups stand for abstract concepts that denote the functions of a product platform, for example, “control,” “insulation,” and “air filtering.” For the next step, each group is considered a design variable with its range defined by the associated components. This enables the GA-based optimization to identify new optimal component combinations for the product platform's set of functions.
Veerappa and Letier (Reference Veerappa and Letier2011) use a distance-based hierarchical clustering algorithm in the domain of requirement modeling. Their underlying problem is finding a set of requirements that maximizes value while minimizing cost. For each solution pair on the value- and cost-dimensioned Pareto frontier, a distance score measures their difference in fulfilled requirements. From these distances, a hierarchy of solution clusters is formed. On the one hand, it is supposed that navigating the hierarchy eases the selection of desired solutions. Moving from a cluster to one of its subclusters narrows the set of considered solutions. At this stage, in order to explore this region of interest in greater detail, one may introduce new constraints that correspond to the subcluster's boundary and rerun the search process. On the other hand, the proposed method also supports the identification of different solutions that achieve similar objectives. This is the case when clusters overlap. As a consequence for problem formulation, further objective functions may be introduced.
Similarly Reich and Fenves (Reference Reich, Fenves, Fisher, Pazzani and Langley1991) used hierarchical clustering to group characteristics of bridge designs (material, lanes, span, etc.) with respect to their occurrence in example design variants. The resulting hierarchical structure resembles a taxonomy of bridge designs, where each subclass is characterized by some specific properties (e.g., wooden bridges and steel constructions form two distinct groups).
4.5. Discovering relationships
The configuration of optimization problems can also be supported by making the relations among design variables, constants, objective functions, and constraint functions more tangible. It is essential for the formulation of optimization problems to know how these elements can be combined and what engineering concepts they reflect. Different approaches exist to acquire this information automatically:
• Analyze how the elements interact with each other during optimization.
• Examine what elements were used in combination over different problem formulations.
• Extract semantic relations among elements from design documentation.
Innovization is a method that discovers regressed functions over the design variables, objectives, and constraints (Bandaru & Deb, Reference Bandaru and Deb2013). These so-called design principles express hidden regularities within the problem formulation like proportionality between design variables. In order to find design principles, the discovery itself is formulated as an optimization problem searching over possible combinations of design variables, objectives, and constraints. The problem is then solved using a GA. As a preparatory step, innovization uses clustering to group related solutions. Bandaru and Deb (Reference Bandaru and Deb2013) distinguish between lower level and higher level innovization. Lower level innovization is used to identify design principles that are common to a subset of solutions from a single trade-off front. The extracted design principles can be used to identify solution subsets that show a desired property or conversely to find properties that characterize a desired region. Higher level innovization targets uncertainty in problem definition. Therefore, different trade-off fronts from varying problem parameterizations are fed into the regression to determine how changes to the problem affect prevalent design principles. For instance, it allows investigating what parts of the problem remain unaffected from the addition or deletion of new constraints.
The goal of Matthews et al. (Reference Matthews, Standingford, Holden and Wallace2006) was to discover abstract relations among the elements used for formulating optimization problems. They used a GP-based approach to determine what elements in a problem specification are strongly related to each other. This strength is computed from the covariances that are computed over the values of existing solutions. From the discovered relations, heuristics like “the thickness of a design has a strong influence on its weight” are derived.
Sarkar et al. (Reference Sarkar, Dong and Gero2008) analyzed multiple formulations of an optimization problem using the feature extraction method singular value decomposition. By means of singular value decomposition, latent syntactic relations among the used variables, constants, and functions were discovered. The trained meta-model can be queried to determine what variables, constants, or functions are relevant in the presence of one another. This feature can be used to guide engineers in finding an adequate ensemble of constraint and objective functions.
Another group of NLP works can be utilized to guide the creation of constraint or objective functions by showing how relevant concepts are related to each other. Wong et al. (Reference Wong, Bing and Lam2011) extended the product attribute extraction approach of Wong et al. (Reference Wong, Lam and Wong2008) with a clustering method that is applied on the found product attributes. It arranges semantically related attributes in hierarchically ordered groups. For instance, the attributes “charger” and “battery” of a digital camera are associated with the group “power information,” which is likewise a member of the group “hardware information.” Dong and Agogino (Reference Dong, Agogino, Gero and Sudweeks1997) analyzed documents from the field of product development to determine what central terms are mentioned in common contexts like “valve” and “pressure.” Similarly Yang et al. (Reference Yang, Wood and Cutkosky2005) automatically derived a thesaurus of design terms. Liang et al. (Reference Liang, Liu, Kwong and Lee2012) extracted terms that are characteristic for product components such as “print cartridge” and “ink drop generator” for an inkjet printhead design. They also present a method to identify sentences within product development documentation that are used for describing problems or solutions. Li and Ramani (Reference Li and Ramani2007) proposed an extraction method that uses some predefined ontology that represents domain knowledge about the texts to be analyzed. Given this, it is possible to build more sophisticated application ontologies that contain detailed information on the relations of mentioned concepts.
4.6. Computing objective functions
ML methods were also used to determine the components of objective functions f(x, c) = [f 1(x, c), f 2(x, c), … , f k(x, c)]T. Instead of describing each objective function manually, regression or classification methods may be used to derive objective functions from existing examples of good design solutions.
Both Kwong et al. (Reference Kwong, Luo and Tang2011) and Yang and Chen (Reference Yang and Chen2014) use regressed functions to describe the relation between customer requirements and engineering characteristics in the context of QFD. This information is crucial for assessing the potential customer satisfaction with the chosen engineering characteristics. The known satisfaction with existing products has been used to obtain estimates for this objective function.
In addition to these approaches, there has been an ongoing interest in the field of engineering design to discover relations between the structural and behavioral properties of designs. Such methods could be used to automate the formulation of fitness functions. Ivezic and Garrett (Reference Ivezic and Garrett1998) employed artificial neural networks (ANNs) to determine a regressed function. This function predicts behavioral aspects (e.g., deflection) and realization characteristics (e.g., construction time) of bridge designs from their structural properties (e.g., geometry, material, expected load). Using knowledge of the expected behavior, designers are able to evaluate whether the design objectives can be met. Reich and Barai (Reference Reich and Barai1999) and Neocleous and Schizas (Reference Neocleous and Schizas2002) also used ANNs. Their goal was to determine relations between the characteristics of propeller designs and their performance. Skibniewski et al. (Reference Skibniewski, Arciszewski and Lueprasert1997) and Szczepanik et al. (Reference Szczepanik, Arciszewski and Wnek1995) proposed rule induction methods that predict the manufacturing effort of beam designs and estimate the weight of designs.
4.7. Learning metamodels for evaluation
The goal is to identify an alternative objective function f ′(x, c) that is equivalent or at least approximate to f(x, c). This new objective function models the details inherent in the components of f(x, c) = [f 1(x, c), f 2(x, c), … , f k(x, c)]T on a more abstract level. Here, the underlying aim is either to apply the same functions to a wider range of problems or to perform the optimization more efficiently. In certain domains, for instance, using exact evaluation functions for the selection of individuals can become very costly, for example, if simulations are to be computed or marketing interviews have to be conducted. Therefore, more abstract evaluation schemes like performance heuristics or approximations can help to make solving the problem more practicable.
Perez and Behdinan (Reference Perez and Behdinan2002) and Lin (Reference Lin2003) both employed ANNs to learn a classification from existing evaluations. If enough evaluation results have been generated, then the neural network is trained and used as a replacement for the costly evaluation function.
There is a range of further ML applications that learn abstract meta-models from existing descriptions of relations. A knowledge compilation approach was taken by Chabot and Brown (Reference Chabot and Brown1994). Their system learned the abstract restriction “x surrounds y” from relations among the diameters of different components. Bhatta and Goel (Reference Bhatta and Goel1994) used instance-based learning to generalize functional relations of two designs to yield an abstract principle solution. Given a functional and behavioral description of a sulfuric acid cooler and a nitric acid cooler, the model of a generic heat exchanger is derived. Using a hierarchical clustering method (Reffat & Gero, Reference Reffat, Gero and Gero2000) grouped geometric restrictions (e.g., symmetry, adjacency) with respect to their joint use within floor plan designs. In addition, Wang and Shan (Reference Wang and Shan2006) provide a comprehensive overview over metamodeling techniques in optimization that go beyond the herein discussed ML/NLP approaches.
4.8. Learning patterns of good design
Here, the idea is to investigate the inverse relation of the overall objective function f(x, c). ML methods are used to determine combinations of value assignments for subsets of x that cause f(x, c) to drop considerably. These promising value combinations are called chunks. Introducing a bias toward the selection of known chunks can help to solve similar optimization problems better and/or faster. This bias can be implemented in different ways:
• Change some variables of x to constants c whose values correspond to those of a desired chunk.
• Introduce additional constraints g i(x, c) and/or h j(x, c) that restrict x to value combinations of known chunks.
• Use special generation methods that tend to choose values of known chunks for x.
Moss et al. (Reference Moss, Cagan and Kotovsky2004) extended the A-Design method (Campbell et al., Reference Campbell, Cagan and Kotovsky1999) to identify well performing patterns in solutions. These chunks are then reused in new problems to generate candidates during optimization. As a result, the system's efficiency and effectiveness are incrementally increased. Mukerjee and Dabbeeru (Reference Mukerjee and Dabbeeru2012) use dimension reduction to identify chunks. In this case, the learned chunks decide whether a design is feasible or not. By analyzing communication protocols of designers, their approach was able to assign a natural language symbol to these learned relations (e.g., the parts of a construction “fit tight”).
Finding appropriate designs for a set of required engineering characteristics has been in the scope of various ML-based approaches. Starting from the problem of finding a frame geometry with optimal load characteristics, Hanna (Reference Hanna2007) applied the SVM technique to learn a classification that conversely identifies adequate frame constructions for given loads. Forouraghi (Reference Forouraghi1999) used multivariate regression trees to determine variant groups that optimally fulfill a goal function. These groups define ranges for design variables that should be obeyed in order to optimize the objective functions. Both Gero et al. (Reference Gero, Louis and Kundu1994) and Yogev et al. (Reference Yogev, Shapiro, Member and Antonsson2010) draw upon the idea that ML can be seen as a search for hypotheses that best explain the data. They make use of GAs to search for production rules for a shape grammar. The language produced by the shape grammar then defines the set of reasonable shapes to choose from.
Table 7 provides a summary of the discussed approaches to configuration and parameterization. It further depicts how these relate to the patterns of problem formulation that could be observed from the reviewed applications of evolutionary optimization.
Table 7. Summary of machine learning/natural language processing approaches to the support of parameterization and configuration
5. CONCLUSION
We presented a short yet comprehensive overview of GA/GP-based engineering design optimization approaches from various phases of design exploration, that is, requirement modeling, function modeling, principle modeling, modularization, and preliminary embodiment design. Although several commonalities can be observed, each of the discussed problems was required to be set up according to the requirements and designing rationale that are specific for the project and engineering domain. In order to integrate this spectrum in a computational framework that spans multiple design phases, additional mechanisms are needed for facilitating the automatic configuration and parameterization of optimization problems.
Despite the different nature of the design phases, the formulation of related optimization problems still reduces to defining constants, design variables, objective functions, and constraint functions. Recurring patterns in problem formulation could be observed from the reviewed applications of evolutionary optimizations. This in turn suggested that methods targeting these patterns can support the formulation of optimization problems over multiple design phases.
Various methods were reviewed from the fields of ML and NLP for this purpose. They can be utilized to acquire the information entities and relations that are needed for configuration and parameterization. Up to now, several of these methods have been integrated into the representation, evaluation, and generation aspects of GA/GP-based design optimization. As discussed, there are further applications of ML/NLP in the field of engineering design that could be used to expand this support.
Julian Eichhoff is a doctoral student at the Institute of Computer-Aided Product Development Systems at the University of Stuttgart. He received BS and MS degrees in computer science from Furtwangen University. His research focuses on integrating machine learning methods with computer-aided design, formal design representations, and design automation. From 2009 to 2012 he participated in the project Re-Use of Semantic Product Knowledge in New Product Design Processes under Prof. Wolfgang Maass at Furtwangen University.
Dieter Roller is a Professor, the Chair of Computer Science Fundamentals, and the Director of the Institute of Computer-Aided Product Development at the University of Stuttgart. He is an Honorary Professor at the University of Kaiserslautern and serves on the board of trustees of the Technische Akademie Esslingen. He is Chairman of several national symposia, congresses, and workshops in product development and automation. Dr. Roller gained comprehensive industrial experience as a former research and development manager with worldwide responsibility for computer-aided design technology within an international computer company.
