Python Ef

Sciences-industrielles.
com
Cours, exercices et corrections en SI
http://sciences-industrielles.com
Python scientifique : application aux

éléments finis
Utilisation de logiciels
Master 1
Steven Masfaraud
26 décembre 2013
Python scientifique : application aux éléments finis Master 1
Table des matières

1 Installation de Python 3
1.1 Généralités sur Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Premiers pas sur Python, utilisation de Spyder 3
3 Résolution élément fini pour une poutre en traction 5

3.1 Problème, résolution élément finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1.1 Formulation du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1.2 Rappels sur la résolution élément finis . . . . . . . . . . . . . . . . . . . . . . 5
4 Implémentation en Python 7
4.1 Chargement des paquets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.2 Mise en données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3 Maillage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3.1 Table de coordonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.3.2 Table de connectivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.4 Assemblage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.5 Prise en compte des conditions limites . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.6 Vérification de la construction des matrices et vecteurs . . . . . . . . . . . . . . . . . 14
4.7 Résolution de système linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.8 Post-traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
http://sciences-industrielles.com 2/18
1 Installation de Python
1.1 Généralités sur Python
Python est un langage open-source multi-plateformes. Son intérêt réside notemment dans les
nombreuses bibliothèques qu’il propose. Dans le domaine du calcul scientifique nous montrerons
qu’il remplace avantageusement matlab.
Nous utiliserons Spyder,un éditeur de texte libre lui aussi, qui nous permettra d’avoir une interface
interractive qui ne dépaysera pas les habitués de Matlab.
Il existe bien sur d’autres éditeurs de texte vous pouvez utiliser si vous préférez. Les installations
proposées après installent Python, numpy et scipy. Si vous voulez utiliser un autre éditeur, assurez
vous d’avoir ces paquets installés.
1.2 Sous Linux

Pour les utilisateurs de Debian ou d’Ubuntu, cette ligne de commande suffit à installer. Connec-
tez vous en superutilisateur pour l’executer.
# aptitude install spyder
Pour utilisateurs d’autres distributions linux, se référer à votre gestionnaire de paquets qui doit pro-
poser Spyder.
1.3 Sous Windows

Pour installer Spyder, Python et les bibliothèques que nous allons utiliser, le plus simple et
d’installer une distribution scientifique qui comporte tous cela.
Je vous propose winPython : http://sourceforge.net/projects/winpython/files/WinPython_2.7/2.7.6.0/
Sur la page de téléchargements, choisir votre fichier d’installation en fonction de l’architecture de
votre ordinateur. En général la version 64 bits convient. La procédure d’installation est classique.
2 Premiers pas sur Python, utilisation de Spyder

