domain-oriented semantics for feature modeling

DOMAIN-ORIENTED SEMANTICS FOR FEATURE MODELING BASED ON TAE STRUCTURES USING CONDITIONAL ATTRIBUTED REWRITING SYSTEMS

Harald E. Otto and Fumihiko Kimura Department of Precision Machinery Engineering The University of Tokyo TOKYO JAPAN Ferruccio Mandorli and Umberto Cugini Department of Industrial Engineering The University of Parma PARMA ITALY

ABSTRACT Requirements of intelligent CAD systems are aimed to enable them to support the designer throughout his/her entire activity, starting from conceptual design and ending with, according to given specifications, an almost complete design object description. Current approaches featuring geometrical constraint-based systems with parametric or variational models, allow the designer to consider the realized design object description as an archetype of a family, based on a unique morphological model with unambiguous sets of parameterized rules. However, functionality for both design and reasoning, are limited to the low geometric level, leaving most of related information from the design intend and related technology unconsidered. Our objective of given study is, to extend the present functionality of existing approaches by integrating different types of knowledge and incorporate dedicated semantics in form features and feature-based methodologies. As a basic representation, typed attributed entity structures (TAE) are used. Computation is performed over domain structured alphabets of attributed symbols using a conditional attributed rewriting system. An application example in form of a wing rib, taken from aerospace engineering, is used, to verify and demonstrate the modeling and consistent handling of knowledge formations within our developed framework. Current limits of our new approach are discussed and a comparison related to the functionality of existing systems is undertaken, to direct the focus on further enhancements and extensions of our approach.

1

INTRODUCTION

Traditional CAD systems allow the designer to model the final design object description (usually limited to geometry) of the product, that is the result of the whole design process. Such systems do not provide means to either model the entire design process or automatically manage the design criteria being used. New developed methodologies (cf. chapter 2.3) and complex product models (Kimura, 1992 - Kimura, 1993a - Kimura, 1993b) require intelligent CAD systems, being capable to assist the designer throughout the design process from the conceptual design to the detailed one, and provide tools for the management of the knowledge used for non-trivial product definitions. Our objective of given study is, according to those requirements, to extend the present functionality of existing approaches by integrating different types of knowledge and incorporate dedicated semantics in form features and feature-based methodologies. Today, both parametric (Colombo et al., 1990 - Ferretti et al., 1992) and variational (Serrano and Gossard, 1986 - Roller, 1988) systems have been developed and are commercially available. However, due to their approach, many limitations and shortcomings (cf. Chung and Schussel, 1989) make their use in design still a cumbersome task. Those systems control the design object description with parametric rules and constraints, located at the low geometric level. Differences in when to insert such conditions, during the design (in case of parametric systems) or after finishing a first sketch of the final design object shape (in case of variational systems), do not affect the level of reasoning nor the fact, that other information regarding design intent and/or used technology, is only partly or not at all considered. Furthermore is, due to the used concept of being bound to shape aspects only, i.e., pure geometry, an accompanied functionality of design operators not able to operate with objects of higher abstraction.

Our goal is, to overcome some of those limitations, originating in the approach of using shape as the basic and only abstract concept, by using a hierarchy of conceptual levels, where elements are defined through their composing properties, which in term, can be other elements defined in the same way. Furthermore, do we try to formalize and integrate different kinds of knowledge, to build up generic structures, not only for data structures, but also for strategies, supporting the concept of embedded semantics, required for application of feature-based methodologies in design. The paper is structured as follows. First, an overview about modeling spaces and related requirements, the general design theory, as a descriptive model with its knowledge manipulation theory, abstract/entity concepts and attributed domains, and feature-based methodologies, is given. Second, some fundamental requirements such as compatibility, representation, and integration related to knowledge, are discussed. In a further step, mathematical spaces of elements called domains are introduced and related to modeling spaces. As a basic structure to represent properties and topology of related objects, typed attributed entity (TAE) structures are introduced together with their underlaid computational structure, so-called conditional attributed rewriting systems. Next, the mapping of our developed typed attributed entity structures into domain structured alphabets of attributed symbols, by way of typed attributed symbol structures, is shown together with the integration of associated knowledge representations. Verification and consistent handling of data and knowledge are finally shown by presenting results of our experimental work, using design and product requirements of a manufactured part, taken from aerospace engineering.

2

ABSTRACT CONCEPTS, ENTITIES AND FEATURE METHODOLOGIES

2.1 Modeling spaces In engineering, functional relationships among mechanical parts can be logically rationalized. The recent trend seems to favor an approach, in which information related to mechanical parts called features (see chapter 2.3), is grouped and related to topological and geometrical data of CAD systems. Features are used as elements of different (conceptual) spaces, to model certain properties of design objects. The logical combination of those descriptive elements is naturally interpreted in a conjunctive or disjunctive way. Concepts can be grouped into types to be a natural categorization of spaces for which information is being encoded. Those sets of concepts or types have to be related to each other in some (at least partial) order, according to their informational structure. A common way is to form inheritance hierarchies (Cardelli, 1984 - Cardelli and Wegner, 1985), which define a relation where information is encoded using concepts. It is one possibility to model certain kinds of agreements easily. Another aspect to be captured in design spaces is the fact of incomplete specified design objects. At each stage during design, an object might become more specific according to successful

carried out computation, being the implicit result of man-made decision and control. Information of incomplete objects has to be combined in a consistent way to guarantee defined relationships among elements of different concepts, which is the base description of another higher type of objects. 2.2 Concepts and entities The general design theory (GDT) (Yoshikawa, 1981 Tomiyama and Yoshikawa, 1987) as a descriptive model describes design performance conceptually in terms of knowledge manipulation. A design process can be regarded as a mapping between a function domain and an attribute domain. Both domains, or generally spaces, are defined over the set of an entity concept. In GDT, a distinction is made between the concept of an entity, which is an abstract impression, and the entity itself, which represents an existing object. Properties, which may include attributes of such an entity concept are called abstract concepts. In case of ideal knowledge, the GDT regards design specifications as points (entities) in the function space, and design solutions (object specification) as points of the attribute space. Due to a common entity concept set of both spaces, a direct mapping among points can be established. Thus, specifications of design solutions can be solely described within particular entity concepts, i.e., attributes and their topology. In our work we are mainly interested in design objects. We use the term context as it is used in GDT, to evaluate the current state of the design object model. The interpretation of a design object model, related to a context, allows a designer to model the current state of the design object in a certain environment. 2.3 Feature-based methodologies In feature-based methodologies two major classes of activities can be identified: design by feature and feature model evaluation. The intent of design by feature is to provide designers with a set of functional primitives (usually organized and stored in form feature libraries) which can be combined and modified to obtain more complex object descriptions (Ostrowsky, 1987 - Pratt, 1988 - Shah et al., 1988 - Shah and Rogers, 1989 - Rossignac, 1990 Laakko and Mäntylä, 1991a - Ranta et al., 1993). Feature recognition, feature extraction, and feature transmutation (Pratt, 1989 - Otto and Mandorli, 1992 - Mandorli et al., 1993), are techniques that have been developed, to perform model evaluation, required to retrieve implicit information present in the model and its organization. A further application of those evaluation techniques, combined with knowledge of work process environments, is the mapping of features. Evaluation techniques directly depend on the representation of the model. Considering three dimensional geometrical models, algorithms and rule-based systems exist for a CSG (Lee and Fu, 1987 - Perng et al., 1990 Waco and Kim, 1993) as well as for a B-rep (Kyprianou, 1980 Henderson and Anderson, 1984 - Falcidieno and Giannini, 1989 Sakurai and Gossard, 1990 - Laakko and Mäntylä, 1991b Mandorli and Vicini, 1991 - Corney and Clark, 1991 - Cugini et al., 1992a - Corney and Clark, 1993 - Regli and Nau, 1993) model evaluation. Examples of an approach, dealing with a combined

evaluation of two and three dimensional models are given in (Cugini et al., 1991). Examples dealing with a combined approach for both 3D design by feature and feature recognition are given in (Laakko, 1993).

3

INTEGRATED KNOWLEDGE REPRESENTATION AND COMPUTATIONAL STRUCTURES

transmutation. Procedural knowledge, to describe functions, relations, and operators, which are parts of feature-based methodologies in design and model evaluation. Declarative knowledge, which is used to model data structures of objects and reflective data of the system and its internal status. In fig. 1 an overview of introduced knowledge types related to their contents and their representational formation within our used computational structure is given. Declarative Knowledge

