Anne Canteaut

Gaëtan Leurent

Distinguishing and Key-recovery Attacks against Wheesht

Wheesht is one of the candidates to the CAESAR competition. In this note we present several attacks on Wheesht, showing that it is far from the advertised security level of 256 bits. In particular we describe a distinguishing attack with 2 70.3 known plaintext words for any number of rounds of Wheesht, and a key-recovery attack (recovering the encryption key) for versions of Wheesht with a single finalization round with very little data and time complexity 2 192 .

Introduction

Wheesht [3] is an authenticated encryption algorithm submitted to the CAESAR competition. The encryption of Wheesht is a stream cipher based on evaluating a keyed function over a counter. More precisely, the main function computes a keystream from • An encryption key k i ; • Some constants q i ; • A public nonce n i ; • A secret nonce s i ; • A block counter b i ; • Some extra parameters p i ; and is described in Figure 1. We use the notation x i , y i , z i for intermediate values during the computation. All values are 64-bit wide.

Generic attacks

We first describe generic attacks based on the high-level structure of Wheesht, as described in Figure 1. They are independent of the number of rounds t m and t f , and of the details of the permutation θ.

Distinguishing attack

Our first attack is a distinguishing attack with complexity around 2 64 . The main property used in this attack is that many values are fixed for all the blocks (excepted the last one) of a given message: n, s, p are fixed, and only b is incremented from one block to the next. In Figure 1, all the values that are kept constant for a given message are shown with a dash-dotted pattern.

SECRET project-team, {Anne.Canteaut, Gaetan.Leurent}@inria.fr

k0 ⊕ q0 k1 ⊕ q1 k2 ⊕ q2 k3 ⊕ q3 k0 ⊕ q4 k1 ⊕ q5 k2 ⊕ q6 k3 ⊕ q7 n0 n1 s0 s1 θ tm θ tm b0 b1 p0 p1 θ tm θ tm θ t f θ t f z4 ⊕ k0 z1 ⊕ k1 z6 ⊕ k2 z3 ⊕ k3 z0 ⊕ k0 z5 ⊕ k1 z2 ⊕ k2 z7 ⊕ k3 k0 k1 k2 k3 k0 k1 k2 k3 x 0 x 1 x 2 x 3 x 4 x 5 x 6 x 7 x 4 x 1 ⊕ b 0 x 6 x 3 ⊕ b 1 x 0 x 5 x 2 x 7 y 0 y 1 y 2 y 3 y 4 y 5 y 6 y 7 y 4 y 1 y 6 y 3 y 0 y 5 y 2 y 7 z 0 z 1 z 2 z 3 z 4 z 5 z 6 z 7
keystream authentication key More precisely, the generation of the keystream can be written as:

(y 1 , y 3 ) = λ x 4 ,x 1 ,x 6 ,x 3 (b 0 , b 1 ) (y 0 , y 2 ) = µ x 4 ,x 1 ,x 6 ,x 3 (b 0 , b 1 ) (z 1 , z 3 ) = χ y 4 ,y 6 (y 1 , y 3 ) (z 4 , z 6 ) = ξ y 4 ,y 6 (y 0 , y 2 )
where the functions λ x 4 ,x 1 ,x 6 ,x 3 , µ x 4 ,x 1 ,x 6 ,x 3 , χ y 4 ,y 6 and ξ y 4 ,y 6 are fixed for all the blocks of a long message, and are expected to behave like random functions (with 128-bit input and output). In particular, we expect that the image set of any of those functions is of size (1 -1/e) In order to distinguish Wheesht keystream efficiently, we look for collisions between the 128-bit values (σ 4i+1 , σ 4i+3 ) (respectively, collisions between the values (σ 4i+0 , σ 4i+2 )), i.e. two indexes i, j with (σ 4i+1 , σ 4i+3 ) = (σ 4j+1 , σ 4j+3 ).

In a random keystream, the first collision would be found after π/2 • 2 64 blocks on average. Moreover, the time of the first collision follows a Rayleigh distribution with parameter σ = 2 64 [2, pages 115-116]. However, with Wheesht keystream, collisions are expected earlier, because they can occur either in λ or in χ (respectively, either in µ or in ξ). Let B denote the random variable of the time of first collision observed in a Wheesht keystream, and B λ and B µ the time of the first collision in λ and µ with random inputs. We have B > t (i.e. the first t keystream block are distinct) if and only if the first t (y 1 , y 3 ) values are distinct, and the corresponding outputs of χ are distinct. Since χ is evaluated on distinct random values, we can write:

Pr B > t = Pr [B λ > t] × Pr [B χ > t]
From the Rayleigh distribution, we have Pr 64 . This gives:

[B λ > t] = Pr [B µ > t] ∼ e -t 2 /2σ 2 , with σ = 2
Pr B > t ∼ e -t 2 /2σ 2 × e -t 2 /2σ 2 = e -t 2 /σ 2 Therefore, B follows a Rayleigh distribution with parameter σ = σ/ √ 2 = 2 64 / √ 2. In particular, the mean value of B is σ π/2 = π/4 • 2 64 ≈ 0.89 • 2 64 (rather than π/2 • 2 64 ≈ 1.25 • 2 64 ).
This allows to build a very efficient distinguisher: we capture blocks of keystream until we detect a collision between the 128-bit values (σ 4i+1 , σ 4i+3 ), and we measure the time until the first collision. Since the Rayleigh distribution has a high variance ( 4-π 2 σ 2 ), we repeat the measure several times, and average the results. We denote the average of n measures by B n (respectively B n ). We have:

E(B n ) = π/2 • 2 64 Var(B n ) = 1 n • 4 -π 2 • 2 128 E(B n ) = π/4 • 2 64 Var(B n ) = 1 n • 4 -π 2 • 2 127
In order to distinguish the distributions, we set a threshold at T = 2 64 √ π 2 -√ 2 . We can use Chebyshev's inequality to bound the success probability of the distinguisher. For instance, with n = 32 we have:

|T -E(B n )| ≥ 1.85 • Var(B n ) Pr [B n < T ] ≤ 0.3 |T -E(B n )| ≥ 1.85 • Var(B n ) Pr B n > T ≤ 0.3
The detailed attack is given as Algorithm 1. The average number of required keystream blocks for each measure of the time of the first collision is at most π/2 • 2 64 ≈ 2 64.33 , implying that the average data complexity of the attack corresponds to 16 known plaintexts, each of length corresponding to 2 64.33 blocks (i.e., 2 69.33 bytes).

If each of the 16 known plaintexts contains more than 2 67 blocks, then the time of the first collision can be observed with overwhelming probability since Pr B < 2 67 ≈ 1 -e -2 2×67 /2 129 ≥ 1 -2 -46 . This attack has been verified experimentally with a reduced version of Wheesht with 16-bit words, and experimental results agree with the analysis: the first collision for Wheesht keystream is detected after 58079 blocks on average, rather than 82137 blocks on average for a random data.

Algorithm 1 Distinguishing attack on Wheesht.

Capture 16 known plaintext messages of length 2 67 blocks. Denote the keystream as σ

