A introduction to finite elements based on examples with Cast3m A NDREI C ONSTANTINESCU
[email protected]
Laboratoire de Mécanique des Solides CNRS UMR 7649 Département de Mécanique, Ecole Polytechnique 91120 Palaiseau, France
http://www.lms.polytechnique.fr
1
Contents
1
. . . . .
4 4 4 5 6 7
. . . . . . . .
12 12 12 13 16 17 17 17 18
. . . . . . . . . . . . .
19 19 19 19 20 20 24 25 26 26 28 29 29 29
4
Parabolic problems: transient heat transfer 4.1 Exemple en analyse dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30 31
5
Elastoplasticity Outline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Plasticity - programming of a incremental algorithm . . . . . . . . . . . . . . . . . . . . . . . 5.2 Plasticity - computation using pasapas . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34 34 34 37
2
3
Introduction 1.1 Historical remarks . . . . 1.2 Linux Installation . . . . 1.3 Windows Installation . . 1.4 Running castem . . . . 1.5 Structure of the program
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
Meshing Outline . . . . . . . . . . . . . . . . . . . . 2.1 General settings . . . . . . . . . . . . . . . . . 2.2 Examples of 2D mesh creation . . . . . . . . . 2.3 Example of a 3D mesh creation . . . . . . . . . 2.4 Deformation of meshes . . . . . . . . . . . . . 2.5 Import and export of meshes, format exchange . 2.6 Numbers and mesures for meshes . . . . . . . Exercises . . . . . . . . . . . . . . . . . . .
. . . . .
. . . . . . . .
Elliptic problems: elasticity and heat transfer Outline . . . . . . . . . . . . . . . . . . . . . 3.1 Variational formulation of the elastic equilibrium 3.2 General settings . . . . . . . . . . . . . . . . . . 3.3 Elasticity - castem problem setting . . . . . . . 3.3.1 Boundary conditions and solution method 3.3.2 Other applied forces: pressure, weight, . . . 3.3.3 Surface traction and applied pressure . . 3.3.4 Body forces . . . . . . . . . . . . . . . . 3.3.5 Spatially varying material coefficients . . 3.4 Thermal equilibrium - castem problem setting . 3.5 Exercices . . . . . . . . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . 3.6 Material coefficients varying with temperature . .
2
. . . . .
. . . . . . . .
. . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
. . . . .
. . . . . . . .
. . . . . . . . . . . . .
6
7
Input and output Outline . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 Cast3m objects . . . . . . . . . . . . . . . . . . . . . . . 6.2 Graphics and plots . . . . . . . . . . . . . . . . . . . . . 6.3 exte[ieur] calling an exterior program . . . . . . . . . . 6.4 chau[ssette] dynamic link with another program, server 6.5 Reading and writing data . . . . . . . . . . . . . . . . . . 6.6 util: reading subroutines . . . . . . . . . . . . . . . . . 6.7 Meshes and file format exchange . . . . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . How to and other questions
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
41 41 41 42 43 43 43 44 45 46 47
3
1
1.1
Introduction
Historical remarks
The CEA - Commisariat à l’énérgie atomique, Saclay, France (http://www.cea.fr) is a french governmentfunded technological research organisation, which has developped in the past twenty years a dedicated toolbox for finite element computations Cast3M. The toolbox contains the essential elements in order to perform a finite element computation. Its main application area is mechanics including elasticity, elasto-visco-plasticity material behaviour and analysis adapted for equilibrium, buckling, vibration or dynamics problems. Other application areas include thermak, hydraulic or elactromagnetic analysis. Its modular character permits program new application in an easy and confortable manner, which make the tool adapted for coupled multiphysics problems. Cast3M is based on family of objets, i.e. data structures and a lexicon of operators, i.e. elementary operations acting on the given objects. ogether they form specific programming language called gibiane:. The code itself is written in an extended Fortran called esope which permit a direct handling of the specific data structure. The website: http://www-cast3m.cea.fr/ contains a general presentation of the code, example files, online and downloadable documentations. Downloadable versions for Linux and Windows of the computer code are available for a non-commercial usage of the program. The source code can also be recovered after a previous acceptance by the CEA. For Mac OS users there is no official release. However Pierre Alain Boucard from the LMT laboratory at ENS-Cachan has complied a version with the adapted libraries and provides kindly dowloadable versions on his website: http://www.lmt.ens-cachan.fr/temp/CAST3M06-OSX.zip (G4/G5) http://www.lmt.ens-cachan.fr/temp/CAST3M06_OSX_Intel.zip (Intel et 10.4) http://www.lmt.ens-cachan.fr/temp/CAST3M07_OSX_Intel.zip.
1.2
Linux Installation
We start from the assumption that the code is already installed in the directory cast3m_dir. Some of the subdirectories are: • bin - containing the binary files and the bash-script: castem launching the binaries. • data - contains a series of files which will be linked with the binary at each execution. They contain informations about errors, procedures, documentation. • dgibi - a large collection of batch-tests of the operators which can be used a basis for examples • docs - contains the documentation in both pdf and html formating. It is pratical to link the favorite webbrowser to the pages containing the lists of operators: 4
cast3m_dir/doc/html/doc-ang.html cast3m_dir/doc/html/doc-fra.html
help files in english help files in french
• docs/pdf In this directory we can retrieve a series of explanatory documents written about the example files or as short introductory lectures. Let us point the introduction to Cast3m written in english by Fichoux [2]: cast3m_dir/doc/pdf/beginning.pdf are interesting documents are the structured list of operators, the annotated examples files, etc.
All documents and examples are also in free access on the Cast3m website, were the example files and the help information can equally been found using a search engine.
Help and example files
cast3m_dir/dgibi cast3m_dir/doc/html/doc-ang.html cast3m_dir/doc/html/doc-fra.html
example files help files in english help files in french
Help commands
noti gibi; info operator_name;
prints general help in the shell (in french) prints the help-file in the shell (in french) Documents
cast3m_dir/doc/pdf http://www-cast3m.cea.fr/
1.3
document files in english and french documents and technical reports
Windows Installation
The file structure of the Windows installation is equivalent with the Linux installation, the difference relies only in the definitions of paths in Windows versus Linux, where becomes /. When installing the program, its is important to pay attention to several details specified in the README (resp. LISEZMOI) files: • the creation of the C:\tmp directory for swapping data during the computation, and • the creation of the environmental variable CASTEM=cast3m_dir. If the home directory lies in the C:\Program Files\cast3m directory the variable should become: CASTEM=C:\Progra˜1\cast3m 5
1.4
Running castem
Linux
In the Linux environment, the castem program is launched usually in a shell terminal (xterm, ...):
The castem command launches the program on the shell command line initiated by the $ character, and creates a new shell environment where again each line initiates with the $ character. The program will send its information in the shell directly or within lines starting with . As in the definition of the paramter a. The -m XL option defines the size of the static memory allocated by the computer to the program and one should understand that castem will afterwards dynamically place its structure is this memory space.
[andrei@rhea Test] $ castem -m XL Le fichier de debordement se trouve dans : /local/tmp .............. &&&&&&&&&&&&&&&&&&&&&&&&&& $ FIN DE FICHIER SUR L'UNITE 3 LES DONNEES SONT MAINTENANT LUES SUR LE CLAVIER $ * $ a = 3; * a = 3; $
If a swap space will be needed the swap file (fichier de debordement) will be defined in the /local/tmp directory. The comment regarding the logic unit UNITE 3 corresponds to the case explained in the following example.
6
This command launches castem and executes in a first step the commands found in the file pressure.dgibi. Technically the program copies the file myfile.dgibi into fort.3 (called logic unit UNITE 3) and reads this file. In a second step the program waits for the commands to be types in the castemshell as in the example before. Technically the program will copy the commands typied in the shell into the fort.98 (called logic unit UNITE 98) and reads this file line by line.
[andrei@rhea Test] $ castem -m XL myfile.dgibi Le fichier de debordement se trouve dans : /local/tmp .............. &&&&&&&&&&&&&&&&&&&&&&&&&& $ * * myfiles content $ * is read here $ * ........ $ * end of myfile; $ * $
It is important to remember this information for the case of a program crash, as the fort.98 will keep a track of all typed commands. The file will keep the information up to the next program start when all its contents is removed and the file is iniatialized as blank. Both fort.3 and fort.98 are to be found in the working directory, therefore one should avoid to launch simulatneously two castem processes in the same directory, as they would be confused in using these files.
Once the program is started as in the examples before with several command should be remembered: • typing the command fin; stops the program • typing the command opti donn 5; in myfile.dgibi stops its reading and returns the hand to the user in the castem-shell. • typing the command opti donn 3; in the castem-shell returns the hand from the user to the reading unit 3, i.e. the myfile.dgibi file.
1.5
Structure of the program
From the programming point of view Cast3M differentiats two levels of programming: • a compiled low level language : ESOPE. This language will be invisible for the normal user, its the language of the creators of Cast3M. As explained earlier its just a derivation of the classical F ORTRAN language enriched with operations for the manipulation of specific objects (creation, copy, removal, . . . of data structure). 7
• a high level interpreted language : gibiane:, formed by a lexicon of operation which permits an easy usage of the code and which is the language of the normal user as examplifyed in this text. From this point of view, Cast3M is comparable with codes like Mathematica, Matlab, Scilab, Octave, Mapple, ..., ESOPE beeing the langauge of the creator and gibiane: the language of the user. The essence of gibiane: 1 can be resumed in the following way: objet_2 = operator objet_1 ; The sign ";" defines the end of the command and obliges the system to execute the operator having objet_1 as its argument and to create a new resulting object object_2. Let us start by defining some basic syntax rules of gibiane:: • name of operators are defined by their first 4 characters. As a consequence vibr defines the vibr[ation] operator, however specifying the complete name does is still permitted. • Names of objects should not be longer than 8 characters. Moreover one should avoid that the first 4 characters coincide with the name of an operator, as this would erase the operator. • As in old versions of the fortran language lines should not be longer than 72 characters. However the code can accept that a command is typed on up to 9 consecutive lines. No special character is needed to announce the continuation of a command on the next line. • Brackets (,) can be used, for example they permit to insert one command into another without creating at each step an additional object. They should be used within algebraic operations. castem does not automatically recognize the order of algebraic operations and execute operations in order of apereance. That means for example that:
a + b * c = (a + b) * c and the excepted equality does not hold:
a + b * c =!= a + (b * c) • The program is not able to distinguish between upper and lower case characters, as an example we note that vibr is equivalent to Vibr or VIBR. • Tabbing spaces TAB and special invisible charcters in editors should be avoided as they might create error in the file reading. • Files containing commands in the gibiane language are simple ASCII text files as created by most of the common editors like: nedit, xemacs, . . . under the Linux operating system or notepad under Windows. Downloading and installation instructions for configuration files for enableling the syntax highlightning of the editors for crimson (Windows) or emacs, nedit (Linux) are found at the follwoing webpage:
http://www-cast3m.cea.fr/cast3m/xmlpage.do?name=utilitaires 1
Most of the names of operators derive from the french common word defining it.
8
Objects are numerical or logical values organised in different data structures describing mathematical and physical fields. We find classical objects defining numbers: • entier is an integer number, the should be described without the . character; • flottant is real number which can be described for example either under the 123.4 or the 1.234e2 = 1.234 × 102 form; • logique are logical objects used in boolean operations with two values: VRAI meaning true and FAUX meaning false. Numbers and strings can be organized in list’s: • listenti[er] is a list of integers, which can be assembled using the lect[ure] operator:
mylist = lect 1 6 89; • listreel is a list of real numbers, which can be assembled using the prog[ramer] operator:
mylist = prog 1. 6.e3 8.9; • listmots (mots, en. words) is a list of strings, which can be assembled using the mots operator:
mylist = mots 'TITI' 'Toto' 'tete';
Creating Lists of Objects
lect prog mots
lists of integers lists of reals lists of strings
Another class of objects are typical for describing a finite element computation, for example : • the maillage (mesh) is described by an element type SEG2, TRI3, QUA4, ..., a list of nodes (geometrical points) and their connectivity; • a chpoint, i.e. "champ par point" (field defined on points) is a scalar, vector or tensor field defined on a domain described by its values at the nodal points of a mesh. Typical examples are the temperature, the displacement, . . . ; • le mchaml, i.e. "champs par élément" (fields defined on elements) is a scalar, vector or tensor field defined on a domain described by its values at specific points of each element of the mesh. Specific points are fore example the Gauss integration points, where the values of stresses, strains or temperature gradients are definied in finite elements proframs. 9
• la rigidité (stiffness) is a stiffness matrix containing eventually a series of preconditioners. Elementary operators are developped to perform a large class of actions: • +, *, / , - , ** , are algebraic operators and apply equally on numbers fields defined at the nodal points, the chpoint, or the spefic points of the elements the mchaml; • droi[te],cerc[le] surf[ace], dall[er], i.e. ligne, cercle, surface and tilling respectively construct lignes, circles and surfaces starting from given points or contours. • the plus (plus) operation performs a translation of a given vector and applies both to a mchaml type object and a geometry type object; • reso[ut] (solve) solves the algebraic equation KX = Y , with K a simetric positive definite matrix of the rigidité (stiffness) type and X et Y fields defined at the nodes (chpoint). • vibr[ation] solves the eigenvalue problem KX − λM X = 0, with K, M simetric positive definite matrix of the rigidité (stiffness) type representing the stiffness and the mass matrixes. • masq[uer] performs a selection of the values of a field defined on nodes, chpoint, or on the elements mchaml with respect to user defined criterion. Other operators are purely algorythmic : • si, sino[n], finsi (if, else, endif) define the classical control statements and are completely equivalent to the if, else, endif operators in the classical programming languages as C,F ORTRAN ,. . . ; • repe[ter], fin (repeat, end) define a loop and correspond to the do, enddo statements of C,F ORTRAN ,. . . ; • debpr[ocedure] (debut procédure) and finp[roc] (fin procedure) define a the "procédure" in gibiane which is the equivalemnt of subroutine end or function end in classical C,F ORTRAN ,. . . ; They are two basic graphical operators: • dess[iner] (draw) which plots a curve strating from the lists of the abcissa and ordinate numbers. • trac[er] (plot) displays a mesh or isolines or isocolours of fields defined on a mesh. A series of the existing operators are complex manipulations of the existing data structure and are themselves writen in gibiane. For example: • pasapas (step-by-step) solves incrementally nonlinear problems under the small and large strain assumption like contact, elastoplasticity, etc. . • The buckling problem is the eigenvalue problem KX − λK G X = 0 with K and K G the stiffness and the geometrical stiffness matrixes. The flambage (buckling) operator is only a gibiane subroutine which passes the needed information to the basic vibr[ation] operator which solves the eigenvalue problem. 10
In the next chapters, we shall present a series of programming examples illustrating on the one hand side the usage of the castem environnement and on the other hand side the programming of some classical algorithms of the finite element theory. However, from the practical point of view, one should not forgot that most of the classical problem settings in mechanics have dedicated operators already programmed in castem.
11
2
Meshing
Outline This chapter is devoted the the discussion of mesh creation. We review the basic commands and show a series of examples one two or three dimensional bodies embedded in a two or three dimensional space.
2.1
General settings
The first setting defines the dimensions of the working space and the coordinate system. These general settings are defined through the opti operator. This command defines a two dimensional working space and quadrangular elements as the basic bricks for the mesh. However simpler elements like points, segments or triangular will also be created by the called operators.
opti dime 2 elem QUA4;
The finite element theory uses fields defining their values at nodal at specific points of elements. Elements are simple geometrical figures, i.e. triangles, quadrangles, . . . , cubes, pyramides, . . . . The set of elements will represent the continous body and the associated data structures are given by the (i) nodal coordinates and (ii) the list of connectivities defining the set of nodes for each element. Depending on the type of the object we can define different types of associated meshes: points, lines, surfaces or volumes.
Mesh Options
opti ...; dime elem
command for defining general settings dimension of the working space basic element type for the mesh 12
2.2
Examples of 2D mesh creation
Quadrangular plate with a hole
The operator opti does not creat objets, but definies the general settings of the computation by using a series of key-words. Here we define a two dime[nsion]-al space and by default a plane strain situation. The basic element is chosen by elem QUA4 to be the linear isoparametric quadrangle. The corners of the mesh are defined using their coordinates values as functions of the size ldom of the domain and of the radius r of the hole (see figure ??)
opti dime 2 echo 1 elem QUA4;
Les opérateurs droit[e] et cerc[le] permettent de construire les segments des droite du contour du maillage. Le nombre d’élements sur différents segments et donné par les paramètres nel et nel_bis ainsi que la dimension du prémier et du dernier élément précisé après le mots clefs dini et dfin. Le maillage dom et construit en utilisant l’opérateur dall[er] initialement en deux parties qui vont être regroupés en utilisant et ensuite. L’utilisation d’inve[rser] change le ordre de parcours des noeuds dans le contour pour obtenir le maillage correct. Et finalment le maillage et visualisé en utilisant la commande trac[er]
nel = 10; nel_bis = -20;
ldom = 1.; r = 0.1; p1 p2 p3 p4
= = = =
0. 0.; ldom 0.; ldom ldom; 0. ldom;
a2 = r 0.; a4 = 0. r; a3 = (r/1.4142) (r/1.4142);
d12 = droite nel_bis a2 p2 dini 0.002 dfin 0.15 ; d23 = droite nelem p2 p3; d34 = droite nelem p3 p4; d41 = droite nel_bis p4 a4 dini 0.15 dfin 0.002 ; bis = droite nel_bis a3 p3 dini 0.003 dfin 0.22 ; arc23 = cerc nelem a2 p1 a3; arc34 = cerc nelem a3 p1 a4; dom1 = dall d12 d23 (inve bis) (inve arc23); dom2 = dall (inve d41) (inve d34) (inve bis) arc34; dom = dom1 et dom2; trac dom;
13
Operators for 2D mesh creation
droi[te] cerc[le] cer3 para[bolic] cubp, cubt
creates a straight line creates circle defined by the center and two of its points creates circle defined by three of its points creates a parablic arc create cubic
dall[er] pav[er] surf[ace] tran[slation]
2D tilling of a curved quadrangular 3D tilling a curved cubic enveloppe creates a surface by filling its closed boundary creates a surface by translation of a ligne along a given vector creates a surface by rotation of a ligne around a point or a line
rota[tion]
In order to illustrate another technique to construct a surface. We first recover the boundary of the domain using the cont[our] operator and we then proceed by refilling the closed boundary using the surf[ace] command. One can remark the that new domain is irregular and that triangles have been used in its creation in spite of the QUA4 element setting at the beginning of the file.
A domain can also be created by tranlation of a line along a vector. The example translates the arc arc23 along the (0. r) vector. The vector is not only used to define a direction but also the length of the translation. The four sides of the new domain can be recovered applying the face (side) command on the domain. Clicking the Qualification button in the tracewindow we can remark that the name arc23b is already associated with the corresponding side.
domcon = contour dom; dombis = surf domcon; trace dombis;
dom23 = arc23 tran nel (0. r); arc23b = dom23 face 3; trace dom23;
14
P4
P3
A4 P1 A 2
P2
GIBI FECIT
Figure 2.1: Le quart d’une plaque trouée en traction
Operators for 2D mesh creation
cont[our] syme[trique] tour[ner] plus elim[iner] dedo[ublement] poin[t] elem[ent] face
recovers the boundary of a domain creates the symetric of a given mesh creates a new rotated mesh from of a given one creates a new mesh by adding a displacement to a given mesh eliminates nodes with close coordinates doubles existing nodes (the opposite of elim[iner]) selects a set nodes of a given mesh selects elements of a given mesh selects the n-th face of a mesh in 2D or 3D
The complete geometry of the quadrangular plate with the hole in the center can simply be created by completing the geometry through symetry (operator syme[trie]). A series of geometrical points are now represented through different nodes, which can be shrinked into one unique node using the elim[iner] operator. The real number at the end of the last command is the tolerance, defining the neighborhood for which nodes are reduced to one single node. It is worth noticing that an inverse command equally exists dedo[ubler] which creates additional nodes (doubles) for existing nodes. An example of application is the creation of cracks.
quart2 = dom syme 'DROIT' p1 p4; half = (dom et quart2) syme 'DROIT' p1 p2; plate = elim (dom et quart1 et half) 0.001;
A difficulty with the new geometry plate is that its points, border lines and nodes, do not have a distinct name. Surely, one can apply theses objects by their node or element number, but this will not provide an intrinsic solution as is might change with a new parametrization of the geometry or simply a new run of the 15
program. The problem is solved by the poin[t] and elemen[t] operators as illustrated in the next lines.
The poin[t] command will select the points of the contour of the plate, cont plate, lying within 0.001 of the line (fr. 'DROITE' ) defined by the points (0., −ldom) and (−1., −ldom). Next in a similar way, the elem[ent] command will select the elements of contour of the plate, cont plate, lying (fr. 'APPUYE' ) strictly (fr. 'STRICTEMENT' ) on the set points poi_line. The result is finally plotted using trac[er]. One can remark that the colour of the points has been changed into green (fr. vert) for a better display.
2.3
poi_line = (cont plate) poin 'DROITE' (0. (-1. * l_dom)) (1. (-1. * l_dom)) 0.001; ele_line = (cont plate) elem 'APPUYE' 'STRICTEMENT' poi_line; trace (( cont plate) et (poi_line coul vert));
Example of a 3D mesh creation
Most of the commands presented in the preceding section will equally fonction in a three dimanesional environment, creating the embedded points, lines or surfaces. We shall briefly illustrate one of the construction commands.
The passage from two to three dimension can be done in the middle of a program, if so the third coordinate of all existing objects will automatically be set to 0.. This can readily be observed by plotting the third coordinate of the plate. The two dimensional surface: plate, can be extruded using the volu[me] command into a three dimensional cube. The enve[loppe] command recovers the boundary of the mesh exactly as cont[our] in the two dimensional case. Parts the extremal sections of the extruded volume can be recoved as the 1 and 2 face of the cube, while the cylindrical surface of the extrusion will form the 3 face.
opti dime 3 elem cub8; trace plate (plate coor 3); cube = plate volu tran nelem (0. 0. ldom); trace cach cube; trace cach (enve cube); trace cach (cube face 1); trace cach (cube face 2); trace cach (cube face 3);
16
2.4
Deformation of meshes
A mesh can be deformed to create a new mesh just by adding a desired displacement field as illustrated in the next example. We first extract the three coordinate fields of the plate, and create the field: uuz = x2 +y 2 . The field will be labelled as the z component of an displaceent field after changing the name of its component from 'SCAL' to 'UZ'. The new mesh is simply creating by adding the displacement to the initial mesh using the plus command. Finally results are plotted using trace after the colouring of the new mesh in red (fr. rouge) using coul[eur]
2.5
xx yy zz = coor plate; uuz = (xx * xx) + (yy * yy); uuz = exco uuz 'SCAL' 'UZ'; pshell = plate plus uuz; trace cach (plate et (pshell coul rouge));
Import and export of meshes, format exchange
The import and export of meshes from and towards Cast3M is of importance for a series of practical applications. This topic is discussed in chapter 6.
2.6
Numbers and mesures for meshes
The number of nodes and the number of elements of a mesh are simply recovered by applying the nbno[euds] nbel[ements] operators. noeud permit to recover the geometrical point corresponding to the node of a mesh.
list (nbno pshell); list (nbel pshell); pp = pshell noeud 347; list (mesu pshell 'SURF');
The area of the created meshes is computed by the mesu[rer] operator and the surf[ace] option. Other option, long[eur] (fr. length) and volu[me] enable the computation of a length and a volume for one and respectively three dimensional objects.
17
Other operators for mesh manipulation
nbel[ements] nb[noeuds] noeu[d]
computes the number of elemnts of a mesh computes the number of nodes of a mesh defines a point using its nodal number
mesu[rer]
mesures the length, surface or volume of a mesh
Summary In this chapter we presented the creation of points, lines, surface and volumes in a twodimensional and three dimensional space. The operators used in the chapter cover a large variety of manipulations. However they do not represent the complet set of mesh manipulation possibilities included in castem, which can be obtained through examples, manual pages and existing reports and documents.
Exercices 1. Hyperbolic paraboloid The hyperbolic parabolid is a ruled surface (fr. surface reglée) generated by a line thqt pertains to two circles. This type of structures is used as a refrigaration tower for eletricity generating plants. Hint use the regl[er] operator
18
3
Elliptic problems: elasticity and heat transfer
Outline 3.1
Variational formulation of the elastic equilibrium
3.2
General settings
The construction of the finite elemnt solutions start with the definition of the main assumptions of the modeling: dimension of the space, coordinate systems, plane strain or plane stress, Fourier representation of the functions, etc. The dimension of the working space and the fundamental assumptions of the computations are choosen using the opti command. The two option illustrated here correspond to plane strain, i.e. defo[rmation] plan[e] in cartesian coordinates and axial symetry i.e. axis in cylindrical coordinates.
opti mode defo plan; opti mode axis;
The chosen spatial configuration will then automatically assign the standard names of the components of different fields, we have for example: • plane strain (defo[rmation] plan[e]). We recall that displacement fields are defined in a cartesian coordinate system (x, y, z) under the following: u(x, y, z) = ux (x, y)ex + uy (x, y)ey In this case automatically the names of the components of the fields are defined in the following way: field component name displacement UX,UY forces FX,FY strain EPXX, EPXY, EPYY SMXX, SMXY, SMYY, SMZZ stress • axial symetry (axis). We recall that displacement fields are defined in a cylindrical coordinate system (r, θ, z) under the following: u(r, θ, z) = ur (r, z)er + uz (r, z)ez 19
In a similar way to plane strain, the names of the compoenents of the fields are defined in the following component name field displacement UR,UZ way: forces FR,FZ strain EPRR, EPRZ, EPZZ stress SMRR, SMRZ, SMZZ, SMTT • ...
An extended list containing this information can be found in [?].
General settings
opti[on] opti[on] opti[on] opti[on] opti[on] opti[on]
3.3
dime n plan defo plan cont axis four[ier] n trid[imensional]
space dimension n = 1,2,3 cartesian coordinates, plain strain cartesian coordinates, plain stress cylindrtical coordinates, axisymetric cylindrtical coordinates, Fourier series expansion up to n harmonics cartesian coordinates, tridimensional
Elasticity - castem problem setting
3.3.1
Boundary conditions and solution method
The method of solution used by Cast3M is based on the Lagrangian relaxation of the boundary condition in displacements as explained for example in [?]. The variational principal of the preceding section transforms into:
ici eq 3.29 p. 53
(3.1)
Applying the On rappelle que cette méthode conduit à la résolution du système linéaire suivant:
ici eq 3.29 p. 53
(3.2)
dans lequel la matrice de rigidité [K] est définie par rapport à tous les déplacements nodaux sans distinction entre les valeurs imposées ou non par les conditions limites. Les déplacements imposés apparaissent ici en utilisant le matrice de projection [A] et les valeurs imposées [UD ]. Les conditions aux limites en traction ainsi 20
que les forces volumiques définissent le vecteur [F]. The mode[le] operator associates to a given mesh a finite element, i.e. a specific form function in the variational principle (here linear functions by default, the QUA4 elements) and a mechanical problem setting mecanique and an linear isotropic elastic constitutive law. Other problem settings are fluid, thermal, etc. The definition of the material behaviour will define the number and names of the parameters to be defined next using the mate[riaux] operator, as well as the structure of the internal variables of the model in consideration. The stiffness matrix [K], is computed using rigi[dité] from the elasticity information provided before.
mod
= dom mode mecanique elastique isotrope;
mat
= mod mate 'YOUN' 2.e11 'NU' 0.3;
In order to construct the projection matrixes [A] which reduce the displacement vector to the sole part of the boundary where the [UD ] displacement is applied we use the bloq[uer] opertaor. The correspond force is then constructed from [A] and [UD ] using depi (fr. déplacement imposé). It is important to notice that the operators bloq[uer] and depi are not only constructing the matrix [A] and the vector [UD ], but will equally creat new degrees of freedom corresponding to the Lagrange multipliers of the system. From a mechanical point of view the Lagrange multipliers will equal the tractions [T] on this boundary part, which are unknown before the resolution of the system. These informations can be obtained by listing the objects [A], for example: list Ad34; . The system is finally solved by calling the reso[lution] operator. As one can remark only non zero components of the right hand side of the system have to be specified, here only ud34.
Ad12 = bloq uy d12; Ad41 = bloq ux d41;
The system is finally solved by calling the reso[lution] operator. As one can remark only non zero components of the right hand side of the system have to be specified, here only ud34.
u = reso (KK et AA) ud34;
KK = rigi mod mat;
Ad34 = bloq uy d34; ud34 = depi Ad34 0.1; AA = Ad12 et Ad41 et Ad34;
21
Listing the components of the displacement field
list (extraire u 'COMP');
shows that we obtain the attended components of the displacement filed UX and UY, and as well a new component LX, the Lagrange multiplier which contains [T]. To obtain the underlying traction vector, we use the reac[tion] operator as in the next command:
td34 = reac u Ad34; .
Plots
trac[er] trac[er] model field trac[er] geometry field trac[er] geometry
plots different objects plots a field defined on elements plots a field defined at nodes plots a mesh
dess[iner] evolution evolution evol[ution] 'CHPO' ...
plots the graph of a function graph of a function defined by lists of numbers extracts the evolution of a field along a path 22
The results can be postprocessed in a series of different forms as shown in the next examples. For plotting the norm of the displacement vector: q ||u|| = u2x + u2y we extract the components using exco (fr. extraire composante), the algebraic operations and trace for the plot. As the displacements fields are defined by their nodal values, we equally specify the underlying mesh for the plot. Strains and stresses are computed using epsi[lon] and sigma and the operations correspond to the following matrix computations: ε = [B][U] σ = [A][B][U]
(3.3) (3.4)
uux = exco 'UX' u 'SCAL'; uuy = exco 'UY' u 'SCAL'; trace ux dom; trace (((ux*ux) + (uy*uy))**0.5)
dom;
eps = epsi mod u: sig = sigma mod mat u; list (extraire eps 'COMP'); list (extraire sig 'COMP');
The name of their components fields can be extracted suing the extr[aire] command. Another command, corresponds to [BT ] and enables the computation of the nodal forces from a given stress field: [F] = [BT ]σ = [A][B][U]
(3.5)
f = bsigma mod sig; trace dom (exco fx f); trace dom (exco fy f);
which corresponds to the computation of divσ in a continuum formulation. As a consequence we can for example easily verify that the nodal forces vanish with the exception of the reactions at the boundary.
Strains and stresse
epsi[lon] sigm[a]
computes the strain tensor computes the stress tensor
bsigm[a]
computes the nodal foirces correspnding to a stress tensor
tres[ca] vmis[es] prin[cipales]
computes the Tresca norm of the stress tensor computes rthe von Mises norm of the stress tensor: 3 vmis = devσ : devσ 2 computes the principal values of stress tensor
@plotpri[ncipales]
plots the principal values of stress tensor (user defined subroutine) 23
To plot the components of the strain or the stress tensor, we directly apply the trac[e] and adjoin the model in order to specify the position of the Gauss points, where the values or defined. Different additional values related to stress tensor can easily be computed: the Tresca and the von Mises norm using tres[ca] and respectively vmis[es]; or the principal values and the their directions using prin[cipales]. @plotpri is a user defined subroutine which permits to plot interactively the principal stresses. It is equally interesting to display the evolution of the stress components along a given path. In the present computation we chose to display σyy along the border of the circular hole. We start by listing the components of the stress field. Then interpolate the σyy component, denoted as 'SMYY' in Cast3m, from Gauss points to nodes using the chan[ger] operation with the 'CHPO' option. Finally evol[ution] with the 'CHPO' option extracts the values over the path (arc23 et arc34) and dess[iner] performs the plot.
3.3.2
trace mod sig;
sigvm = vmises sig mod; sigtr = tresca sig mod; sigpr = prin sig mod; @plotpri
sig mod;
list (extr sig comp); sigyy = changer 'CHPO' mod (exco sig 'SMYY'); dess (evol 'CHPO' sigyy (arc23 et arc34));
Other applied forces: pressure, weight, . . .
The load of the previous example was only defined by an imposed displacement, as a consequence the exterieur load vector: [F] = [0] and its zero values have been automatically been completed by the program. The next examples will show how surface traction and body forces can be imposed.
Applied Forces
forc[e] pres[sion]
equally distrutes a given force on a set of nodes computes the nodal force distribution for a given pressure distribution
coor[donnees] mass[e] manu 'CHPO'
computes the coordinate fields of a given mesh computes the mass matrix constructs a nodal field 24
Creation of ’stiffness matrixes’
rigi[dite] mass[e] cond[uctivite] capa[cite] conv[ection]
3.3.3
creates stiffness matrix creates mass matrix creates conductivity matrix creates capacity matrix creates stiffness coresponding to convection boundary condition
Surface traction and applied pressure
The main operators for the construction of applied forces are forc[e] and pres[sion] (fr. pressure). The coor operators constructs for a given mesh the fields of coordinates. In the example presented here we recover the coordinates x and y in each point of the line d23. The operator press computes nodal force field corresponding to the pressure distribution defined by: p(x, y) = 3x2 . The model mod is necessary for this operation as the computation takes into account the form function of the underlying element (oir [?]). Finally we can change the orientation of the normal pressure fnor distribution into a tangential traction distribution ftan, only be exchanging the components of the vector field.
If one wants to impose
xx yy = coor d23; fnor = pres mass mod (3* (xx * xx));
ftan = (exco 'FY' fnorm 'FX') et (-1. * (exco 'FX' fnorm 'FY')) ;
a Hertzian pressure distribution, for example defined as a parabola centered around the origin: p(x) =
pmax (a2p − x2 ) 0
if if
||x|| < ap ||x|| ≥ ap
we proceed as defined before. Let us only remark the differences. manu[el] constructs constant nodal field which enable the computation of the formula of the pressure distribution. masq[uer] constructs the characteristic function defined by the condition ||x|| < ap . The final nodal distribution correspondig to the pressure is assembled after multiplication of the two preceding fields.
xx = coor 1 d34; ap = ldom / 3.; pmax = 1.e8; one = manu 'CHPO' d34 1 'SCAL' 1.; px = pmax * ((( ap * one) ** 2) - (xx ** 2)); ppx = exco (xx masq inferieur ap) 'SCAL' 'FY'; fp = press mass mod px; fp = ((exco fp 'FY') * ppx) et ((exco fp 'FY') * ppx);
25
3.3.4
Body forces
In order to construct a body force, which will take into account the distribution of density of the body: RHO we adjoin this information to the model mod and compute the mass matrix of the body by using mass[e]. If the gravitational acceleration is defined as g, the simple multiplication of the mass matrix and of the acceleration will provide the body force fvol.
3.3.5
mat
= mod mate 'YOUN' 2.e11 'NU' 0.3 'RHO' 2000.;
MM = mass mod mat; g = manu chpo dom 1 'UY' -9.81; fvol = MM * g;
Spatially varying material coefficients
In the poreceding subsections we have mentioned that spatially varying boundary tractions can be easily defined using the coor[donnes] and masq[er] commands. A similar setting will permit to define varying material parameters as illustrated in the next lines of programming for an elastic problem. The first example illustrates an square inclusion in a domain, while the second example illustrates a continously varying distribu26
tion. The first command defines the model mod which is associated with the mesh plaq. We then define the coordinates of the lower-left and the upper-right corner of the square inclusion, X_min, Y_min and X_max, Y_max respectively. The nodal fields xx,yy will now help to define the characteristic field of the inclusion: D_CAR, which takes the value 1 inside the square and 0 outside, and the complemenatry field: M_CAR, which takes the value 0 inside the square and 1 outside. The unit field over the mesh was manually defined by the command manu[al]. The distribution of Young modulus and of the Poisson ratio are now created from the D_CAR and M_CAR fields using the values of the two materials of the matrix and the inclusion. The next step is to interpolate the values from the nodes to the Gauss points of the elments, where materials parameters fields are practically defined within finite element computations. This is reached using the chan[ger] command with the keywords 'CHAM', from the french champs meaning field and 'RIGIDITE' meaning stiffness. The words will define the usage and the header of the new field. On can remark that the name of the component of the field was changed in the process from SCAL[AIRE], i.e. scalar to 'YOUNG' respectively 'NU' using the nomc operator. The material and stiffness matrix are then created using the standard command settings.
mod = mode plaq mecanique elastique isotrope; X_min = 0.2; Y_min = 0.2; xx yy
= coor
D_CAR D_CAR D_CAR D_CAR
= = = =
X_max = Y_max =
0.8; 0.8;
plaq; xx masq D_CAR * D_CAR * D_CAR *
'SUPERIEUR' X_min; (xx masq 'INFERIEUR' X_max); (yy masq 'SUPERIEUR' Y_min); (yy masq 'INFERIEUR' Y_max);
M_CAR = (manu 'CHPO' plaq 1 scal 1.) - D_CAR; *
material coefficients - Aluminium and Copper YG_al = 33.e9;
NU_al = 0.32;
YG_co = 33.e9;
NU_co = 0.32;
YG_reel = (YG_co * M_CAR) + (YG_al * D_CAR); NU_reel = (NU_co * M_CAR) + (NU_al * D_CAR); yg_comp = changer 'CHAM' (nomc 'YOUNG' YG_reel) mod 'RIGIDITE'; nu_comp = changer 'CHAM' (nomc 'NU' NU_reel) mod 'RIGIDITE'; trace mod yg_comp; mat = mate mod young yg_comp nu nu_comp; rig = rigi mod mat;
Manipulation of fields
chan[ger] manu[el] nomc
changes field type by interpolation creates new objects changes name of component 27
3.4
Thermal equilibrium - castem problem setting
The finite element model and the material properties are declared in a similar way as in the elastic equilibrium using the mode[le] and mate[riaux] commands. The resolution of the thermal equilibrium problem (??) depands only of the conductivity K of the material. However if thermal capacity and density RHO and C are equally given, then we can compute both the conductivity matrix KK and the capacity matrix CC, which are similar to the stiffness and the mass matrix in elasticity. thermique, heat conduction heat conduction, thermique conductivite, conductivity matrix capacite, capacity matrix An imposed temperture on the boundary is realised using the same Langrange multiplier technique as in elasticity. Therefore we create the projection matrix Ad34 using the bloq[uer] command. The name of the degree of freedom is 'T' definig equally the component of the temperature field. Afterwards depi will create the force vector associated to the imposed temperature value on the boundary under consideration. The nodal forces, equivalent to a boundary heat flux are obtained by applying the flux operator. The model mod is necessary as the underlying finite element are needed to compute the distribution over the nodes and elements. The convection boundary condition: ∂θ = h(θ − θ∞ ) ∂n is of a special mathematical type. Therefore it will introduce a new conductivity matrix KK_hole defined by the material parameter h and a corresponding nodal force Fhole defined by the same h and the environmental temperature h. Forced convection conditions of the type: ∂θ = h(θ − θ∞ )4 ∂n are nonlinear and can not be solved in this problem setting. A first approximation can be obtained by a applying temperature varying exchange coeffiencient: h = h(θ).
mod mat
= dom mode thermique isotrope; = mod mate 'RHO' 1. 'K' 1. 'C' 1.;
KK = conductivite mod mat; CC = capacite mod mat;
Ad23 = bloq 'T' d23; AA = Ad23; Fd23 = depi Ad23 4.;
Fd34 = flux mod 2. d34;
mod_hole = mode (arc23 et arc34) convection; mat_hole = mod_hole mate 'H' 1.; KK_hole = conductivite mat_hole mod_hole; Fhole = convection mod_hole mat_hole 'T' 200. ;
28
Varying boundary temperatures, fluxes or convections, and volume heat sources can be imposed using similar commands as in the elastic case when imposing a varying pressure. This problem will be left to the reader as an exercice.
3.5
Exercices
1. Stresses and strains in a plate with a hole Runs the program presented in the text of chapter. Perform the following operations • check the stress distribution for all types of applied forces, i.e. body force, applied pressure applied surface pressure and tangential traction • compute the solution applying a given linear momentum (resultant force) on the upper face of the plate using both forc[e] and the pres[sion] operators. Explain the difference ! See file traction_trou.dgibi
2. Elastic and thermal analysis example files Run the elasticity example files for an elastic analysis: elas*.dgibi and for the thermal analysis ther*.dgibi from castem_dir/dgibi directory and read the notes in castem_dir/dgibi/annotated_testing_files_98.pdf
3.6
Material coefficients varying with temperature
Suppose now that we dispose of a law correlating a material property P with temperature θ (for example consider the young modulus E(θ) or the dilation coefficient α(θ)). The question we would like to answer next is: how to compute the spatial distrubution of of P in the presence of an inhomogenous temperature distribution θ(x), i.e. P (x) = P (θ(x))
29
4
Parabolic problems: transient heat transfer
Dans cette section on reprend les équations de la conduction thermique en régime instationnare discutés en chapitre ?? et on va étudier un exemple d’échauffement de la plaqué trouée.
Ce type de problème peut être résolu numériquement en utilisant l’opérateur pasapas de Cast3M comme présenté dans les fichiers exemple du code. Dans la suite on va partir de la formulation discritisée en espace en en temps (voir ??) et montrer les pas de programmation de l’algorithme en utlisant le langage GIBIANE.
On rappele que la famille d’algorithmes présentée précedement repose sur l’équation:
eq. 8.31 p. 159 30
(4.1)
qui permet de déterminer Tn+1 connaissant Tn+1 . θ ∈ [0, 1] est un paramètre. Avant de demarrer on défini le pas de temps.
dt = 0.1;
Le choix θ = 1 est justifié par un algorithm implicit et donc stable.
theta = 1.;
Dans une première étape on contruit les matrices de conductivité et de capacité, qui sont des objets de type matrice de rigidité.
KK = conductivite mod mat; MM = capacite mod mat;
Ensuite on calcule les matrices intervenant dans l’algorithme, i.e. dans l’équation (??).
Matnpun = ((1./dt) * MM) et (theta * KK); Matn = ((-1./dt) * MM) et ((1 - theta) * KK);
La matrice A correspondant à la temperature imposé sur la frontière exterieure et la temprature exterieure maximale est imposé.
Td = 1.; Ad23 = bloq 'T' d23; AA = Ad23;
On initialise la table des champs de temperature et des temperatures imposées.
T = table; T . 0 = manu chpo dom
Le calcule consiste maintenant en la résolution de l’équation pour chaque pas de temps.
ndt = 20;
1 'T' 0.;
F = table; F . 0 = depi Ad23 0.;
repeter boucle ndt; n = &boucle - 1; F . (n + 1) = depi Ad23 ((n*Td/ndt)); T . (n + 1) = reso (Matnpun et AA) ((Matn * (T . n)) et ((theta * F . (n + 1)) + ((1 - theta) * F . n))); fin boucle;
4.1
Exemple en analyse dynamique
Comme example d’analyse dynamique, on reprend ici les équations de l’élasticité linéaire en régime dynamique et on va présenter la programmation de l’algorithme de Newmark (voir ??) en langage GIBIANE. Comme pour le problème thermique instationnaire, ce type de problème peut être résolu numériquement en utilisant l’opérateur pasapas de Cast3M. Une variante qui utilise un algorithme fondé sur une projection du champ des déplacements sur une base modale est également disponible avec l’opérateur dyne. 31
On rappele que la famille d’algorithmes présentée précedement repose sur l’équation:
eq. 8.31 p. 159 32
(4.2)
qui permet de déterminer Tn+1 connaissant Tn+1 . θ ∈ [0, 1] est un paramètre. La construction d’une barre de longeur ldom et de largeur hdom se fait en partant de la droite definissant la frontière gauche dgauche et générant le maillage avec l’opérateur tran[slation].
ldom = 50.; hdom = 1.; p1 = 0. 0.; p2 = 0. hdom; nlelem = 100; nhelem = 2;
Ensuite on crée le modèle et le matériau.
mod mat
Les paramètre du calcul: pas de temps dt et les paramètres de l’algoritme β et γ sont choisies pour assurer la convergence et la stabilité du calcul ??.
ndt = 200; dt = 1.;
On défini les conditions aux limites:
AA = bloq depla dgauche;
• extremité gauche: barre encastré • extremité droite: un créneau temporel de force pendant quelques instants
dgauche = droite nhelem p1 p2; dom = dgauche tran nlelem (ldom 0.); ddroite = dom face 3; = dom mode mecanique elastique isotrope; = mod mate 'RHO' 1. 'YOUNG' 1. 'NU' 0.3;
beta = 0.25; gamma = 0.5;
F F F F
= . . .
table; 0 = force ddroite (0. 0.); 1 = force ddroite (-1. 0.); 2 = force ddroite (-1. 0.);
On assemble les matrice de rigidité [K] et de masse [K] et on calcule la matrice [S] la seule qui va être inverse pendant l’algorithme. et de masse
KK = rigi mod mat; MM = mass mod mat;
On initialisé les déplacements [U] les ˙ et les acceleration [U]. ¨ vitesses [U]
U = table; dU = table; ddU = table;
SS = MM et (( beta * (dt ** 2.)) * KK );
U . 0 = manu chpo dom 2 'UX' 0. 'UY' 0.; dU . 0 = manu chpo dom 2 'UX' 0. 'UY' 0.; ddU . 0 = reso (SS et AA) (F . 0); Et enfin on calcule la boucle d’incrémentation temporelle formée des trois étapes: • (a) prédiction • (b) calcul de l’accéleration • (c) correction et actualisation
repeter boucle ndt; n = &boucle - 1; * ** prediction Upred = (U . n) + ( dt * (dU . n)) + ((0.5 * dt * dt * (1 - (2*beta))) * (ddU . n)); dUpred = (dU . n) + ((dt * (1 - gamma)) * (ddU . n)); * ** calcul de l'acceleration ddU . (n + 1) = reso (SS et AA) ((F.(n+1)) - (KK * Upred)); 33 * ** correction et actualisation U . (n + 1) = Upred + ((dt * dt * beta) * (ddU . (n + 1))); dU . (n + 1) = dUpred + ((dt * gamma) * (ddU . (n + 1)));
5
Elastoplasticity
Outline
5.1
Plasticity - programming of a incremental algorithm
L’exemple présenté ensuite se restreint volontièrement à un calcul élastoplastqiue avec une matrice de rigidité constante avec similaire à l’algorithme de la section ??. Dans cette version on utilise l’opérateur ecou[lement] pour le calcul de l’incrémént des contraintes et des variables internes. Pour l’instant on ne 34
calcule donc pas explicement en langage gibiane le retour radial. On demarre d’un domain dom carre sur lesquel on défini le chargement suivant: • déplacement imposé:
dom
= dall d12 d23 d34 d41;
u1 = 0.; u2 = 0.01; ndt = 8;
• conditions de symétrie sur ...
AA1 = (bloq uy d34 ); AA2 = (bloq ux d23); AA3 = (bloq uy d12) et (bloq ux d41); AA = AA1 et AA2 et AA3;
• surfaces libres ailleurs
FF1 = depi AA1 u1; FF2 = depi AA2 u2;
uy |d34 = tu1 ux |d12 = tu2
t ∈ [0, 1] désigne le parametre du temps fictif. Le chargement est imposé en ndt pas de longeurs égales. Les matrices de rigidité associées aux blocages sont AA1, AA2, AA3 et AA et les forces imposées sont stockées pour chaque pas de temps n dans un vecteur force FF . n appartenant à la table FF. On défini premièrement les paramètres du comportement: • le module de Young EE et le coefficient de Poisson nu • la limite élastique sigy et le module d’écrouissage H Et ensuite on va associé un comportement élastoplastique cinématique à écrouissage isotrope par l’opréateur mode au maillage dom. Les paramètres du modèle sont associés aux modèle mod par l’intermédiare de l’opérateur mate. La rigidité KK associé à la partie élastique du comportement est calculé en utilisant l’opérateur rigi comme dans le cas élastique, donc associé à EE et nu.
tol_res est la tolérance accépté pour l’équation d’équilibre et est actuellemnt le seul paramètre du calcul. Les tables des déformations plastiques des variables internes des déplacement sont intialisées en uitilisant les opérateurs table pour la structure de liste généralisée et par zero pour la valeur initiale à t = 0. La boucle qui calcule les incréments du chargement est nommé it_char et demarre avec l’initialisation des valeur des champs à l’itération n avec la valeur calculé à l’itération précedente n − 1.
FF = table; repeter boucle (ndt + 1); n = &boucle - 1; FF . n = ((flot n) / ndt ) * (FF1 et FF2); fin boucle;
EE = 2.e11; nu = 0.3; sigy = 600.e6; H = 2000.e6; mod = mode dom mecanique elastique plastique cinematique; mat = mate mod'YOUNG' EE 'NU' nu 'H' H 'SIGY' sigy; KK = rigi mod mat;
tol_res = 1.e-3; UU = table; sig = table; epsp = table; alpha = table; UU . 0 = manu chpo dom 2 ux 0. uy 0.; epsp . 0 = zero mod 'DEFINELA'; alpha . 0 = zero mod 'VARINTER'; sig . 0 = zero mod 'CONTRAIN'; repeter it_char ndt; n = &it_char; mess 'increment charge ' n; UU . n = UU . (n - 1); epsp . n = epsp . (n - 1); sig . n =35 sig . (n - 1); alpha . n = alpha . (n - 1); du = reso (KK et AA) (FF . n - FF . (n - 1 )); UU . n = UU . n + du; deps = epsi mod du;
A l’intérieur de la boucle it_char des incréments du chargement on construit une nouvelle boucle it_equi. A l’intérieur de celle-ci on trouve le calcul dce l’incrémént des variables internes si nécessaire, ceci est réalisé par l’intermédiaire de l’opérateur ecou[lement] et puis la vérification de l’équilibre. La vérification de l’équilibre démarre avec le calcul du résidu RR, défini comme différence entre les efforts extérieures imposées FF . n et la "divergence" des contraintes, i.e. les forces nodales: [BT ]σ, calculée en utilisant l’opérateur bsigma. Le dernière terme permet d’enlever la contribution des déplacements imposées dans les forces nodales. Entre si et findi on teste si la norme max du résidu des forces nodales est plus petite que la tolérance et alors on va quit[ter] la boucle it_equi. Si la condition n’est pas vérifiée alors on calcule un nouveau incrémént des déplacements du pour équilibrer le résidu et on revien au commencement de it_equi pour une nouvelle itération: mis à jour des variables internes et des contraintes, etc. Les deux commandes ferment la boucle de vérification de l’équilibre it_equi et celle des incréments de chargement it_char. Les commandes debp[rocedure] et finp[rocedure] marquent le commencement et la fin de la procédure n_force. Par extraction des composantes fx,fy du champs des forces ff et des opération algébriques on calcule la norme définie comme le champ: q ||f || = fx2 + fy2 où f = fx ex +fy ey
repeter it_equi max_ip; nsig nalpha ndepsp = ECOU mod (sig . n) (alpha . n) deps
mat;
sig . n = nsig; alpha . n = nalpha; epsp . n = ndepsp;
RR =
((FF . n)
- (bsigma mod sig . n) - (AA * (uu . n)) );
no_res = n_force RR; no_for = n_force ((FF . n) + (reac AA uu . n)); si ((maxi no_res) < (tol_res * (maxi no_for))); quit it_equi; finsi; du = reso (KK et AA) RR; UU . n = UU . n + du; deps = epsi mod du;
fin it_equi; fin it_char;
debproc n_force ff*chpoint; lanorme = (((exco fx ff scal)*(exco fx ff scal)) + ((exco fy ff scal)*(exco fy ff scal)) )**0.5; finproc lanorme;
36
5.2
Plasticity - computation using pasapas
In this section we shall illustrate the usage of the standard castem command pasapas (fr. step-to-step) command, which enable to compute the solution of an nonlinear problem. The case discussed next will be that of an elastoplastic problem. In the example we shall refer to the already defined geometry of the plate with a circular hole (see chapter ?? and ?? ) and will directly start with the definition of the material, the boundary conditions.
Model and laoding history The mode[l] and the mate[riaux] operators are used as in the elastic case to define the material behaviour and its parameters. In this case the model is a elastoplastic model with kinematic hardening.
mod_p mat_p
= mode dom mecanique elastique isotrope plastique cinematique; = matr mod_p 'YOUN' 2.e11 'NU' 0.3 'SIGY' 200.e6 'H' 2.e9;
As in the first version of the elastic computation in chapter ??, we shall define an imposed displacement on the line d34 of the plate. However if the value of the displacement was fixed in the elastic case, we shall define here a varying amplitude. The introduction of the imposed displacements will again be performed using a Lagrange multiplier technique. If the imposed displacement can be written as: u(x, t) = u(x, t) = a(t)u0 (x)
x ∈ ∂Ωd
Then the projection matrix [A] will be the same with the one defined in the elastic case and will not vary in time. We shall just have to introduce the displacement amplitude in the program a(t). We start again by defing the projection matrixes and assembles them into only one element: [A]. Next we define the associated nodal force vector [UD 0 ] of the imposed displacement distribution u0 , denoted as ud34 in the program. The amplitude a(t) is defined by its graph. In castem this corresponds to a evolution object assembled from the list of time instants tt and the coresponding amplitudes a_ud34. The association of the amplitude ev_ud34 with the correspoding nodal force vector ud34 is done using the char[gement] (fr. laoding) operator. The string 'DIMP' annonces that the loading is an imposed displacement. The keywords for different loading types is specified in the help of the char[gement] and the pasapas operators.
Ad12 = bloq uy d12; Ad41 = bloq ux d41; Ad34 = bloq uy d34; ud34 = depi Ad34 0.001; AA = Ad12 et Ad41 et Ad34; tt = prog 0. 5. 10. 15. 20.; a_ud34 = prog 0. 1. 0. -1. 0.; ev_ud34 = evol manu 'TEMPS' tt 'DIMP' a_ud34; dess ev_ud34; ch_ud34 = char 'DIMP' ud34 ev_ud34;
37
The computation using pasapas The nonlinear computation is performed using the pasapas operator. Its input variables are oragnized in a large table, that means a generalized list, where the different indexes specify the objects: • 'MODELE' - the model • 'CARACTERISTIQUES' - the material parameters • 'BLOCAGES_MECANIQUES' - the projection matrixes for imposed displacement or temperature
tabexp = table; tabexp . 'MODELE' = mod_p; tabexp . 'CARACTERISTIQUES'
=
mat_p;
tabexp . 'BLOCAGES_MECANIQUES' = AA; tabexp . 'CHARGEMENT' = ch_ud34; tabexp . 'TEMPS_CALCULES'
= prog 0. pas 1. 20.;
pasapas tabexp;
• 'CHARGEMENT' - the loads, expressed as histories of nodal forces, constructed with the char[gement] operator • 'TEMPS_CALCULES' - the list of time instant where equilibrium has to be checked
If the information proivided for pasapas is consistent then the computation starts and during the performance a series of parameters are displayed for its monitoring. The output of the example will be discussed next. The inforlations provides for each the step number ( Numero du pas) or the coresponding time instant (Indice d evolution) a series of information about the inner iterations to reach plastic admissibility and global equilibrium: • Nplas • Critere • Deps.max • Eps.max • Crit.flex
------------------ DEBUT DE LA PROCEDURE PASAPAS -----------------Calcul MECANIQUE *** PLASTICITE *** *** CONVERGENCE FORCEE Numero du pas : Iter Nplas
***
1 Indice d evolution : 3.0000 Critere Deps.max Eps.max
38
Crit.flex
Pas d incr\uffffment de charge, initialisation calcul\uffffe avec le temps Initialisation \uffff partir de la solution precedente Coeff 0.0000 1 35 0.50000 8.40624E-06 2.14937E-03 0.50000 2 34 1.17475E-04 8.79403E-06 2.15165E-03 1.17475E-04 3 34 8.47313E-05 1.14535E-05 2.15337E-03 8.47313E-05 ****** CONVERGENCE A L ITERATION 3 Numero du pas :
2
Indice d evolution :
Iter Nplas Critere Deps.max 1 248 0.11013 5.67786E-04 2 255 1.42363E-03 7.69312E-04 3 253 9.79151E-04 9.04782E-04 act3 : reduction at 3 dimensions 4 250 1.22652E-03 1.18403E-03 5 251 2.00070E-04 1.21039E-03 6 243 2.03488E-04 1.28299E-03 7 240 9.73268E-05 1.29365E-03 ****** CONVERGENCE A L ITERATION 7
4.0000 Eps.max Crit.flex 2.72116E-03 0.11013 2.92268E-03 1.42363E-03 3.05815E-03 9.79151E-04 3.33740E-03 3.36376E-03 3.43636E-03 3.44703E-03
1.22652E-03 2.00070E-04 2.03488E-04 9.73268E-05
.... ------------------- FIN DE LA PROCEDURE PASAPAS -------------------
39
Analysis of the results After the completetion of the pasapas computation a series of results can be analysed. list-ing the contents of tabexp presents the complete list of the entries of the table, ranging from computational options and settings to the fields of the solution. Some of the important entries are: • deplacements - the displacement fields • contraintes - the stress fields • variables_internes - the fields of the internal variables of the constitutive model, its component fields are described in the manuel pages of mode[le] and mate[riaux], as well as in documents like [?]
list tabexp; list tabexp . deplacements ; list tabexp . contraintes ; list tabexp . variables_internes ; list tabexp . temps ; trace mod tabexp . contraintes . 15 ; trace dom tabexp . deplacements . 4 ; list (extr tabexp . variables_internes . 5 'COMP' ) ;
• deformations_inelastiques - the fields of the inelastic strains All these entries are themselfs tables indexed after the number the computed step. The correspondence between steps an time instants can easily be recored by listing the table of time tabexp . temps. The global strain field is not saved in the procedure, but can easily been computed with epsi[lon]. The computed fields can be displayed using trac[er], in the usual way, that means appending the mesh for the nodal fields, chpoint, and the model for the fields on elements (chamelem, defined for examplet at the Gauss points). If one wants to track the history of a field at a certain point, one can easily construct the coresponding evolution object. The prog[amer] command initiates and then constructs by appending the list of values for the time and field evolutions. The repe[ter], fin command permits to construct the loop over all time steps. The user defined string loop is only a flag indicating the start and the end of the loop. This functionnality is of importance for intricate loops. &loop is the iterator of the loop loop and varies from 1 to (dime tabexp . deplacements). However as the lists in tabexp start with the initial step set at 0 we insert the new iterator ii. The use of dime[ension] permits to extract automatically the number of time
thetime = prog; uuy = prog; sigyy = prog; sigxy = prog; repeter loop (dime tabexp . deplacements); ii = &loop - 1; thetime = thetime et (prog tabexp . temps . ii); uuy = uuy et (prog (extr tabexp . deplacements . ii 'UX' a3)); sigyy = sigyy et 40 (extr tabexp . contraintes . ii 'SMYY' 1 30 2)); (prog sigxy = sigxy et (prog (extr tabexp . contraintes . ii 'SMXY' 1 30 2)); fin loop;
6
Input and output
Outline 6.1 Cast3m objects Saving in an exterieur file castem objects can be realized through the sauv[er] (fr. save) command. The option defines first the output file my_file.dat in the working directory. The string format ensures, defined by the , ensures that lower and upperscale letters are respected and the filename is therefore correctly defined. A directory path can also be given here. The sauv command is followed by e number of objects which should be savec, the mesh plate and the displacement u in the current example. The output information gives a detailed list of the saved objects. The program will equall save the underlying objects forming the objects to be saved. The data saved with the sauv[er] procedure can be recovered uisng the rest[ituer] command. The option set the filename to be recovered, and the second command imports the complete contents of the file, and the castem output keeps a track of the operation. All objects will be imported with their previous names.
$ $
* *
opti sauv 'my_file.dat'; sauv plate u;
LA PILE NUMERO 1 CONTIENT 19 OBJET(S) MAILLAGE IL Y A 10 OBJET(S) NOMME(S) : LA PILE NUMERO 2 CONTIENT 1 OBJET(S) CHPOINT IL Y A 1 OBJET(S) NOMME(S) : LA PILE NUMERO 27 CONTIENT 1 OBJET(S) MOT IL Y A 1 OBJET(S) NOMME(S) : LA PILE NUMERO 32 CONTIENT 494 OBJET(S) POINT IL Y A 6 OBJET(S) NOMME(S) : LA PILE NUMERO 33 CONTIENT Fin normale de la sauvegarde $ * $ $
* *
1 OBJET(S) CONFIGUR
opti rest 'my_file.dat'; rest;
NIVEAU DU FICHIER 16 NIVEAU D'ERREUR LECTURE DE 19 LECTURE DE 1 LECTURE DE 1 LECTURE DE 494 LECTURE DE 1 FIN DE LECTURE DU LABEL AUTOMATIQUE
0 DIMENSION 2 DENSITE OBJETS MAILLAGE OBJETS CHPOINT OBJETS MOT OBJETS POINT OBJETS CONFIGUR LABEL : : 1
Fin normale de la restitution
41
0.00000E+00
The presented version of the sauv[er] command realises an export file in a binary format. The output can equally be written in a txt format if the option format is called. For more information see the help file of the sauv[er] command.
6.2
Graphics and plots
Graphics created with the trac[er] or the dess[iner] command can be saved in a P OSTSCRIPT format in an external file. The steps are the following: • click succesively the following quadrangles in the castem graphics window:(i)Softcopy (ii) choose one of the formats Framemaker, Postscript couleur (colour), Postscript NB (black and white). • all succesive graphic outputs will be saved in a single file temporary file in the working directory called fort.24. This file will be copied after the end of the castem run in one of the following files: – .ps if the run command is: castem – my_file.ps if the run command is: castem my_file.dgibi
How to read P OSTSCRIPT files Saved displayed files, are written in Postscipt. We recall that Postscript is a programming language specialised in displaying graphical information, created by A DOBE. It is based on a vectorial command description and and the objects are constructed from base objects. There are several programs for reading this format: • the classical drawing and image processing softwares like: A DOBE P HOTOSHOP, A DOBE I LLUSTRA TOR , C OREL D RAW , G IMP (free), I MAGE M AGICK (free), etc. • the free software family of ghostscript programs
How to change the gray level in the saved The P OSTSCRIPT commands can be read from the files using standard text editors. In the header we can find a series of settings and definitions. In the case of the castem generated graphics the commands for the graylevel definitions look as displayed next. The graylevels are defined by their names /eA, /eB, ... and the associated graylevel value 1.0000, 0.9841, ... respectively. def stands for the end of the definition.
/eA /eB ... /e& /e@
{ 1.0000 setgray } def { 0.9841 setgray } def { 0.0159 setgray } def { 0.0 setgray } def
In order to change the graylevel scales in a graphic it is therefore necessary to change the values in the definitions, the only restriction to respect is to chose values in the [0, 1] interval. 42
6.3 exte[ieur] calling an exterior program 6.4 chau[ssette] dynamic link with another program, server 6.5
Reading and writing data acqu: reading data from a file
The standard operator used to get data from a file is acqu[erir] (fr. to get), we shall simply illustrate its functioning on an example. Let us first present the strucure of the file mesure.dat, which we would like to import in castem The file contains measurements organized in four columns of real numbers over 786 lines. Under the Linux operating system its structure can be displayed using the head command. wc will count lines, words and characters in the file.
In order to read the contents of the file, we first set the opti acquerir to the filename. Then we initialize, using the prog[ramer] command, four lists which will containt the values of each column The values are then read line by line using the acquerir command which is inserted in a repe[ter] loop.mylop is only the name of the loop and permits to fix the beginning and end of the loop. One can further remark that the type of each word is set to flottant (fr. real number) and that the lists are appended with the new read value by a simple use of et. After the reading is complete we can structure the lists into evolution objects which can be displayed using dess[iner].
[constant@rhea-lms]$ head mesures.dat 0. 25.58 24.8297 0.7503 0.1 42.4199 24.9874 17.4325 0.2 125.599 24.998 100.601 0.3 247.493 25.0107 222.4823 0.4 368.41 25.0788 343.3312 0.5 479.224 25.1354 454.0886 ... [constant@rhea-lms EssaisEMP]$ wc mesures.dat 786 3136 27653 mesures.dat [ opti acquerir 'mesure.dat'; mes_t = prog; mes_text = prog; mes_tint = prog; mes_del = prog; repeter myloop 780; acquerir t*flottant text*flottant tint*flottant delta*flottant; mes_t = mes_t et (prog t); mes_text = mes_text et (prog text); mes_tint = mes_tint et (prog tint); mes_del = mes_del et (prog delta); fin myloop; ev_text = evol manu 'temps' mes_t 'mesures t_ext' mes_text; ev_tint = evol manu 'temps' mes_t 'mesures t_int' mes_tint; ev_delta = evol manu 'temps' mes_t 'mesures delta t' mes_del;
43
The @excel1 procedure, writing to a file The @excel1 procedure is a user defined subroutine which permits to save an evolution object in a standard E XCEL format. The subroutine was written by Christian Laborderie in 1994 and gratiously give to the castem community. We shall briefly analyse the procedure, which can than be used as an inspirational model for creating other similar output programs. The complete gibiane structure of the subroutine can be printed on the standard output using the list command. The the beginning and the end of subroutine are marked by the debproc and endproc commands. The input variables are ev1 an evolution object and the name of the output file ficout given as a string (fr. mot). First the two list of the ev1 are extracted using extr[aire] and the two options absc[isse] and ordo[nee] which denote the list on the two coordinate axes, respectively. Second, the standard output is defined by the value of the impr[imer] option which is recovered for further use in ii using vale[ur]. The opti[on] of the standard output is then defined to be the ficout file. Next, the procedure defines a loop in which the values of the two lists are printed on the standard output, now defined as the ficout file using the mess[age] command. Finally the standard output is redefined to its initial value ii.
list @excel1; Liste de la PROCEDURE ********************* 1 * @EXCEL1 PROCEDUR AM 94/01/20 21:15:10 1033 2 *----------------------------------------------------------3 ****** PROCEDURE @EXCEL1 ****** 4 *----------------------------------------------------------5 * 6 * CETTE PROCEDURE A ETE MISE GRACIEUSEMENT 7 * A DISPOSITION DE LA COMMUNAUTE CASTEM2000 8 * PAR Ch. LABORDERIE (LMT - ENS Cachan ) 9 * 10 *----------------------------------------------------------11 DEBPROC @EXCEL1 EV1*EVOLUTION FICOUT*MOT; 12 PROG1=EXTR EV1 ABSC; 13 PROG2=EXTR EV1 ORDO; 14 NB=DIME PROG1; 15 I=0; 16 ii=vale impr; 17 OPTI IMPR 10 IMPR FICOUT; 18 REPETER BOU1 NB; 19 I=I+1; 20 X1=EXTR PROG1 I; 21 Y1=EXTR PROG2 I; 22 MESSAGE X1 ';' Y1 ; 23 FIN BOU1; 24 OPTI IMPR II; 25 FINPROC;
6.6 util: reading subroutines In the preceeding section we have been analysing an example of a procedure, i.e. a subroutine or a function when refered in classical programming languages. For programming convenience one can group a series of subroutines in an external file. If the file is correctly uploaded using the util[sateur] procedure (maning user in french) the subroutine will appear in the following runs of the program as already complemented castem commands. 44
The file containing the procedures should be organized as follows:
The file containting the procedures is actaully a simple list of the programming lines, were before each subroutine a ligne should be added containg the strings $$$$ followed by the name of the subroutine. The last line of the file should contain only the $$$$ string.
$$$$ MYFIRST debproc MYFIRST ...; * * finproc; $$$$ MYSECOND debproc MYSECOND ... ; finproc; $$$$
Once created one can include the procedure using the following commands:
The file containing the procedures was denoted in this example my_procedure_file.dgibi. The ending of the file, denoting usually a file type is of no special importance in this instance. In order to load the commands in the castem environnement one has to make a special run, using only the util command and finishing directly afterwards. The util command will load the procedure in the UTILPROC file in the working directory and will make it available for the next runs of castem.
6.7
util proc 'my_procedure_file.dgibi'; fin;
Meshes and file format exchange
The import and export of meshes from and towards Cast3M is of importance for a series of practical applications. This topic is discussed in chapter 6. This can be performed using the standard castem commands lire, sortir (see example of the next chapter) or by using for example a series perl scripts kindly proposed by Laurent Champaney [1]. The tools permit exchanges between mesh formats of the following finite element programms, pre- or postprocessors Abaqus, Cast3m, GMSH, Nastran, SAMCEF, etc. 45
Next we present a series of standard Cast3m commands for mesh export and import. The command opti sort[ir] sets the file mon_fichier as the standard write output file and sort[ir] (getting out) writes the data structure of the mesh dom (coordinates of the nodes and connectivity) as well as the displacement field U on the file. 'AVS' is a key word which defines only the standard output format. To recover the data from the file mon_fichier one has to define the file reading file. Then lire (read) recoveres the data in the table tab. The indexes lemailla and lechpoin indicate the position of the mesh (le maillage) and of the nodal field (le champs par points) respectively. The precision of the operation can be controled by plotting both the mesh and one of the compoenents of the displacement field.
opti sort 'mon_fichier'; sort 'AVS' dom u;
opti lect 'mon_fichier'; tab = lire 'AVS'; trace (tab . lemailla) ; trace (tab . lemailla) (exco 'UX' (tab . lechpoin));
Exercices
46
7
How to and other questions
How to save a standard display
47
Bibliography [1] L. Champaney. Outils personnels (exchange http://laurent.champaney.free.fr/perso/outils.html.
tools
for
finite
elemnt
[2] P. Fichoux. Presentation et utilisation de castem 2000. Technical report, ENSTA, 1998.
48
programs).
Index do, end repe[ter], 43 do, start repe[ter], 43
acqu[erir] (getting data from file), 42 and et, 12 axial symetry axis, 19 axis (axial symetry), 19 bsig[ma], nodal force , 22 buckling flam[bage], 9
dedo[ubler], 14 defo[rmation] plan[e] (plane strain), 18 dess[iner] (draw), 9 dess[iner], save graphics, 41 do repe[ter], 9 draw dess[iner], 9 droi[te] (line), 9 droit[e] (line), 12
editors (editeurs, outils) , 7 elem[ent] (select elements), 15 calling an exterior program, see exte[ieur], 42 elim[iner], 14 capacite, 27 elim[iner], 14 cer[le] (circle), 9 else sinon, 9 cerc[le] (circle), 12 chan[ger] 'CHPO' (change field into nodal values), end fin, 9 endif finsi, 9 23 chang[er] (change, from nodal to element field), 26 entier (integer), 8 change field into nodal values chan[ger] 'CHPO', 23 enve[loppe], boundary surface of a volume, 15 epsi[lon], strain , 22 change from nodal to element field chpo, 26 et (and), 12 change from nodal to element field mchml, 26 evol[ution] change order inve[rser], 12 'CHPO', along path on nodal field, 23 change, from nodal to element field chang[er], 26 'MANU', from lists , 39 characteristic function masq[er], 24 exte[ieur], calling an exterior program, 42 chpo (change from nodal to element field), 26 extr[aire] extract, chpoint (nodal field), 8 'COMP', components , 39 circle cer[le], 9 chpoint, field on elements , 39 circle cerc[le], 12 chpoint, nodal field , 39 conductivite, 27 extr[aire] evolution, 43 cont[our], boundary line of a surface, 13 convection, boundary condition, 27 face of a volume, 15 creates fields and other objects manu[el], 26 fin (end), 9 dall[er] (tilling 2D), 12 finp[roc] (subroutine; end), 9 dall[er] (tilling), 9 finsi (endif), 9 debp[procedure] (subroutine file, util[isateur]), 44 flam[bage] (buckling), 9 debp[procedure] (subroutine, end), 43 flottant (real number), 8 debp[procedure] (subroutine, start), 43 getting data from file acqu[erir], 42 debpr[ocedure] (subroutine; start), 9 49
heat, 27 if si, 9 integer entier, 8 inve[rser] (change order), 12
lect[ure], 8 line droi[te], 9 line droit[e], 12 lire (read), 44 listenti[er], list of integers, 8 listmots, list of strings, 8 listreel, list of real numbers, 8 logical value logique, 8 logique (logical value), 8 loop, end repe[ter], 43 loop, start repe[ter], 43
read lire, 44 real number flottant, 8 recover data from file rest[ituer], 40 repe[ter] , 39 repe[ter] (do, end), 43 repe[ter] (do, start), 43 repe[ter] (do), 9 repe[ter] (loop, end), 43 repe[ter] (loop, start), 43 reso[ut] (solve), 9, 20, 27 rest[ituer] (recover data from file), 40 rigi[dite] (stiffness), 20 rigidite (stiffness), 9
sauv[er] (saving data in file), 40 save graphics, 41 saving data in file sauv[er], 40 select elements elem[ent], 15 maillage (mesh), 8 select points or nodes poin[t], 15 manu[el] (creates fields and other objects), 26 settings opti[on], 11 mask, characteristic function masq[uer], 9 si (if), 9 masq[er] (characteristic function), 24 sigm[a], stress , 22 masq[uer] (mask, characteristic function), 9 sinon (else), 9 material maté[riaux], 20 maté[riaux] (material), 20 solve reso[ut], 9, 20, 27 mchml (change from nodal to element field), 26 sortir (write), 44 mesh maillage, 8 step-by-step, incremental problem pasapas, 9 mess[age], 43 stiffness rigi[dite], 20 mesu[rer], mesures length, areas and volumes, 16 stiffness rigidite, 9 Mises stress norm (von Mises) vmis[es], 23 strain, epsi[lon] , 22 mode[le] (model), 20 stress, sigm[a] , 22 model mode[le], 20 stress, von Mises, vmis[es] , 23 mots, 8 string , list of strings8 subroutine file, util[isateur] debp[procedure], 44 nbel[ements], computes the number of elements, 16 subroutine, end debp[procedure], 43 nbno[euds], computes the number of nodes, 16 subroutine, start debp[procedure], 43 nodal field chpoint, 8 subroutine; end finp[roc], 9 nodal force , bsig[ma], 22 subroutine; start debpr[ocedure], 9 surf[ace] (surface), 9 opti[on] (settings), 11 surf[ace], meshes a closed line, 13 pasapas (step-by-step, incremental problem), 9 surface surf[ace], 9 plane strain defo[rmation] plan[e], 18 thermique, 27 plot trac[er], 9 tilling 2D dall[er], 12 plus, new mesh by a adding a displacement, 15 tilling dall[er], 9 plus, 9 trac[er] (plot), 9 poin[t] (select points or nodes), 15 trac[er], graylevels, 41 prog[ramer], 8 50
trac[er], save graphics, 41 util[isateur], 44 vibr[ation], 9 vmis[es] (Mises stress norm (von Mises)), 23 write sortir, 44
51