3.1 Compatibility of knowledge Intelligent CAD systems used in design applications, have to cope with a finite, but very large space of discourse. Traditional systems with mostly fixed, i.e., static, huge and complex architecture, lacking modular (information/knowledge) structures, are not able to keep pace with rapidly changing requirements of modeling and performance capabilities. Therefore, a new architecture and methodologies are required. If we extend our view of the entire design process and include reflective aspects of the used system (Otto and Mandorli, 1992), we recognize that not only design specifications and design solutions (cf. GDT) are in a state of evolution while design proceeds, but also particular sections of the system knowledge. According to above mentioned perceptions, an architecture with different forms of knowledge, being integrated, extensible, and partly exchangeable, would represent an appropriate structural base to overcome given problems. However, given requirements have to be valid also within one knowledge formation. If we use the object-oriented approach, compatibility and order of information within one structure can be modeled using hierarchies of concepts and information inheritance. Local extension and restriction of knowledge, as a consequence of design object refinement / evolution, can be realized with specialization and generalization of particular concepts, respectively. 3.2 Types of represented knowledge During the development of our reference kernel architecture for feature-based CAD systems (Otto and Mandorli, 1992 - Mandorli et al., 1993), we tried to incorporate as much as possible of previously discussed requirements focusing on system modularity, compatible and flexible knowledge representation, and feature-based methodologies. We tried to formally describe and operationalize computerized concepts, models, and data of the design process as well as the design object description, based on a basic non-trivial structure, where all elements of models, descriptions, and their theories/constraints can be specified with. Those so-called typed attributed entity structures (see chapter 3.4) posses an underlain computational structure in form of a conditional attributed interactive rewriting system (see chapter 3.5), which in term performs computation over alphabets of attributed symbols. During our knowledge modeling activities, we made use of the following different types: Control knowledge, to model strategies for design and evaluation of object descriptions, which includes also automated complex feature recognition and feature

Data Structures • Objects • Reflective Data Attributed Symbols Procedural Knowledge Functional Description • Design • Evaluation Rewriting Rules

Inference Engine Management • Data • Strategies Interpreter

Control Knowledge Strategies • Design • Evaluation Rewriting Meta-Rules

FIGURE 1

-

RELATED KNOWLEDGE AND REPRESENTATIONS

3.3 Modeling spaces and domains One possibility to represent mathematically spaces of elements with a certain topology are domains. They can be used to model semantic constructs and computability properties of functions (Smyth, 1977 - Stoy, 1977 - Mosses, 1990). We will use domains to model implementation-independent semantics of our attributed entities at the feature level as well as geometric level. However, due to elements being described through types/values of elements of the next lower conceptual level, we are also forced to model their semantics with (perhaps) another type of appropriate domains. Those inductive mappings of mathematical objects modeling semantics are based on compositionality, where the semantics of each element only depends on the semantics of its direct components. Techniques where one describes (denote) those mappings functionally with so-called semantic equations are known as denotational semantics (cf. Mosses, 1990). Before we try to define the structure of our elements of interest, we have to characterize mathematically what domains are and which are appropriate for our purpose. Domains are supposed to be sets of partially ordered elements. The order relation is the degree of informational contents (definedness) an element consists of. Formally, a tuple (D, ) with a set D and with a binary relation , being reflexive, antisymmetric and transitive, is called a partially ordered set (poset).

A subset S ⊆ D is directed, if all (finite) sets U ⊆ S have a least upper bound x S. If there is a least element ⊥D D and all directed subsets S ⊆ D have a least upper bound S, the poset D is a complete partial ordered set (cpo). An element x with x S of a cpo D is compact, if there is a point z S with x z for a directed subset S of D.

Assembly Level Assemblies made of high level objects. This level remains until now a space of tentative assumption and scientific speculations Feature Level

Definition: A cpo D with computable compact elements, where

High level objects and their relationships

each element is a directed limit of its finite approximation is called a domain. Note that any domain D is an algebraic lattice, if all subsets have a least upper bound. This is one restriction to ensure, that cpo's of continuous functions D1 ∅ D2 on domains D1 and D2 are themselves domains. This class of domains is also called bounded complete domains (cf. Gunter and Scott, 1990 for details).

Geometric Level Concepts to build up form feature, shapes, and their geometrical semantics Basic Level

3.4 Typed attributed entity structures Features can be regarded as entities of a particular entity concept. Associated properties are captured by abstract concepts and attributes. Abstract concepts can be any set of elements (data, functions, etc.) with a certain topology and order, respectively. In our framework, entities are formally treated as objects of different domains. Syntax and semantics are determined through properties, which are their attributes (cf. Otto, 1993b). Those attributes in term can be also attributed entities of other domains. Therefore, each type of an attribute has either an atomic value, i.e., a structure without any further attributes or a complex value with a structure consisting of other attributes and (possibly) nested sub structures. Within this structure, we define relationships between types and attributes, which innate a bidirectional nature. For each type it is exactly specified which attributes (if they are present by having a value assigned) are appropriate. It is also determined for each attribute, which types are appropriate to be assigned as values. Those type/attribute checks have to respect our assumed relationships (hierarchy) of types, to guarantee an appropriateness monotonicity related to hierarchies, i.e., an upward closure of this type/attribute check function. Formally, given finite sets of types T and attributes A, and a binary relation (expressing subsumption of types) types t1, t2 T, and an attribute a1 A, a partial function type_attribute_check: T ∞ A ∅ T is required to hold for the following given condition type_attribute_check(t1,a1) type_attribute_check(t2,a1) iff t1 t2 and being defined for the attribute a1 in both cases, for type t1 as well as type t2 . However, note that there has to exist for any attribute a most general type for which it is defined, to avoid non-determinism during type interferences. Within our framework a hierarchy of conceptual levels (cf. fig. 2) has been developed.

Litterals and their basic operators supported by most programming environments Machine Level Not considered in detail BLACK BOX

FIGURE 2 - HIERARCHY OF CONCEPTUAL LEVELS

At the basic level we consider literals such as numbers, characters, strings, Booleans, and their basic functions, together with basic mathematical objects and operators such as vectors, matrices, dot products, etc. At the conceptual level of geometry we have several different geometrical and functional types, which describe and realize our used concepts, to built up form features and their geometrical semantics. The geometrical topology of shape is captured with a boundary representation. Further types have been created, to realize concepts other than shape, to describe geometrical semantics of form features. Those can be pure functional properties or other elements, described with attributed entities. Currently, at the top conceptual level, form features are handled. All objects are described with attributes (values/types) of objects representing mostly concepts of previously described lower modeling levels. More information and detailed overviews with some examples can be found in (Mandorli et al., 1993 - Otto, 1993a - Otto and Kimura, 1993, 1994a, 1994c). Typed attributed entity structures (TAE) can be conceptualized and represented in different ways, textually as well as graphically. In the following, we use the concept of attribute value cluster (AVC) as their representation. AVC's have a matrix-like appearance of clustered elements, consisting of attributes and (nested) types. However, the domains of elements are not identical (as it is supposed for this structures in mathematical disciplines), which led us to refrain from the usage of the same name. Structure sharing is denoted by encircled

identifiers/labels (to distinguish visually between structure parentheses and an encircled structure identifier) with identical names (tokens), usually given as integer numbers. The type is written in boldface, to ease its visual distinction from attributes, which are written in plain style. Fig. 3 shows an example of such a conceptualized structure of an outermost type t together with its subsumption relations on types and the proper settings of parameters for the type/attribute check function. t a : 1

t1 a 4 :[ t4 ]

a : 2

8 t2 a 5 : [t 5 ]

∀ t i with i ∈ Ν i = 1. .. 6, (t i ∈ Τ ) ∧ (t ∈ Τ ) ∀ a i with i ∈ Ν i = 1.. . 7, a i ∈ Α (t1 t) ∧ (t 2 t) ∧ (t 3 t ) ∧ (t2 t 3) type _ attribute _ check (t , a1 ) = t1 type _ attribute _ check (t , a 2 ) = t 2 type _ attribute _ check (t , a 3 ) = t3 type _ attribute _ check (t1 , a 4 ) = t4 type _ attribute _ check (t2 , a5 ) = t5 type _ attribute _ check (t3 , a 6 ) = t 2 type _ attribute _ check (t3 , a 7 ) = t 6

t3 a : a : 3 6 [ 8] a : [t ] 7 6 FIGURE 3

-

ATTRIBUTE VALUE CLUSTER (AVC)

