Pergamon

Computers ind. Engng Vol. 30, No. 4, pp. 999-1013, 1996

Copyright 1996 ElsevierScience Ltd
Printed in Great Britain. All rights rsrved
S0~30-~(96)0004~4
0360-8352/96 $15.00+ 0.00

THE APPLICATION OF GENETIC ALGORITHMS TO

OPERATION SEQUENCING FOR USE IN
COMPUTER-AIDED PROCESS P L A N N I N G
JOHN M. USHER* and ROYCE O. BOWDEN
Department of Industrial Engineering, Mississippi State University, P.O. Drawer 9542, Mississippi State,
MS 39762, U.S.A.
Absa'act---Operation sequencing has long been a difficult problem in process planning. As part complexity
increases, the number of potential solutions increases exponentially. This paper presents an approach to
operation sequence coding that permits the application of genetic algorithms for quickly determining
optimal, or near-optimal, operation sequences for parts of varying complexity. This approach improves
on existing techniques by utilizing common sequencing constraints to guide the coding process resulting
in a further reduction in the size of the solution search space. These improvements permit the
determination of near-optimal operation sequences for complex parts within a time frame necessary for
real-time dynamic planning. Application of this strategy is illustrated using three parts of varying
complexity as well as comparing the genetic algorithm's performance using the improved constrained
coding strategy with that of an unconstrained strategy. Copyright 1996 Elsevier Science Ltd

1. INTRODUCTION

Process planning is the function which translates a set of design requirements and specifications
into a set of technologically feasible instructions describing how to manufacture a piece part or
assembly. This important function encompasses many different tasks including the determination
of the routing for a part, the processes involved in its production, process parameters, machines,
and tooling. Of these tasks, sequencing of the defined operations is one of the most complex due
to the need to take into account several types of constraints and the size of the resulting solution
space. Investigation of past research in the area of operation sequencing for computer-aided process
planning reveals that many different approaches to sequencing have been attempted. One problem
is that these systems take into account only one or a few of the applicable constraints, or use an
approach that becomes intractable when dealing with parts composed of a large number of features
whose interaction complicates the sequencing task and greatly expands the size of the search space.
Therefore, this paper proposes the application of a genetic algorithm (GA) for finding
near-optimal operation sequences for use within the context of CAPP. In this application, an
improved coding strategy for operation sequences is presented that reduces the size of the solution
space by taking into account a set of feasibility constraints in the coding process. Such a reduction
enhances the performance of the GA permitting the application of the system to more complex
parts and supporting the notion of dynamic planning.

2. OPERATION SEQUENCING

The essence of operation sequencing involves determining in what order to perform a set of
selected operations such that the resulting order satisfies the precedence constraints established by
both the part and operations. Reported methods for implementing operation sequencing include
the use of production rules [1], precedence graphs with procedural algorithms for evaluation and
pruning [2], and predefined sequences which are refined using production rules [3]. The approach
reported in this study combines a part of each of these methods to develop a coding strategy for
operation sequences that will permit the consideration of constraints in the search process
*To whom correspondence should be addressed.
999

1000

John M. Usher and Royce O. Bowden

enhancing the capability and flexibility of the genetic algorithm for finding an optimal, or
near-optimal, sequencing solution.

2.1. Sequencing constraints

The overall goal of this research project is the development of a distributed process planning
system where planning is performed in two stages: resource-independent planning followed by
resource dependent planning. The purpose of the resource-independent stage is to provide a means
for determining and archiving the best set of plans for a part independent of the status of the shop
floor resources. Then later, when production of that part is released to the shop floor, the
resource-dependent planning phase completes the planning tasks (machine selection, parameter
determination, etc.) based on knowledge of what shop-floor resources are available. Therefore, this
study is concerned with defining a set of optimal operation sequences independent of the
availability of resources.
The task of operation sequencing is complicated by the large number of interactions that exist
between the various factors which affect decision-making. An investigation of the factors which
are resource independent results in the classifications shown in Table 1 [4]. As Table 1 reveals, the
constraints which affect sequencing can be divided into those which address either the feasibility
or optimality of a sequence. This division permits the construction of a system which applies the
feasibility constraints to the task of generating alternative sequences, and the optimality criteria
to the task of judging the quality of the resulting alternatives. This methodology simplifies the
automation of the sequencing task and permits a structured approach to its solution.
A feasible sequence is deemed to be one which does not violate any of the feasibility constraints
listed in Table 1. These constraints are processed sequentially by the system with the results of each
application being the generation of either precedence or relation statements. A precedence statement
takes the form, f~ (fi), meaning that feature, fa, cannot be machined until feature, J~, has been cut.
A relation statement of the form, (fo,fi . . . . ), pertains to multiple features indicating that these
features must be machined in the same setup.
The location constraint is concerned with an examination of the defined part features to
determine what reference face is used to locate each feature. This reference identifies the necessity
that the locating surface be machined prior to the associated feature. Based on each relationship,
a dependency statement, f~(J~), between the feature, f~, and its locating feature, J~, is generated.
In order to machine a feature it must be accessible. The accessibility constraint evaluates each
feature's accessibility based on the feature type and its location relative to other features. Features
are defined as either primary or secondary. With the primary features defining the basic shape of
the part (diameters, tapers, etc) and secondary features providing the detailed shape aspects
(grooves, threads, etc.). The fact that since a secondary feature is defined as residing on a primary
feature, it makes sense not to machine the secondary feature until the primary feature has been
formed. Therefore, before a secondary feature, such as a thread, is cut on the diameter of the part,
the diameter (a primary feature) must be machined to specifications.
The non-destruction constraint is concerned with ensuring that a subsequent operation does not
destroy the properties of features machined in prior operations. This type of problem is limited
to the interactions that occur between the secondary features which reside on the same primary
feature. A destructive interaction between two features is determined using knowledge about such
interactions encapsulated within each secondary feature. Each primary feature instantiated in the
product model knows what secondary features it contains. It then queries each secondary feature
for knowledge about what other secondary features (if present) must be machined prior to its
Table 1. Sequencing constraints

