Computer-Aided Design 43 (2011) 170–179

Contents lists available at ScienceDirect

Computer-Aided Design

journal homepage: www.elsevier.com/locate/cad

On the architecture of a human-centered CAD agent systemShrey Modi a, M.K. Tiwari b, Yingzi Lin c, W.J. Zhang a,∗

a Advanced Engineering Design Laboratory, University of Saskatchewan, Saskatoon, SK, Canadab Department of Industrial Engineering and Management, I.I.T Kharagpur, WB, Indiac Department of Mechanical and Industrial Engineering, Northeastern University, Boston, MA, USA

a r t i c l e i n f o

Article history:Received 11 November 2009Accepted 26 October 2010

Keywords:Design softwareHuman-centered designMulti-agent systemsPetri-netsACT-RFuzzy logic

a b s t r a c t

With an increasing role of computers in the design process, a strong foundation of the basic principles forbuilding CAD systems is extremely necessary. This work describes the architecture of a CAD system fromthe perspective of the capabilities required to build a human centered CAD system. These capabilities havebeen reported as task-sharing, communication, transparency, design rationale and cognition. Existingsystems for engineering design have been analyzed from the perspective of these capabilities and anagent-based system previously reported in literature has been extended to a new architecture to supportthree of the aforementioned capabilities. The proposed architecture is an amalgamation of multi-agentsystems, the ACT-R cognitive architecture and fuzzy rule based Petri nets. The salient advantage of thisarchitecture is that it focuses on the capabilities of design rationale, transparency and cognition together—something which has been missing from all the current works in literature and is unique to the domainof application of the software system, which in this case is engineering design. The other capabilitiesnamely task sharing and communication can be incorporated from lessons learnt from human–computerinteraction research. The effectiveness of the proposed architecture is demonstrated by a hypotheticaldesign case along with its implementation.

© 2010 Elsevier Ltd. All rights reserved.

1. Introduction

Computer support in engineering design has inarguably be-come a necessity. This is especially true in case of configurationdesign problems where the component space is very large and itbecomes difficult for human designers to manually produce ef-fective design solutions. Design practices followed by human de-signers have evolved over the last three decades—so have the CADsoftware systems support for design. Unfortunately, these softwaresystems fail to mimic some of the essential aspects of human de-signers.

An unprecedented majority of the software systems discussedin the current literature have the ability to produce solutions toconfiguration design problems in a completely automated processwith very little collaboration with human designers. Also, verylittle evidence can be found in the literature focusing on softwaresystems which are capable of explaining the rationale behind thedesign process to the human designers. Even lesser research isconducted on understanding and implementing the human factorsperspective in the design synthesis, for example, how humandesigners synthesize design solutions and how they learn withexperience.

∗ Corresponding author. Tel.: +1 306 3742604.E-mail addresses: chris.zhang@usask.ca, wjz485@mail.usask.ca (W.J. Zhang).

0010-4485/$ – see front matter© 2010 Elsevier Ltd. All rights reserved.doi:10.1016/j.cad.2010.10.006

Fully automated software systems are of very little final valuein the domain of configuration design, as they take the human outof the design loop; instead the software systems should be activeparticipants in the design synthesis process having appropriate ra-tionale,mediumof expression andknowledge about thehumanac-tivity in design. This notion of a software system leads to researchtowards Human Assistance Systems (HAS) for computer-aided de-sign (CAD) systems. Following the aforementioned discussion, afew capabilities that the software system should possess have beenidentified: task sharing, transparency, design rationale, communi-cation and cognition.

‘‘Task sharing’’ refers to the sharing of tasks/sub-tasks in thedesign process among the participants, who in this case are ahuman designer and a software program system (or a CAD agent).The CAD agent should support the human designers in their tasks,rather than removing them from the design synthesis loop. Suchphilosophy of CADagents originates in ourmind fromSheridan andParasuraman’s [1] summary on human–automation interaction,Norman and Drapers’s [2] book on Human-centered design, anda recent paradigm being raised in the context of human-centereddesign [3]. An example of why task sharing is very important isthe necessity of creativity. Task sharing would help the designerto focus on the task which requires creativity, while he/she gainssupport from the software to perform other tasks. Had all thetasks been accomplished by the software, the creativity in design

S. Modi et al. / Computer-Aided Design 43 (2011) 170–179 171

would have been compromised. Another disadvantage of totalautomation of design synthesis is that human designers would nolonger be able to hone their design skills with experience.

To achieve the best performance from a CAD agent, it is ex-tremely important that the agent clearly explains the rationalebehind its design process to the human designer. To achieve thisobjective, a two-way dialogue should exist between the humandesigner and the CAD agent for information transfer and commu-nication. This school of thought gives way to the following require-ments. (1) ‘‘Transparency’’: the capability of the agent to representits actions to the designer so that the designer can be ‘in-the-loop’.(2) ‘‘Design Rationale’’: the capability of the agent to have appro-priate rationale for every step it executes in the design synthe-sis. (3) ‘‘Communication’’: the ability of the agent to communicatewith and receive feedback from the human designer through ahuman–agent interface.

The capability of ‘‘cognition’’ refers to the ability of the agentto learn from the design experience. It is well known that humandesigners gain experience over time and become efficient astheir experience in a design domain increases. This performanceimprovement can be explained by a human’s cognitive ability toapply the knowledge acquired over experience to produce efficientsolutions [4]. The agent should be able to simulate this ability.

All of the aforementioned capabilities are vital to be possessedby the agent to realize an ideal HAS for CAD. However, the scope ofthis paper is to investigate the architecture of an agent which hasthree capabilities of cognition, transparency and design rationaleinto the system. The other capabilities, namely communication andautomation level, are not focused upon in this study, as lessonslearnt from traditional software design principles can be borrowedand applied to the proposed agent-based system to impart thesecapabilities. However, a study of the combination of the cognition,transparency and rationale is essential, as it would be unique tothe software’s application domain, which in this case is the fieldof engineering design. Essentially, we extend a model of an agent-based system in the literature [4], which is built upon the ACT-R cognitive architecture, to incorporating the transparency anddesign rationale capabilities into the system by using Petri netsand Fuzzy Logic. The effectiveness of the proposed architectureis demonstrated by solving a hypothetical configuration designproblem along with its implementation. This implementation alsogives great confidence for a more comprehensive implementationof the proposed architecture for more complex design problems.