Note, that due to transitivity of this relation the explicit statement of (t2 t) could be omitted. The structure is specified by its attributes a1 , a2 , and a3 , having values of types t1 , t2 , and t3 respectively, which in term consist of the attributes a4, a5, a6, and a7 with assigned types t4, t5, and t6 , respectively. The structure of the value of attribute a6 is identical to the one of the attribute a2 , which is marked by label 8 . More details on attribute value clusters and other representations such as labeled ordered directed graphs are given in (Otto, 1993a). The aforementioned structures are formally described as following: A typed attributed entity TAE over finite sets of types T and attributes A is defined as a tuple TAE := (V,vR,δT,δV) where V is a set of values with the outermost value vR representing the type being specified, and δT: V ∅ T, δV: A ∞ V ∅ V as total type function and partial attribute value function, respectively. 3.5 Conditional attributed rewriting systems As a computational structure, enabling us to use a homogeneous representation of different integrated knowledge types, we use conditional attributed rewriting systems (CARW, cf. Bergstra and Klop, 1986 - Bottoni et al, 1994). Rewriting systems are directed equations used to compute by repeatedly replacing subterms (in a certain context) of a given term with equal terms. Enabling conditions in form of implications together with semantics are given to such systems, to specify, semantically as well as syntactically, when and how rewriting may be performed. Rewriting systems have the full (computational) power of Turing machines, which qualifies them as a universal formalism to

describe knowledge as required. CARWs can be formalized as following:

Definition: A CARW is defined by a semantic domain D = (ΩD, ΦD, ΓD) and a rewriting system RW=(V, F, I). ΩD ΦD ΓD

is a set of sets of values. is a set of functions. is a set of predicates, also comprising the constant predicates true and false.

V F I

is a finite set of symbols called the alphabet. is a finite set of productions. is the interpreter, i.e., the specification of the direct generation relation.

∀x V, ∃ A(x), called set of attributes, ∀α A(x), ∃ Dα(x) ΩD which specifies the possible values an attribute α can assume when associated with the symbol x. Dα(x) is called the domain of the attribute α for the symbol x. Each production p is of the form: , denoting that for δ to be rewritten as ε, it must be embedded in the context represented by ω1 and ω2. ω1=ω11, …, ω1m V* ω2 = ω21, …, ω2n V*. δ V+ is called the rewriting part of the antecedent, ε = ε1, …, εt V* is called the consequent. ∀p F, ∃γp ΓD, γp:Dα1(ω11) ∞…∞ Dαs(ω1m) ∞…∞ Dαp(ω2n)∅{true, false}. γp is the condition associated with p. ∀p F, ∃ rp which is a finite set of semantic rules of the form: αi(εj)= ƒj(α1(ω11), α2(ω11),…,αs(ω2n)), where ƒj ΦD. Semantic rules compute attributes of the consequent as a function of those of the antecedent. The interpreter I specifies the application of the rules in P to directly generate a string Z from a different one W, both being strings over V (in symbols W Z). Two main strategies (and hence interpreter types) have been proposed for direct generation: sequential and parallel. In both strategies the first step consists of finding all the occurrences of antecedents in the string to be rewritten. The result is a set of rules, whose antecedents appear in the string. In case of sequential strategies only one instance of one antecedent is rewritten as its consequent, each time one rule is applied. This strategy is typical of Grammar-like rewriting systems (Salomaa, 1973 - Rosenfeld, 1979). In case of parallel strategies, simultaneous substitution of all antecedents of the rule selection by their consequent is carried out. The application of all rules in the set is performed simultaneously. This strategy is typical of Lindenmayer-like systems (Lindenmayer, 1968 - Salomaa, 1973 - Rosenfeld, 1979). In both cases, semantic rules in the set rp are computed when the rule p is applied. To fulfill additional requirements such as

• • • • •

capability to specify a context-sensitive language over an alphabet of (recursive) attributed symbols use as a language-defining as well as languageaccepting device free specification according to syntax and semantics of any target language functional as well as equational specification of semantics possibility to describe simultaneously acting operations by parallel rewriting

we selected a special class of CARW systems called conditional attributed interactive Lindenmayer system (CAIL, cf. Cugini et al., 1984 - Mussio et al., 1988). CAIL systems are characterized by an interpreter, which specifies that direct generation occurs by simultaneous application of rules as follows: Let X = x1 x2 … xk be a string over V. For each xi in X, let Pref(xi, X) = x1 … xi-1 and Suf(xi, X) = xi+1 … xk. Let W and Z be words over V such that W=u1 w1 … ut wt ut+1, Z = u1 z1 … ut zt ut+1 where ui V* for i=1,…,t+1 wi = wi1 … wim i, i=1,…,t

Definition: W directly generates Z (in symbols W Z) iff: ∀wi ∃p F, s.t. p = , γp(α1(wi11),…, αq(wi2n)) = true, … wi1 and Suf(wim, W)=wi2 … Pref(wi1, W)= u1 ut+1 This is to say that rewriting occurs by substitution of wi by zi if wi is embedded in the proper context and the associated condition evaluates to true. Conditions of CAIL specify the constraints that a given disposition of symbols has to satisfy in order to constitute a particular object description (form feature, geometrical element, etc.) and therefore integrating additional knowledge in an evaluation rule. CAIL systems can be used to recognize descriptions of any object consisting of descriptions of elements located at the same or next lower level of abstraction. A conditional attributed rewriting system can be converted into a recognition device by specifying a set of words on V, and a set of axioms Ax. The triple can be used as a device to recognize a word y, if and only if y can be transformed into an axiom x Ax. A conditional attributed rewriting system used as a generative device over a set of words on V, and sets of axioms Ax, is the triple with a language as follows:

Definition: L(RW, D, Ax) = {y | ∃x where

Ax, ∃n

L0(x) = {x}, Lk+1(x) = {y | ∃z, z

N, y

Lk(x), z

Ln(x)}, y}.

The language, being recognized by a CAIL system (RW, D) with a set of axioms Ax can be formalized as follows:

Definition: L(RW, D, Ax) = {y | ∃x where:

Ax, ∃n

L0(x) = {x}, Lk+1(x) = {y | ∃z, z

Ν, y

Ln(x)},

Lk(x), y

z}.

Note, according to our given requirements, alphabets CAIL is computing with, have to contain all symbols representing all entities of the design object model. 3.6 Model and framework integration In order to use a CAIL system, we have to unify and map introduced concepts, methodologies, and representation structures into semantic domains and alphabets of attributed symbols, being part of the foundation of a CARW. In the following we demonstrate those structural relationships by relating stepwise attributed descriptions of design objects, entities, elements, and finally symbols. Entity concepts and attribute domains, as defined in the GDT, can be mapped into schemata (cf. conceptual levels) and types, with an immanent order of information (Otto, 1993a). Those abstract constructs in term can be formally described with above introduced TAE structures and semantical models as described in (Otto, 1993b, Otto and Kimura, 1994b). Engineering functionality, design intent, and shape aspects, clustered to build up form features (Cugini et al., 1992a), can be mapped into TAE structures by assigning to each conceptual entity of the form feature/application domain an attribute, which has a value of just the type, representing this concept. In our given approach, design object descriptions are composed of sets of (form) features, each having assigned a particular type. Let us denote the sets of all used feature types, feature identifiers, and property characterizing attributes with T, ID, and ATTR, respectively. Note, that those attributes are supposed to take values only in well-defined domains. Now we can recast given (form) feature definitions, based on TAE structures, in terms of entities consisting of sets (powersets) of a type, attributes, and identifiers, as follows: Definition: A description δ of a feature is a triple δ = with DTYPE(δ) = T, where: δn Id is the identifier of the described feature and specifies the description uniquely. δD = {,…,}, ai ATTR, ai ≠ aj for i ≠ j, vi Dai i=1,…,s is the finite set of the descriptors; TYPE δD denotes the attribute specifying the type of δ; δF is a collection of sets {F1,…,Fr}, Fi P(Id-{δn}) where P denotes the power set and (≈i=1 ... r Fi) ≈ δD ≠ . δF contains the identifiers of the features composing the structure identified by δn (Bottoni et al, 1993). All given representations of an element can be further mapped into a representation of an attributed symbol, and consequently a whole object description into a string of attributed symbols. Each symbol consists of an m+1 tuple of symbols, starting with its type t T, a new set of attributes including the identifier δDn := δD ≈

δn, and an appropriate coding for the list of composing elements δF. Given an object description in such a form, any data interpretation and knowledge manipulation can be modeled as a rewriting process (Bottoni et al., 1992 - Mandorli, 1994).