Feasibility constraints

Location reference
Accessibility
Non-destruction
Geometric-tolerance
Strict precedence

Optimality criteria

Number of setups
Continuity of motion
Loose precedence

Operation sequencing

1O01

production. This knowledge is used by the primary feature to define any required precedence. One
example would be the need to machine a chamfer on a cylinder prior to cutting the threads.
Another constraint considers strict precedence whereby order is determined based on feature type
and properties. One example would be an internal cylinder whose properties require the use of a
reaming operation. However, before reaming can be performed, there is a need to first drill, and
possibly bore, the cylinder. The need for these preparatory operations is actually determined during
operation selection. Therefore, the results of this constraint will not actually influence the plan until
the operations are considered when writing out the sequence.
The last constraint pertains to the geometric tolerances defined for the part. The types of
tolerances that affect sequencing include: profile of a line and surface, perpendicularity, angularity,
parallelism, total and circular runout, position, symmetry, and concentricity [5]. The result of this
analysis is the identification of those features which must be cut in the same setup. These
relationships are indicated using the relation statement, ( f a , f i , . . . ) .
Application of the feasibility constraints provide the system with the capability to define a set
of precedences between the features of a part resulting in the construction of a feature precedence
graph (FPG) to represent these precedence relationships. However, since the effects imposed by
the geometric tolerance constraint cannot be represented within a FPG, this constraint is used by
the system to further eliminate sequences generated based on the FPG. Sequences which satisfy
all the feasibility constraints can then be judged and ranked using the optimality criteria. For details
concerning this approach and its implementation see Usher [4, 6, 7].
When one tries to determine the sequences that can arise from the consideration of a set of part
features and their respective operations, the vast number of possibilities becomes evident. Without
the consideration of the constraints and assuming at most one operation per feature (a lower
bound), it would be possible for a part composed of N features to be processed from one of N
factorial sequences. But in reality this solution space is reduced by the consideration of the
feasibility constraints. However, even taking into consideration these constraints it is possible for
a simple part composed of 8 features to be processed by as many as 420 sequences. As part
complexity increases to that of a 13 feature part this number grows to 667,992 different valid
sequences [6]. Likewise, for a 17 feature part the solution space expands to more than 1 billion
valid sequences. Therefore, what is needed is an efficient method for searching for valid sequences
within the large solution space bounded by the sequencing constraints.
3. SEARCH STRATEGIES

Strategies for determining an optimal sequence have included the use of integer programming
[8], branch and bound [9], dynamic programming [10], and evolutionary techniques [11-13].
Consideration of all the applicable constraints results in a problem that is difficult to formulate
and solve when using a dedicated search strategy. Such hindrances favor the application of an
evolutionary search technique which often requires less effort. This study makes use of an
evolutionary search technique employing a genetic algorithm to identify optimal, or near-optimal,
sequences based on a consideration of the constraints mentioned earlier.

3.1. Operation sequence coding

Application of an evolutionary search technique like genetic algorithms (GA) requires a method
for representing a solution. An obvious choice would be to represent a sequence as a string whose
elements define a list of operations, or possibly the features processed by those operations.
However, inherent within this representation is the need to express the constraints which must be
fulfilled by the resulting sequence. Therefore, most representations begin from this point, adding
attributes to the definition of each element in the string or devising a method of coding the
representation to impose these constraints.
Vancza and Markus [12] define a string representation where each element represents a step
within the process plan. Each step is defined by an operation, a feature state generated by that
operation, and the reference features of the operation. This method of representing a sequence
string provides some means of addressing precedence requirements, but as they point out,
reproduction operations (crossovers and mutation) result in the generation of strings representing

1002

John M. Usher and RoyceO. Bowden