The rest of the paper is organized as follows. Existing modelsof software systems for engineering design are discussed fromthe perspective of the aforementioned capabilities in Section 2.A brief description of the ACT-R architecture and the Petri Netsis also presented in Section 2, and they are the tools available inliterature to realize the aforementioned capabilities. The proposedarchitecture is elaborated upon in Section 3. The implementationof the architecture to demonstrate how the proposed HAS conceptworks and to drive the feasibility of a more comprehensiveimplementation of such a CAD agent system is described inSection 4. The paper is concluded in Section 5.

2. Capabilities and tools

Imparting capabilities of communication, transparency, etc. tothe software system fall under the contemporary definition of useof a computational agent (henceforth referred to as agent). Agentsare sophisticated computer programs which possess attributessuch as social behavior, reactivity, etc. and can solve tasks onbehalf of their users. Franklin and Graesser [5] summarize theliterature on agents and distinguish between agents and othersoftware programs. Increasingly, complex tasks require multipleagents that can work together. A multi-agent system (MAS) is

a collection of multiple agents, possessing diverse capabilities,which work interactively, distributing various resources amongstthem, to achieve a common goal [6]. Building the capabilitiesas discussed in the aforementioned paragraphs would essentiallymeanbuilding up on the ideology of an intelligent agent-basedHASsystem.

Agent-based design models are reported in the literature. A-Design [7–9] is an iterative, multi-agent-based design for solvingengineering design problems. It consists of four classes of inter-acting agents—The Configuration agents (C-Agents) construct can-didate designs using a library of embodiments depending on theinput and output constraints specified by the human designer; theInstantiation agents (I-Agents) take the configuration designs fromC-agents and instantiate the parameters in the system with val-ues obtained from a catalogue of components; the Manager agents(M-agents) take the design population and produce feedback thatcontrols how other agents in the system operate; the Fragmenta-tion agents (F-agents) take out one or more components from thegood designs and these fragmented designs are reconstructed andbecome part of the next iteration’s design population.

A-Design system has a primitive level of communication ca-pabilities: it consists of two monologues between the humandesigner and the system—the designer issues the command; soft-ware displays the result. Also, the rationale built in the system isto heuristically search and connect inter-connectible componentsto complete the design. However, this can be considered as oper-ating logic which is the behavior of the system. The ‘‘actual’’ ratio-nale should be the rationale behind the choice of the components,which in this case is a heuristic search. This serves very little valueas this rationale is not understandable to the human designer. Adetailed description of A-Design can be found in [7–9].

Establishing useful and successful communications betweenthe computer software and the human designer has also beendemonstrated in literature in another agent-based design systemproposed in [10]. In this system, human designers can interruptthe design synthesis and initiate a small dialog with the Man-ager–agent if he/she wishes to, by which he can adjust the rat-ing system of the design process. The dialog consists of a task forthe human designers to rate three design variants on a scale of1–10 provided that the best solution in a particular iteration is con-sidered to have a rating of 5. It is worthwhile to note that in theagent-based design in [10], there is a notion of human designersand agents cooperating with each other to produce the designs.In other words, there is a level of automation built into the sys-tem such that the system is not fully automated. The sharing oftasks here is that the human designer uses his experience, to guidethe agent to produce good designs, by teaching the agent to ratethe design variants. This capability keeps the human-in-the-loopwhich is an increasing necessity in human–automation interaction[11–14]. Another notable improvement of this system is the in-creased level of communication capabilities. However, the capabil-ities of transparency and cognition are still lacking in this system.

Moss et al. [4] proposed a software system in which the agentspossess the ability to learn from design experience. This systemseems to be very effective in deploying the experience by transfer-ring the knowledge learnt in the previous iterations. Design pro-cesses for three electromechanical problems were demonstratedwith this system.

The ability of cognition is given to the agents in [4] by using theACT-R architecture. ACT-R is a cognitive architecture to understandand simulate human cognition [15–17]. It consists of two types ofmemory modules namely, ‘Declarative Memory’ and ‘ProceduralMemory’. Knowledge is represented as chunks (or buffers) that col-lectively constitute the declarative memory. Procedural memoryconsists of production rules representing the knowledge of howhumans do things [16]. It is essentially the most vital module of

172 S. Modi et al. / Computer-Aided Design 43 (2011) 170–179

ACT-R, as it possesses the knowledge of performing the tasks [18].For example, in case of a calculation task, the procedural memoryis the generalised knowledge of the process of performing addi-tion tasks making use of addition chunks (declarative memory)—the effectiveness of ACT-Rdependsmore on the effectiveness of theprocedural module, and hence it should be carefully modelled.For further information on the ACT-R architecture, the reader isdirected to the bibliography maintained by the ACT-R group atCMU [19].

Although the agent-based ACT-R model of Moss et al. [4] is suc-cessful in imparting cognitive abilities in terms of representingdesign components in the declarative module or declarative mem-ory, the procedural memory remains a black box. The design syn-thesis process is highly event-driven; the type of component to bechosen in later stages of design depends on the component chosenin the current design stage as the component functional parame-ters should match. The model of Moss et al. [4] lacks a proper for-malism to represent this complex event-driven behaviour of thedesign system. In other words, the software system lacks the ca-pability to make its design procedure transparent to the humandesigner. Also, at each stage, selection made between competingsolutions depends on several parameters. For example, a structuralframe with built-in fixtures for an air conditioner might eventu-ally yield a low cost design rather than buying the frame and fix-tures separately. Hence at the design stage of choosing the frame,the human designer’s past experience at the stage comes into play.Furthermore, the human designer does consider the cost of indi-vidual components while deciding different solution components,and this means that his/her decision is also influenced by his/herexperience of howwell the component would minimize the entiredesign cost. This issue is to do with logic, or the rationale behindthe choice of the components.