Spyder est un environnement de développement sous Python qui permet sur une même fenêtre
d’éditer un fichier Python et de l’executer.
Deux sous fenêtres sont donc absolument indispensables : l’éditeur et la console.
Je vous conseille de maximiser en largeur la taille de l’éditeur car c’est cette fenetre dans la-
quelle vous passerez le plus de temps, et ensuite de maximiser la taille de la console notamment en
hauteur. Les autres fenetres ne sont pas indispensables, vous pouvez les fermer pour l’instant pour
économiser de la place pour l’éditeur et la console.
L’interêt de Spyder et d’éditer un fichier, puis en appuyant sur F5 il est executé dans la console.
On peut alors voir le résultat de nos modifications en direct.
Créez un nouveau fichier. Enregistrez le où vous voulez. Spyder vous à généré un code minimaliste
qui ressemble à celui-ci :
1 # −∗− c o d i n g : u t f −8 −∗−
2 """
3 Cr ea ted on Tue Dec 24 1 7 : 0 7 : 3 7 2013
4
5 @author : s t e v e n
6 """
La première ligne précise l’encodage. Cela permet notamment d’afficher les caractéres spéciaux
proprement. Dans mon cas, sous linux c’est de l’utf8. Les lignes suivantes, entourées de """ sont
une description de votre code, vous pouvez renseigner le but de votre script, l’auteur, etc...
Ajoutez la ligne suivante à la fin de votre fichier :

1 p r i n t "Ca marche ! "
Appuyez ensuite sur F5. Si une boîte de dialogue s’ouvre pour vous demander les options d’execu-
tion, cochez "Executer dans l’interpréteur Python" actif puis validez.
Vous devriez voir dans la console le message "Ca marche !" être affiché. Vous avez exécuté votre
premier script Python !
3 Résolution élément fini pour une poutre en traction

3.1 Problème, résolution élément finis
On s’intéresse au comportement d’une poutre console (encastrée à une extrémitée) en traction
de longueur L, de section S, de module de Young E soumise à une force F en bout de poutre et à
une force linéique sur l’ensemble de la poutre de valeur f.
L
b b b b b b
F
f
3.1.1 Formulation du problème
La théorie de la résistance des matériaux nous fournit les deux équations suivantes :
dN
= −f (1)
dx
du
E×S× =N (2)
dx
(3)
avec :
– N l’effort normal dans la poutre
– u le déplacement longitudinal dû à la traction.
En combinant ces deux équations on obtient :
d2 u
E×S× = −f (4)
dx2
Cette équation différentiell peut être facilement résolue analytiquement (à la main). Dans le
cadre général des problèmes d’élasticité 2D ou 3D se n’est pas possible. D’oû la méthode d’approxi-
mation que sont les éléments finis.
3.1.2 Rappels sur la résolution élément finis

En multipliant l’équation 4 par un champ test v et en l’intégrant sur la longeur de la poutre, on
obtient :
Z L Z L
d2 u
E×S× ×v =− f ×v (5)
0 dx2 0
En intégrant par partie on obtient :
Z L Z L
du L du dv
[E × S × v] − E×S× × =− f ×v (6)
dx 0 0 dx dx 0
On impose à v d’être nul en L et 0, c’est à dire sur les bords du domaine. D’où :
Z L Z L
du dv
E×S× × = f ×v (7)
0 dx dx 0
C’est alors que l’on injecte l’approximation élément fini :
 
ϕ1
Xnn  ϕ2 
 
u= ϕi ui u =  .  u1 u2 . . . unn
i=1
 .. 
ϕnn
avec nn le nombre de noeuds.
On choisit pour v :  
ϕ1
nn
X  ϕ2 
 
v= ϕi v= . 
i=1
 .. 
ϕnn
ϕi−1 ϕi ϕi+1
1
b b b
noeud i-1 noeud i noeud i+1
Ce qui conduit à :
 dϕ1     
dx u1 ϕ1
Z L  dϕ2
  u2  Z L  ϕ2 
 dx
 ..    
ES  .  dϕ1 dϕ2
. dϕnn  .. = f .  (8)
0  ..  dx dx dx  .  0  .. 
dϕnn unn ϕnn
dx | {z }
| {z }
K F
On peut montrer que la construction de ces opérateurs peut se décomposer en l’addition de

contribution des élément à la rigidité du système et au vecteur force.
On a donc affaire à la résolution d’un système matriciel :
Ku = F (9)
Voilà pour la théorie, voyons comment coder cela en pratique !
4 Implémentation en Python
Dans la suite, nous écrirons notre programme dans un fichier Python. Pour cela, ouvrez un
nouveau fichier et enregistrez le où vous le souhaitez.
4.1 Chargement des paquets

Comme nous l’avons vu, Python fonctionne avec des bibliothèques d’outils regroupés en paquets
(packages). Le langage en lui meme définit des éléments de base comme les boucles, les conditions,
la gestion des variables et certaines structures de données comme les listes.
Pour résoudre un problème élément fini, nous aurons besoin de manipuler des vecteurs et des ma-
trices, et de tracer des graphiques pour visualiser les résultats. Pour cela nous utiliserons des paquets
qui sont fournis avec les distributions qui ont été présentées précédemment.
Nous allons utiliser :

– numpy : un paquet définissant les matrices et vecteurs et permettant de les manipuler
– linalg, sous-paquet de numpy
– pyplot, sous-paquet de matplotlib, comme son nom l’indique une bibliothèque de tracé pour
les maths.
Certains paquets peuvent en contenir d’autres, ce qui permet dans le cas de paquets volumineux
de ne pas charger trop de fonctions dont on ne va pas se servir.
Pour importer un paquet on utilise le mot-clé import. Pour importer la paquet numpy on doit
écrire :
1 impo r t numpy
Tout simplement. Nous pouvons alors utiliser les outils de numpy par exemple la fonction identity
en tapant :
1 numpy . i d e n t i t y ( 3 )
Ecrivez ces lignes à la fin de votre script et executez le. La console vous affiche le résultat :
array([[ 1., 0., 0.],

[ 0., 1., 0.],
[ 0., 0., 1.]])
La fonction numpy.identity crée une matrice identitée (1 sur la diagonale, zéros ailleurs) de la
taille passée en paramètre.
Pour appeller la fonction identity inclue dans le paquet numpy il faut taper numpy.identity
Comme nous risquons d’appeler plusieurs fonctions de ce paquet, il faudra à chaque fois les préfixer
par "numpy.". Pour ne pas avoir à faire cela, une solution consiste à modifier l’import du paquet
en tapant :
1 from numpy impo r t ∗
On peut alors taper directement identity(3). Mais cette méthode pose un problème pour les grands
projets où sont utilisés beaucoup de paquets. Deux paquets peuvent avoir chacun une fonction avec
le meme nom pour des utilisations radicalement différentes. On est alors plus trop sûr de quelle
fonction va etre appellée.
Une solution à mi-chemin est d’importer le paquet sous un nom raccourci :
1 impo r t numpy a s np
Il faut alors taper np.identity(3). Cette solution garde l’avantage de savoir quel paquet on utilise
sans pour autant alourdir trop le code. Nous garderons cette écriture pour la suite du projet.
Les autres paquets à inclure sont des sous-paquets. Pour cela :

1 from numpy impo r t l i n a l g a s l g
2 from m a t p l o t l i b impo r t p y p l o t a s p l t
Pour résumer, voici à quoi doit ressembler votre script. Remarquez la ligne de commentaire,
précédée d’un # pour commenter le code et le rendre plus sympa.
1 # −∗− c o d i n g : u t f −8 −∗−
2 """
3 @author : s t e v e n
4 """
5
6 # Import des p a c k a g e s
7 impo r t numpy a s np
8 from numpy impo r t l i n a l g a s l g
9 from m a t p l o t l i b impo r t p y p l o t a s p l t
4.2 Mise en données

L’étape précédente était purement informatique, nous nous attaquons maintenant à la mise en
données du problème avant sa résolution.
Dans chacune des étapes de la résolution, nous aurons besoin de connaitre certaines grandeurs
comme les paramètres matériau ou les dimensions de la poutre ou encore des paramètres de discré-
tisation.
1 # Pa r a metr es
2 E=200e9 #Module de young
3 S=0.01 # S e c t i o n de l a p o u t r e
4 L=1 # Longueur de l a p o u t r e
5 Fp=1000 # I n t e n s i t e de l a f o r c e p o n c t u e l l e en Newtons
6 ne=5 # Nombre d ’ e l e m e n t s
7 f l =500 # I n t e n s i t e de l a f o r c e l i n e i q u e en Newtons/ metre
4.3 Maillage
Un mailleur est un logiciel qui pour une géométrie en entrée crée un maillage et génère une
table de connectivité et une table de coordonnées du maillage. L’étape du maillage consiste donc à
générer ces deux tables.
La table de coordonnées permet de connaitre les coordonnées du noeud i du maillage.
Noeud 1 →  x1 y1 z1 
Noeud 2 →  x2 y2 z2 
..  .
 . .. .. 
.  . . .
coor = Noeud i → 
 xi yi zi 

..  .
 . .. .. 

. . . .
Noeud n → xn yn zn
La table de connectivité permet, pour un élément i, de savoir comment sont appelés dans le
système global chacun de ces noeuds
16 3
12
Element i
28
6
Element 1 →  1 2 3 
Element 2 → 24 12 3 
.. .
. .. ..

. . . .
connec = Element i → 
28 6 12 

.. .
. .. .. 

. . . .
Element n → 56 58 123
Ces deux tables suffisent à définir complètement le maillage.

Dans notre cas, nous choisissons de numéroter comme suit :
Elements 1 2 3 4 5
b b b b b b
Noeuds 1 2 3 4 5 6
Pour ne nombre d’éléments, il y a donc ne + 1 nombre de noeuds.
La suite cherche donc à générer de manière automatique ces tables pour notre problème.
4.3.1 Table de coordonnées

Dans notre cas, le problème est à une dimension. Une coordonnée d’un noeud est donc uni-
quement sa distance algébrique à l’origine. dans le cas où ne=5 et L=1, la table de coordonnées
est :  
0.0
0.2
 
0.4
coor = 0.6

 
0.8
1.0
La table est de taille (ne+1,1). Le plus simple est de partir d’une table de la bonne dimension
remplie de 0 puis de la remplir case par case. Pour l’initialiser, on utilise la fonction np.zeros qui
remplit exactement ce but. Pour lui indiquer la taille de la matrice à créer :
1 # Maillage
2 # G e n e r a t i o n de l a t a b l e c o o r
3 c o o r=np . z e r o s ( ( ne +1 ,1) ) # I n i t i a l i s a t i o n
Pour ceux qui ont l’habitude de matlab, la différence est qu’il faut rajouter une paire de paren-
thèse. En effet, np.zeros ne prend qu’un seul paramètre.
Il faut maintenant peupler le vecteur qui pour l’instant est vide. Pour s’en convaincre, exécuter
le script puis taper dans la console :
1 print coor
Le plus simple pour remplir le vecteur est de parcourir les noeuds, et de remplir leur coordonnée
dans le vecteur. Il faut donc parcourir ne+1 éléments, il est tout indiqué d’utiliser une boucle for
qui aura ne+1 itérations, une pour chaque noeud. On cherche à faire prendre à une variable i les
valeurs 1,2,3,...,ne+1. Nous irons insérer dans la i-ème case du vecteur la valeur i−1
ne L
Pour générer une liste de valeur, on utilise la fonction range. Dans le terminal taper :
1 r a ng e ( ne+1)
Python répond :
[0, 1, 2, 3, 4, 5]
Or dans notre programme ne vaut 5 et nous voulions avoir la réponse :
[1, 2, 3, 4, 5, 6]
En fait, Python à le mauvais goût, comme le C++ et d’autres langages, de compter à partir de
0, question de conventions.
De la même manière ,pour accéder à la i-ème valeur du vecteur on appellera donc coor[i,0], 0 signi-
fiant la première colonne.
La syntaxe de la boucle for en Python est la suivante :

1 fo r variable in p o s s i b i l i t e s :
2 action 1
3 action 2
4 ...
5 action n
6 a c t i o n en d e h o r s de l a b o u c l e
Notez bien les deux points " :" après avoir déclaré la condition de parcours des valeurs. Pour
délimiter les actions qui vont être exécutés à chaque itération, il est obligatoire d’indenter (décaler
vers la droite) le code. Pour cela il suffit d’appuyer sur la touche [TAB].
Nous voulions insérer dans la i-ème case la valeur i−1

ne L, si i allait de 1 à ne+1. Or pour Python,
i
i va de 0 à ne. Il faut alors insérer la valeur ne L dans le vecteur (on a décalé de +1)
La boucle for qui fait prendre à une variable i ces valeurs s’écrit :
1 f o r i i n r a ng e ( ne+1) :
2 c o o r [ i , 0 ] = ( f l o a t ( i ) / ( ne ) ) ∗L
Pour calculer la valeur à insérer dans la i-ème case,on doit se servir de la valeur de i qui est un
entier pour le diviser. Le problème est que pour Python, la division d’un entier donne un entier
(division euclidienne). Pour le forcer à considérer i comme un réel, on lui convertit explicitement i
en réel en appellant float(i).
4.3.2 Table de connectivité

La table de connectivité se génère en parcourant les éléments cette fois et en listant le numéro
des noeuds de l’élément dans le système global.
1 # G e n e r a t i o n de l a t a b l e co nnec
2 co nnec=np . z e r o s ( ( ne , 2 ) )
3 f o r i i n r a ng e ( ne ) :
4 co nnec [ i , 0 ] = i +1
5 co nnec [ i , 1 ] = i +2
4.4 Assemblage
Cette étape consiste à créer la matrice de rigidité et le vecteur force. Comme précedemment,
on les initialise de la bonne taille à zéro puis on vient les remplir par les contributions de chaque
élément.
1 K=np . z e r o s ( ( ne +1 , ne+1) )
2 F=np . z e r o s ( ( ne +1 ,1) )
On itère ensuite sur chaque élément grâce à une boucle for. On génère pour chaque élément sa
matrice de rigidité élémentaire, dans notre cas de taille (2,2). lors de l’assemblage, on "éclate" la
matrice élémentaire entre n1 et n2 , qui sont les numéros des noeuds de l’élément dans le système
global, information que l’on trouve dans la table de connectivité.

n1 n2
 

Ke11 Ke12

ES

1 −1
 Ke11 Ke12  n1
Ke = = K = K + 
Ke21 Ke22 L −1 1 



Ke21 Ke22 n2
La première chose à faire dans la boucle est de récupérer ces nombres n1 et n2 dans la table de
connectivité, qui sont rangés à la ligne i.
1 # Assemblage
2 K=np . z e r o s ( ( ne +1 , ne+1) )
3 F=np . z e r o s ( ( ne +1 ,1) )
5 n1=co nnec [ i , 0 ]
6 n2=co nnec [ i , 1 ]
On calcule ensuite la matrice de rigidité. Le seul paramètre qui change d’une matrice à l’autre
est la longueur l de l’élément. Il faut la calculer, en allant chercher pour cela les coordonnées des
noeuds de l’élément.
Comme Python compte à partir de 0, on décale nos valeurs de −1. Par exemple, au lieu d’assi-
gner K[n1, n1] comme on le ferait sous matlab, on est obligés d’écrire K[n1 − 1, n1 − 1].
Pour l’assemblage de la force ponctuelle, chaque noeud reçoit la moitié de la force totale subie
par la force surfacique.
1 # Assemblage
2 K=np . z e r o s ( ( ne +1 , ne+1) )
3 F=np . z e r o s ( ( ne +1 ,1) )
5 n1=co nnec [ i , 0 ]
6 n2=co nnec [ i , 1 ]
7 l=abs ( c o o r [ n1 −1 ,0] − c o o r [ n2 − 1 , 0 ] )
8 Ke=E∗S/ l ∗np . a r r a y ( [ [ 1 , − 1 ] , [ − 1 , 1 ] ] )
9 K[ n1 −1 ,n1−1]+=Ke [ 0 , 0 ]
10 K[ n2 −1 ,n1−1]+=Ke [ 1 , 0 ]
11 K[ n1 −1 ,n2−1]+=Ke [ 0 , 1 ]
12 K[ n2 −1 ,n2−1]+=Ke [ 1 , 1 ]
13 F [ n1 −1]+=0.5∗ f l
14 F [ n2 −1]+=0.5∗ f l
Remarquez que la syntaxe de Python pour incrémenter une variable selon le schéma a = a + b
s’écrit a+ = b, ce qui permet une ecriture plus compacte.
Il ne faut pas oublier d’aditionner la contribution de la force ponctuelle, qui s’ajoute au dernier
noeud.
1 # Ajout de l a f o r c e p o n t c u e l l e
2 F [ ne]+=Fp
4.5 Prise en compte des conditions limites

Il faut maintenant imposer le déplacement à certains noeuds. On sépare, quitte à réorganiser la
matrice de rigidité les déplacements connus uc et inconnus ui . Le problème s’écrit alors :

Kii Kic ui Fi
=
Kci Kcc uc Fc
Si on ne garde que la première ligne du système :
Kii ui + Kic uc = Fi
D’où :
ui = Kii−1 (Fi − Kic uc )
Dans notre exemple, uc est réduit à un seul élément, u1 , déplacement du premier noeud et égal
à 0. Dans ce cas particulier, l’expression devient :
ui = Kii−1 (Fi )
Pour obtenir Kii , il faut supprimer la première ligne et première colonne de K et pour Fi , sup-
primer le premier élément de F . Ceci s’écrit grâce à la fonction np.delete. Elle prend respectivement
comme paramètre :
– la matrice ou le vecteur à partir duquel la fonction va travailler
– la place de l’élément à supprimer. Ici les premières lignes ou colonnes donc 1, donc 0 en
convention Python
– 0 si c’est une ligne à supprimer, 1 si c’est une colonne
Il est important de remarquer que la fonction ne modifie pas la matrice ou le vecteur passé en
paramètre. Elle le copie, effectue les opération demandées et renvoie le résultat. C’est pour cela
qu’il faut assigner ce résultat :
1 # P r i s e en compte des CL
2 K i i=np . d e l e t e (K, 0 , 0 )
3 K i i=np . d e l e t e ( K ii , 0 , 1 )
4 Fi=np . d e l e t e (F , 0 , 0 )
Cette série d’instruction réalise :
– copier K et supprimer dans cette copie la première ligne. Assigner le résultat dans une nouvelle
variable Kii . Il faut remarquer que K n’a donc pas été modifié !
– copier Kii , supprimer dans cette copie la première colonne. Assigner le résultat dans Kii pour
le mettre à jour
– copier F , supprimer dans cette copie la. Assigner le résultat dans Fi pour le mettre à jour
4.6 Vérification de la construction des matrices et vecteurs

Nous avons effectué des opérations relativement complexes sur des matrices et vecteurs, et on
peut rapidement se tromper surtout quand on débute dans un nouveau langage. Pour vérifier les
opérations effectuées, on peut vouloir afficher une matrice ou un vecteur par exemple Kii . La
manière simple est de taper dans la console ou d’écrire à la fin du script :
1 print Kii
La réponse en console est du genre :
[[ 2.00000000e+10 -1.00000000e+10 0.00000000e+00 0.00000000e+00

0.00000000e+00]
[ -1.00000000e+10 2.00000000e+10 -1.00000000e+10 0.00000000e+00
0.00000000e+00]
[ 0.00000000e+00 -1.00000000e+10 2.00000000e+10 -1.00000000e+10
0.00000000e+00]
[ 0.00000000e+00 0.00000000e+00 -1.00000000e+10 2.00000000e+10
-1.00000000e+10]
[ 0.00000000e+00 0.00000000e+00 0.00000000e+00 -1.00000000e+10
1.00000000e+10]]
Ce qui n’est pas très visuel. Si vous changez en haut du script ne=20 par exemple, le résulat
sera une bouillie de nombres...
C’est pourquoi je vous propose de taper ces lignes après les opérations sur Kii notamment :
1 plt . figure ()
2 plt . pcolor ( Kii )
3 plt . gca ( ) . i n v e r t _ y a x i s ( )
4 plt . colorbar ()
Vous avez alors une visualisation de la matrice, les nombres étant transformés en couleurs.
4.7 Résolution de système linéaire

Finalement, la résolution du système linéaire tient en une seule ligne :
1 u i=l g . s o l v e ( K ii , Fi )
4.8 Post-traitement
Nous avons obtenu les ui par calcul. Il faut maintenant réintégrer les uc pour former u :
1 u=np . i n s e r t ( ui , 0 , 0 )
2 p l t . p l o t ( co o r , u )
L’instruction plot permet de tracer la courbe, en prenant le premier vecteur comme valeurs sur x,
le deuxième sur y.
Nous obtenons alors le déplacement on fonction de la coordonnée des noeuds.

Maintenant que l’on a un code élément finis qui donne des résultats qui semblent cohérents, on
cherche à comparer le déplacement obtenu avec le déplacement analytique. En effet, en program-
mation, il est obligatoire de vérifier le bon fonctionnement du code en essayant sur un cas test
dont on connait à l’avance le résultat.
L’équation 1 permet la résolution de l’effort normal :
N (x) = −f x + c1
Or en bout de poutre, N (L) = F , d’où
N (x) = F (l − x)
La relation de comportement (eq. 2) nous donne le déplacement :
1 f (L − x)2
u(x) = (F x − + c2 )
ES 2
Or u(0)=0, d’où :
1 x2
u(x) = (F x + f Lx − f )
ES 2
Nous voulons donc tracer sur un même graphique le déplacement élément fini et le déplacement
analytique. Nous n’allons pas tracer cette fonction de manière exacte, nous allons l’évaluer en un
certain nombre de points. Pour cela on se donne pour x un nombre fini de valeurs grâce à la fonction
linspace, qui retourne un vecteur de valeurs régulièrement espacées en donnant la valeur de début,
de fin et le nombre de valeurs.
1 x=np . l i n s p a c e ( 0 , L , num=100)
Nous pouvons alors écrire la formule de uth en utilisant le x ainsi défini. On le trace en superpo-
sition avec la solution élément fini avec une légende pour distinguer les deux courbes avec le code
suivant :
1 uth =1/(E∗S ) ∗ ( ( Fp+ f l ∗L) ∗x− f l ∗np . s q u a r e ( x ) / 2 )
2
3 plt . figure ()
4 p l t . p l o t ( co o r , u , x , uth )
5 l e g e n d ( ( ’ Deplacement EF ’ , ’ Deplacement a n a l y t i q u e ’ ) , l o c =2)
Il n’est pas possible de mettre tous les éléments d’un vecteur au carré en tappant x2̂ comme cela
se fait pour les réels. On utilise alors la fonction np.square
Les deux courbes se superposent, on valide ainsi le calcul élément fini. On peut remarquer que
le résultat est exact à l’endroit ou sont positionnés les noeuds. Entre ceux-ci, on a postulé avec l’ap-
proximation élément fini que le déplacement était linéaire, or la résolution analytique nous montre
qu’elle est quadratique. On ne peut donc pas représenter convenablement entre les noeuds la solu-
tion.
Le code ainsi créé est une suite d’instructions simples qui travaillent directement sur les variables
pour arriver au résultat. Cette technique de programmation est intuitive mais devient rapidement
complexe lorsque l’on veut empiler les fonctionnalités. Nous pourrions par exemple vouloir que
l’utilisateur puisse définir de manière plus complexe le chargement ou les conditions aux limites.
Nous présenterons dans un autre cours une manière différente d’envisager la manière de coder pour
permettre d’avoir un code bien plus maintenable et modulaire.

Python Ef

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Python Ef

Hochgeladen von

Copyright:

Verfügbare Formate

Sciences-industrielles.

Python scientifique : application aux

Table des matières

2 Premiers pas sur Python, utilisation de Spyder 3

3 Résolution élément fini pour une poutre en traction 5

1.2 Sous Linux

1.3 Sous Windows

2 Premiers pas sur Python, utilisation de Spyder

Ajoutez la ligne suivante à la fin de votre fichier :

3 Résolution élément fini pour une poutre en traction

3.1.2 Rappels sur la résolution élément finis

noeud i-1 noeud i noeud i+1

On peut montrer que la construction de ces opérateurs peut se décomposer en l’addition de

4.1 Chargement des paquets

Nous allons utiliser :

array([[ 1., 0., 0.],

Les autres paquets à inclure sont des sous-paquets. Pour cela :

4.2 Mise en données

générer ces deux tables.

La table de coordonnées permet de connaitre les coordonnées du noeud i du maillage.

Ces deux tables suffisent à définir complètement le maillage.

4.3.1 Table de coordonnées

La syntaxe de la boucle for en Python est la suivante :

Nous voulions insérer dans la i-ème case la valeur i−1

4.3.2 Table de connectivité

global, information que l’on trouve dans la table de connectivité.

4.5 Prise en compte des conditions limites

4.6 Vérification de la construction des matrices et vecteurs

[[ 2.00000000e+10 -1.00000000e+10 0.00000000e+00 0.00000000e+00

4.7 Résolution de système linéaire

Nous obtenons alors le déplacement on fonction de la coordonnée des noeuds.

L’équation 1 permet la résolution de l’effort normal :

La relation de comportement (eq. 2) nous donne le déplacement :

Das könnte Ihnen auch gefallen