4

A PRACTICAL APPLICATION

4.1 Overview In the following we will present a selection of used data and knowledge, modeling given descriptions and requirements of a real product. Those data were used to verify theories and concepts, developed within our introduced framework. Due to space limitations, only a selection of our entire modeled test data are presented, sufficient to demonstrate how information is mapped and processed in case of a real application. The example, a wing rib, taken from results of the FEMOD project (cf. Bozza et al., 1993) is related to the aeronautical context of milled parts manufacturing. As an implementation environment for data representation, domain modeling, and computation, a prototype system developed following our developed reference kernel architecture has been used. Further implementation details on CAIL, its interpreter structure, and the integrated commercially available non manifold solid modeler kernel with its object-oriented environment are given in (Otto and Mandorli, 1992 - Otto and Kimura, 1993 - Mandorli et al., 1993). 4.2 Informal design object specifications An airframe is composed of a structure, the skeleton of the aircraft, and of a covering, the external skin that determines the aircraft contour. The milled parts are intrinsically resistant so they are located mainly in the airframe structure. Milled parts are manufactured using milling machines and lathes that remove particles of metal (chips) from an initial metal block or an unfinished product, obtained by die casting. The example of a milled part considered, is a wing rib, shown in fig.4.

FIGURE 4

-

EXAMPLE OF A MILLED WING RIB

First, we recognize two attachment flanges, a superior attachment flange and an inferior attachment flange, used to connect the part to the wing skin through rivets. The milled wing rib shown in fig.4.1., contains on each attachment flange, a pattern of 17 fixing holes to displace such rivets. The two attachment flanges are connected through a flat flange, the web. A certain number of flat flanges, connecting attachment flanges and the web, the stiffening flanges, can be displaced to stiffen the part. The milled wing rib, shown above, contains two stiffening flanges. Because of the presence of the stiffening flanges, the part contains a certain number of disjoint zones, the pockets, which are manufactured separately. The milled wing rib contains also three pockets. Depending on the wing rib location within the wing, the web or the stiffening flanges may contain a certain number of apertures, of circular or of more complex shape, allowing the passage of the wing equipment (tubes, etc.). To reinforce the zones around those apertures, a pad-up can be added. The shown example contains a circular aperture on the web, reinforced by a circular pad-up around it. To fix the wing rib with the neighboring parts or to fix the external equipment to the wing rib, the web and the stiffening flanges contain fixing holes, to displace bolts and rivets. The given example contains 4 such fixing holes on the web and one fixing hole on each stiffening flange. 4.3 Feature-based point of view The attachment flanges, the web, the stiffening flanges, and the different kinds of holes are entities with well defined functional meaning associated, which can be used as design features. However, those form features, having a different associated meaning, may have the same associated shape aspect. In case of

through holes, we may have according to our taken example a form feature as a hole, with its specialization into fixing holes, passing holes, lightening holes, and tooling holes. Individual requirements are given in table 1. Further feature-based requirements exist also for our previously introduced set of different flanges.

(c4 * R) ≤ D2 R

R

D1

Feature Name

D2

Hole

Feature Type

Design and Manufacturing

Global/Condit.

Conditioned

Description

Hole having various locations on the part and various

FIGURE 5

-

GEOMETRIC CONSTRAINTS

functions Geom. Attributes

Center

Input data

Diameter

Standard selected from tables

Other Attributes Geometry

Obtained by subtracting from the feature they are referred to a cylinder of diameter positioned in center

Specialization

Fixing hole

Used to displace bolts and rivets to fix the part to the neighboring parts or to fix the external wing equipment to the part. Can be organized in patterns. Can be located on the attachment flange, on the

Such design rules, defined over geometrical concepts, i.e., dimensional parameters of the features, can be easily managed by a parametric or variational system. However, difficulties arise if other types of relations among elements of higher conceptual levels, e.g., features, need to be defined and managed. Perhaps we should consider this case on a concrete example related to the wing rib and its fixing holes positioned on the attachment flange and the stiffening flanges. Let us consider the case to add the stiffening flanges to the wing rib, to increase the strength of the wing rib. We make an example of parameterization, given

web and on the stiffening flanges. Passing hole

Used to allow the passage of the external wing equipment.

Lightening hole

Used to lighten the part. Can be

Tooling hole

Used to fix the raw material during

located on the web. the manufacturing. Can be located on

L = length of the web R = radius of the fixing holes The 17 fixing holes have to be positioned on the attachment flanges, to keep an equidistant pattern among holes as well as holes and the border. This can be parametrized as follows:

the raw material.

TABLE 1

-

APPLICATION REQUIREMENTS FOR THE FORM FEATURE HOLE

PHi =

position of the i-th hole in respect with the left side of the web NH = number of fixing holes PHi = (L / (NH + 17)) * i

This fact highlights the nature of a form feature, consisting of the shape aspect (its appearance related to geometrical syntax) and the associated meaning (engineering and technological aspects constituting its semantic). Note, that individual parts of the functional meaning of form features can be expressed using design rules, that define how the feature has to interact with other features in the model. In the following we give two possible examples of geometrical constraints, the attribute LOCATION of fixing holes has to satisfy, to maintain their meaning (cf. fig. 5): Distance between holes: Given constants c1, c2, c3, N, the radius of a hole R, and the distance between the centers of two holes D1, then R and D1 have to satisfy constraints that can be defined as follows: ((c1 * R) ≤ D1 ≤ (c2 * R)) ∆ (D1 = c3 * R) Distance of holes from borders: Given a constant c4 N, the radius of a hole R, and the distance D2 of a hole's center to the borders of the attachment flange, then R and D2 have to satisfy a condition, being defined as follows:

Due to conditions of symmetry, the two stiffening flanges need to be also located equidistantly to each other as well as to the borders. The following equations express this condition: PSi = position of the i-th stiffening flange NS = number of stiffening flanges PSi = (L / (NS +1)) * i Using a parametric system the user can add the stiffening flange to the model using one of the existing adding method provided by the system. For example he/she can select the faces on the attachment flanges where to add the stiffening flange and then set the location parameters as previously described. Using a variational system the user makes a draft of the model, approximately positioning the stiffening flange in the right position, and defines the location parameters afterwards. Let us now fix some value of the parameters: L = 180 R=4

NH = 17 NS = 2

FIXING_HOLE

With these values, the positions of the holes are: 10, 20, 30, ... , 170. The distance from the borders and between two holes is 10 > 2*R, which is consistent with the design requirement as described above. But the positions of the stiffening flanges are: 60 and 120. Hence, the two stiffening flanges are located on top of two fixing holes (No. 6 and No. 12) present on the attachment flange (cf. fig. 6). Due to a missing explicit parametrization among the stiffening flange and the fixing holes, no parametric or variational system is able to detect this inconsistency in respect to the related functionality of the holes. All the verification and control are left to the user, who ought to visually check the entire consistency of the model. This might be possible in trivial cases such as our example, but might become almost impossible in case of complex model descriptions. Hence, incorrect models can be specified.

Web Stiffening flange

Fixing holes L=180 Attachment flange PH6=PS1=60

FIGURE 6

-

PARAMETERIZED WING RIB

We assume, that some basic functional meaning related to a form feature (e.g., a through hole has to be open on both sides; a blind hole has to be open only on one side, etc.) has to be maintained from the feature itself. Therefore, we propose to use typed entities (features) which have, due to their type specification, semantics embedded, which contains enough knowledge to achieve this task. The proper control of such typed spaces, i.e., domains, provides the mechanism to ensure the consistency of features. 4.4 Examples of mapped knowledge In the following we show domain specifications for some basic entities, geometrical entities, and the form features hole and flange with a selection of their specializations, as given in the example. Descriptions are based on the framework and formal specification, introduced in chapters 3.4-3.6. Next, an overview is given, on how type checking and interference of objects is handled, using reflective techniques controlled by rewriting rules.

FH_ID FH_ATTACH_TO FH_SHAPE FH_LOCATION FH_STATE FH_ENTRANCE_1 FH_ENTRANCE_2 FH_LATERAL FH_DIAMETER

: [FIXING_HOLE_ID] : [FH_HOLE_CONNECT] : [FH_GEOMETRIC_PRIMITIVE] : [FH_FORM_FEATURE_LOCATION] : [FH_FORM_FEATURE_STATE] : [FH_TOP_LOOP] : [FH_BOTTOM_LOOP] : [FH_WALL_FACE] : [HOLE_DIAMETER]