We propose an agent system which eliminates the aforemen-tioned limitations in [4], namely the lack of transparency and ra-tionale in the agent-based system, by building upon their ideaof the ACT-R based design software. It is noted that the capabil-ities of task sharing and communication are generic to softwareinterface research, and lessons learnt from Human–Computer In-teraction (HCI) literature can be borrowed to the design interfacedomain. Therefore, our proposed agent system does not addressthese two capabilities. In sum, the capabilities of cognition, trans-parency and rationale are unique to the domain of engineering de-sign, and theywill be equipped in the newCAD agent by using Petrinets and Fuzzy Logic, concurrently with a multi-agent system andthe ACT-R architecture.

Petri nets (PNs) provide a proper tool to explicitly representprocess knowledge, and Fuzzy Logic is best suited for explanationof the rationale of decision making in the case of competingsolutions. The PN is a very promising tool to represent concurrentor parallel systems and can clearly capture the system constraintsbetter thanothermodels [20]. The PNmaybe viewed as a particularkind of directed graph (Fig. 1) comprising of four kinds of primitiveobjects–places, transitions, directed arcs connecting the places tothe transitions and the transitions to the places and tokens. Adetailed tutorial of PNs can be found in [21].

A Petri net (PN) is represented in tuples, an example of which isillustrated below.

PN = (P, T , I,O,M) (1)

where,P = Set of places,T = Set of transitions,I = Input function,O = Output function, andM = Marking of the Petri Net.

Fig. 1. A sample Petri net depicting places and transitions.

The example shown above consists of 5 tuples. The numberof tuples may be increased to incorporate additional information.Marking denotes the state of the PN by associating places with to-kens. A transition can be enabled only when the number of tokensat all the places is greater than the weight of the correspondingconnecting arcs. However, this may not be the sole criteria of en-abling a transition but it is the constraint for a particular transitionto qualify for enabling.More information on Petri nets can be foundin the seminal paper by Murata [20].

Instances of applications of evolutionary algorithms for solv-ing engineering design problems are also seen in the literature.Tay et al. [22] evolve a bond graph representation of the dynamicsystem using genetic algorithms to meet the specified design cri-teria. A genetic-search approach was presented by Brown andHwang [23], which configures design by searching parts out ofthe design catalogues. An evolutionary algorithmwas proposed byCarlson-Skalak et al. [24], which was developed for catalogue de-sign, and it was able to find good design solutions that satisfiedthe given specification. However, evolutionary algorithmbased ap-proaches have three major disadvantages: (1) They fail to incorpo-rate the human cognitive process of problem solving (i.e., capturethe human activity in design); (2) They keep the human operatorin the dark and act as a black box thus lacking transparency in rep-resenting the design synthesis; (3) They lack a good formalism toexplain the rationale of their problem solving approach. In otherwords, the heuristic algorithmic approach to software design doesnot follow thehuman-centred design principle andwould not yielda good HAS for design.

Researchers have also tried the Object Oriented approach forsolving engineering design problems [25,26]. However, modellingdesign knowledge in an object fashion is similar to the declarativemodule of the ACT-R architecture—the objects in the object ori-ented programming paradigmare the same as the chunks in ACT-R.The added benefit that ACT-R provides is to use this representationto solve problems in terms of procedural knowledge.

3. Proposed architecture

In the present work, an agent-based architecture of a HASfor CAD system is proposed. From a conceptual standpoint, wepropose to use fuzzy rule based Petri nets for design rationale andtransparency, and ACT-R of [4] for cognition. However, to discussthe architecture in detail, a context (or function) of the CAD systemis necessary.

The proposed architecture describes a CAD agent system withthe following functionality: given a set of input and outputspecifications of design requirements, the CAD system returnsdesign solutions with minimum cost. Hence the design cost isthe objective function which is to be optimized by the CAD agentsystem. It is to be noted that the scope of this objective functionis limited to the parameters such as weight, cost, or cumulative

S. Modi et al. / Computer-Aided Design 43 (2011) 170–179 173

Table 1Modified representation of the chunks of Moss et al. [4].

Design-chunk C

Isa: Design-chunkInput-domain: Translation/rotation etc.Input-interface: Bolt/shaft-hole etc.Output-domain: Translation/rotation etc.Output-interface: Bolt/shaft-hole etc.Components: C1, C2 etc.Connectivity: Port-1 of C1 is connected to Port-1 of C2.Goodness: Cost of the chunk

error, in which the cumulative sum of the specified parameters ofthe components in the design solutions represents the parametersof the entire design itself. For example, the weight of a designsolution or product is same as the sum of the weights of theindividual components in the product. The proposed architectureis based on the aforementioned context (or function) of the CADsystem. However, it is noted that the architecture can be modifiedappropriately to suit other contexts.

In the proposed architecture, the human designer studies theproblem and identifies the input and output constraints (domainand interface) required in the design. He/she inputs these con-straints into the CAD agent system and specifies an objective towhich the function is to be optimized (minimization of the ob-jective function). After the human designer inputs the requiredspecifications, the agents take charge and search for designs iter-atively until the number of iterations exhaust or the design costreaches an acceptable level—this criterion being specified by thehuman designer. The remainder of this section first describes themodelling of the context of the problem using ACT-R and rule-based Petri Nets. Second, a short note is presented on the multi-agent structure illustrating the interactions between the agentsand their collective problem solving technique. Finally, the aspectof learning from knowledge transfer is discussed, and a pseudo-code of the entire architecture is presented.

The chunk representation, which constitutes the declarativepart of ACT-R, in the context of engineering design problems, hasbeen illustrated in the work of Moss et al. [4]. In our architecture,the cost attribute of the chunk is added to the representationpresented in [4] as shown in Table 1, and this representation isused as the design chunk in the proposed model. This extensionto the representation in [4] is necessary as the cost of the chunk isused in the rule based Petri net to take decisions which build thedesign rationale of the software tominimize the objective function,as discussed in subsequent paragraphs.

The domain and interface attributes collectively represent theFunctional Parameters (FPs) of the chunk. Two chunks can connectwith each other only if the output FPs of the former chunkmatchesthe input FPs of the latter—e.g., in the case of a desktop computer,a monitor can only connect to the CPU via the socket provided inthe CPU for the monitor cable; this joint is the match of the outputand input FPs of the monitor and the CPU, respectively. A chunkconsists of several components (Table 1) and the cost of the chunkis the cumulative sum of the cost of these individual components.