invalid sequences in that they violate some precedence constraint or result in a redundant feature.
To attempt to reduce the likelihood of generating invalid sequences, they employ a complex
crossover strategy. This helps to reduce the chance of generating an invalid sequence to around
10%, but increases the complexity of the crossover algorithm.
Another approach for representing sequences was proposed by Husbands et al. [11]. Their coding
has each element of the string representing in combination a feature, the machine selected to
generate that feature, and the setup associated with the operation. Groups of elements within the
solution string are then formed based on relationships they identify between the features. Group
separators are then used to identify the start and end points of each of these clusters. These
indicators provide a basis for coordinating the crossover operations to ensure that the elements
and their ordering within a cluster are not disturbed. This approach eliminates the problem of
generating invalid sequences, but at the expense of having to devise a means for defining the
contents of each cluster and the sequences within them. Also, depending on how the features are
clustered, the ability of the system to find an optimal sequence may be hindered in that it is possible
that the system will not be able to generate certain valid sequences due to non-required constraints
being imposed as a result of the assignment and sequencing of features within these groups.
A third more flexible approach to coding operation sequences is that presented by Dutta and
Yip-Hoi [13]. Instead of imposing restrictions on the string elements, their attributes, and
organization within the string to express constraints, they focus on the development of a coding
method to translate between an operation sequence and its string representation. This coding
strategy involves constructing a feature precedence tree (based on a defined FPG and a list of
unprocessed nodes) one level at a time with each element's value representing the branch connected
to the operation selected to be processed next. Each branch value is normalized based on a
predefined value representing the maximum number of branches that will appear at any level of
the tree.
The use of such a coding strategy to generate the values of each element within the solution string
means that the resulting operation strings can be reproduced using existing GA methods of
crossover and mutation with the assurance that only valid sequences will be produced. In order
to evaluate the fitness of the resulting coded feature string it must be decoded to determine the
feature sequence within. Problems arise with the strategy Dutta and Yip-Hoi [13] employ in that
they do not consider the case where a feature node may have multiple parents. This type of
relationship is not an uncommon occurrence within complex parts where a feature cannot be
processed until one of several previous features have been machined (example of an OR relation),
or all of several features have been machined (an AND relation).
This paper presents a strategy for operation sequence representation and coding that can be
used within an evolutionary search technique. A solution is represented using a string where
each element represents a feature and the order of those features within the string defines
the operation sequence. Therefore, the size of the solution is defined by the number of features
which comprise the part. For example, a solution for a 13 feature part might be the string:
(1, 3, 4, 6, 7, 12, 13, 10, 8, 1l, 9, 5, 2). This solution defines an operation sequence instructing that
feature l be machined first, followed by feature 3, and so on up to the last operation on feature 2.
Like Dutta and Yip-Hoi's the proposed makes use of a coding strategy to simplify crossover and
mutation operations, but extends the capability of the strategy to handle FPGs containing nodes
with multiple parents possessing either AND or OR parental dependence. Also, in addition to the
consideration of feature precedence, this coding strategy incorporates the consideration of
constraints that cannot be represented within a FPG (in this case geometric tolerance) and "good
manufacturing practices" such as minimizing the number of setups. These additions to the
representation of an operation sequence and the decoding process result in a more useful and
efficient basis for employing a search strategy for CAPP.
4. GENETICALGORITHMIMPLEMENTATION
The strategy employed by the system for searching the solution space is illustrated in the block
diagram of Fig. 1. This process begins with an initial population of coded sequences (referred to
as members) that are produced by randomly generating a value for each element within each

Operation sequencing

1003

Create
Initial
Decode
Determine
Population -.. Population -~ Member
of Coded
Members
Fitness
Sequences

Select
Members
to
Reproduce

Produce New
Generation of
Coded Sequences

Fig. 1. Implementation of search strategy.

solution string. The range of values from which each element's value is generated is defined by the
complexity of the FPG (discussed later in Section 4.1). Therefore, if the permissible range for each
element is from 1 to 6, then one possible coded solution string for a 13 feature part might be:
(2, 2, 3, 1, 3, 4, 4, 5, 3, 3, 6, 6, 4). The decoding process is then applied translating each coded
sequence into a string of features (stored as integer values corresponding to their number as defined
within the product model). For the same 13 feature part, the decoded solution for the above coded
string would be (1, 3, 4, 6, 7, 12, 13, 10, 8, 11, 9, 5, 2). This decoding is necessary since the sequence
must be expressed in terms of the features of the part in order to provide the system with the
information needed to evaluate the fitness of each member. The resulting fitness value is then stored
with the coded sequence for further processing.
Given that the fitness of each member has been determined, the system makes use of an elitist
strategy by identifying the member with the best fitness and placing it in the next generation
unchanged. Next, members from the population are selected for reproduction and the remainder
of the new generation is created using the genetic operators: crossover and mutation. The
probability that a member is selected for reproduction is based on its fitness relative to the fitness
of the other members in the population (e.g. Prob[selecting Member(i)] = Fitness Member(i)/E
Fitness of all members). Members are selected two at a time and the application of the standard
single point crossover operator is considered based on a predefined probability. Mutation of each
element within the sequence string is also determined based on a predefined probability. Using a
13 feature part as an example, zero, one or more elements in a solution string are randomly selected
for mutation. The value of each element selected for mutation is replaced by a uniform random
number on the interval from 1 to 6 (for this example). The reproduction of members is performed
until the number of members in the new generation equals the population size. At this point the
cycle repeats.

4.1. Operation sequence constraint coding