(i) j , 0 ≤ i < 16, 0 ≤ j < 2 69 for 0 ≤ i < 16 do for 0 ≤ k < 2 do S ← ∅ for 0 ≤ j < 2 67 do if (σ 4j+k , σ 4j+2+k ) ∈ S then B[2i + k] ← j break loop else S ← S ∪ {(σ4j,

Key-recovery attack

Another important observation is that the keystream words (k 1 ⊕ z 1 , k 3 ⊕ z 3 ) can be computed from only eight values: x 4 , x 1 , x 6 , x 3 , y 4 , y 6 , k 1 , k 3 , and from the block counter b. Moreover, for successive blocks of the same message, all those values are fixed, only the block counter b is modified (incremented). We denote this computation by f :

(z 1 , z 3 ) = f (x 4 , x 1 , x 6 , x 3 , y 4 , y 6 , b), (σ 1 , σ 3 ) = (z 1 , z 3 ) ⊕ (k 1 , k 3 ).
Finally, since the key k 1 , k 3 is only used at the end, it can be cancelled by XORing two different outputs. In our attack we first compute the XOR of successive output blocks for 2 3×64 = 2 192 values of x 4 , x 1 , x 6 , x 3 , y 4 , y 6 ; then we collect plaintext/ciphertext pairs, and we use the offline computation to detect a match for the values of x 4 , x 1 , x 6 , x 3 , y 4 , y 6 . We expect to find a match after about 2 3×64 = 2 192 output blocks, due to the birthday paradox. The full attack is described by Algorithm 2.

The attack uses only the high level structure of Wheesht, as shown in Figure 1. It is independent of the number of rounds t m and t f , and of the details of the permutation θ. The attack requires about 2 192 known plaintext data, but the data can come from any number of different sessions (with different nonces), and even with different keys (in this case, only the key of one session will be recovered). It is not clear whether this violates the designers claim (there is no clear limit on the amount of data), but this seems to violate the security level of 256 bits.

Algorithm 2 Generic key-recovery attack on Wheesht.

Offline computations: (x4, x1, x6) ← (0, 0, 0) for all x3, y4, y6 do for 0 ≤ i < 8 do Evaluate (z

(i) 1 , z (i) 3 ) = f (x4, x1, x6, x3, y4, y6, i) end for X ← (z (i) 1 ⊕ z (0) 1 , z (i) 3 ⊕ z (0) 3 ) 7 i=1 Store X, (x4, x1, x6, x3, y4, y6) in a hash table T end for
Online computations: Capture 32 × 2 3×64 words of known plaintext data for all keystream words σ0, σ1, . . . σ31 do

Compute X = (σ4i+1 ⊕ σ1, σ4i+3 ⊕ σ3) 7 i=1 if X is in the table T then Recover (x4, x1 , x6, x3, y4, y6) from
T Recover k1, k3 from the keystream and z1, z3. Recover k0, k2 by brute force end if end for

Low data complexity Attack

We now show a low data complexity attack using properties of the components of Wheesht. In particular, we study the final transformation θ t f . We target Wheesht-3-1-256, which is supposed to give 256 bits of security with t f = 1.

Following the previous observations, we know that blocks inside a fixed message have the same values y 4 and y 6 . We now explain how to detect this using the outputs z 1 and z 3 . Figure 2 shows the details of the finalization function θ t f , inspired by the Salsa family. In particular, we note that y 6 can be computed from z 1 , z 2 , z 3 . We denote this function as g: y 6 = g(z 1 , z 2 , z 3 ).

If we consider several blocks inside the same message, we can observe z 1 ⊕ k 1 and z 3 ⊕ k 3 from the keystream, and we know that the values must be coherent with a fixed y 6 . If we guess k 1 and k 3 , we can compute a set of possible values of y 6 as {g(z 1 , z 2 , z 3 ), ∀z 2 ∈ Z 2 64 } for every observation of (z 1 , z 3 ); we expect about (1 -1/e) • 2 64 distinct values in the set. If we take the intersection of the sets corresponding to several observations, we expect a single remaining value after a few hundred observations, or no value if the key guess was incorrect. More precisely, with N = 128 observations, a wrong key will have a non-empty intersection with probability (1 -1/e) 128 ≈ 2 -84 , therefore we expect about 2 44 wrong candidates, and testing them is a negligible part of the attack. This leads to the attack given in Algorithm 3.

The attack has been verified experimentally with a reduced version of Wheesht with 8-bit words. Those experiments show two small differences with the theoretical analysis. First the most significant bit of z 1 cannot be recovered because flipping it only shifts the set of y 6 candidates. Second, the filtering is slightly lower than expected: after 32 blocks of keystream, bad key guess are still valid with probability about 2 -12 , rather than the expected 2 -20 . Therefore, we suggest to use N = 256 in the attack against the full Wheesht.

Algorithm 3 Low data complexity key-recovery attack on Wheesht.

Input: known keystream σ0, σ1, . . . σ4N-1, N ≈ 256 for all k1, k3 do S ← 0, 1, . . . ,

2 64 -1 for 0 ≤ i < N do z1 ← σ4N+1 ⊕ k1 z3 ← σ4N+3 ⊕ k3 T ← g(z1, z2, z3), ∀z2 ∈ Z 2 64 S ← S ∩ T end for if S = ∅ then

Conclusion

We have described several attacks on Wheesht, proving that the security is far from the target level of 256-bit. Their respective complexities are given in Table 1.

The attacks of Section 2 are based only on the high level structure of Wheesht and can be applied with any number of rounds, while the attack of Section 3 use properties of the finalization round to reduce the complexity of a key-recovery.

Our attacks assume that the image sets of several functions are close to the size expected for a randomly chosen function. This has been checked experimentally on reduced versions on Wheesht (e.g. for the function g, we used a reduced version of θ operating on bytes instead of 64-bit words). Table 1. Complexities of the proposed attacks. The data complexity of the distinguisher corresponds to 16 known plaintexts of average length 2 66.3 words, while the data complexity of the second attack corresponds to messages of 32 words from 2 192 possibly different sessions.

In order to avoid those attacks, a simple tweak to Wheesht would be to have more layers in the global structure. For instance, an extra finalization and swapping step seem to avoid the issues reported here.

Fig. 1 .

 1 Fig. 1. Wheesht main block. Values that are fixed for all blocks (excepted the last one) of a given message are shown in a dash-dotted pattern.

Fig. 2 .

 2 Fig. 2. θ function

Acknowledgement

We would like to thank Peter Maxwell for fruitful discussions about those results.


Gilles Sérasset
email: gilles.serasset@imag.fr

An Interlingual Lexical Organisation Based on Acceptions From the PARAX mock-up to the NADIA system

Keywords: Multilinguism, Lexical Databases Management System, Lexical Database, Interlingua, Acception

Many projects are conducted to develop multilingual lexical databases. Some of these projects use an interlingual approach (KBMT-89, EDR, …), where others choose a bilingual approach (Multilex, …). This paper presents an interlingual approach based on acceptions (word-senses) aiming at the development of a multilingual lexical database management system: NADIA. With this approach, the interlingual lexicon is the union of the acceptions of the languages that appear in the database.

The interlingual set of relations is freely defined by the linguist, with the exception of the predefined "is-a" relation, necessary because acceptions of terms from one language don't always have lexical equivalents in another language.

To illustrate this lexical organisation, we show in detail a mock-up build as a preliminary experimentation: the PARAX mock-up which handles 5 languages: French, English, German, Russian and Chinese.

This lexical organisation has no influence neither on the linguistic content of the monolingual dictionaries, nor on the format adopted by the linguist to encode the information.

The NADIA system is designed to be multilingual (multilingual databases can be handled), application independent (databases can be used for several purposes), generic (the linguistic structures are defined by the linguist) and theory independent (many computational formalisms can be used to define the linguistic structures). The system provides many tools (browser, editor, defaulter, coherence checker, …) to simplify the management of a multilingual lexical database. Moreover, it handles the management of the interlingual dictionary as much as possible.

Finally, we justify our choices by a detailed study of existing projects on multilingual lexical databases and some of the problems they have had to deal with: EDR and KBMT-89 projects (which use a knowledge based approach) are faced with theoretical and methodological problems (concept discrimination, knowledge representation, concept classification, …). The acception based approach is a good choice to avoid the complexity introduced by knowledge representation problems and to keep the advantages of the interlingual approach.

Multilex provides a way for the linguist to define the different linguistic structures, however, the linguist can only use typed feature structures to code his linguistic theory. We have chosen to provide the linguist with different formalisms (trees, graphs, typed feature structures, sets, …).

Introduction

The needs in large scale lexical resources for Natural Language Processing (NLP) in general and for Machine Translation (MT) in particular, increases every day. These resources are considered as representing the most expensive part of an NLP system. Hence, we can observe an increasing interest for the development of reusable dictionaries.

To develop a Multilingual Lexical Database, one can use two main approaches. First, the transfer approach where the links between the languages are realised via unidirectional bilingual dictionaries. This approach is used by many MT systems and by some lexical database projects (notably Acquilex or Multilex). Second, the interlingual approach where the links between the languages are realised via an unique interlingual dictionary. The KBMT-89 project (Knowledge Based Machine Translation) at Carnegie Mellon University in US and the EDR (Electronic Dictionary Research) project in Japan use this approach.

We are interested by the problems posed when constructing and using application and theory independent multilingual lexical databases. In this framework, we chose to develop a Lexical Database Management System, the NADIA system. This system is based on an interlingual approach. We chose acceptions as interlingual units. The NADIA system provides many tools for the management of multilingual lexical databases. Moreover, This system gives the linguist a great liberty in the choice of the linguistic structures. This article presents the NADIA project. After a general study on the interlingual approach, we will present the framework of the system. Then, we will give a detailed view of the acception based approach. Next, we will have a closer view on the project with a brief description of Parax, a feasibility study, and the architecture of the system. Finally, we will study some lexical database projects. We will see the choices made for these projects and the problems they have had to deal with. We will finish by a justification of our choices, compared to those projects.

I. Acception based approach 1. Interlingual approach

The interlingual approach uses an artificial intermediary language (called interlingua and used as a pivot language) to realise the link between the languages.

An interlingua is an intermediate artificial language in which the utterances of all considered languages can be represented in a neutral way. Hence, an interlingua must have its proper lexicon and its own set of attributes and relations.

An interlingua must be defined with reference to a certain set of natural languages, unless a fixed universe of reference ("ontology") is represented autonomously in the computer.

An interlingua basically consists in two distinct parts, a lexicon and a set of attributes and relations.

Interlingual lexicon

The first part of an interlingua is the interlingual lexicon, which must be sufficient to represent the word senses of all considered languages. Therefore the interlingual lexicon contains at least as many word-senses as each monolingual lexicon.

As an interlingua is defined to establish a link between languages, the interlingual lexicon must provide a lexical link between words of different dictionaries. Hence, two equivalent word-senses in different languages must refer to the same interlingual unit. However, there is not necessarily a direct mapping between word-senses of different languages. As an example, the French words "rivière" and "fleuve" (in their most common sense) are translated in English by an unique word-sense (the most common sense of the word "river"). The French words are not equivalent1 . These two word senses are not distinguished in English. A link must be established via the interlingual lexicon between these word senses. However, such a distinction is only pertinent in an English-French context. In an English-Japanese context, this distinction is not relevant, as the Japanese word for river ("kawa") has the same sense as the English word "river".

If the interlingua is defined via an autonomous fixed universe or reference ("ontology"), one must give a description of each word-sense of each language in this universe.

In that case, equivalent word-senses of different languages must have exactly the same description. Moreover, "close" utterances (like the French words "rivière" and "fleuve") must have "close" descriptions. This "distance" between the descriptions must be recognised automatically for translation matter in case of non direct equivalence.

Interlingual attributes and relations

The second part of the interlingua is its set of attributes and relations. These attributes and relations must be sufficient to code the linguistic particularities of all considered languages. This part is not easy to define, even if fundamental linguistic studies are slowly producing more and more interlingual or universal "microtheories" (in the words of [START_REF] Nirenburg | Lexical and Conceptual Structure for Knowledge-Based Machine Translation[END_REF]) for parts of languages, such as aspect, time, modality, etc., which 20 years ago seemed to be describable only on a language specific manner.

Existing interlingual projects

Some projects have adopted the interlingual approach in lexical database definitions. Among these projects, we will look at the American KBMT-89 project and the Japanese EDR project. These projects have different aims. The former develops dictionaries for a particular application (a translation system based on knowledge representation) when the later develops lexical databases for any kind of MT system. KBMT-89 project ([Gates et al. 1989[START_REF] Nirenburg | Knowledge-based machine translation[END_REF]) has defined and implemented a translation system based on knowledge. For this purpose, a dictionary of 900 lexical units for English and 800 lexical units for Japanese (representing about 1500 concepts) has been developed. EDR project [START_REF] Edr | EDR Electronic Dictionary Technical Guide[END_REF]) deals with large scale resources. It develops large dictionaries of about 300,000 words in both English and Japanese (200,000 of general vocabulary, 100,000 of terminological vocabulary). EDR also develops a dictionary of 400,000 concepts, a dictionary of 300,000 co-occurrences (both in English and Japanese) and a dictionary of 300,000 bilingual entries (both for Japanese-English and English-Japanese).

Framework of the NADIA project

Our project, NADIA (Neutral Advanced Dictionaries by Interlingual Acceptions), aims at the development of a management system for multilingual lexical databases.

In this framework, we have four main objectives:

• Multilinguism: the lexical databases management system must handle multilingual databases. Hence, it must handle various writing systems, various sorting procedures, etc. • Application independence: the management system should not introduce any restriction on the applications that will use the databases. Many systems can use the defined databases (Machine Translation, Natural Language Processing, Natural Language Learning, …) provided that the necessary linguistic information is present. • Genericity: the linguistic structures used by the databases are to be defined by a linguist via a specialised language. • Theory independence: the management system should not introduce restrictions on the linguistic theory used by the databases. On the contrary, it should allow the use of numerous linguistic theories which make use of many computer formalisms.

We have chosen an interlingual approach because we think that it is the best solution to the application independence criterion. Such an approach is compatible with interlingual and transfer approaches as it is possible to generate transfer dictionaries for each language pair present in the database.

In order to reduce problems of interlingual approach, we have chosen to use acceptions as interlingual units. A language acception is a generally accepted meaning of a word.

An interlingual acception is one of the acceptions of one of the languages of the database.

The ULTRA project at CRL (Computing Research Laboratory, New Mexico State University) uses an equivalent approach ( [START_REF] Farwell | The Automatic Creation of Lexical Entries for a Multilingual MT system[END_REF]).

NADIA's approach to interlingua

In order to provide useful and powerful tools, the management system introduces some restrictions on the databases themselves: the multilingual lexical databases will be based on acceptions.

Lexical architecture

The lexical architecture deals with the organisation of the different dictionaries and their inter-relations inside a database.

We stress the fact that this lexical architecture has no influence on the linguistic content of dictionaries, neither on the format adopted by the linguist to code the information.

A lexical database defined within NADIA consists of two kind of dictionaries. The first kind consists of only one dictionary: the interlingual dictionary. The second kind of dictionaries consists of any number of monolingual dictionaries.

The interlingual dictionary contains the acceptions of the different languages of the database.

The monolingual dictionaries contain the linguistic information at the different lexical entries. The linguist is free to define, for each language, his own lexical units and lexical entries, provided that the monolingual dictionary makes the link between entries and acceptions. A monolingual dictionary generally consist of two parts; the first one dealing with acceptions of the language (the purely monolingual part) and the second one (called contrastive part) dealing with interlingual acceptions that do not have any equivalent in the language of the dictionary.

Interlingual lexicon

By using acceptions, we avoid the problem of word-sense refinement. For each language, we can choose an existing reference dictionary. Then, the acceptions of the language will be the acceptions found in the reference dictionary.

The interlingual lexicon is the union of all the acceptions of all the languages of the database. If there is a direct correspondence between two acceptions of different languages, these acceptions are merged in an unique interlingual acception. If there is no direct correspondence, the acceptions of a language are kept in the interlingual dictionary.

The management of an interlingual lexicon is a complex task. Hence, this management is done by the machine. The modifications on the interlingual lexicon is done when the machine detects a problem.

Interlingual set of relations and attributes

The interlingual set of relations and attributes is not fixed. It will be defined by a linguist for each lexical database.

However, in order to handle non direct mappings (see example of "rivière", "fleuve" and "river" above), a kind of "is-a" relation (relation from super-acception to sub-acception) is defined between acceptions. Then, with this relation, we code the fact that the usual acceptions of "rivière" and "fleuve" are sub-acceptions of the usual acception of "river".

This kind of relation will always be defined in the lexical databases. It constitutes the minimal set of interlingual relations.

An example

Let's consider the above example more in detail.

In the purely monolingual part of the English dictionary, the entry "river" has two acceptions:

river Natural stream of water flowing in a channel to the sea or to a lake, etc. or joining another ~.

Great flow, a ~ of lava; ~s of blood, great bloodshed (in war)

English Dictionary river_1 river_2

The purely monolingual part of the French dictionary contains the following acception for the entries "rivière" and "fleuve". As the English word "river" can be translated by "rivière" or by "fleuve" depending on what it represents, the interlingual dictionary must state that the acceptions "rivière_1" and "fleuve_1" are sub-acceptions of the acception "river_1". The contrastive part of the English dictionary reflects this problem and contains the information allowing the distinction of the two acceptions. Parax is a mock-up implemented with Hypercard™ by Étienne Blanc to study the feasibility of the acception based approach. This mock-up currently handles 5 languages: French, English, German, Russian and Chinese.

The linguistic structure of monolingual dictionaries comes from the dictionaries of the ARIANE system: a translator generator developed at GETA [START_REF] Boitet | ARIANE-78: an integrated environment for automatic translation and human revision[END_REF][START_REF] Boitet | A case study in software evolution: from ARIANE-78.4 to ARIANE-85[END_REF] . This linguistic structure is fixed.

The mock-up illustrate the choice of an interlingua by acceptions. The user can select a word in one of the languages. Then, Parax displays a list of acceptions corresponding to the chosen word. Each acception comes with a definition in French (the working language of the database).

Then, the user selects one acception. In the given example, there is a contrastive lexical problem between French and German. Two German acceptions correspond to the selected French acception: "fermer_replier" (closing by folding something). If the object of the verb is a fist, the German translation is "ballen", else, it is "zuklappen".

If the user wants a Russian equivalent, there is a direct equivalent to the selected acception.

However, if he wants the German translation, he has to chose the desired sub-acception.

NADIA : software architecture

The Parax mock-up is an illustration of the interlingual approach we chose. This mockup does not satisfy the theory independence objective. It does not provide specialised tools for the management of multilingual lexical databases.

In the framework of the NADIA project, we will develop a prototype of such a system using Common Lisp and Common Lisp Object System (CLOS).

NADIA's software architecture contains 3 parts:

• The database level is the lowest one. It is the level where objects are stored/restored. This level will remain completely transparent for users (lexicographers, linguists, end-users…). • The internal level is the level to which the different tools have access. The different linguistic objects are coded as Common Lisp Objects. This level will remain transparent for users. • The user level is the abstract level at which the user works. At this level, the user directly manipulates linguistic object (trees, typed feature structures, lists, automata, graphs, sets,…). The tools will provide outputs and accept inputs at this level. The functioning is based on the backward and forward motion between the user, the internal and the database levels.

A linguist defines the structures of the entries at the user level using usual (trees, features structures, graph, …). This definition is translated in terms of Common Lisp Objects.

Definitions and integrity rules are defined by a linguist at the user level. These rules are "compiled" and effectively used at the internal level and permanently stored in the database.

Queries are defined at the user level. They can be translated and evaluated at the internal level. The results of the queries will be presented at the user level.

The user can import or export entries or part of entries. The importing and exporting definitions will be defined at the user level, "compiled" and effectively used at the internal level. The result of exporting procedures will be stored in a SGML (Standard Generalised Markup Language) format reflecting the linguistic structures (TEI (Text Encoding Initiative) guidelines will be followed as much as possible).

Management of the dictionaries

There are 2 kinds of dictionaries in a NADIA multilingual lexical database:

• The monolingual dictionaries are divided in two parts:

• a purely monolingual part that contains acceptions of the language and the linguistic information that concern them • a contrastive part that contains information about acceptions existing in an other language, but not in the language of the dictionary. • The interlingual dictionary contains the interlingual units (acceptions) and their relations.

The linguist defines the linguistic structures of the entries for each monolingual dictionary via a specialised language. It is possible to define coherence, integrity and defaulting rules on these structures. The linguist manages the information of monolingual dictionaries with tools provided by the NADIA system (editors, defaulters, coherence checker, …).

The interlingual dictionary is complex to manage. An interlingual acception is created when a new acception appears in one language. The interlingual lexicon must provide lexical links between the different languages. For that purpose, all equivalent acceptions must be linked to the same interlingual acception. Hence, when adding a new term, the lexicographer has to check if an equivalent interlingual acception already exists in the interlingual lexicon. If so, he has to link the term to the acception, if not, he has to create a new acception in the interlingual lexicon. Such a basic management is not at all easy as it implies some constraints:

• The lexicographer has to browse the interlingual database to determine if the acception has been already defined by another lexicographer. This detection is not easy as the database may not be fully complete. • All problems detected in the interlingual dictionary have to be solved in a coherent way. • The interlingual lexicon must provide information for the lexicographer who checks the existence of an acception. This information must be sufficient to define unambiguously an acception and must be understable for all lexicographers. So, it must be given in a common language. • The lexicographer who has to create a new acception must provide this information, using the common language (which is not necessarily his native language).

For these reasons, the management of the interlingual dictionary will be handled by the system as much as possible. The system will create a new acception in the interlingual lexicon when a new acception is created in a monolingual dictionary. The system will link a new term with an already existing acception when it is possible.

Determining the existence of an interlingual acception or the need to create a new one is done by a "side effect". The lexicographer gives an equivalent of a term. In this way, the system knows if the corresponding interlingual acception exists or not and creates a new acception if necessary.

For example, let' us have a look at the indexation of the French words "rivière" and "fleuve". We suppose that the lexical database already contains an English dictionary.

The lexicographer indexes the French word "rivière". He finds the acception corresponding to the word "river" in English and links the new term to this already existing acception. After a while, he has to index the word "fleuve" and he finds the acception corresponding to "river". The first choice is incorrect as the acception is already linked to "rivière" and as "rivière" and "fleuve" are no synonyms. The second choice is also incorrect as a "fleuve" is not a "river".

The correct choice to resolve this problem is to modify the link between "rivière" and the original acception (which corresponds to "river") with the creation of two new acceptions (one for "rivière", one for "fleuve"). These new acceptions are subacceptions of the original one. In order to ensure a coherence in the management of the interlingual dictionary, and to simplify the work of the lexicographers, it is the system that takes in charge the different problems that can arise. It will detect them and propose solutions to the lexicographer.

III. Justification of the choices 1. Analysis of existing projects

KBMT-89

KBMT-89 (Knowledge Based Machine Translation) is a research project of Carnegie Mellon University's Center for Machine Translation. The goal of this project is to construct a MT system based on knowledge. The KBMT-89 system uses a knowledge representation of the domain as an interlingua.

The knowledge acquired by the system includes an ontology (about 1500 concepts). The lexicons contain about 800 Japanese lexical units and 900 English lexical units. A more detailed description of the project can be found in [START_REF] Meyer | Lexicographic Principles and Design for Knowledge-Based Machine Translation[END_REF][START_REF] Nirenburg | Knowledge-based machine translation[END_REF]].

KBMT-89's dictionaries are composed of:

• a knowledge base (ontology),

• monolingual lexicons (Japanese and English).

The knowledge base contains a set of concepts, classified in a hierarchy. These concepts are used as an interlingua.

The lexicons contain a set of "super-entries" (lemmas) decomposed in entries (senses).

Each of these senses are combined with linguistic information (category, orthography, phonology, morphology, syntactic features, syntactic structures, semantics, lexical relations and pragmatics).

Each sense of a word is generally linked to a concept of the knowledge base. A sense can be linked to an interlingual structure which is not reflected by a concept of an ontology (an attitude or a relation).

EDR

EDR (Electronic Dictionary Research) is a Japanese project aiming at the construction of a large scale lexical database for different MT systems. EDR has developed word dictionaries, a concept dictionary, bilingual dictionaries and co-occurrence dictionaries for English and Japanese.

The EDR concept dictionary contains a description of the concepts. This description is done by way of relations between concepts. EDR uses 32 types of relations and 5 attributes for this description. The concepts are also classified in a hierarchy.

The concept dictionary is used as an interlingual dictionary. Word dictionaries are linking entries and concepts and contain the linguistic information attached to the entries.

Multilex

The European project Multilex (DG XIII -ESPRIT project) aims at the definition of standards for the construction of multilingual lexical databases. Multilex deals only with languages of the European Community.

Multilex uses a transfer approach. A Multilex lexical database contains 2 kind of dictionaries: monolingual dictionaries and bilingual dictionaries.

The monolingual dictionaries contain lexical units (senses) and their associated linguistic information. A language has been developed for the linguist to define the structures used in a dictionary. These structures must be coded as Typed Feature Structures.

Bilingual dictionaries are unidirectional. Each bilingual unit is composed of a source lexical unit, a target lexical unit, a condition that is required to select this bilingual unit and a transformation rule linking the structures of the source lexical unit and the structure of the target lexical unit.

Encountered problems

It is interesting to analyse the main problems encountered by these projects. All of these projects face problems with the coding of linguistic information and the interlingua based project faces problems with concept refinement. We will also see the problems induced by knowledge representation and problems induced by concept classification.

Representation of linguistic information

The EDR project represents linguistic information as attributes. The possible attributes are defined a priori and cannot be modified. The linguistic information is not very detailed, but the present information is sufficient to be used by MT systems.

The Multilex project is more flexible as it allows the linguist to define the linguistic structures of the dictionaries. However, the linguist is obliged to use Typed Feature Structures to code his lexical information. These structures are well adapted for some problems but they are not well adapted to code certain linguistic structures like trees or automata.

Concept refinement

In order to use concepts as an interlingua, one must answer the question: "what is a concept?". Let's take an example:

• An elephant appears.

• An elephant is a clever animal.

• The elephant is an endangered species One has to know if there are 3 different concepts for "elephant" or if there are 3 different realisation of the concept "elephant".

EDR considers that the 3 sentences contain 3 different realisations of the same concept (the first sentence is about an individual elephant, the second one is about a typical elephant and the third one is about the species).

KBMT-89 has defined four criteria to refine the concepts. One of these criteria states that if a lexical unit has two incompatible sets of grammatical attributes, then two lexical units must be created. The grammatical attributes can be morphological, syntactic or lexical. But this criterion is not absolute: it depends on the size and systematicity of the differences between the 2 sets.

In the given example, it is not easy to see if we deal with one or three concepts. In the first sentence, the noun "elephant" is a discrete noun (it is possible to say "3 elephants appear"). In the second sentence and the third sentence, "elephant" is not discrete (saying "3 elephants are clever animals" is not analogous). Moreover, in the third phrase, one can not use the article "an".

One must make a choice between creating 3 concepts or only one. When this choice is done (whatever it is), the same choice must be done when an analogous problem appears. When constructing a real scale database, many lexicographers will have to work together. Ensuring the coherence of the choices is a complex methodological problem.

Problems introduced by the knowledge representation

EDR and KBMT-89 use a knowledge representation as an interlingua.

This choice introduces some methodological problems when one wants to construct real scale lexical databases.

First, it is difficult to describe concepts for a large scale (EDR, which successfully developed 400,000 concepts, needed 1200 man-years). To be really feasible, such a description should be done via a (semi-)automatic extraction of concepts. EDR has largely used this approach (from a large corpus).

When extracting knowledge, EDR has used a large corpus of texts. For speed and complexity reasons, EDR had to make hasty generalisations [H. Suzuki, personal communication]. Let's take for example the sentence "An elephant eats an apple". This sentence states that a particular elephant is eating a particular apple. EDR extracts two relations from this sentence:

• Any elephant can be an agent of the verb "to eat",

• Any apple can be the object of the action "to eat".

Problems introduced by a concept classification

EDR and KBMT-89 reduce the number of relations between concepts by a factorisation. This factorisation is done by way of a hierarchy and an inheritance mechanism.

For example, in the EDR hierarchy, the fact that a bird can fly is coded. The inheritance mechanism states the fact that a lark, a swallow, … can fly.

However, this classification of concepts can introduce theoretical and methodological problems.

First, one has to deal with exceptions. How can we represent the fact that an ostrich is a bird that cannot fly? EDR has chosen to declare texplicitly hat an ostrich can not fly via a negative relation [H. Suzuki, personal communication]. This assertion replaces the inherited assertion. However, negative relations should be used carefully and cannot be inserted automatically as they can introduce incoherence in the database.

The modification of such a hierarchy is really difficult as all the sub-concepts of the modified concept will be affected.

The addition of a relation to a concept in the hierarchy can be problematic if this concept has sub-concepts. This new relation will be inherited by all the sub-concepts. A verification will have to be done in order to verify if there are no new exceptions among the sub-concepts.

Justification of the choices

The choices we have made for the general organisation of the project are justified by our desire to ensure a certain compatibility (at least for data exchange) with the above projects and by the problems they encountered.

Multilex uses a transfer approach, when EDR and KBMT-89 have chosen an interlingual approach. In order to be compatible with both approaches, we have chosen an interlingual approach. With such an approach, it is possible to generate transfer dictionaries (compatible with Multilex dictionaries).

The EDR project uses a relatively fixed linguistic structure. Multilex is more adaptable, but allows only the use of Typed Features Structures. As adaptability is a really strong point, we chose to give the linguist the possibility to define his own linguistic structures.

To increase this adaptability, we do not restrict the choice of the computer structures that will code the linguistic structures. The NADIA system allows the use of most of the linguistic structures used now in Natural Language Processing. It is also possible to mix these different structures in a single entry, in order to dispose of an representation adapted to each linguistic problem. This way, we guarantee an independence of the system toward the chosen linguistic theory.

The two studied interlingual projects use a knowledge representation approach. We saw that this approach introduces some theoretical and methodological problems. In order to avoid some of those problems, we chose to use the acceptions as interlingua. This choice avoids the problem of refinement of the interlingual units (this refinement is systematic as we can use existing dictionaries as a reference). We also do not have to represent knowledge which lowers the cost of the creation of such a base.

The EDR project uses a classification of concepts to reduce the number of relations. As we do not use a description of concepts, this classification is useless. We use only one relation between acceptions: a relation from super-acception to sub-acception. This relation is useful to code contrastive problems. It is not intended to code a complete hierarchy. It will only be used "locally" in case of contrastive problems.

Conclusion

We have presented here the main ideas of the NADIA project, which aims at the construction of a management system for multilingual lexical databases.

The NADIA project uses an original interlingual approach: interlingua by acceptions. This approach avoids some problems of knowledge representation that often appear when dealing with interlingual projects.

By giving the linguist the possibility to choose the linguistic structure(s) he wants, we guarantee an independence toward the linguistic theory used for each base.

The NADIA prototype described here is currently under development. This prototype will open the way to the solution of different problems. For example, improving import/export tools will bring us to the problem induced by the sharing of linguistic data (especially data implementing different linguistic theories).

We would also like to develop the analogy between dictionaries and structured documents. Such an analogy gives us the ability to use results coming from this field. Hence, we can define different views of a lexicon. It is interesting to study how to simulate different linguistic theories using different views of the same lexicon.

  Fig. Flots, ruisseau. "des rivières de sang" Fig. rivière de diamants: collier de diamants montés en chatons

  this problem, the lexicographer might adopt different solutions: link this acception with the entry "fleuve" or create a new acception for "fleuve" and link it with an "is-a" relation to the acception of "river".

A "rivière" is a rather small river flowing into another river. A "fleuve" is a large river flowing to the see.


Flavien Boussuge
email: flavien.boussuge@eads.net

Ahmad Shahwan
email: ahmad.shahwan@grenoble-inp.fr

Jean-Claude Léon
email: jean-claude.leon@grenoble-inp.fr

Stefanie Hahmann
email: stefanie.hahmann@inria.fr

Gilles Foucault
email: gilles.foucault@ujf-grenoble.fr

Lionel Fine
email: lionel.fine@eads.net

Template-based geometric transformations of a functionally enriched DMU into FE assembly models

Keywords: Assembly, DMU, CAD -CAE integration, Functional information BC: boundary condition, DMU: digital mock-up, FE: finite elements, FEA: finite element analysis(es), KBE: Knowledge-based engineering, PDP: product development process

Pre-processing of CAD models derived from Digital Mock-Ups (DMUs) into finite element (FE) models is usually completed after many tedious tasks of model preparation and shape transformations. It is highly valuable for simulation engineers to automate time-consuming sequences of assembly preparation processes. Here, it is proposed to use an enriched DMU with geometric interfaces between components (contacts and interferences) and functional properties. Then, the key concept of template-based transformation can connect to assembly functions to locate consistent sets of components in the DMU. Subsequently, sets of shape transformations feed the template content to adapt components to FE requirements. To precisely monitor the friction areas and the mesh around bolts, the template creates sub-domains into their tightened components and preserves the consistency of geometric interfaces for the mesh generation purposes. From a user-selected assembly function, the method is able to robustly identify, locate and transform groups of components while preserving the consistency of the assembly needed for FE models. To enlarge the scope of the template in the assembly function taxonomy, it is shown how the concept of dependent function enforces the geometric and functional consistency of the transformed assembly. To demonstrate the proposed approach, a business oriented prototype processes bolted junctions of aeronautical structures.

FI: functional interface;

I C : set of components such that each of its components has all its FIs in T; P C : set of components such that each of its components has some of its FIs in T; T CI : taxonomy of conventional interfaces;

T FD : taxonomy of functional designations of components;

T FI : taxonomy of functional interfaces;

T FN : taxonomy of functions; S ME : reference state expressing static mechanical equilibrium of a component; S LC : reference state expressing a static load cycle inside an assembly; S T : shape transformation incorporated in a template, hence S T (T); S T1 : removal of a threaded link; S T2 : cylindrical sub domain around a screw shaft to localize friction effects; S T3 : removal of the locking nut of a bolted junction; S T4 : screw head transformations; S T5 : preserve the cylindrical loose fit between screw and plates to set up contact friction BCs; T: function-based template performing shape transformations;

T I : union of all components belonging to I C .

INTRODUCTION

To speed up a PDP, aeronautical, automotive and other companies face increasing needs in setting up FE simulations of large sub-structures of their products. The challenge is to study not only standalone components but to simulate the structural behavior of large assembly structures containing up to thousands of components [START_REF] Boussuge | An analysis of DMU transformation requirements for structural assembly simulations[END_REF]. DMUs are widely used during a PDP as the virtual geometric product reference. This model contains detailed 3D representation of the whole product structure available for simulation engineers. To prepare large sub-structure models for simulation (such as wings or aircraft fuselage section); the DMU offers a complete geometric input model. However, speeding up the simulation model generation strongly relies on the time required to perform the geometric transformations needed to adapt the DMU to FE requirements.

Currently, time and human resources involved in pre-processing CAD models derived from DMUs into FE models prevent engineers from setting up structural analyses. Very tedious tasks are required to process the large amount of DMU components and the connections between them. The shape transformations required for each assembly component, and interactively performed by engineers, can cover defeaturing [START_REF] Fine | A new approach to the Preparation of models for F.E. analyses[END_REF][START_REF] Thakur | A survey of CAD model simplification techniques for physics-based simulation applications[END_REF], idealization [START_REF] Armstrong | Techniques for interactive and automatic idealisation of CAD models[END_REF][START_REF] Armstrong | Integrating CAE concepts with CAD geometry[END_REF], domain decomposition [START_REF] Quadros | A computational framework for automating generation of sizing function assembly meshing via disconnected skeletons[END_REF][START_REF] Robinson | Automated mixed dimensional modelling from 2D and 3D CAD models[END_REF] as well as the definition of contact areas. Even on repetitive configurations such as junctions, similar geometric transformations must be repeated on all the components and interfaces of all the assembly junctions. Aeronautical structures are particularly complex to transform due to their many independent connectors such as bolts or rivets (see Fig. 1). Even though CAE software possess specific operators for bolted junctions, pre-stressed configurations, …, to speed up FEA pre-processing, the user must already have available a DMU incorporated all the desired geometric transformations. Automated domain decomposition, geometric simplifications, selection of target components are examples of processes still interactive and error prone that a user must perform tediously. Within the available resources and time scale planned in an industrial PDP, the analyst is therefore limited to simulate small models rather than complete assembly structures. Compared to standalone components, the above observations highlight the prominence of geometric interfaces processing when preparing an assembly model for FEA. Their mechanical behavior and the new shape transformations they convey are specific features of assemblies [START_REF] Boussuge | An analysis of DMU transformation requirements for structural assembly simulations[END_REF]. As described in [START_REF] Shahwan | Qualitative behavioral reasoning from components' interfaces to components' functions for DMU adaption to FE analyses[END_REF], component's geometric interfaces are the basis of component's functional designation. Effectively, to speed up the transformation of a DMU into a FE model, the engineer would process the components in accordance to their mechanical effect in the assembly, i.e. their function. Consequently, the relationship between FE simulation hypotheses, component's functions and component's interfaces appears as a key issue to improve the efficiency of DMU transformation for FEA. Indeed, setting up a FEA aims at studying the mechanical behavior of an assembly. Function, behavior and shape share strong connections, as studied by Gero [START_REF] Gero | The situated function-behaviour[END_REF][START_REF] Gero | Design prototypes: a knowledge representation schema for design[END_REF] and Albers [START_REF] Albers | Contact and channel modeling to support early design of technical systems[END_REF][START_REF] Albers | Contact and Channel Model for Pairs of Working Surfaces[END_REF] among others, hence the aforementioned example of the FE preparation process contributing to the representation of bolted connections in an aeronautical assembly.

In this paper, we propose an approach to reduce the FE model preparation time to adapt CAD assembly models derived from DMUs, into FE assembly models. Based on the analysis of DMU transformation requirements for FE assembly model preparation [START_REF] Boussuge | An analysis of DMU transformation requirements for structural assembly simulations[END_REF], the method uses an enriched DMU as input. It is obtained from previous developments and contains explicit geometric interfaces between components (contacts and interferences) as well as their functional designations. This last step is achieved using a qualitative reasoning process. From this enriched model, it is shown that further enrichment is needed to reach a level of product functions where simulation objectives can be used to specify new geometric operators that can be robustly applied to automate components' and interfaces' shape transformations during an assembly preparation process for FEA. If close to KBE, this scheme is nonetheless more generic and more robust than KBE approaches because functional designations and functions are generic concepts. KBE aims at structuring engineering knowledge and processing it with symbolic representations [START_REF] Chapman | Design engineering -a need to rethink the solution using knowledge based engineering[END_REF][START_REF] Rocca | Knwledge based engineering: between AI and CAD. Review of a language based technology to support engineering design[END_REF] using language based approaches. Here, the focus is on a robust connection between geometric models and symbolic representations featuring functions.

To prove the validity of our approach and the methodology proposed in [4-9], this paper presents a template-based operator dedicated to automate shape transformations of bolted junctions. Using the functional information and geometric interfaces, the operator applies a user-defined template to simplify bolts and sets control sub-domains around them in their associated tightened components to enable the description of the friction phenomenon between these components. This template is used to precisely monitor the meshing process while preserving the consistency of contacts and adapting the assembly model to simulation objectives.

The rest of the paper is organized as follows. In Section 2, we review the CAD-CAE integration research for FE assembly models. Section 3 reviews the method to enrich the DMU with geometric interfaces between components and functional designations of components. New requirements are introduced to connect functional designations with functions. Section 4, describes the concept of template-based transformation operator and illustrates it with a template-based operator of bolted Junctions transformation. Finally, the paper presents the result of this operator on an industrial aeronautical use-case and section 5 exemplifies an extension of the template definition with idealization transformations.

RELATED WORK

Assembly models have been studied throughout the development of solid modeling concepts. Essentially, assembly models have been proposed for design and manufacture applications [START_REF] Rahmani | Ontology based interface design and control methodology for collaborative product development[END_REF][START_REF] Robinson | Automated mixed dimensional modelling from 2D and 3D CAD models[END_REF][START_REF] Roy | Design with part behaviors: behavior model, representation and applications[END_REF][START_REF] Roy | Function-to-form mapping: model, representation and applications in design synthesis[END_REF] with recent applications to collaborative design. With the development of features, approaches set assemblies as components related to each other through geometric constraints [START_REF] Van Holland | Assembly features in modeling and planning[END_REF]. These approaches share a common denominator where assemblies are described as geometric models progressively enriched with technological and then, functional data [START_REF] Dixon | Assembly Feature Tutor and Recognition Algorithms Based on Mating Face Pairs[END_REF]. However, the closer the functional information, the higher is the requirement to obtain external information to CAD environments and the greater is the need of user's interactions during a design process. Though these additional informations are mandatory in a design process, it does not seem efficient to incorporate them into a preparation process for FE simulation when time reduction is critical to insert simulations into a PDP. If these informations were available at the level of FE simulation, a dedicated approach could be set up to process them but companies are currently not able to set up a digital representation of these data that is connected to the DMUs they produce with CAD systems. Within this framework, Roy and Bharadwaj [START_REF] Roy | Design with part behaviors: behavior model, representation and applications[END_REF] set up a design approach to connect functions to 3D geometry using a Part Function Model (PFM). There, they address the relationships between function, behavior and geometry of a part in a top-down manner from function to geometry to obtain parts from functional specifications. The PFM described requires up to low level functions that connect part boundary faces to function since the behavior model builds up on interfaces between parts, i.e. contact surfaces to position parts with respect to each other. At the level of complex assemblies with hundreds to thousands of parts, adding the amount of complementary data defining such a behavioral model becomes too tedious. Recent approaches [START_REF] Kim | Design formalism for collaborative assembly design[END_REF] reduce the description of junctions between components to global parameters describing bolted and riveted connections without referring to the individual surfaces of each bolt or rivet. This fits well with a design process but simulation objectives may require a detailed representation of interfaces when the purpose is to assess the stress field distribution in a bolted connection with tens or hundreds of bolts.

Developments of ontology-based approaches take advantage of new capabilities to structure concepts and to connect them with component models [START_REF] Kitamura | Ontology-based systematization of functional knowledge[END_REF][START_REF] Rahmani | Ontology based interface design and control methodology for collaborative product development[END_REF] or at the level of 3D geometry entities [START_REF] Barbau | OntoSTEP: Enriching product model data using ontologies[END_REF][START_REF] Bickford | Introduction to the Design and Behavior of Bolted Joints[END_REF][START_REF] Boussuge | An analysis of DMU transformation requirements for structural assembly simulations[END_REF][START_REF] Choudria | Identifying and re-meshing contact interfaces in a polyhedral assembly for digital mock-up[END_REF][START_REF] Clark | Conformal Assembly Meshing with Tolerant Imprinting[END_REF][START_REF] Champaney | A domain decomposition method for studying the effects of missing fasteners on the behavior of structural assemblies with contact and friction[END_REF][START_REF] Champaney | Adaptive multi-analysis strategy for contact problems with friction[END_REF][START_REF] Chapman | Design engineering -a need to rethink the solution using knowledge based engineering[END_REF][START_REF] Dixon | Assembly Feature Tutor and Recognition Algorithms Based on Mating Face Pairs[END_REF][START_REF] Fine | A new approach to the Preparation of models for F.E. analyses[END_REF][START_REF] Fiorentini | An Ontology for Assembly Representation[END_REF][START_REF] Gero | The situated function-behaviour[END_REF][START_REF] Gero | Design prototypes: a knowledge representation schema for design[END_REF][START_REF] Horvath | Towards an ontology-based definition of design features[END_REF]. Some of these approaches have been applied to assemblies [START_REF] Barbau | OntoSTEP: Enriching product model data using ontologies[END_REF][START_REF] Kim | Ontology-based assembly design and information sharing for collaborative product development[END_REF][START_REF] Rahmani | Ontology based interface design and control methodology for collaborative product development[END_REF] and can take advantage of reasoners to set up inference rules to ensure the consistency of the assembly description or extract information that is not readily available in the dataset describing an assembly. In [START_REF] Kim | Ontology-based assembly design and information sharing for collaborative product development[END_REF][START_REF] Rahmani | Ontology based interface design and control methodology for collaborative product development[END_REF], there is no direct connection between the ontology content and the 3D model of components. Here, ontologies support a design process where the engineer gets consistent information in a collaborative context but the ontology does not connect to boundary entities of component geometric models. Barbeau et al. [START_REF] Barbau | OntoSTEP: Enriching product model data using ontologies[END_REF] cover a larger description of a product with an ontological description incorporating the geometry and structure levels as available through STEP APIs [START_REF]-Application Protocol: Configuration controlled 3D design of mechanical parts and assemblies[END_REF][START_REF]Part 214 -Application Protocol: Core data for automotive mechanical design processes[END_REF], up to the functional description that can be inserted through ontological representation of the Core Product Model (CPM) [START_REF] Fiorentini | An Ontology for Assembly Representation[END_REF]. The authors showed that not all concepts of STEP could be rigorously expressed using OWL standard [START_REF]OWL Web Ontology Language Overview[END_REF] leading to limitations in detecting inconsistencies. If CPM is able to relate component functions to form features, the content of the CPM reflects the designers' choices to determine the level of product features inserted in this model and its level of connection with each component's geometry. Consequently, there is no guarantee that functional information can be available downward to the level of B-Rep entities of each component. Reasoning capabilities associated with ontologies are set up to browse the whole assembly ontology but they are not applied to derive new functional information or reinforce the connection between function and geometry in an assembly model. Consequently, we can observe that assembly processing is often addressed in a design context of top-down approach from primary product function point of view and there is no low level robust connection between components' geometry and low level functions. Additionally, the reasoning capabilities of ontology-based approaches are exploited to browse existing assembly data and derive data not readily available. These reasoning processes do not extend further than relative positioning constraints between components. KBE approaches [START_REF] Chapman | Design engineering -a need to rethink the solution using knowledge based engineering[END_REF][START_REF] Rocca | Knwledge based engineering: between AI and CAD. Review of a language based technology to support engineering design[END_REF] formalize engineering knowledge to automate some design tasks. KBE concepts take advantage of artificial intelligence techniques and strongly rely on language-based approaches. As such, they follow top-down approaches based on enterprise 'best practices' and address preliminary design stages rather than embodiment or detailed design ones, which is the product geometric description addressed here with DMUs. This is hardly applicable to other companies and even more to other products. Still, if KBE approaches incorporate connections with geometric models, geometry is perceived as attribute of higher level concepts like components, which does not bring new structure to the geometric models of components. Recently, Shahwan et al. [START_REF] Shahwan | Qualitative behavioral reasoning from components' interfaces to components' functions for DMU adaption to FE analyses[END_REF] inserted a qualitative reasoning process that can relate geometric interfaces up to the functional designation of components, thus creating a robust and automated connection between 3D geometric entities and functional designations of components. It is a bottom-up approach that fits to our current requirements.

Research in CAD-CAE integration has mainly focused on the use of global geometric transformations of standalone CAD components [START_REF] Thakur | A survey of CAD model simplification techniques for physics-based simulation applications[END_REF]. Few contributions addressed the automation of assembly pre-processing. Automatic simplifications of assembly for collaborative environment as the multi-resolution approach of Kim [START_REF] Kim | An integrated approach to realize multiresolution of b-rep model[END_REF] or surface simplification of Andujar [START_REF] Andujar | Topology-reducing surface simplification using a discrete solid representation[END_REF] transform assembly components independently of each other. This is not sufficient to pre-process FE assembly models because mechanical joints and interfaces tightening the different components must be part of their pre-processing. Commercial software proposes to automatically detect geometric interfaces between assembly components. However, their algorithms use a global proximity tolerance to find face pairs of components and they don't produce explicitly the geometric model of their contact area. In the assembly simplification method of Russ et al. [START_REF] Russ | Automated assembly model simplification for finite element analysis[END_REF], the authors propose to set components dependencies to remove groups of components having no influence on a simulation or to replace them by defeatured equivalent ones. However, the parent/child relationships created from constraint placement of components do not guarantee to obtain the entire neighborhood of a component because these constraints are not necessarily related to the components' geometric interfaces. In addition, DMUs don't contain components' location constraints when assemblies are complex, as occurring in the automotive and aeronautic industries, to ease design modifications during a PDP. Moreover, part naming identification used in this approach is not sufficient because it locates only individual components contained in the assembly without establishing relations with their adjacent components and their associate geometric model, i.e. replacing a bolted junction by an idealized fastener implies simplifying its nut, its screw as well as the hole connected to them in the tightened components. To provide mesh domains connectivity, Lou [START_REF] Lou | Merging enriched Finite Element triangle meshes for fast prototyping of alternate solutions in the context of industrial maintenance[END_REF] and Choudria [START_REF] Choudria | Identifying and re-meshing contact interfaces in a polyhedral assembly for digital mock-up[END_REF] proposes to identify and re-mesh contact interfaces. Quadros [START_REF] Quadros | A computational framework for automating generation of sizing function assembly meshing via disconnected skeletons[END_REF] establishes sizing functions to control assembly meshes. However, these methods are used directly on already meshed models, which addresses specific PDP configurations where CAD models are not readily available. Clark [START_REF] Clark | Conformal Assembly Meshing with Tolerant Imprinting[END_REF] detects interfaces in CAD assemblies to create non-manifold models before mesh generation but does not consider the interactions between interfaces and components' shapes transformation processes. In [START_REF] Boussuge | An analysis of DMU transformation requirements for structural assembly simulations[END_REF], we underline that if a component is simplified or idealized, its shape transformation has an influence on the transformation of its neighbors, e.g. a component idealized as a punctual mass impacts its neighboring component interfaces. Indeed, to adapt an assembly to FEA requirements, geometric transformations derive from simulation objectives and components' functions are needed to geometrically transform groups of components. It is also critical to structure the geometric models of components so that their shape transformations can preserve the DMU consistency [START_REF] Boussuge | An analysis of DMU transformation requirements for structural assembly simulations[END_REF]. We propose an approach where a DMU is enriched with geometric interfaces between its components, i.e. contacts and interferences, and functional properties. From this enriched model, simulation objectives can be used to specify geometric operators that can be robustly applied to automate components and interfaces shape transformations during an assembly preparation process.

DMU ENRICHMENT WITH FUNCTIONAL INFORMATION

From a component geometry to its functional designation

The principle of DMU functional enrichment can be summarized with the process flow shown on Fig. 2. Its detailed description can be found in [START_REF] Shahwan | Qualitative behavioral reasoning from components' interfaces to components' functions for DMU adaption to FE analyses[END_REF]. The focus is placed on this approach because, to the authors' knowledge, Shahwan's approach can automatically produce a functionally enriched DMU from a pure geometric input model, which is the reliable input data addressed here.

Fig. 2 starts from the STEP [START_REF]-Application Protocol: Configuration controlled 3D design of mechanical parts and assemblies[END_REF][START_REF]Part 214 -Application Protocol: Core data for automotive mechanical design processes[END_REF] representation of an assembly model with the extraction of geometric interfaces between components. Two categories of interfaces are addressed: contacts (surface and line ones) and interferences. The latter originates from the conventional representations of components, e.g. a screw is represented with a threaded part defined as a cylinder whose diameter equals the outer diameter of the thread and its nut is represented with a threaded part defined as a cylinder whose diameter equals an inner diameter of the thread; this produces a geometric interference between these components. At this stage, each component boundary gets modified to incorporate the imprints of its neighboring components through contacts and interferences. The geometric interfaces feed instances of 'conventional interfaces' (CI) classes structured into a taxonomy, T CI , that binds geometric and symbolic data, e.g. planar contact, spherical partial contact, cylindrical interference, … Simultaneously, CIs and assembly components are organized into a CI graph: CIG(C, I) where the components C are nodes and CIs I are arcs. Then, instances of functional interfaces (FIs) are derived from CI ones, possibly with multiple instances of FIs originated from a single instance of CI, e.g. a cylindrical contact can become either a cylindrical loose fit or cylindrical tight fit but a planar contact becomes only a planar support. Instances of FIs fit also into a taxonomy T FI . Now, the duality between geometry and interaction forces is used to derive mechanical parameters, i.e. screws (resulting force, resulting moment), from each instance of FI. These parameters are expressed qualitatively and feed symbolic behaviors of the assembly in order to take advantage of the shape, behavior, function relationship [START_REF] Albers | Contact and channel modeling to support early design of technical systems[END_REF][START_REF] Albers | Contact and Channel Model for Pairs of Working Surfaces[END_REF][START_REF] Gero | The situated function-behaviour[END_REF][START_REF] Gero | Design prototypes: a knowledge representation schema for design[END_REF]. Assembly behaviors are characterized by reference states and aim at reducing a single FI instance per CI instance. Here, two reference states are of interest: the mechanical equilibrium reference state, S ME , and the static load cycle one, S LC . S ME expresses the fact that each component must hold tight when the assembly has no mechanical interaction with its environment, i.e. each component can satisfy the static equilibrium equations. S LC expresses the fact that any threaded link between any two components of an assembly must generate close loops of forces, i.e. force cycles so that the corresponding components stay at static equilibrium. Fig. 3 illustrates this concept with a bolted junction and a force cycle in magenta.

From components' functional designations to functions

Though the bottom-up approach summarized in the previous section provide assembly components with a structured model incorporating functional information that is independent of their dimensions, their functional designation does not appear as an appropriate entry point to derive shape transformation operators as required for FE analyses. Indeed, to set up FE assembly models, an engineer looks for bolted junctions that he, resp. she, wants to transform to express friction phenomena, pre-stressed state in the screw, … Consequently, the functional level needed is not the functional designation, which is bound to a single component, it is the function itself to address the corresponding set of components and their FIs.

To this end, it is mandatory to refer to functions. This is achieved with a taxonomy of functions, T FN , that can produce a functional structure of an assembly (see Fig. 5). Blue items define the sub-path in T FN hierarchy that characterizes bolted junctions. Fig. 5: Subset of T FN , defining a functional structure of an assembly.

Each instance of a class in T FN contains a set of components identified by their functional designation, i.e. it contains their structured geometric models and FIs. The generation of these instances takes advantage of the functional designations of components, e.g. adjusted cap screw in the present case, and the load cycles attached to them and derived from S LC . This generation is achieved with inferences on functional designations and properties of load cycles. To this end, it is mandatory to distinguish statically determined configurations from statically undetermined ones. These details are not described here to preserve the paper consistency and concentrate on the exploitation of these functional informations.

As a result of the use of T FN , a component of a DMU can be automatically identified when it falls into the category of cap screws, nuts, locking nuts that are required to define bolted junctions. This means that their B-Rep model incorporates their geometric interfaces with neighboring components.The graph of interfaces identifies the components a bolted junction contains, the components are assigned functional designations that intrinsically identifies cap screws, nuts, locking nuts, …, and connects them with and assembly instance in T FN .

It is now the purpose of the next section to take advantage of this information to set up the template-based transformations.

TEMPLATE-BASED TRANSFORMATIONS FOR FE MODELS

As a result, the DMU is now geometrically structured, components are linked by their geometric interfaces, and groups of components can be accurately identified and located in the DMU using their function and geometric structure, e.g. 'adjusted bolted junctions with screw+nut' (see Fig. 5). Now, the geometric transformations needed to adapt the DMU to FEA objectives are strengthened because screws, nuts, locking nuts can be robustly identified, groups of tightened components are also available through the load cycles attached to cap screws.

Two possible accesses are proposed to define a function-based template related to an assembly function:

-A component through a user-defined selection: from it and its FD, a datastructure gives access to the functions it contributes to. After selecting this component, the user selects the function of interest. Other components are recovered through the selected function this component participates to, -The function itself that can lead to the set of components needed to define this function and all the instances of this function existing in the targeted assembly.

These accesses can be subjected to constraints that can help identifying the proper set of instances. Constraints aim at filtering out instances when a template is defined from a function to reduce a set of instances to the user's needs, e.g. assembly function with bolts 'constrained with' tightening plates 'plate_i' and 'plate_j' where these designations are functional designations of these components.

Constraints aim at extending a set of instances when a template is defined from a component, i.e. a single function instance recovered, and needs to be extended, e.g. assembly function with bolts 'constrained with' same tightened components and screw head FI of type 'planar support' or 'conical fit'.

Function-based template and compatibility conditions of transformations

The previous paragraph has sketched how component functions can be used to identify sets of components in an assembly. Indeed, this identification is based on classes appearing in T FN . Here, the purpose is to define more precisely how the template can be related to T FN and what constraints are set on shape transformations to preserve the geometric consistency of the components and assembly. Shape transformations are application-dependent and the present context is structural mechanics and FEA to define a range of possible transformations.

The simplest relationship between a template T and T FN is to relate T to a leaf of T FN . In this case, T covers instances defining sets of components that contain a variable number of components. T is also dimension independent since it covers any size of component, i.e. it is a parameterized entity. Shape transformations on T are designated as S T and the template devoted to an application becomes S T (T). Now, reducing the scope to disassemblable assembly functions and more specifically bolted junctions, one leaf of T FN can be used to define more precisely T and S T (T). Conforming to Fig. 5, let us restrict first to the leaf 'screw+nut' of T FN . Then, T contains the following FIs: one threaded link, two or more planar supports (one between nut and plate and at least one between two plates), either one planar support or one conical fit between the screw head and a plate, as many cylindrical loose fits as plates between the screw and plates because the class of junctions is of type adjusted. The shape transformations S T (T) of T set up to process bolted junctions can be summarized as: Each of these transformations will be detailed throughout the following sections.

Now, the purpose is to define S T so that S T (T) exists and preserves the consistency of the components and the assembly. This defines compatibility conditions, C C , between T and S T that are conceptually close to attachment constraints of form features on an object [START_REF] Van Den Berg | Specification of free-form features[END_REF]. C C apply to S T and are introduced briefly here. Given the set of components contained in T, this set can be subdivided into two disjoint subsets as follows:

-I C is the set of components such that each of its components has all its FIs in T, e.g. the screw belongs to I C . Consequently, components belonging to I C are entirely in T; -P C is the set of components such that each of its components has some of its FIs in T, e.g. a plate belongs to P C . Components belonging to I C are partially in T.

I C can be used to define a 3D sub domain of T, T I defined as the union of all components belonging to I C . Now, if a transformation S T takes place in I C and geometrically lies inside T I , S T (T) is valid because it cannot create interferences with other components of the assembly, i.e. C C is satisfied.

Let us consider some of these transformations to illustrate some C C . As an objective of FEA, the purpose of the assembly model is to analyze the stress distribution between plates and their interactions with bolts. To this end, the stress distribution around the threaded link between a screw and a nut is not relevant. Therefore, one shape transformation, S T1 is the removal of the threaded link to merge the screw and the nut (see Fig. 6a). S T1 is always compatible since the screw and the nut belong to I C , hence the validity of C C . Now, considering another transformation, S T2 , is the localization of friction effects between plates around the screw shaft and the representation of the stress distribution nearby the screw shaft. This is modeled with a circular area centered on the screw axis and a cylindrical sub domain around the screw shaft (see Fig. 6b). Indeed, S T2 , is a domain decomposition [START_REF] Champaney | A domain decomposition method for studying the effects of missing fasteners on the behavior of structural assemblies with contact and friction[END_REF][START_REF] Champaney | Adaptive multi-analysis strategy for contact problems with friction[END_REF] taking place in the plates belonging to T. Because the plates belong to P C , C C are not trivial. However, S T2 , takes place inside the plates so they cannot interfere with other components, rather they can interfere with the boundary of the plates or they can interfere between them when several screws are close to each other on the same plate (see Fig. 7). In this case, C C can be simply expressed, in a first place, as a non interference constraint.

Other shape transformations will be listed when describing one example template in section 4.4.

Shape transformations and function dependency

The previous section has connected T to T FN in the simplest way possible, i.e. using a leaf that characterizes a single function. The purpose of this section is to analyze into which extent T can connect to classes of T FN that perform several functions in the assembly.

In a first place, let us review shortly some concepts of functional analysis [START_REF] Ullman | The Mechanical Design Process[END_REF]. There, it is often referred to several categories of functions that are related to a design process, i.e. external, internal, auxiliary, … However, this does not convey consistency conditions among these functions, especially from a geometric point of view. Here, the current content of T FN refers to internal functions, i.e. functions strictly performed by components of the assembly. The 'screw+nut' function, as part of bolted junctions, is one of them. Bolted junctions can contain other functions. Let us consider the locking function, i.e. the bolt is locked to avoid any loss of tension in the screw when the components are subjected to vibrations. The locking process can take place either on the screw or on the nut. For the purpose of the analysis, we consider here a locking process on the nut, using a locking nut (see Fig. 9a). In functional analysis, this function is designated as auxiliary function but this concept does not characterize geometric properties of these functions.

From a geometric point of view, it can be observed that FIs of the screw, nut and locking nut are located in 3D such that the FI (planar support) between the nut and locking nut cannot exist if the nut does not tighten the plates. Consequently, the locking function cannot exist if the tightening function does not exist. Rather than using the designation of auxiliary function, which is geometrically imprecise, it is referred to dependent function.

The concept of dependent functions is inserted in T FN at different levels of T FN to attach the corresponding functions when they exist (see Fig. 5). Based on the concept of dependent function, it is possible to extend the connection rule between T and T FN . Rather than connections at the leaf level, higher level classes can be connected to T if the dependent functions are taken into account in the C C of shape transformations S T so that S T (T) exists and preserves the consistency of the assembly. As an illustration, let us consider T connected to 'Bolted adjusted' (see Fig. 5). Now, S T can cover the class of bolted junctions with locking nut. Let S T3 , be the transformation that removes the locking nut of a bolted junction, which meets also the FEA objectives mentioned earlier. Because S T3 , applies to a dependent function of 'screw+nut', is satisfies the C C and the resulting model has a consistent layout of FIs. Consequently, T can be effectively connected to 'Bolted adjusted', which is a generalization of T.

Template generation

T is generated on the basis of the components involved in its associated function in T FN . T incorporates the objectives of the FEA to specify S T . Here, S T covers all the transformations described previously, i.e. S T1 , S T2 , S T3 . Fig. 6 and 7 illustrates the key elements of these shape transformations. Other shape transformations, S T4 , can be defined to cover screw head transformations and extend the range of screws to flat head ones.

Then, the set of shape transformations structures the dialog with the user to allow him, resp. her, to select some of these transformations. However, the user settings are applied to instances whenever possible, i.e. when the instance belongs to a class where the shape transformations are applicable. From the physical testing and preliminary numerical models, the following simulation objectives have been set up that initiate the requirements for the proposed template-based transformations.

To adapt the FE model to these simulation objectives while representing the physical behavior of the structure, an efficient domain decomposition approach [START_REF] Champaney | A domain decomposition method for studying the effects of missing fasteners on the behavior of structural assemblies with contact and friction[END_REF][START_REF] Champaney | Adaptive multi-analysis strategy for contact problems with friction[END_REF] uses a coarse mesh far enough from the bolted junctions and a specific sub domain around each bolted junction with friction and preload phenomena (see Fig. 8a,b). The objective is not to generate a detailed stress distribution everywhere in this assembly but to observe the load distribution areas among bolts using the mechanical models set in the sub domains. The objective of this section is to validate the template-based approach based on a demonstrator that transforms automatically the bolts into simplified sub domains ready for meshing with friction area definition while preserving the consistency of the assembly. The template features are aligned with the needs for setting up a simulation model able to exhibit some of the physical phenomena observed during testing and expressed in the above simulations results.

5.4.1

Operator description Having enriched the assembly with functional information, the template interface lets the user select a node of T FN that is compatible with T. In this example, the function to select is: 'assembly with Bolted junction' (see Fig. 10). Now, several S T are either pre set or user accessible. S T3 is user accessible and set here to remove the dependent function 'locking with locking nut' because the simulation objective does not focus on dynamic effects. Then, S T5 is pre set in T to preserve the cylindrical loose fit between screw and plates to set up contact friction BCs without interpenetration over these FIs. S T1 is also pre set as well as S T4 . The latter is performed on the FI (planar support) between the screw head/nut and the plates to obtain a meshing process independent of nut and screw head shapes. Now, T can cover any bolted junction to merge screw, nut and locking-nut into a single domain, reduce the screw and nut shapes to a simple shape of revolution while preserving the consistency of its interfaces. To precisely monitor the stress distribution around bolts and friction between plates, S T2 is user-selected. It a simplified model of the Rotscher's cone [START_REF] Bickford | Introduction to the Design and Behavior of Bolted Joints[END_REF] (see Fig. 9) that enables generating a simple mesh pattern around bolts. Based on T, S T (T) is fairly generic and parameterized to intelligently select and transform bolts, i.e. it is independent of the number and thicknesses of plates, of the screw diameter, the length and head type (cylindrical (see Fig. 9a) versus flat ones) in addition to the location of each bolt.

Here, S T (T) contains S T2 , a generation of sub domains taking into account the physical effects of the Rotscher's cone. This geometric transformation could interact with plate boundaries to change the shape of these sub domains and influence the mesh generation process. Presently, templates are standalone entities and are not taking into account these effects left for future developments. At present, the user can adjust the sub domain to avoid these interactions (see Fig. 10a).

Implementation and results

The developed prototype is based on OpenCascade and Python scripting language. The DMU is imported as STEP assembly models, the geometric interfaces between components are represented as independent trimmed CAD faces with identifiers of the initial face pairs of the FI. The assembly functional description is imported as a text file from the specific application performing the functional enrichment described in [START_REF] Shahwan | Qualitative behavioral reasoning from components' interfaces to components' functions for DMU adaption to FE analyses[END_REF] and linked to the assembly model by components' identifiers. Fig. 10a shows the user interface of the prototype. When selecting the 'assembly with Bolted Junction' function, the user has a direct access to the list of bolted junctions in the assembly. To allow the user filtering his selection, DMU parameters are extracted from the FD of components, e.g. the screw and nut type, the number of tightened or from geometry processing based on FDs, e.g. screw diameter. Using these parameters, the user is able to select bolted junctions with diameter between 10 and 16 mm (see Fig. 10b) or bolted junctions with screw and locking nut (see Fig. 10c), etc. The user can monitor the Rotscher's cone dimension with a FEA parameter called 'sub domain ratio' that represents the ratio between the screw nominal diameter and the sub-domain diameter (see Fig. 10d ande). Then, the user-defined 'meshing tolerance' is used during the verification phase to check the compatibility conditions, C C , between instances and their surrounding geometry (see Fig. 7). The final CAD assembly (see Fig. 11b) with simplified bolted junctions has been exported to a CAE software, i.e. Abaqus. STEP files transfer the geometric model and associated xml files describes the interfaces between components to trigger meshing strategies with friction area definition.

Comparing with the process pipeline used with existing industrial software, the figures are as follows. The model preparation from CAD software to Abaqus simulation model takes 5 days of interactive work for aircraft structure 1 mentioned above. Using the pipeline performing the functional enrichment of the DMU and the proposed template-based shape transformations, to directly produce the meshable model in Abaqus and perform the mesh in Abaqus, the overall time is reduced to one hour. The adequacy of this model conforms to the preliminary numerical models set up in ROMMA project and extending this conformity to testing results is ongoing since the template enables easy adjustments of the mesh model. Regarding the aircraft structure 2, there is no reference evaluation of its model preparation time from CAD to mesh generation because it is considered as too complex to fit into the industrial product development process. However, it is possible to estimate the time reduction since the interactive time can be linearly scaled according with the number of bolted junction. This ends up with 25 days of interactive work compared to 1.5 hour with the proposed approach where the time is mostly devoted to the mesh generation phase rather than the templatebased transformations, which stay automated.

Though the automation is very high, the template-based approach leaves the user with meaningful parameters enabling him/her to adapt the shape transformations to subsets of bolted junctions when FE is required models.

CONCLUSION

In this work, a template-based method empowers the use of DMUs enriched with geometric interfaces and functional information, to automate CAD assembly pre-processing and generate a FE-friendly equivalence of this assembly. Because the template is directly connected to assembly functions, its instances contain a group of components consistently involved in the same assembly function. When selecting a specific function, the user has a direct access to the associated components, their structured model as well as their FIs. It has been shown also that the template can cover a rather large range of configurations since it is parameterized with respect to components' dimensions, components' number, components' shapes and finally, component function with the concept of dependent function. Using the template-based transformations, the user can robustly and efficiently define the geometric transformations according to his/her FEA objectives and meshing constraints. Thus, new components' shapes adapted to CAE software requirements are produced while the consistency of the assembly model is preserved. The template can be instantiated over the whole assembly to transform quickly repetitive configurations such as bolted junctions which were highly time consuming with interactive processing. Finally, a demonstrator has been presented to prove the efficiency of the template-based transformation approach and its valuable contribution to a PDP. The template-based approach show how shape transformations highly benefit from functional information and strengthen these transformations in the context of complex models like assemblies where many components interact with each other. Bolted junctions of two industrial use-cases have been automatically transformed into simplified macro elements with sub-domains generation. The resulting model produces a seamless generation of FE models conforming to the simulation objectives while taking into account meshing constraints.

Fig. 1 :

 1 Fig. 1: Examples of aeronautical DMUs with a variety of bolted junctions.

Fig. 2 :

 2 Fig. 2: Process flow to enrich a DMU with functional designations of components and their associated structured geometric models.

Fig. 3 :

 3 Fig. 3: Example of force cycle, as subset of the CIG, initiated by a threaded link.

Fig. 4 :

 4 Fig. 4: Structuring the model of a component with functional properties after analyzing its geometric interactions and assigning it a functional designation, here a 'cap screw'.

-

  S T1 : merging screw and nut; -S T2 : localization of friction effects with a sub domain around a screw; -S T3 : removal of locking nut if it exists; -S T4 : screw head transformation for mesh generation purposes; -S T5 : cylindrical loose fit around the screw shaft to support the contact condition with tightened plates.

Fig. 6 :

 6 Fig. 6: Compatibility conditions (C C ) of shape transformations S T applied to T.

Fig. 7 :

 7 Fig. 7: Checking the compatibility of S

Fig. 9 :

 9 Fig. 9: Template based transformation S T (T) of a bolted junction into simple mesh model with friction and contact areas definition around screw and nut.

Fig. 11 Fig. 10 :Fig. 11 :

 111011 Fig. 11 shows two results of the template-based transformations on aircraft structures: 1. A junction between the wing and the fuselage. The assembly contains 45 bolted junctions with 3 different diameters and 2 different screw heads;2. An engine pylon. The assembly contains over 250 bolted junctions with identical screws and nuts.

ACKNOWLEDGMENT

This work is carried out as part of the ROMMA (RObust Mechanical Models for Assemblies) project [4] under the reference ANR-09-COSI-012. The authors are very grateful for the financial support from the Agence Nationale de la Recherche (ANR).