The computer agents start building the solution by selectinga chunk whose input FPs match with the input FPs specified bythe human designer. At each stage of the design, including theinitialization of a design, there might be several chunks that haveinput FPs similar to the output FPs of the current stage of the design(and for the initialization chunk the input FPs need to be similarto the input FPs specified by the human) and decisions have tobe made to select one of these chunks to proceed towards thecompletion of the design. In other words, the choice system isparallel and concurrent. Ideally, the analysis process has to be ableto learn to build and take smarter decisions and this requires thedecision evaluation system to be adaptive. A rule-based Petri net

Fig. 2. An example of the RB-PN implemented in the current work.

is chosen for such system in the current model because it offers alogical reasoning about the choice of decisionsmade and thewholeanalysis process is clear to the human designer who is in control ofthemodel; it offers a grey box if not awhite box understanding andtransparency. This rule based Petri net (RB-PN) accounts for theprocedural knowledge (or the production system) of ACT-R. TheRB-PN proposed in an 8-tuple PN as follows:

RB-PN = (Pst, Pso, T , I,O,D,W ,M) (2)

where,Pst = Set of state places (current state of the design),Pso = Set of source places (chunks that can be added to the currentstate),T = Set of transitions (events which advance the design stage byfiring),I = Input function,O = Output function,D = Set of proposition s,W = Preferences of the transitions, andM = Marking of the Petri Net.A primitive example is illustrated in Fig. 2. The alphabets ‘A’,‘X’, ‘F’, etc. in Fig. 2 represent various chunks available in theknowledge pool (collection of design chunks) which also denotethe places of the RB-PN. The places ‘A’, ‘A–X’, ‘A–F’, ‘A–X–F–M’,and ‘A–X–C–M’ denote the state places (Pst) and the places ‘X’, ‘F’,‘P–M’, ‘C–M’ denote the source places (Pso). The transitions ‘t1’, ‘t2’,‘t3’ and ‘t4’ represent the events which advance the design. Theproblem is to construct a solution which has the input and outputFPs of the chunks ‘A’ and ‘M’, respectively. Such a design can beobtained by either firing transitions of the set (t1, t3) or the set(t2, t4), respectively, and there might be many more similar setsto construct the design.

It is worthwhile to specifically cite the transparency achievedby use of PN. Fig. 2 is a pictorial representation of the designsynthesis to produce the product ‘A- · · · -M’. The steps leading tothe evolution of a particular solution to the problem is visible tothe human designer bymeans of such a pictorial diagram. Consideran example where it is required to build a table which can beeasily moved, and the objective is the minimization of the totalcost of the table. Let A, X, F, P, C and M in Fig. 2 correspond to tabletop, metallic frame, wooden frame, metallic legs, wooden legs andwheels respectively. The same is shown in Fig. 3. By representingthese chunks, pictorially in the PN gives the ability to the softwareto transparently and visually represent the steps which lead to aparticular design solution, i.e., either ‘A–X–P–M’ or ‘A–C–F–M’. Therationale behind the choice of a particular solution is explained bythe set of transitions which are fired, based on the rules specified(discussed in the following paragraphs).

At each stage of the design, the transitions which qualifyfor enabling are extracted and the choice of the transition to

174 S. Modi et al. / Computer-Aided Design 43 (2011) 170–179

Fig. 3. A sample table-design problem being solved and shown by use of the conceptualized Petri net interface.

Table 2Conversion of the fuzzy variable to the synthetic variable x.

Fuzzy variable Synthetic variable (x)

The transition’s cost x =(cmax−c)(cmax−cmin)

where,c = cost of the transition in consideration.cmin = the minimum cost among all the possible transitions.cmax = the maximum cost among all the possible transitions.

The transition’s preference x =(w−wmin)

(wmax−wmin)

where,w = preference of the transition in considerationwmin = the minimum preference among all the possible transitionswmax = the maximum preference among all the possibletransitions

be fired is to be determined. This choice is not just dependenton the component cost but also its performance in minimizingthe entire design cost in previously constructed designs. Thecomparison of transitions (firing a transition is equivalent tochoosing the component at its source place) to be made is relativeamong the available options and is very vague in nature. Asample rule can be as follows: ‘‘Among all available transitions,if the cost of the component at the source place is least and itsperformance is highest, then the transition is fired’’. Followingthis ideology, a fuzzy logic principle [27] is employed to decidebetween competing transitions. The fuzzy variables are identifiedas the transition’s cost and the transition’s preference. These fuzzyvariables denote the cost (equal to the cost of the source chunk ofthe transition) and the preference value (tuple of the RB-PN) of thetransition, respectively. (The preference of the transition correlatesto how well firing the transition (or choosing the componentchunk at its source place) performed in previous designs; thepreference of a transition is updated if it was fired to build asolution so that later instances can learn from experience. Themathematical update function of the preference value is listedconsequently, in this section.) The fuzzy sets are identified asbeing high, medium and low. To determine the association rules(trapezoidal) between the fuzzy variables and sets, a syntheticvariable x is considered as shown in Table 2. The associationfunctions of the synthetic variable x (which is equivalent to theassociation of the corresponding fuzzy variable) to the fuzzy setshave been summarized in Table 3. It is to be noted here that thetransition with low cost and high preference is desired (Table 2).

The choice of the transition to fire is determined by a set ofrules which constitute the design rationale of the software system.

Table 3Association rules of x with the fuzzy sets high, medium and low.

Range of a variable x Association function of the variable to the fuzzy sets:High Medium Low

0 ≤ x < 0.25 1.0 0.0 0.00.25 ≤ x < 0.4 (0.4 − x)/0.15 (x − 0.25)/0.15 0.00.4 ≤ x < 0.6 0.0 1.0 0.00.6 ≤ x < 0.75 0.0 (0.75 − x)/0.15 (x −

0.6)/0.150.75 ≤ x < 1.0 0.0 0.0 1.0

Table 4Rule-table of the software system which represents the ‘‘design rationale’’.

Transition’s cost Transition’s preference Enabling factor (EF)

Low High 1.00Low Medium 0.90Low Medium 0.15Medium High 0.80Medium Medium 0.75Medium Low 0.15High High 0.15High Medium 0.10High Low 0.05