As shown in the previous section, since the process begins with an initial population of coded
sequences, only the decoding side of the translation process must be implemented. Therefore, the
heart of this implementation is the strategy used to decode a sequence. This procedure is best
illustrated through the use of an example for the decoding of the coded solution string:
(2, 2, 3, 1, 3, 4, 4, 5, 3, 3, 6, 6, 4). Therefore, consider the part shown in Fig. 2. This is a rotational
part composed of 13 features. Given a set of selected operations for these features and taking into
consideration the feasibility constraints, results in the generation of the FPG shown in Fig. 3.
Details of these steps can be found in [7].
Use of a coded representation for an operation sequence permits the consideration of constraints
in the search process. To illustrate this capability, this research study developed a prototype system

1004

John M. Usher and Royce O. Bowden

+0.3
140

'. +01,0:xL..oo.l.
I: eo--IF
X

I,

M20 x

,55 xx

+0.2

58

"~,.___ 1.5r +0'1

.

.5x4o

"" j , ' f ~

MI2 X 1.5mm ~

1,5m~

45

+0.4-

I"

/-12.oo-o,o

18

.
1(~

0,04
0,1 I A

I1

0.06

Fig. 2. Example part.

whose decoding process takes into consideration constraints dealing with feature precedence,
feature accessibility, and geometric relationships defined between feature pairs (e.g. concentricity,
parallelism, etc.). However, it would be possible to include other constraints, if desired.
4.1.1. Consideration of feature precedence. The overall decoding process (defined by the
algorithm in Fig. 4) begins with a consideration of feature precedence in the determination of what
features can be processed next in the sequence. The basis for this determination is the precedence
relationships defined by the part's FPG (shown in Fig. 3).
The decoding process begins with a determination of which features can be processed first (in
this example, features 1 or 12, since they have no precedent features). This determination forms
a tree with a null parent node and a branch emanating from the null node to each of the child
nodes (see Fig. 5). Which feature (or branch) to select from this tree is derived by decoding the
first element (integer value) in the coded sequence. The decoded value is determined by referencing
an entry in the lookup table using the coded value of the element (e.g., 2 for Step A, 2 for Step
B, 3 for Step C etc.) and the number of branches which occurred at the current level in the tree
(e.g., 2 for Step A, 1 for Step B, 1 for Step C, etc.). Using the lookup table (Table 2), the branch

,)

Fig. 3. FPG for example part.

Operation sequencing

1005

~epeat (until all features processed) {

//Identify all features that are available for processing
for (each features of the part)
if (all precedent features have been machined
AND feature is not a member of the processed node list
AND feature is a member of the current setup
AND geometric tolerance not violated)
feature is available;
else//no features available
switch to next setup and try again;
Place selected features in coding tree
Use the lookup table to decode the next string element of the coded sequence
Select the coding tree branch whose number matches the decoded string element
Add the selected feature on that branch to the (decoded) operation sequence
Add the selected feature to list of processed nodes
}
Fig. 4. Decodingalgorithm.
to select for Step A (normalized code value is 2 with 2 branches in this level) would be branch
1 (shown in bold in Table 2). At this point the selected branch identifies what feature (feature l)
comes next in the sequence. This feature is added to a list identifying the processed features which
form the feature sequence (last row of table in Fig. 5). This process is then repeated for each element
in the coded sequence. A complete example of the decoding process for a single coded sequence
is shown in Fig. 5.
The system is able to handle FPGs which contain both AND and OR relationships between the
nodes of the graph. The use of an AND relationship represents the need for all precedent (parent)
features to be machined prior to the one in question. While, an OR relationship indicates that a
feature can be machined after any one of the parent features is machined. The type of relationship
affects the decoding process in the step where the system identifies from the FPG what features
are available for processing next. Given the FPG representation, the system notes whether it is an
AND or OR relationship that exists with the parents, and then determines from the FPG what
features can be processed next.

Code
~-~

2--"1 - - a,~nc.
"
2--,-1 3---1

4--~2

5-*2

3--1

1-,,-1

3-,-1

M)~

3---1

6~1

4-,-1

6-*2

Step
ABCDEF
G H I J KLM
Code
2 2 3 1 3 4 4 5 3 3 6 6 4
Setup
1 1 1 2 2 2 2 2 2 2 2 1 1
4-,-1 Sequence 1 3 4 6 7 1 2 1 3 1 0 8 1 1 9
5 2
Fig. 5. Decodingexample.

1006

J o h n M. U s h e r a n d R o y c e O. B o w d e n
Table2. L o o k u p t a b l e ~ r d ~ i ~

No~alizedcode
No. o f b r a n c h e s
B~nch~l~ted

1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6
6 6 6 6 6 6 5 5 5 5 5 5 4 4 4 4 4 4 3 3 3 3 3 3 2 2 2 2 2 2
I 2 3 4 5 6 1 1 2 3 4 5 1 1 2 2 3 4 1 1 2 2 3 3 1 1 2 2 2

I 2 3 4 5 6
I 11
1 1 1
11
1 1 1 1