STIFFENING_FLANGE SF_ID : [STIFFENING_FLANGE_ID] SF_ATTACH_TO : [SF_FLANGE_CONNECT] SF_GEOMETRIC_PRIMITIVE GEOMETRIC_PRIMITIVE SF_SHAPE : PRIM_VALUE : GP_VALUE : [GEOMETRIC_TYPE] GP_GENESIS : [GEOMETRIC_MODELER] PRIM_AGG_TYPE : [GEOMETRIC_PRIMITIVE_TYPE] SF_LOCATION SF_STATE SF_LEFT SF_RIGHT SF_FRONT SF_BACK SF_TOP SF_BOTTOM SF_HEIGHT SF_WIDTH SF_DEPTH

FIGURE 7

: [SF_FORM_FEATURE_LOCATION] : [SF_FORM_FEATURE_STATE] : [SF_WALL_FACE] : [SF_WALL_FACE] : [SF_WALL_FACE] : [SF_WALL_FACE] : [SF_WALL_FACE] : [SF_WALL_FACE] : [H_LENGTH] : [W_LENGTH] : [D_LENGTH]

-

AVCs OF A SELECTED FEATURE DESCRIPTION

To above given description we need further to specify type subsumption relations such as ... ... ...

HOLE FIXING_HOLE FLANGE STIFFENING_FLANGE LENGTH W_LENGTH ... ..

to model inheritance relationships. For example W_LENGTH, being a subtype of LENGTH, inherits the property of being a nonnegative numerical value greater than zero, while adding a link to a geometrical entity belonging to a stiffening flange, to represent the concept of a flange length at the feature level. Note, that attributes discussed in the following are prefixed in above given description to avoid name clashes. The attribute IDENTIFIER is used to uniquely identify the feature. The attribute ATTACH-TO is used to model the relationship between the feature and its parent features. For example, a fixing hole cannot be attached to a pad-up of an aperture. The attribute SHAPE is used to relate to a form feature its geometrical appearance. The attributes GP_VALUE and GP_GENESIS from type GEOMETRIC_PRIMITIVE relate a given sequence of neutral operations to a modeler (in our case a geometric modeler), to generate the geometrical representation

(shape aspect) of an assigned (geometric) primitive. The value of PRIMITIVE_AGG_TYPE determines the aggregation type of the primitive. The attribute LOCATION is used to store a transformation matrix that represents the 3D location of a feature. Attributes DIAMETER (for fixing hole ), HEIGHT, WIDTH and DEPTH (stiffening flange) are used to relate the concept of dimensional parameters (at the feature level) to their representation through restricted numerical values and related geometrical entities. Attributes such as ENTRANCE-1, ENTRANCE-2 of the fixing hole feature are used to represent the relationship between the feature-based representation of the model and the pure geometrical/topological representation. By controlling the values of those attributes, it is possible to determine parts of the functional semantics related with the feature. For example, a through hole must refer with ENTRANCE_1 and ENTRANCE_2 to two internal convex loops of the boundary representation, to delimit such virtual faces (cf. face types WALL_FACE versus TOP_FACE).

INTEGER SUM DIFF PROD DIV REAL SUM DIFF PROD DIV LENGTH DIAMETER BOOL AND OR CHARACTER NUMCHAR CHAR STRING STR FTR_STATE GMTP_STATE

Definition: Given domains D, D1, D2 the operator L(D) denotes the domain of lists of finite length, with length(L(D1)) length(L(D2)) incomparable in .

Note, that IDENT is a countable flat domain of character strings, called identifier, which is composed of domains of identifiers of all existing typed symbols, mapped through an access function to a value. To specify the domain structure of any attributed entity, which is mapped into domain structured spaces of attributed symbols, we denote the attribute and its type with a domain and build up a new domain consisting of all (attribute types) domains generated with the smashed coalesced product as following:

Definition: Given domain D, the operator P(D) denotes the domain of powersets of D . Definition: Given domains D1, D2 the smashed product D1 D2 is defined as the set {(x,y) D1 ∞ D2 | x ⊥ y ⊥ } ≈ {⊥D1 D2} with ⊥D1 D2 z for every z D1 D2 Definition: Given domains D1, D2 the smashed coalesced sum D1 Η D2 is defined as the set ( (D1 − {⊥D1}) ∞ {0}) ≈ ((D2 - {⊥D2}) ∞ {1}) ≈ {⊥D1 D2} with D1 − {⊥D1} and D2 {⊥D2} being sets D1 and D2 with their respective bottom elements removed. The domain DFLEV of all specified geometrical objects (FACE, LOOP, EDGE, VERTEX) is a recursively given space, generated with the smashed coalesced sum of partial domains of geometrical entities, as given below, together with specifications of basic domains. Basic domains DFLEV DFF DMOD IDENTFLEV IDENTHOLE

= = = = =

IDENTFLANGE = IDENT VAL BAS

= =

DFACE Η DLOOP Η DEDGE Η DVERTEX DHOLE Η DFLANGE Η ... Η DFLEV Η DFF Η ... Η FACE_ID + LOOP_ID + EDGE_ID + VERTEX_ID HOLE_ID + FIXING_HOLE_ID + PASSING_HOLE_ID + LIGHTENIG_HOLE_ID + TOOLING_HOLE_ID FLANGE_ID + STIFFENING_FLANGE_ID + ATTACHMENT_FLANGE_ID + ... + IDENTFLEV + IDENTHOLE +... + IDENT ∅ DMOD {nil} ≈ {⊥}

=

=

=

=

= = =

N ≈ {⊥} (INTEGER INTEGER) ∅ INTEGER (INTEGER INTEGER) ∅ INTEGER (INTEGER INTEGER) ∅ INTEGER (INTEGER INTEGER) ∅ INTEGER R ≈ {⊥} (REAL REAL) ∅ REAL (REAL REAL) ∅ REAL (REAL REAL) ∅ REAL (REAL REAL) ∅ REAL (REAL) ∅ (R+ ≈ {⊥}) {0} (REAL) ∅ (R+ ≈ {⊥}) {0} {true, false} ≈ {⊥} (BOOL BOOL) ∅ BOOL (BOOL BOOL) ∅ BOOL not further specified CHARACTER ∅ NUMBER NUMBER ∅ CHARACTER not further specified CHARACTER ∅ STRING {GEO_MOD, TOPO_MOD} {NEW, SPLIT, MERGE, DELETE}

Domains for geometrical entities DFACE(IDENTIFIER) DFACE(LOOPS) DFACE(OWNER) DFACE(GEOM_PARAM) DFACE(GEOM_TYPE)

=

P(FACE_ID) 1 P(LOOP_ID) 2 P(FEATURE_ID) 3 L(REAL) 4

=

{PLANE, CONE}

= = =

DFACE(STATE) = GMTP_STATE DFACE = DFACE(IDENTIFIER) DFACE(LOOPS) DFACE(GEOM_PARAM) DFACE(STATE) DLOOP(IDENTIFIER) DLOOP(EDGES) DLOOP(ADJ_FACES) DLOOP(FACE) DLOOP(N_CONCAVE) DLOOP(N_CONVEX) DLOOP(TYPE) DLOOP(INTERN) DLOOP(OWNER)

= = = = =

DFACE(OWNER) DFACE(GEOM_TYPE)

P(LOOP_ID) 2 P(EDGE_ID) 5 P(FACE_ID) 1 P(FACE_ID) 1 INTEGER

=

INTEGER

=

{CONCAVE, CONVEX, MIX}

=

BOOL

P(FEATURE_ID) 3 DLOOP(STATE) = GMTP_STATE DLOOP = DLOOP(IDENTIFIER) DLOOP(EDGES) DLOOP(ADJ_FACES) DLOOP(FACE) =

DLOOP(N_CONCAVE) DLOOP(N_CONVEX) DLOOP(TYPE) DLOOP(INTERN) DLOOP(OWNER) DLOOP(STATE) DEDGE(IDENTIFIER) = P(EDGE_ID) 5

DEDGE(ADJ_FACES) DEDGE(VERTEX_1) DEDGE(VERTEX_2) DEDGE(SOLID_ANGLE) DEDGE(GEOM_TYPE)

= = = = =

DEDGE(GEOM_PARAM) = DEDGE(OWNER) =

P(FACE_ID) 1 P(VERTEX_ID) 6 P(VERTEX_ID) 6 {CONCAVE,CONVEX,SMOOTH} {STRAIGHT, CIRCLE, ELLIPSE, INT-CURVE} L(REAL) 7 P(FEATURE_ID) 3 GMTP_STATE