These rules are summarized in Table 4, and an example of a ruleis constructed from a record of the rule-table is: ‘‘If the transition’scost is low, and the transition’s preference is high, then EF = 1.00’’,there ‘‘EF’’ is the enabling factor of the rule, which is used to obtainthe modified truthfulness value of the rule as

Modified truthfulness = Actual truthfulness × EF. (3)

S. Modi et al. / Computer-Aided Design 43 (2011) 170–179 175

Fig. 4. The multi-agent structure.

For each transition, all of these rules are applied and the transi-tion which has the maximum modified truthfulness value is firedand the marking of the Petri net is adjusted.

In the multi-agent system used in this proposed architecture,three agents are proposed—Configuration Agent (CA), EvaluatorAgent (EA) and Fragment Agent (FA). The CA is responsible for theconstruction of the candidate solutions depending on the inputand output specifications provided by the user. At each stage ofthe design, it extracts the transitions from the RB-PN that qualifyfor enabling, and depending upon the rules of the RB-PN, it firestransitions to advance the state of the design. At the end, itsends the completed candidate solution to the EA for evaluation.The EA evaluates the fitness of the solution by the objectivefunction specified by the human designer and eventually, updatesthe weights of the transitions, which were fired to complete thesolution, as per the following rule:

w = w0 +1w (4)1w = β/C (5)

where,w0 = initial preference value of the transition,w = updated preference value of the transition,β = update index (0 < β ≤ 1) (specified by the human designer),andC = Cost of the solution.By updating the preference of the transitions, it is ensured thatthe agents learn from previous experience by use of the updatepreference in the fuzzy choice between the transitions. It is notedthat the objective is to minimize the design cost of the entiresolution, and hence the update rule is an inverse function of thesolution cost; cheaper the solution, higher the preference. Afterupdating the preference values in the RB-PN, the EA passes thesolution to FA which optimizes the final solution considering eachchunk as a fragment. For example, if ‘A–B–C–D’ is a solution (‘A’,‘B’, ‘C’, and ‘D’ being chunks), and ‘E’ is another chunk matchingthe FPs of ‘B’ but having lower cost than ‘B’, then the solution‘A–E–C–D’ is conceptualized (since the problem is to minimize thecost of the design) and the corresponding transitions’ preferencevalues are updated so that the CA can learn from this discoveryduring construction of the next candidate solution. The EA andthe FA have a similar function which is to update the transitionpreference values. However the FA has an additional responsibilityof optimizing the solution by optimizing individual fragmentsof the solution. The interaction between the agents has beendepicted in Fig. 4. The model searches for the optimal solutioniteratively, given that the process of the construction, evaluationand chunk wise optimization of a candidate solution by the agentsis considered as a single iteration.

It is to be noted that thewhile constructing a candidate solution,a part of the solution might be unnecessary loops of chunks, a

Table 5Pseudo code.

Human designer initializes the parametersFor each iteration iBegin

While solution S is incompleteBegin

CA fires transitions based of the RB-PN to complete SIf any loops have been encounteredBegin

CA eliminates the loopCA penalizes the transitions which lead the creation of the loop

EndEndCA sends S to Evaluator Agent (EA)EA updates the transition weights related to S and passes S to Fragment

Agent (FA)FA optimizes S chunk-wise to generate solution SoFA updates the transition weights corresponding to So

EndPrint the best solution obtained

worse situation being that the CA might get caught up in the loopand never complete the solution. To overcome this situation, theCA back-checks the solution state after the firing of each solution,to cut the loop and penalize the fired transitions (i.e., reduce thepreferences of the transitions)which led to the creation of the loop,so they do not appear in later designs, as follows: If t1, t2, t3, . . . , tnwere the transitions that were required to fire for the creation of aloop (in series), then the total penalty to be imposed is a fraction ofthe cumulative cost of the transitions. This penalty is distributed inparts to all the transitions (t1, t2, t3, . . . , tn) in an arithmetic series,in which case t1 and tn are the least andmost penalized transitions,respectively. The penaltyψi on the preference of the transition ti isgiven by

ψi =iΩ

n(n+1)2

(6)

whereΩ = Total penalty = α

∑ni=1 ci,

α = Penalty index (0 < α ≤ 1) (specified by the human designer),i = Transition Index,n = Total number of transitions in the loop, andci = cost of transition ti (equal to the cost of the source place of thetransition).Learning from design experience has been demonstrated by Mosset al. [4] by passing the learned chunks between different prob-lems. This is similar to humans retaining good designs in mem-ory and using them when they encounter a similar problem [4]. Inthe currentmodel, we propose the transfer of the transition prefer-ences across problems for learning. It is to be noted that the pref-erences of the transition are equivalent to the preferences of thesource places, or the chunks, of the transition. Hence, passing thepreferences effectively infers the passing of the knowledge of thegood and bad chunks. The pseudo code of the architecture is pre-sented in Table 5 and Fig. 5, which illustrates the flow chart of themodel.

4. Example, results and discussion

The requirements for a human-centered CAD system proposedin the current work are revisited as having transparency, designrationale and cognitive capabilities. The proposed architecture de-scribed previously is hypothesized to be able to lead to a softwaresystem that can fulfil these requirements.

Petri nets and fuzzy logic together satisfy the transparency anddesign rationale requirements as fuzzy logic gives a natural way

176 S. Modi et al. / Computer-Aided Design 43 (2011) 170–179

Fig. 5. Flow chart of the architecture.

Table 6An example design chunk.Source: Adapted from [4].

Chunk belt–pulley

Isa: Design chunkInput domain: TranslationInput interface: BoltOutput domain: RotationOutput interface: Shaft-holeComponents: Belt, pulleyConnectivity: Port-1 of component-1 is connected to Port-1 of

component-2Goodness: 180

of decision making which can be easily understood by humandesigners and by means of the pictorial representation of thedesign synthesis process (an example of which is shown in Fig. 3).The pictorial representation of the transitions fired to complete thedesign provides a transparent and white-box view of the actionsexecuted by the agent system at every step of the design synthesis.

The capability of cognition is hypothesized to be achieved byuse of the ACT-R architecture of [4]. This hypothesis is verified inthis section as the original architecture of [4] is not used ‘as is’ butis modified and a rule based Petri Net is used as the proceduralmemory of the ACT-R. Some other issues related to the architecturesuch as convergence and loop elimination by the multi-agentsystem are also tested in the implementation.