The decoding process is dependent on establishing a value for the maximum number of branches
that can occur in a single level of the graph that is constructed in each step of the decoding process.
This value is used to define the contents of the lookup table. For example, if the coded value of
the operation string contained a value of 3, but there are only two possible features which can be
processed next (as shown by a graph with two children as in Step E of Fig. 5), then there is no
third branch to select from. This 3 represents a 3 from a possible range of 1-6. Therefore, the system
uses the lookup table to determine that a coded value of 3 is equivalent to a branch value of 1when
the maximum number of branches is 6 and only two branches emanate from the parent. This
specific translation is shown in italics in Table 2.
For the decoding example the maximum number of branches was set to six. This maximum value
is mainly dependent on the number of features of the part with variances due to the feature
relationships as defined in the structure of the FPG. At this point no precise deterministic method
has been devised for calculating this value, it is only estimated based on an examination of the
FPG. If the system determines that the number of possible branches is greater than the maximum,
then the system can increase this value and restart the process. Further work in this area is
underway to explore and possibly characterize the relationship between this maximum and the FPG
of the part.
4.1.2. Consideration of feature accessibility. To supplement the robustness of the search process,
this decoding process also makes it possible to incorporate constraints related to "good
manufacturing practices" such as minimizing the number of setup changes in the processing of a
part (as demonstrated in this application). Each time the system decodes a single digit of the coded
sequence (corresponding to a single step in Fig. 5), it consults the FPG to determine which features
are available for processing. In addition to this consideration, the system also further constrains
its selection based on whether a feature is currently accessible.
Feature accessibility is defined using setup templates listing the features that are accessible
within each setup. For the example rotational part, the setup templates are defined as:
SU(f~,f2,fi,fi,fi,fT) and SU(f~, f7,.~,J~,J~0,J~l,J~2,~3). Note that based on location only, feature
6 could be a member within either setup, but due to the need to maintain the geometric tolerance
by processing features 6 and 8 within the same setup, the system deleted feature 6 from the first
setup template.
So, when the system identifies which features are available for processing, the system will only
consider those features which meet all of the following criteria: their precedence is satisfied, they
have not already been selected (processed), and they are within the setup template of the currently
active setup. Determination of the first active setup is performed immediately after the selection
of the first feature in a sequence. If no features within the currently active setup are available for
processing at a level of the tree, then the active setup is changed and the search repeated. Therefore,
as the system builds the tree, priority for feature selection is governed by the contents of the setup
templates.
For example, given that feature 1 was selected first (Step A), since feature 1 is a member of the
first setup template, this setup template becomes the active setup. Then, in Step B, when the system
determines which features can be processed next, it is confined to first look at only those within
the first setup template whose precedence has been satisfied. Since only feature 1 has been processed
at this point in the decoding process the FPG indicates that features 3 and 6 are possible based
only on precedence. However, only feature 3 is a member of the active setup (features 6 and 12
appear in the second setup template) and therefore the system limits its consideration to only that
feature. This is represented by the graph for Step B in Fig. 5.
An example of the need to make a change in the active setup is illustrated for Step D. In the
beginning of Step D, setup template 1 is still the active template. However, based on precedence,
there are not features in that template that can be processed. Therefore, the system makes a
change of the active setup to the second template and repeats the process. This time it finds that

Operation sequencing

1007

features 6 and 12 can be processed in that their precedence is satisfied and they are members of
the active setup.
4.1.3. Consideration of geometric tolerance. In addition to "good manufacturing practices," it
is also possible to incorporate the consideration of other constraints which cannot be represented
within the FPG. This application considers the geometric tolerances that define additional
relationships between the features of a part. These relationships are defined through the use of
relations statements. For the sample part shown in Fig. 2, concentricity is specified between features
6 and 8. This is expressed using the relations statement: RE(6, 8).
The necessity for maintaining the relationships defined by the relations statement is implemented
within the decoding process by ensuring that a setup change does not take place before both
features declared in a statement have been processed. If one does, then that sequence is assigned
a fitness of zero eliminating its chance of showing up in the next generation. For coding strategies
which do not incorporate these constraints, these tolerance conditions are often violated resulting
in the creation of population members that are invalid which degrades the performance of the
search.

4.2. Fitness calculations