DEDGE(STATE) = DEDGE = DEDGE(IDENTIFIER)

Domains for fixing holes DFIXING_HOLE(IDENTIFIER) DFIXING_HOLE(ENTRANCE_1) DFIXING_HOLE(ENTRANCE_2)

= = =

DFIXING_HOLE(LATERAL) = DFIXING_HOLE(INHERIT-FROM) = DFIXING_HOLE(ATTACH_TO) DFIXING_HOLE(SHAPE)

P(HOLE_ID) 10 P(LOOP_ID) 2 P(LOOP_ID) 2 P(FACE_ID) 1

=

P(FEATURE_ID) 3 P(FEATURE_ID) 3

=

GEOMETRIC_PRIMITIVE

DEDGE(ADJ_FACES) DEDGE(VERTEX_1) DEDGE(VERTEX_2) DEDGE(SOLID_ANGLE) DEDGE(GEOM_TYPE)

DFIXING_HOLE(PRIMITIVE_AGG_TYPE) =

DEDGE(GEOM_PARAM) DEDGE(STATE)

DFIXING_HOLE(LOCATION) DFIXING_HOLE(DIAMETER)

DVERTEX(IDENTIFIER) DVERTEX(COORD) DVERTEX(INC_EDGES)

= = =

DEDGE(OWNER)

P(FACE_ID) L(REAL) 8

1

P(EDGE_ID) 5 P(FEATURE_ID) 3

DVERTEX(OWNER) = DVERTEX(STATE) = GMTP_STATE DVERTEX = DVERTEX(IDENTIFIER) DVERTEX(COORD) DVERTEX(INC_EDGES) DVERTEX(STATE)

DVERTEX(OWNER)

GEOMETRIC_PRIMITIVE_TYPE =

L(REAL)

=

HOLE_DIAMETER

DFIXING_HOLE(STATE) = FTR_STATE DFIXING_HOLE = DFIXING_HOLE(IDENTIFIER) DFIXING_HOLE(ENTRANCE_1) DFIXING_HOLE(ENTRANCE_2) DFIXING_HOLE(LATERAL) DFIXING_HOLE(INHERIT-FROM) DFIXING_HOLE(ATTACH_TO) DFIXING_HOLE(SHAPE) DFIXING_HOLE(PRIMITIVE_AGG_TYPE) DFIXING_HOLE(LOCATION) DFIXING_HOLE(DIAMETER) DFIXING_HOLE(STATE)

Domains for form features A generic through hole is defined with the following set of attributes and attribute domains: DHOLE(IDENTIFIER) DHOLE(ENTRANCE_1)

= =

DHOLE(ENTRANCE_2) DHOLE(LATERAL)

=

DHOLE(INHERIT_FROM) DHOLE(ATTACH_TO)

=

= =

P(HOLE_ID) 9 P(LOOP_ID) 2 P(LOOP_ID) 2 P(FACE_ID) 1 P(FEATURE_ID) 3 P(FEATURE_ID) 3

Domains for stiffening flanges DSTIFFENING_FLANGE(IDENTIFIER) = DSTIFFENING_FLANGE(LEFT) = DSTIFFENING_FLANGE(RIGHT) DSTIFFENING_FLANGE(FRONT) DSTIFFENING_FLANGE(BACK) DSTIFFENING_FLANGE(TOP) DSTIFFENING_FLANGE(BOTTOM)

= = = = =

P(STIFFENING_FLANGE_ID) 11 P(FACE_ID) 1 P(FACE_ID) 1 P(FACE_ID) 1 P(FACE_ID) 1 P(FACE_ID) 1 P(FACE_ID) 1 P(FEATURE_ID) 3 P(FEATURE_ID) 3

DHOLE(SHAPE) = GEOMETRIC_PRIMITIVE DHOLE(PRIMITIVE_AGG_TYPE) = FTR_STATUS

DSTIFFENING_FLANGE(INHERIT_FROM) = DSTIFFENING_FLANGE(ATTACH_TO) =

DHOLE(LOCATION) DHOLE(DIAMETER)

DSTIFFENING_FLANGE(SHAPE) = GEOMETRIC_PRIMITIVE DSTIFFENING_FLANGE(PRIMITIVE_AGG_TYPE) =

=

L(REAL)

=

HOLE_DIAMETER

DHOLE(STATE) = FTR_STATE DHOLE = DHOLE(IDENTIFIER) DHOLE(ENTRANCE_1) DHOLE(ENTRANCE_2) DHOLE(LATERAL) DHOLE(INHERIT_FROM) DHOLE(ATTACH_TO) DHOLE(SHAPE) DHOLE(PRIMITIVE_AGG_TYPE) DHOLE(LOCATION) DHOLE(STATE)

DHOLE(DIAMETER)

A generic through hole can be specialized into several types of holes for fixing, passing, lightening, and tooling, having different related functionality, but the same shape.

GEOMETRIC_PRIMITIVE_TYPE DSTIFFENING_FLANGE(LOCATION) DSTIFFENING_FLANGE(HEIGHT)

=

L(REAL)

=

H_LENGTH

DSTIFFENING_FLANGE(WIDTH) DSTIFFENING_FLANGE(DEPTH)

=

W_LENGTH

=

D_LENGTH

DSTIFFENING_FLANGE(STATE) = FTR_STATE DSTIFFENING_FLANGE = DSTIFFENING_FLANGE(IDENTIFIER) DSTIFFENING_FLANGE(LEFT) DSTIFFENING_FLANGE(RIGHT) DSTIFFENING_FLANGE(FRONT) DSTIFFENING_FLANGE(BACK) DSTIFFENING_FLANGE(TOP) DSTIFFENING_FLANGE(BOTTOM) DSTIFFENING_FLANGE(INHERIT_FROM) DSTIFFENING_FLANGE(ATTACH_TO) DSTIFFENING_FLANGE(SHAPE) DSTIFFENING_FLANGE(PRIMITIVE_AGG_TYPE) DSTIFFENING_FLANGE(LOCATION) DSTIFFENING_FLANGE(HEIGHT)

DSTIFFENING_FLANGE(WIDTH) DSTIFFENING_FLANGE(STATE)

DSTIFFENING_FLANGE(DEPTH)

Comment: 1 identifiers of faces 2 identifiers of loops 3 identifiers of features 4 parameters of face's geometry 5 identifiers of edges 6 identifiers of vertices 7 parameters of edge's geometry 8 coordinates of vertices 9 identifiers of hole features 10 identifiers of fixing hole features 11 identifiers of stiffening flange features

Feature Level Geometrical Level

FIGURE 9

Attachment flange Fixing hole

Feature Level Geometrical Level

Attachment flange

Stiffening flange

Fixing hole Stiffening flange - Fixing hole Interaction

FIGURE 8

-

OWNER

LATERAL

INTERACTION OF FEATURES

-

OWNER

ENTRANCE_1

ADJ_FACE

In order to support type checking and detection of interference of objects, reflective data and techniques (cf. Maes, 1988 - Otto and Mandorli, 1992 - Mandorli et al., 1993 - Bottoni et al., 1991 Bottoni et al., 1994), processed by control knowledge, are used. Referring to our wing rib example and the problem of the fixing holes covered by the stiffening flange, the internal state of the model must be checked, to identify all interactions occurred among features. Notice, that this problem is due to the interaction of a feature, which was not referred to in the modeling operation definition. This modeling operation was solely defined between the stiffening flange and the attachment flange. However, additionally an interaction occurred between the stiffening flange and the fixing hole. This interaction affects the geometry of the model. Therefore it can be checked at the geometric level. However, the detection of such an interaction at the feature level is a non-trivial problem because no direct relation exists among the features involved in the interaction (see fig. 8).

Stiffening flange

ATTACH_TO

ADJ_FACE

RELATED ENTITIES OF DIFFERENT CONCEPTUAL LEVELS