To determine the effectiveness of the proposed agent systemfor supporting engineering design, a design example is essentialas long as a sufficiently large component base is available forthe design synthesis. For example, in the case of solving electro-mechanical design problems, the component base,which primarilyconsists of elements such as footpad, lever, springs, pulleys, belts,cylinders, generators, resistors, etc., has to be large enough sothat the software agents be able to not only produce variants ofdesign solutions using different combinations and configurationsof components, but also be able to learn which components yieldbetter design solutions and which effect the design solution theworst, with respect to the objective function (say minimization ofthe design cost). Table 6 depicts a chunk (belt–pulley chunk) as perthe proposed architecture.

Any electro-mechanical problem can be broken down by thehuman designer as a set of input and output functions. For exam-ple, a pressure-gauge problem has a pressure source as an inputand the output is a dial display which displays the pressure ap-plied by the source. Hence, the human designer instructs with the

Table 7A sample design chunk as represented in the model.

Design-chunk #16

Isa: Design-chunkInput-domain: D4Input-interface: I7Output-domain: D8Output-interface: I3Components: C1, C2, etc.Connectivity: Port-1 of C1 is connected to Port-1 of C2.Goodness: 180

agent to produce a design solution which has the input functionalparameters similar to that of a cylinder and the output functionalparameters similar to that of a dial, using the electro-mechanicalcomponent base. These functional parameters can be labelled as(D1, I1) and (D2, I2), where D1,D2 represent the domains of the in-put (cylinder) and output (dial) and I1, I2 represent the interfacesof the input (cylinder) and output (dial) respectively. It is notedhere that the various domains and interfaces of electromechanicalcomponents can be labelled, in the software system, as two sepa-rate lists: (D1, D2, D3,. . . .) and (I1, I2, I3,. . . ), and each component’functional parameters can be labelled as the combination of twolabels from the lists (as shown above).

Labelling the various domains and interfaces offers the adva-ntage of testing the software system even in the case of lack ofsufficient data of machine design components, as hypotheticalcombinations of domains and interfaces can be created and tested.Also, such an arrangement does not hamper the design synthesisof the software system. Table 7 presents the same example ofthe design chunk as shown in Table 6, but using hypotheticaldomains and interfaces. In the present article, due to the lack ofsufficient data of machine design components, a computationaldomain is constructed as follows: seven hypothetical domainsare taken into consideration (D1, D2, D3. . .D7) which representdomains like translation, rotation etc. Similarly for the interfaces,which in general represent components like bolt, shaft-hole etc.,seven hypothetical interfaces (I1, I2, I3. . . I7) are considered. Usingthis notation, a sample chunk has already been depicted in Table 7.

As shown in Table 7, chunk #16 is an ACT-R design chunk. Ithas the domains D4, D1 for input and output, and interfaces I5,I6 for input and output, respectively. This particular chunk hastwo components C1, C2 which are obtained from a predefinedcatalogue. The cost of the chunk is determined by the sum of the

S. Modi et al. / Computer-Aided Design 43 (2011) 170–179 177

Table 8An example of the elimination of loops by the CA.

#4037-#85#4037-#85-#614#4037-#85-#614-#524#4037-#85-#614-#524-#85#4037-#85#4037-#85-#679

Fig. 6. Cost of the transitions obtained in the iterations.

cost of the components constituting it. The model was tested fora pool of 5000 chunks which collectively represent the knowledgepool. A chunk string, ‘#12-#54-#93’, represents a design solutionwith the specifications: input FPs of chunk ‘#12’ and output FPs ofchunk ‘#93’.

The capability of the CA to overcome loops was tested. It isdesired that loops are not only removed as and when they areremoved, but also the system does not repeat the mistake again—a learning mechanism comes into play here. A sample solutiongeneration process has been shown in Table 8 which illustratesthat loop ‘#85-#614-#524-#85’ was encountered and was laternot again repeated by penalizing the transitions which led to theformation of the loop. This component-loop formed because thechunk ‘#85’ was able to connect to the chunks ‘#614’ and ‘#524’through its output and input functional parameters respectively.Several of such loops (of different configurations) were encoun-tered and the system was able to not repeat the formation of eachof the previously encountered loops and hencewas able to increasethe efficiency of producing design solutions using memory.

Themodelwas tested for convergence by solving a hypotheticalproblem to produce a design with having a specified combinationof the input and output FPs. For each design problem, the modelwas run for 200 iterations and the results (cost of the solutions)of a randomly selected design problem have been plotted in Fig. 6.The cost converges after around 92 iterations.

The model was also tested for the knowledge transfer abilityby passing the transition information (the weights) and the modelwas once again run for 200 iterations. The cost of the solutionsobtained in the iterations is plotted in Fig. 7. The average cost ofthe design is calculated for both run (with and without transitionknowledge) and the results are displayed in Fig. 8. As is clearlyvisible from all these graphs, the model converges in about 60iterations when knowledge transfer is used—30% less number ofiterations.

5. Conclusion

In response to the need for the software system for supportingengineering design following the ideology of a Human-assistancesystem (HAS), a software architecture is proposed for producingarrays of conceptual design solutions. The software architecture

Fig. 7. Cost of the designs obtained with prior transition knowledge.

Fig. 8. Average cost of the solutions obtained with and without transitionknowledge.

possesses the capabilities of transparency, design rationale andcognition using a combination of Petri nets, ACT-R and Fuzzy Logic.The fuzzy rule-based Petri net represents the procedural moduleof ACT-R in this architecture. This architecture is not only ableto capture the human activity in the design solutions, by use ofACT-R and multi-agent systems, but also able to represent thecomplex event-driven behaviour and the inherent fuzzy nature ofthe configuration design very effectively, by use of fuzzy Petri-nets.

There are several salient advantages behind this architecture.First, Petri net best describes a complex event-driven dynamicprocess, which is the nature of engineering design. Use of thePetri net helps to impart the capability of transparency to thesystem. Second, ACT-R is a very good formalism for constructingthe agent to simulate the human cognitive process of problemsolving. Third, fuzzy logic is able to represent knowledge and logicin a natural way and is further convertible to artificial neuralnetworks [28]. Finally, the proposed architecture is built upon amulti-agent system which builds a strong foundation for futuredevelopment of an effective interface between the human designerand the computer designer.