The optimality criteria from Table 2 can be used to evaluate the fitness of alternative sequences.
Although processing cost and time are favored measures for judging alternatives, they cannot be
used at this point in the planning process since no resources have been selected. Therefore, this
research made use of optimality criteria which are resource independent. These criteria include the
number of setups, continuity of motion, and loose precedence. For each criterion, a scoring method
was devised to rate the fitness of each alternative on a scale from 0 (representing the worst case)
to 1 (the best). The square of the weighted sum of these scores is used to determine the overall
fitness of each population member.
4.2.1. Number of setups. This criteria scores each alternative based on the number of setups
required to process the features as sequenced. The number of setups required by the sequence is
determined during the decoding of a sequence using the setup templates as discussed in the previous
section. Based on this number, a score is calculated using the equation:
# o_fsetups-Min _#_ _setups '~
Setup Score = Max # setups-Min # setups,]
The maximum and minimum number of setups required by a sequence can be determined based
on the composition of the setup templates using the equations:
Min # setups = # Setup templates,
Max # s e t u p s = A + B + C + 2 D ,
A = )'0 # of features in templates is equal with no features in common
0 otherwise,
B = [Sum of # features in both templates],
C = [Difference in the # features in the two templates],
D = [ # common features in the two templates)].

4.2.2. Continuity of motion. One way to save time in processing is to minimize the motion of
the tools and reduce the number of tool changes. Therefore, the system scores each alternative by
looking for groupings of operations of like type within each setup. This process is supported
through the construction of continuity templates. Each template is a list of features grouped by
commonality of setup, operation type, and location. Using these templates the system searches for
the prescribed patterns within the alternative sequences. For the sample part shown in Fig. 2, the
two continuity templates result from a grouping of the facing and turning operations (the only
repeated operations in this case) are CN(J~,A,fi) and CN(fs,f~2).

1008

John

M. Usher and Royce

0. Bowden

Scoring of each alternative is based on the degree with which a feature pattern in the sequence
matches that of a template. These values are then used to calculate a score for each sequence using
the equation:

c
Continuity Score = ]Ai 1 Bi]T [A, - l]
Ai = # features in continuity template(i)
Bi = # features in sequence which match template(i)
4.2.3. Loose precedence. Over time a shop will begin to adopt a preferred way of ordering the
operations for a part. This order represents good manufacturing practice in terms of processing,
but is not an essential requirement. For example, removing material associated with interior
features early in the process reduces the rotating mass which stabilizes the part for further
processing. To represent such practices, the system contains a predefined list of operations
representing a generally acceptable order of processing for a shop. Using this list the system will
create processing templates for use in evaluating the alternative sequences.
Beginning with the first operation on the list, the system examines the features within a single
setup group looking for a match between the operation listed and the operation selected for the
features. If a match is found, then the feature is placed in a processing template for that setup.
If not, the system moves on to the next operation. This process continues until all attempts have
been made to match all the operations in the list with those of a setup template. For example,
consider the predefined list shown in Table 3. Given the operations selected (in an earlier planning
step) for each feature, the system would generate two continuity templates by matching the selected
operations for each feature in each setup template with those in the list. The resulting processing
templates for the sample part would be: PR(fi,h,_&,_Lf7,_L) and PR(fi*,Ss,fs,fil,f7,~~,~~,~),
Using these templates the system will evaluate each alternative to determine the number of
operations out of order while keeping track of the maximum value of all the alternatives. Then
each alternative is scored based on how well it matches the template using the equation:
[ # features out of sequence in template(i)]
Precedence Score =

Max # features out of sequence

Max # features out of sequence = 1 (Ai - l),

Ai = # features in processing template(i).
The resulting fitness of a sequence is then determined using the square of a weighted sum of the
three individual scores. The assignment of weights is based on the preference of the shop. For the
example applications presented in the next section, loose precedence is assigned a weight of one

Table 3. Loose orecedence table

Operation
External facing
Drilling
External turning
External chamfer
External groove
Internal groove
Internal countersink
Internal theadin
External thread&

setup #1

f
/L/S
f4

fl

fl

setup #2

fil
f6
fa
h

fi

fl3
IlO
f9

Operation sequencing

1009

with continuity and setups being weighted two and three, respectively. The fitness of each member
of the population is then calculated as:
Fitness = (3*setup score + 2*continuity score + l'precedence score)2
5. E X P E R I M E N T A L S T U D Y

This section presents the results of the study designed to evaluate the efficiency of the coding
strategy presented in Section 4.1. Remember that this coding strategy includes information about
feature precedence, feature accessibility, and geometric tolerance constraints, and supports FPGs
containing nodes with multiple parents possessing either AND or OR parental dependence. The
constrained-based coding strategy is compared with a coding strategy similar to Dutta and
Yip-Hoi's [13] which does not support the inclusion of feature accessibility and geometric tolerance
constraints. However, the coding strategy by Dutta and Yip-Hoi was modified to support FPGs
containing nodes with multiple parents so that the comparison could be made based on more
realistic problems. Therefore, the comparison is between a coding strategy that encompasses
precedence, accessibility, and tolerance constraints and a coding strategy that does not encompass
accessibility and tolerance constraints. The former coding strategy is referred to as the constrained
coding strategy and the latter as the unconstrained coding strategy.
The comparative study was conduced using three different rotational parts. These parts were
chosen because of their authenticity and the range of operation sequencing complexity that they
provide. The first part is the eight feature part illustrated in Fig. 6. The corresponding FPG is
shown in Fig. 8. There are 420 valid operation sequences for this part. The second part is the 13
feature part presented in Section 4.1 (Figs 2 and 3). This part has 667,992 valid operation sequences.
The third rotational part is composed of 17 features (Figs 7 and 9) and can be processed using
one of more than one billion valid operation sequences. This part provides a very realistic problem
for the comparison and for evaluating the GA's suitability for the operation sequencing problem
in general.
The two coding strategies were evaluated relative to the ability of the GA to find either the
optimal, or best known, operation sequence and the number of generations required to do so. For
each of the three rotational parts, 10 independent runs of the GA were made using the constrained
coding strategy and 10 independent runs were made using the unconstrained coding strategy. Note
that for each rotational part, the same 10 starting seed values were used for the GA's random
number generator for both the constrained and unconstrained coding strategies. Therefore, the same
stream of random numbers were used by the GA for both coding strategies to select parents,
generate crossover points, and select elements to mutate. This was done to ensure that differences
in performance are due to differences in the coding strategies and not due to random variation.
For each run, the GA was configured with a population size of 100, a probability of a crossover
of 1.0, a probability of a mutation of 0.001, and a termination criterion of 100 generations. These

~27,5
l.

57,00

254

11,7

I" 205
18,00

15

1-33 "
45

degrees

~x

15

~2X2mm
Fig. 6. Example 8 feature part.

_1
groove

I010

John M. Usher and Royce O. Bowden

100.0
L..,_ 12

--

53,0

~ .5x45de9

44.0 dla

" ~ - 10.0 - - -

13.0 | d l J
30.0 dla

16.0 dla

i
i

28,0

--

30,0

Fig. 7. Example 17 feature part.

settings for the GA's parameters produced good results in terms of the convergence of the search
and the quality of the solution. Better results may be achieved with different settings for the GA's
parameters. However, the objective of this research was to optimize the coding strategy used to
represent solutions and not to optimize the setting of the GA's parameters.
The results from the 60 runs made with the GA are summarized in Table 4. For each rotational
part, the table presents the average and standard deviation, from the 10 independent runs, of the
fitness of the best member (operation sequence) in the population and the number of generations
that it took for the best member to be found.
For the two coding strategies, the table records the number of times that the best solutions were
equivalent or better.
For the eight feature part, both coding strategies allowed the GA to find the optimum solution
of 34.03 in 10 out of 10 independent runs. For this part, an exhaustive search revealed that there
are two optimum solutions (fl,fi,f2,fi,fi,fs,fi,f6 and fi,J~,]~,/'~,3q,J~,~,/5). Notice, however,
that the initial population of the GA using the constrained coding strategy always contained an
optimal sequence and it took the GA using the unconstrained coding strategy an average of 25.1
generations to locate an optimal sequence. These results suggest that a population size of 100 is
unnecessary when the constrained coding strategy is used for parts composed of such a small
number of features.

Setup Templates:
SU(fl,f2,f3,f4) & SU(f5,f6,f7,f8)
Fig. 8. FPG for 8 feature part.

Operation sequencing

1011

SU(f6,f9,f10,f11,f12,f13,f15,f16)
Fig. 9. FPG for 17 feature part.

For the 13 feature part, the average best fitness for the GA using the constrained coding strategy
was 3.64 higher than that achieved by using the unconstrained coding strategy. Using the constrained
coding strategy, the GA found the best solution an average of 2.6 generations sooner than the GA
using the unconstrained coding strategy. Noting the differences in the standard deviations for the
fitness of the best solution and for the number of generations required to find the best solution,
it is clear that the GA using the constrained coding strategy is much more stable than the GA using
the unconstrained coding strategy. An exhaustive search revealed that the optimal sequence is
(A2,A,A,A,,A, A~,Z0,A,A,A, f~,A,A) with a fitness of 34.03. Using the constrained coding
strategy, the GA found the optimal sequence five times out of the 10 independent runs verses zero
times out of the 10 independent runs using the unconstrained coding strategy. In fact, the GA using
the constrained coding strategy found the second best solution in the remaining five runs. The GA
using the unconstrained coding strategy found the second best solution only one time out of the
10 runs.
In Table 4, the results obtained on the 17 feature rotational part are also summarized. Again,
these results indicate that better solutions are found more quickly using the constrained coding
strategy versus using the unconstrained coding strategy. Due to problem size, it was not feasible
to conduct a search to determine the optimal solution. However, the best solution found to date
is a sequence with a fitness of 30.80. This solution was found by making extremely long runs
(thousands of generations) with the GA using a fairly high rate of mutation. The GA using the
constrained coding strategy found this solution once out of the 10 independent runs as did the GA
using the unconstrained coding strategy. However, the GA using the constrained coding strategy
converged on a better solution than the GA using the unconstrained coding strategy 80% of the
time and required almost half as many generations to do so.
To evaluate the possibility of improving the solution quality without increasing the size of the
population, the standard single-point crossover operator was replaced with a three-point crossover
operator. Using the three-point crossover operator, the GA with the constrained coding strategy
found the best known solution for the 17 feature rotational part three out of the 10 independent
runs versus finding it once using the single-point crossover operator. Therefore, for parts with a
larger number of features, the use of multi-point crossover operators should be considered due to
the increased length of the solution strings being processed by the GA.
Table 4. Experimental results for the three test problems
Constrained coding
No.

features
8
13
17

Unconstrained coding

Best
fitness
~.,S

Generation
found
~,S

Better

Same

34.03, 0.00
33.55, 0.51
29.39, 1.15

0, 0
I 1.6, 5.4
16.8, 10.7

0
9
8

10
1
1

Better

Best
fitness
~,S

Generation
found
~,S

0
0
1

34.03, 0.00
29.91, 1.78
27.29, 2.16

25.1, 29.3
14.2, 26.1
32.2, 34.0

1012

John M. Usher and Royce O. Bowden

30
25
,-
,-

20

,~ 15

'"

eL

....

:----A~am

- -

Best

lO

Unconstrained Strategy

17

25

33

41

49

57

65

73

81

89

97

Generation

Fig. 10. Unconstrained results for 17 feature part.

Figures 10 and l l illustrate the convergence characteristics of the GA on the 17 feature part using
the single point crossover. The plot was produced by averaging the 10 independent runs. Both the
average fitness of the population and the fitness of the best member in the population are shown.
The constrained coding strategy clearly dominates the unconstrained coding strategy in terms of
both speed and solution quality. These differences in performance can be attributed to the fact that
when feature accessibility and geometric tolerance constraints are inherent in the coding of
operation sequences, every solution generated through crossover and mutation is feasible Without
constraints being inherent in the coding, infeasible solutions are generated which encumbers the
genetic search process. It should be noted that on average, it required 14 s to run the GA for 100
generations using a Gateway 2000 4DX2-66V personal computer However, it required an average
of only 2.5 s for the GA using the constrained coding strategy to find the best solution. This rate
of convergence supports the notion that both GA and the constrained coding strategy can be used
for dynamic process planning
6. CONCLUSION

For a computer-aided process planning system to handle complex parts comprised of a large
number of interacting features, an efficient means is needed for exploring and reducing the size of
the search space of valid operation sequences. That is the purpose of the genetic algorithm and
coding strategy presented in this study This paper has shown that a genetic algorithm is a viable
means for searching the solution space of operation sequences providing a computational time on
the order of a few seconds.
The results of this study also show that improvements in the search for optimal sequences for
process plans are possible through the incorporation of constraints within the representation and
coding of the operation sequences This use of constraints in the decoding of operation sequences
was found to simplify the application of the genetic operators and enhance the performance of the
GA as compared to the use of a GA without considering constraints The performance
improvements result from the ability of the constrained approach to find a better (and often
30
,o-

25
20

. . . . . . . . . Average
- -

i,

Best

lO
5

Constrained

Strategy

o
9

17

25

33

41

49

57

65

73

81

Glnemtlon

Fig 11. Results for 17 feature part.

89 97

Operation sequencing

1013

optimal) solution more often than the unconstrained approach, and to find this solution in fewer
generations (meaning less time). Therefore, this technique for planning operation sequencing has
proven beneficial for its use as a module within the development of a computer-aided process
planning system. Also, based on these results, the use of genetic algorithms shows promise in
supporting the notion of dynamic process planning.
REFERENCES
1. M. Wang, M. B. Waldron and R. A. Miller. Prototype integrated feature-based design and expert process planning
system for turned parts. Int. J. Systems Automation: Res. Applic. (SARA) 1, 7-32 (1991).
2. U. P, Korde, B. C. Bora, K. A. Stelson and D. R. Riley. Computer aided process planning for turned parts using
fundamental and heuristic principles. Trans. ASME, J. Engng Industry 114, 31-40 (1992).
3. C. Yeh and G. Fischer. A structured approach to the automatic planning of machining operations for rotational parts
based on computer integration of standard design and process data. Int. J. Adv. Manuf. Tech. 6, 285-298 (1991).
4. J. M. Usher and G. Sharma. Process planning in the face of constraints. Proc. Industrial Engineering and Management
Systems Conf., pp. 278-283 (1994).
5. H. Wang and R. A. Wysk. A knowledge-based approach for automated process planning. Int. J. Prod. Res. 26(6),
999-1014 (1988).
6. J. M. Usher and G. Sharman. A new approach to selection and sequencing for process planning. In Intelligent
Automation and Soft Computing: Trends in Research, Development, and Applications, Vol. 1 (Edited by M. Jamshidi
et al., pp. 245-250. TSI Press (1994).
7. J. M, Usher and G. Sharma. Intelligent reasoning in the generation of alternative sequences for feature-based process
planning. Intelligent Automation and Soft Computing (in press).
8. C.-J. Lin and H.-P. Wang. Optimal operation planning and sequencing: minimization of tool changeovers. Int. J. Prod.
Res. 31(2), 311-324 (1993).
9. C. Koulamas. Operation sequencing and machining economics. Int. J. Prod. Res. 31(4), 957-975 (1993).
10. G. Halevi and R. Weill. Development of flexible optimum process planning procedures. Ann. CIRP 29(1), 313-317
(1988).
11. P. Husbands, F. Mill and S, Warrington. Generating optimal process plans from first principles. In Expert Systems
for Management and Engineering (Edited by Balagnrusamy and Howe), Chap. 8, pp. 130-152. Ellis Horwood Pub.
(1990).
12. J. Vancza and A. Markus. Genetic algorithms in process planning. Computers in Industry 17, 181-194 (1991).
13. D. Dutta and D. Yip-Hoi. A genetic algorithm application for sequencing operations in process planning for parallel
machining, lIE Trans. 28, 55-68 (1996),