In order to deal with such problems, the system has to provide a mechanism to reason about the state of computation. Following our approach, reflective functionality and data are provided for each level of the model (cf. STATE attributes). Links among entities at the same level and among different levels are realized with a certain class of attributes shown in fig. 9. A (feature-based) modeling operation provides functionality to control the evolution of the model. The control is provided by the monitoring functionality that performs reflective activities over the model that is changed using the procedural knowledge, embedded in functions which manage the feature graph and the boundary representation. We will now illustrate how our used modeling operations can be mapped into a CAIL rule. The object model is described in our theoretical framework in terms of a string of attributed symbols. The string is divided into three sub string: the first part contains symbols representing entities of the boundary level; the second one contains symbols of the feature level, and the third part contains the set of possible features to be added to the model. The string evolves through rewriting, performed by application of rewriting rules. The string represents at each point in time the exact state of the design object description, which reflects the model evolution during the design process. In the following as an example, the aggregate operation, we call it ADD, that allows to insert a new feature into the model, is taken. Each rule (production belonging to the feature F in an CARW definition) has a syntactic part that describes the context in which a rewriting step can be performed. In case of ADD, the syntactic part is: , NBM, $, NFG, $, FL > Where: $ BM FG FL NBM NFG

= separation symbol, = boundary model = Feature Graph = Feature library = new calculated boundary model = new calculated feature graph

The rewriting part of the antecedent is BM, $, FG, and $, with FL representing the context. The rewriting part includes the two

parts of the string that describe the boundary and feature level of the model at a given state of computation. The context is in this case the third part of the string which represents the feature library, from where a new feature can be selected. The consequent part describes the model after the modeling operation has been performed. NBM, $, and NFG indicate the modified model. In particular, NBM represents the part of the string containing the rewritten boundary entities; NFG represents the updated feature graph with its new feature inserted; FL remains unchanged. The set of conditions, associated to a rule defines the control of the rewriting action. The set of conditions for the ADD rule can be described as a set of functions as follows: 1

Select_Feature_From_Library(FL) This function provides the interface to the user and allows to select the feature F1 (return value), to be added to the model, from the feature library FL.

2

Select_Features_From_Model(FG) This function provides the interface to the user and allows to select from the feature graph those features F2... Fn (return values) where to connect F1.

3

Locate(F1, F2 ... Fn) This function checks, that a valid method exists, to locate the feature F1 in respect with F2 ... Fn. The possible location method is selected from a pre-defined set. At this stage all the topological attributes of the feature level are set.

4

Boolean_Operation(F1, BM)) This function performs a simulation of the Boolean operation between the boundary representation of the model BM and the boundary representation of the new feature F1. In order to perform the operation, the GEOMETRIC-PRIMITIVE and BOOLEAN-OPERATION attributes of the feature F1 are used.

5

Type_Attribute_Check(F1, BM) The geometrical level is checked to find features, F2 ... Fn , probably intersecting with F1. Those features are selected using the OWNER attribute of the geometrical entities that have a modified value of the STATE attribute. The type of the attributes of F1 and found intersecting features are checked to ensure that the features remain consistent after the Boolean operation.

Note, that above mentioned type/attribute checks are only an examplified selection of all performed checks, related to attributes of entities, involved in an operation. If all steps are succesfully completed , the rewriting may take place using a set of semantic rules associated to the rule, to compute values for given attributes of involved symbols in the antecedent. In case of our example, those functions confirm the result of the Boolean operation, performed at step 3 and forward all values, as indicated by given type subsumption relations.

5

CONCLUSION One major advantage of our framework, which was evident during the experiments, was the general architecture of typed attributed entity structures being mapped into attributed symbols, which combine syntax as well as semantics in a compositional way, covering all conceptual layers, while remaining homomorphic. Within this architecture, the approach of form features, uniting shape aspects and engineering functionality through embedded semantics, proved to be a promising combination This was also one of the central shortcomings of current (parametric) CAD systems, which model only at one conceptual layer, viz. geometry. Other models, e.g., form features are only connected on top of such systems, but lacking a real integration, which complicates direct embedding of semantics. This fact is also one consequence of lack of integrated knowledge representations in most available systems up to now. Regarding applications of type checks and interference detection among elements of different conceptual layers (functional side effects), the use of reflective data and techniques proved to be a further basic element of our framework, which showed its power during our experimental work. Unfortunately is this technique not much used yet. Although, having some advantage over traditional introduced systems, our approach is somewhat handicapped by the fact, that our integrated knowledge representation at the lowest computational level, in form of domain-structured alphabets of attributed symbols and conditional attributed rewriting rules, becomes quite complex and therefore difficult to specify. Thus automated mappings among different levels of abstraction, modeled with related attributed structures are required. Work, to have models at higher levels of abstraction such as interactive graphics languages directing an automated rule generator (Mandorli, 1994) or algebraic specifications related to our computational structure (Otto, 1993b, Otto and Kimura, 1994b), is underway.

ACKNOWLEDGMENTS We would like to thank Isabella Bozza for providing application relevant data and assisting us in the preparation of our experimental work, related to the described example.

REFERENCES Bergstra, J.A. and Klop, J.W., Conditional rewrite rules; Confluence and termination, Journal of Computational Science, 32, pp 323-362, 1986. Bottoni, P., Mussio, P. and Protti, M., Metalevel Control in: Planning and Executing Image Interpretation Strategies, 6th International Conference on Image Analysis and Processing, 1991. Bottoni, P., Mussio P. and Protti, M., Metareasoning as a tool for pattern recognition, in: Proceedings of 11th IAPR Conference on Pattern Recognition, Vol. II, pp. 285-289, 1992.

Bottoni, P., Mussio P. and Protti, M., A data structure for form feature based image interpretation, to appear in Proc. 7th Int. Conf. on Image Analysis and Processing, 1993. Bottoni, P., Mussio, P., Protti, M., Metareasoning in the determination of image interpretation strategies, in: Pattern Recognition Letters, V. 15, pp. 176-190, 1994. Bozza, I., Cugini, U., Moroni, F., Vicini, I., IMU mock-up on milled part domain, Technical Report, BRITE project FEMOD BREU-0333, Milan July 1993. Cardelli, L., A semantics of multiple inheritance, in: Proceedings of the International Symposium on the Semantics of Data Types. Lecture Notes in Computer Science 173, G. Kahn, D. MacQueen, and G. Plotkin (eds.), pp. 51-67, 1984. Cardelli, L. and Wegner, P., On understanding types, data abstraction and polymorphism, Computing Surveys, 17, 4, pp. 471-522, 1985. Chung, J.C.H., Schussel, M.D., Comparison of Variational and Parametric Design, in: Proceedings of Autofact '89, Detroit, MI., pp. 27-44, October 1989. Colombo, G., Ferretti, D., Folini, F., GIPS: an Example of Integration between Parametric Design and Design Rules in a 2D CAD System, IFIP WG 5.2, Workshop on Geometric Modeling, Rensselaerville, June 1990. Corney, J. and Clark, D.E.R., A Method for Finding Holes and Pockets which connect Multiple Faces in 2 1/2 D Objects, Computer Aided Design, 23, 10, pp. 658-668, 1991. Corney, J. and Clark, D.E.R., Efficient Face-Based Feature Recognition, in:, Second Symposium on Solid Modeling and Applications, J. Rossignac, J. Turner, and G. Allen (eds.), Montreal, Canada, pp. 313-322, 1993. Cugini, U., Ferri, M., Mussio, P. and Protti, M., Pattern-directed restoration and vectorization of digitized engineering drawings, Computers & Graphics, 8, pp. 337-350, 1984. Cugini, U., Falcidieno, B., Giannini, F., Mussio, P., Protti, M., Task-driven description of mechanical parts in a CAD system, in: First International Conference on Artificial Intelligence in Design - AID '91, Edinburgh U.K., pp. 407-419, June 1991. Cugini, U., Mandorli, F. and Vicini I., Form Features Recognition as a Technique for CAD-CAM Integration, in: Proceeding MICAD ‘92, pp. 115-126, Paris, February 1992. Falcidieno, B. and Giannini, F., Automatic Recognition and Representation of Shape based Features in a Geometric Modelling System, Computer Vision, Graphics and Image Processing, 48, pp. 93-123, 1989. Ferretti, D., Folini, F., Truffelli, G., Capturing Engineering Knowledge: an Approach to Visual Programming in CAD Environement, in: Proceedings of the IFIP TC5/WG5.3 Eight International PROLAMAT Conference, Man in CIM, G.J. Olling and F. Kimura (eds.), pp. 515-524, Tokyo, June 1992. Gunter, C.A. and Scott, D.S., Semantic Domains, in: Handbook of Theoretical Computer Science, Vol. B, J. van Leeuwen (ed.), pp. 635-674, 1990. Henderson, M.R. and Anderson, D.C., Computer Recognition and Extraction of Form Features: A CAD/CAM Link, Computers in Industry, 5, pp. 329-339, 1984. Kimura, F., Future Perspective of CAD / CAM Research and Development in Japan, in: CAD'92, Neue Konzepte zur Realisierung anwendungsorientierter CAD-Systeme, GI Informatik aktuell, Springer-Verlag, Heidelberg, Germany, pp. 20-29, May 1992.