Experiments have shown the model to yield satisfactory re-sults in eliminating the encountered loops from the design synthe-sis, the convergence of the model and the transfer of knowledge.Learning from design experience is achieved by transferring thetransition knowledge which results not only in the faster conver-gence of the model but also reduces the average cost of the designsolutions obtained in the iterations (Fig. 8).

Though the model is proposed for the minimization of anobjective function, it can be used to maximize an objective byadjusting the conversion of the fuzzy variable (the transition) to the

178 S. Modi et al. / Computer-Aided Design 43 (2011) 170–179

synthetic variable (x) and theweight update function of the agents.A limitation of the proposed architecture is that the objective is tooptimize the design from the single perspective (in this case, thecost of the design). The architecture can be extended to accountfor multiple objectives by using approaches such as Pareto-optimality [29] which can extend the single objective approachto the multi objective approach. The proposed architecture isdescribed for the context of problems which can be characterisedas optimization of the design. The architecture can be extendedto other contexts by making appropriate modifications in therepresentation of the chunks and the rule based PN.

The tools used in the proposed architecture help to impart thedesired capabilities very effectively. However, they induce a fewlimitations as well. The use of Petri nets to represent the designsynthesis leads to complex pictorial representations because ofthe immense number of places and transitions in the net [20].Since this is a classical problem with Petri nets, several studiesin literature can be found which deal with this problem by usingapproaches such as hierarchical PNs [30].

A natural extension of the proposed framework is to de-velop an interface for the human designer and computer agent(designer–agent for short), to incorporate the abilities of task-sharing and communication. Ongoing research in the area ofHuman–Machine Interaction, Human–Computer Interaction andother similar fields offer useful insights towards building these ca-pabilities into the software system. The future of design includesmany human designers as well as several CAD agents collaboratingwith each other as a group on various design problems. Principlesfrom research in psychology and human behaviour can be used tomodel the CAD agent–agent interactions.

It can be envisioned that several architectures can be builtaround the principles of the capabilities mentioned in this paper.The differences would be in the tools used and the representationof information in these architectures. For example, one could usethe QN-MHP for cognitive modelling [31]. The fuzzy productionrules can be replaced by a human designer making decisions ofthe choice of the components. However, it is clear that all thesearchitectures would depend on the context of the CAD system,the cooperation between the human designer and the CAD agents,etc. At their core, it is evident that the capabilities discussed inthis paper provide a strong foundation for the principles of theCAD system. These principles need to provide best utility to thedesigner and yet not compromise on the goals such as creativity,innovation and aesthetic beauty. This can be achieved only witha best cooperation between the human designers and the designsoftware.

It is worthwhile to make a note of the implementation of theproposed architecture. The current testing was performed usingthe JAVA programming language and the components’ informa-tion was accessed via an SQL database. Although there are severalcommercially available or open-source software systems availableto implement ACT-R and Petri nets, the very nature of the contextof engineering design provide several challenges to use these soft-ware systems to achieve the goal of implementation. It was foundby the authors that implementation of the architecture to pro-duce a CAD system would require a group of expert programmersand interface designers. Several computational issues can also beforeseen such as extremely long computation time to synthesizesolutions. However this issue can be solved using both hardwareenhancements and software tuning (such as the loop eliminationcase in the proposed architecture).

In essence, a basic understanding of the HAS for design isextremely vital. The combination of all the capabilities discussedin this paper would lead towards realizing the goal of an idealHAS for designwhichwould ultimately result in highly usable CADsystems.

Acknowledgement

This study has been supported in part by the Natural Scienceand Engineering Research Council of Canada (NSERC), through adiscovery grant.

References

[1] Sheridan TB, Parasuraman R. Human–automation interaction. Reviews ofHuman Factors and Ergonomics 2005;1:89–129.

[2] Norman DA, Draper SW. User-centered system design: new perspectives onhuman–computer interaction. Hillsdale (NJ): Lawrence Erlbaum Associates;1986.

[3] Flanagan J, Huang T, Jones P, Kasif S. National science foundation workshop onhuman-centered systems: information. Interactivity and intelligence (HCS)—final report [online]. Urbana Campaign: University of Illinois. Available from:http://www.ifp.uiuc.edu/nsfhcs/final_report/toc.html [accessed: November2009].

[4] Moss J, Cagan J, KotovskyK. Learning fromdesign experience in an agent-baseddesign system. Research in Engineering Design 2004;15(2):77–92.

[5] Franklin S, Graesser A. Is it an agent, or just a program? In: Muller JP,Wooldridge M, Jennings NR, editors. Intelligent agents III. LNAI, vol. 1193.Berlin (Germany): Springer-Verlag; 1997. p. 21–36.

[6] Lesser V. Multiagent systems: an emerging subdiscipline of AI. ACM ComputerSurveys 1995;27(3):340–2.

[7] Campbell MI. The A-design invention machine: a means of automating andinvestigating conceptual design. Ph.D. thesis. Pittsburgh (PA): CarnegieMellonUniversity; 2000.

[8] Campbell MI, Cagan J, Kotovsky K. A-design: an agent based approach toconceptual design in a dynamic environment. Research in Engineering Design1999;11(3):172–92.

[9] CampbellMI, Cagan J, Kotovsky K. Agent-based synthesis of electromechanicaldesign configurations. Journal of Mechanical Design 2000;122(1):61–9.

[10] Campbell MI, Cagan J, Kotovsky K. The A-design approach to managingautomated design synthesis. Research in Engineering Design 2003;14(1):12–24.

[11] Parasuraman R, Sheridan TB, Wickens CD. A model for types and levels ofhuman interaction with automation. IEEE Transactions on Systems, Man &Cybernetics, Part A (Systems & Humans) 2000;30(3):286–97.

[12] Ruff AH, Narayanan S, Draper MH. Human interaction with levels ofautomation and decision-aid fidelity in the supervisory control of multiplesimulated unmanned air vehicles. Presence 2002;11:335–51.

[13] Steinfeld AM, Fong TW, Kaber D, Lewis M, Scholtz J, Schultz A. et al. Commonmetrics for human–robot interaction. In: Proc. 2006 human–robot interactionconference. HRI 2006. 2006. p. 33–40.