Kimura, F., Product and Process Modelling as a Kernel for Virtual Manufacturing Environment, Annals of the CIRP, 42/1, pp. 147-151, 1993. Kimura, F., A Computer-supported Framework for Concurrent Engineering, in: DIISM'93, Preprints of JSPE-IFIP WG 5.3 Workshop on The Design of Information Infrastructure Systems for Manufacturing, Tokyo, Japan, November 1993. Kyprianou, M.R., Shape Classification in Computer Aided Design, Ph.D. Dissertation, University of Cambridge, Cambridge, U.K., 1980. Laakko, T. and Mäntylä, M., Feature-Based Modelling of Families of Machined Parts, Report TKO-B71, Department of Computer Science, Helsinki University of Technology, Helsinki, Finland, 1991. Laakko, T. and Mäntylä, M., A New Form Feature Recognition Algorithm, in: Computer Applications in Production and Engineering: Integration Aspects, Elsevier Science Publishers B.V. (North-Holland), IFIP, pp. 369-376, 1991. Laakko, T. and Mäntylä, M., A Feature Definition Language for Bridgin Solids and Features, Second Symposium on Solid Modeling and Applications, J. Rossignac, J. Turner, and G. Allen (eds.), Montreal, Canada, pp. 333-342, 1993. Lee, Y.C.and Fu, K.S., Machine Understanding of CSG: Extraction and Unification of Manufacturing Features, IEEE Computer Graphics & Applications, 7, 11, pp. 20-32, 1987. Lindenmayer, A., Mathematical models for cellular interaction in development I - II, Theoretical Biol., 18, pp. 280-315, 1968. Maes, P., Computational Reflection, Knowledge Engineering Review, 3, pp. 3-19, 1988. Mandorli, F. and Vicini, I., A form feature automatic recognition system, in: Proceeding ICAR'91, Pisa, pp.1398-1403, 1991. Mandorli, F., Otto, H.E. and Kimura, F., A Reference Kernel Model for Feature-Based CAD Systems Supported by Conditional Attributed Rewrite Systems, Second Symposium on Solid Modeling and Applications, J. Rossignac, J. Turner, and G. Allen (eds.), Montreal, Canada, pp. 343-354, 1993. Mandorli, F., Interactive Knowledge Elicitation For Application Dependent Feature Evaluation Supported By Conditional Attributed Rewriting Systems, Internal Report, Dept. of Industrial Engineering, University of Parma, January 1994. Mosses, P.D., Denotational Semantics, in: Handbook of Theoretical Computer Science, Vol. B, J. van Leeuwen (ed.), pp. 577-631, 1990. Mussio, P., Padula, M., Protti, M., Attributed conditional Lsystems: a tool for image description, in: Proc. 9th International Joint Conference on Pattern Recognition, IEEE Computer Society Press, pp. 607-609, 1988. Ostrowski, M.C., Feature-based Design using Constructive Solid Geometry, Internal Report, General Electric Corporate Research and Development, March 1987. Otto, H.E. and Mandorli, F., A Reference Kernel for FeatureBased CAD-Systems; Theoretical and Practical Aspects, Research Note RN-KLO-7-92, Dept. of Precision Machinery Engineering, University of Tokyo, July 1992. Otto, H.E., On mathematical domain structures and typed attributed features: Some thoughts and experiments, Research Note RN-KLO-1-93, Dept. of Precision Machinery Engineering, University of Tokyo, January 1993.

Otto, H.E., Structural and semantical aspects of order-sorted algebras and typed attributed entity structures, Research Note RN-KLO-6-93, Dept. of Precision Machinery Engineering, University of Tokyo, June 1993. Otto, H.E. and Kimura, F., Integrated Entity Concepts and Attributed Structures as a Base for Feature Modeling, in: Proceedings of JSPE Symposium on Factory Automation and Computer-Integrated Manufacturing, Kyoto, October 1993. Otto, H.E. and Kimura, F., Information Preserving Aggregation of Attributed Entity Structures in Form Feature Modeling, in: Proceedings of JSPE Symposium on Feature Modeling, Tokyo, March 1994. Otto, H.E. and Kimura, F., Algebraic interpretation of Attributed Structures as an Semantical Model for Feature-Based CAD Systems, in: International Workshop on Knowledge Engineering and Applications, Beijing, August 1994, to appear. Otto, H.E. and Kimura, F., Denotational Spaces for Geometrical Semantics of Design Form Features Based on Typed Attributed Entity Structures, in: International Conference on Computer Aided Geometric Design, Penang, July 1994, to appear. Perng D., Chen Z.and Li, R., Automatic 3D Machining Features Extraction from 3D CSG Solid Input, Computer Aided Design, 22, 5, pp. 285-295, 1990. Pratt, M.J., Synthesis Of An Optimal Approach To Form Feature Modeling, ASME Computer and Engineering Conference, San Francisco, California, pp. 263-274 , 1988. Pratt, M.J., A Hybrid Feature-Based Modelling System, Advanced Geometric Modelling For Engineering Applications Conference, F.-L. Krause and H. Jansen (eds.), Berlin, Germany, pp.177-189, 1989. Ranta, M., Inui, M., Kimura, F., Mäntylä, M., Cut and Paste Based Modeling with Boundary Features, in: Second Symposium on Solid Modeling and Applications, J. Rossignac, J. Turner, and G. Allen (eds.), Montreal, Canada, pp. 303-312, 1993. Regli, W.C. and Nau, S.D., Building a General Approach to Feature Recognition of Material Removal Shape Element Volumes (MRSEVs), in: Second Symposium on Solid Modeling and Applications, J. Rossignac, J. Turner, and G. Allen (eds.), Montreal, Canada, pp. 293-302, 1993. Roller, D., A System for Interactive Variation Design, in: Proceedings of the IFIP/NSF Workshop on Geometric Modeling - Geometric Modeling for Product Engineering, M. Wozny, J. Turner and K. Preiss (eds.), North-Holland, 1988. Rosenfeld, A., Picture languages, Academic Press, 1979. Rossignac, J.R., Issues On Feature-Based Editing And Interrogation Of Solid Models, Computers & Graphics, pp. 149172, 1990. Sakurai, H.and Gossard D.C, Recognizing Shape Features in Solid Models, IEEE Computer Graphics & Applications, 10, 5, pp. 22-32, 1990. Salomaa, A., Formal languages, New York, Academic Press, 1973. Serrano, D., Gossard, D.C., Combining Mathematical Models with Geometric Models in CAE Systems, in: Proceedings of the ASME '86 - International Computers in Engineering Conference and Exhibit., Chicago, July 1986. Shah, J.J., Sreevalsan, P., Rogers, M.T., and Billo, R., Current Status of Feature Technology, Revised Report R-88-GM-04, CAM-I, Arlington, Texas, 1988.

Shah, J.J. and Rogers, M.T., Feature Based Modeling Shell: Design and Implementation, ASME Computer and Engineering Conference, San Francisco, California, pp. 255-261 , 1989. Smyth, M., Effectively given domains, Theoretical Computer Science, 5, pp. 257-274, 1977. Smyth, M., Power domains, Journal of Computer Systems Science, 16, pp. 23-36, 1978. Stoy, S.E., Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory, The MIT Press, Cambridge, MA., 1977. Tomiyama, T. and Yoshikawa, H., Extended General Design Theory, in:Design Theory for CAD - Proceedings of the IFIP Working Group 5.2 Working Conference, H. Yoshikawa and E.A. Warman (eds.), pp.95-124, 1987. Waco, D.L., Kim, Y., Geometric Reasoning for Machining Features Using Convex Decomposition, in: Second Symposium on Solid Modeling and Applications, J. Rossignac, J. Turner, and G. Allen (eds.), Montreal, Canada, pp. 323-332, 1993. Wesley, M.A., Lozano-Perez,T., Lieverman, L.I., Lavin,M.A. and Grossman, D.D., A Geometric Modelling System for Automated Mechanical Assembly, IBM Journal of Research and Development, 24,1, pp. 64-74, 1980. Yoshikawa , H., General Design Theory and a CAD System, in: Man-Machine Communication in CAD/CAM - Proceedings of the IFIP Working Group 5.2-5.3 Working Conference, T. Sata and E. A. Warman (eds.) , pp. 35-53, 1981.