[14] Wickens CD,Mavor A, Parasuraman R,McGee J. The future of air traffic control:human operators and automation.Washington (DC): National Academy Press;1998.

[15] Anderson JR, Lebiere C. The atomic components of thought. Mahwah (NJ):Lawrence Erlbaum Associates; 1998.

[16] Anderson JR, Matessa M, Douglass S. The ACT-R theory and visual attention.In: Proc. seventeenth annual conf. of the cognitive science society. Universityof Pittsburg; 1995.

[17] Lebiere C, Anderson JR. A connectionist implementation of the ACT-Rproduction system. In: Proc. fifteenth annual conference of the cognitivescience society. Boulder: University of Colorado; 1993.

[18] Anderson JR, Matessa M, Lebiere C. ACT-R: a theory of higher level cognitionand its relation to visual attention. Human–Computer Interactions 1997;12(4):439–62.

[19] ACT-R: Publications. Carnegie Mellon University [online]. Available from:http://act-r.psy.cmu.edu/publications/index.php [accessed: May 2010].

[20] Murata T. Petri nets: properties, analysis and applications. Proceedings of theIEEE 1989;77(4):541–80.

[21] Zurawski R, Zhou M. Petri nets and industrial applications—a tutorial. IEEETransactions on Industrial Electronics 1994;41(6):567–83.

[22] Tay EH, Flowers W, Barrus J. Automated generation and analysis of dynamicsystem designs. Research in Engineering Design 1998;10(1):15–29.

[23] Brown DR, Hwang K-Y. Solving fixed configuration problems with geneticsearch. Research in Engineering Design 1993;5(2):80–7.

[24] Carlson-Skalak S, White MD, Teng Y. Using and evolutionary algorithm tocatalog design. Research in Engineering Design 1998;10(2):63–83.

[25] Kusiak A, Szcherbick E, Vujosevik R. Intelligent design synthesis: an objectoriented approach. International Journal of Production Research 1991;29(7):1291–308.

[26] Lang WY, O’Gardy P. OODS: an objected-oriented design system—an exampleof electronic assemblies. Computers & Industrial Engineering 2001;40(3):229–47.

[27] Zadeh LA. Fuzzy logic and approximate reasoning. Synthese 1975;30:407–28.[28] Pedrycz W, Gomide F. Generalized Petri nets as pattern classifiers. Pattern

Recognition Letters 1999;29(14):1489–98.[29] Deb K. Multiobjective optimization using evolutionary algorithms. Wiley;

2001.

S. Modi et al. / Computer-Aided Design 43 (2011) 170–179 179

[30] Huber P, Jensen K, Shapiro RM. Hierarchies in coloured Petri nets. In: Rozen-berg G, editor. Advances in Petri nets. Lecture notes in computer science,vol. 1990. Springer-Verlag; 1990. p. 313–41.

[31] Liu Y, Feyen R, Tsimhoni O. Queueing network-model human processor(QN-MHP): a computational architecture for multitask performance in hu-man–machine systems. ACM Transactions on Computer–Human Interaction2006;13(1):37–70.

Shrey Modi is an M.Sc. student of Mechanical Engineeringat the University of Saskatchewan, Canada. He graduatedfrom the Indian Institute of Technology, Kharagpur, Indiawith a Bachelors (Honors) degree in Civil Engineeringwhere he also achieved the prestigious Best B.Tech ProjectAward. His current research interests include human-centered design, human automation interaction, interfacedesign and artificial intelligence.

M.K. Tiwari is an Associate Professor in the departmentof Industrial Engineering and Management, IIT Kharagpur,India. He has 19 years of teaching and research experi-ence at different levels. He works in the area of Evolution-ary Computing, applications, modelling and Simulation ofManufacturing System, Supply Chain Management, Plan-ning and Scheduling of Automated Manufacturing Systemetc. He was visiting Professor in the Department of In-dustrial and System Engineering, University of WisconsinMadison. He has published around 140 articles in lead-ing international journals and is serving as Editorial Board

Member of eleven International Journals including the International Journal of Pro-duction Research (IJPR). He is associate editor of the Journal of Intelligent Manu-facturing (JIM) and the International Journal of System Science (IJSS). He is wellknown for grooming undergraduate students and motivates them to pursue a ca-reer through the research route.

Yingzi Lin is an Assistant Professor with the Depart-ment of Mechanical and Industrial Engineering, North-eastern University, Boston, where she directs the In-telligent Human–Machine Systems Laboratory and co-directs the Virtual Environments Laboratory. She receiveda Ph.D. in mechanical engineering from the University ofSaskatchewan, and another Ph.D. in vehicle engineeringfrom China Agricultural University. Her research has beenfunded by the National Science Foundation (NSF), Natu-ral Sciences and Engineering Research Council of Canada(NSERC), and major industries. She has published over 90

technical papers in referred journals and conferences. Her area of expertise in-cludes: intelligent human–machine systems, non-intrusive sensor development,multimodality information fusion, human–machine interface design, and humanfriendly mechatronics. Dr. Lin is the Chair of the Virtual Environments TechnicalGroup of the Human Factors and Ergonomics Society (HFES). She is on the commit-tees of the Transportation Research Board (TRB) of the National Academy of Sci-ences. She serves as an Associate Editor of the IEEE Trans. on Systems, Man andCybernetics—Part A.

W.J. Zhang received a Ph.D. degree from Delft Universityof Technology in The Netherlands in 1994 on the designtheory and computer aided design of mechanism systems.He is currently a professor with the Mechanical Engineer-ing and Chair of the Division of Biomedical Engineering atthe University of Saskatchewan. His current research in-terests include: informatics, design, modelling and con-trol ofmicro-motion systems,modelling andmanagementof large complex systems, and socio-tech and physical-biological systems interaction and human behaviours. Dr.Zhang has published over 250 technical papers in refer-

eed journals and conference proceedings. Dr. Zhang is a member of ASME, a seniormember of IEEE, a senior member of SME, and a member of IRMA. He is an asso-ciate editor of The International Journal of System Science, an associate editor ofEnterprise Information System, and a technical editor of IEEE/ASME Transactionson Mechatronics.