Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

I). Introduction
MATLAB est un logiciel interactif basé sur le calcul matriciel (MATrix LABoratory). Il est utilisé
dans les calculs scientifiques et les problèmes d’ingénierie parce qu’il permet de résoudre des
problèmes numériques complexes en moins de temps requis par les langages de programmation
courant, et ce grâce à une multitude de fonctions intégrées et à plusieurs programmes outils testés et
regroupés selon usage dans des dossiers appelés boites à outils ou "toolbox".
Le calcul par éléments finis nécessite le maniement de nombreuses valeurs numériques, il est plus
aisé d’exprimer celles-ci sous forme matricielle. En regroupant des termes de même nature au sein
d’une seule et même variable, cette écriture plus synthétique permet en effet une meilleure
compréhension des différentes phases de construction de la méthode. Ceci nécessite néanmoins la
maitrise des opérations de base associées à ce type de calcul : l’addition ou le produit de plusieurs
matrices de grandes dimensions, la résolution de systèmes linéaires, …etc
Pour ce fait, on propose de faire un code de calcul sous MATLAB, basé sur ce qu’on a appris en cours
pour calculer la matrice de rigidité d’un élément quadrilatère à 4 nœuds.

Buts de T.P :

 Réaliser un programme sous matlab permettant la formation de la matrice de rigidité

élémentaire d’un élément quadrilatère ;
 Avoir une idée sur comment les logiciels de calcul MEF fonctionnent.

II). Travail

1. Sous-programme de calcul des fonctions d’interpolation N

< 𝑵(𝒙, 𝒚, 𝒛) > = < 𝑷(𝒙, 𝒚, 𝒛) > [𝑷𝒏 ]−𝟏

Tel que : p(x,y,z) est la base polynomiale correspondante à ce type d’éléments

< 𝑷(𝒙, 𝒚, 𝒛) > = < 𝟏 𝒙 𝒚 𝒙𝒚 >

𝟏 𝒙𝟏 𝒚𝟏 𝒙𝟏𝒚𝟏
𝟏 𝒙𝟐 𝒚𝟐 𝒙𝟐𝒚𝟐
Et [𝑷𝒏 ] = [ ]
𝟏 𝒙𝟑 𝒚𝟑 𝒙𝟑𝒚𝟑
𝟏 𝒙𝟒 𝒚𝟒 𝒙𝟒𝒚𝟒

1
Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

Le code de calcul :

clear all
clc
syms x y x1 y1 x2 y2 x3 y3 x4 y4 E v t real %définir les variables
comme étant des réels
disp('ce programme a pour but de former la matrice de rigidité élémentaire
d un élément quadrilatère')
disp('---------------------------------------------')
disp('la première partie est le calcul des fonctions d interpolation')
p=[1 x y x*y] % p(x,y) est la base polynomiale pas complète pour un élément
quadrilatére dans le domaine 2D
disp('l expression symbolique est:')
Pn=[1 x1 y1 x1*y1; 1 x2 y2 x2*y2; 1 x3 y3 x3*y3; 1 x4 y4 x4*y4]; %tant
qu'on a un élément quadrilatère à 4 noeuds, la matrice Pn va etre d'une
dimesnsion (4*4)
invPn=inv(Pn) % On inverse la matrice Pn pour calculer les fonctions de
forme.
N=simple(p*invPn); % N sont les fonctions d'interpolation.
disp('les expressions symboliques des fonctions de forme des 4 noeuds:')
N1=N(1,1)
N2=N(1,2)
N3=N(1,3)
N4=N(1,4)

Veuillez exécuter le programme pour voir les fonctions de forme car ses expressions sont très
longues.

2. Sous-programme de calcul de la matrice d’élasticité D

La matrice d’élasticité dans un problème de contraintes planes est :

𝟏 𝝂 𝟎
𝑬 𝝂 𝟏 𝟎
𝑫= 𝟐
[ 𝟏 − 𝝂]
𝟏−𝝂
𝟎 𝟎
𝟐
E : est le module de Young

ν : est le coefficient de Poisson

Le code de calcul :

disp('la matrice d élasticité pour le cas d un probleme en contraintes

planes en fonction de module de Young E et coefficient de poisson v est:')
D=simple((E/((1+v)*(1-v)))*[1 v 0;v 1 0;0 0 1-v]) % E c'est le module de
Young et v c'est le coefficient de poisson

2
Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

3. Calcul de la matrice B
𝜹
𝟎
𝜹𝒙
𝜹
𝐁= 𝟎 ∗< 𝑵(𝒙, 𝒚, 𝒛) >
𝜹𝒚
𝟏 𝜹 𝟏 𝜹
[𝟐 𝜹𝒚 𝟐 𝜹𝒙]
Le code de calcul :
B=simple([diff(N1,x) 0 diff(N2,x) 0 diff(N3,x) 0 diff(N4,x) 0; 0 diff(N1,y)
0 diff(N2,y) 0 diff(N3,y) 0 diff(N4,y); diff(N1,y)*1/2 diff(N1,x)*1/2
diff(N2,y)*1/2 diff(N2,x)*1/2 diff(N3,y)*1/2 diff(N3,x)*1/2 diff(N4,y)*1/2
diff(N4,x)*1/2])

Veuillez, S.V.P, exécuter le programme pour voir la matrice B car son expression est très longue.

4. Formation de la matrice de rigidité élémentaire k

𝒌 = ∬ 𝑩𝒕 . 𝑫. 𝑩. 𝒕 𝒅𝒙𝒅𝒚
Le code de calcul :
disp('avant l''intégration:')
k_av=(B'*D*B*t) %soit k_av la matrice avant l'intégration et t l'épaisseur

disp('après l''intégration')
k=(int(int(k_av,x),y)) %k est la matrice de rigidité élémentaire pour un
élément quadrilatère

Veuillez, S.V.P, enlever le signe « % » pour pouvoir voir les expressions symboliques des matrices
de rigidité car le temps que matlab prend pour calculer est énorme !

5. Etude de cas

 Cas 1 :
La forme de l’élément :
disp('la forme de cet élément est illustrée sur la figure:')
axis([-10 10 -10 10]); % ici on a défini l'espace que l'élément 1 occupe
tel que x=[xmin xmax]=[-10 10] et y=[ymin ymax]=[-10 10]
X=[-10 10 10 -10]; % le vecteur X définit l'ensemble des abcsisses de
l'élément 1
Y=[-10 -10 10 10]; % le vecteur Y définit l'ensemble des ordonnés de
l'élément 1
subplot(1,2,1) % mettre la figure qui représente l'élément 1 dans
la première case
patch(X,Y,'w') % patch a pour but de créer un polygone à partir
des vecteurs X et Y et 'w' représente la couleur de remplpissage de ce
polygone, dans ce cas w=white=blanc
title('élément 1')
grid('on') % grid a pour but de créer un grillage

3
Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

Calcul des fonctions de forme :

disp('calcul des fonctions d interpolation')
Nc1=simple(subs(N, {[x1, y1, x2, y2, x3, y3, x4, y4]}, {[-10, -10, 10, -10,
10, 10, -10, 10]})) % Nc1 est la matrice des fonctions d'interpolation pour
le cas 1
disp('les expressions des fonctions de forme des 4 noeuds:') %Nc1_i
représentent les fonctions d'interpolation pour chaque noeud i dans le cas
1
Nc1_1=Nc1(1,1)
Nc1_2=Nc1(1,2)
Nc1_3=Nc1(1,3)
Nc1_4=Nc1(1,4)

Nc1_1 = ((x - 10)*(y - 10))/400

Nc1_2 = -((x + 10)*(y - 10))/400

Nc1_3 = ((x + 10)*(y + 10))/400

Nc1_4 = -((x - 10)*(y + 10))/400

La matrice d’élasticité D :
D1=simple(subs(D,{[E, v]},{[210000, 0.3]})); % matrice d'élasticité pour
le cas 1

Calcul de la matrice de déformation B :

disp('calcul de la matrice B1')
B1=simple([diff(Nc1_1,x) 0 diff(Nc1_2,x) 0 diff(Nc1_3,x) 0 diff(Nc1_4,x) 0;
0 diff(Nc1_1,y) 0 diff(Nc1_2,y) 0 diff(Nc1_3,y) 0 diff(Nc1_4,y);
diff(Nc1_1,y)*1/2 diff(Nc1_1,x)*1/2 diff(Nc1_2,y)*1/2 diff(Nc1_2,x)*1/2
diff(Nc1_3,y)*1/2 diff(Nc1_3,x)*1/2 diff(Nc1_4,y)*1/2 diff(Nc1_4,x)*1/2])

4
Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

Veuillez, S.V.P, exécuter le programme pour voir la matrice B car son expression est très longue.

La matrice de rigidité élémentaire k :

disp('formation de la matrice de rigidité élémentaire k pour le cas 1')
k1_av=(B1'*D1*B1*2);
k1=vpa(simple(int(int(k1_av,x,-10,10),y,-10,10))) % vpa a pour but de
rendre les valeurs sous forme numérique (sans vpa les valeurs sont sous
forme d'une fraction)

Veuillez, S.V.P, exécuter le programme pour voir la matrice k car son expression est très longue.

 Cas 2 :
La forme de l’élément :
disp('la forme de cet élément est illustrée sur la figure:')
axis([-12 10 -8 10]); % ici on a défini l'espace que l'élément 2 occupe
tel que x=[xmin xmax]=[-12 10] et y=[ymin ymax]=[-8 10]
X=[-12 5 10 -10]; % le vecteur X définit l'ensemble des abcsisses de
l'élément 2
Y=[-8 -7 10 6]; % le vecteur Y définit l'ensemble des ordonnés de
l'élément 2
subplot(1,2,2) % mettre la figure qui représente l'élément 2 dans
la deuxième case
patch(X,Y,'w') % patch a pour but de créer un polygone à partir
des vecteurs X et Y et 'w' représente la couleur de remplpissage de ce
polygone, dans ce cas w=white=blanc
title('élément 2')
grid('on') % grid a pour but de créer un grillage

Calcul des fonctions de forme :

disp('calcul des fonctions d interpolation')
Nc2=simple(subs(N, {[x1, y1, x2, y2, x3, y3, x4, y4]}, {[-12, -8, 5, -7,
10, 10, -10, 6]})) % Nc2 est la matrice des fonctions d'interpolation pour
le cas 2

5
Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

disp('les expressions des fonctions de forme des 4 noeuds:') %Nc2_i

représentent les fonctions d'interpolation pour chaque noeud i dans le cas
2
Nc2_1=Nc2(1,1)
Nc2_2=Nc2(1,2)
Nc2_3=Nc2(1,3)
Nc2_4=Nc2(1,4)

Nc2_1 =(4*x*y)/1011 - (95*y)/4044 - (109*x)/4044 + 110/1011

Nc2_2 =(179*x)/5055 - (43*y)/1011 - (17*x*y)/5055 + 412/1011

Nc2_3 =(839*x)/40440 + (239*y)/8088 + (59*x*y)/20220 + 415/2022

Nc2_4 =(295*y)/8088 - (1181*x)/40440 - (71*x*y)/20220 + 563/2022

La matrice d’élasticité D :

D2=simple(subs(D,{[E, v]},{[210000, 0.3]})) % matrice d'élasticité pour le

cas 2

Calcul de la matrice de déformation B :

disp('calcul de la matrice B2')

B2=simple([diff(Nc2_1,x) 0 diff(Nc2_2,x) 0 diff(Nc2_3,x) 0 diff(Nc2_4,x) 0;
0 diff(Nc2_1,y) 0 diff(Nc2_2,y) 0 diff(Nc2_3,y) 0 diff(Nc2_4,y);
diff(Nc2_1,y)*1/2 diff(Nc2_1,x)*1/2 diff(Nc2_2,y)*1/2 diff(Nc2_2,x)*1/2
diff(Nc2_3,y)*1/2 diff(Nc2_3,x)*1/2 diff(Nc2_4,y)*1/2 diff(Nc2_4,x)*1/2])

Veuillez, S.V.P, exécuter le programme pour voir la matrice B car son expression est très
longue.

La matrice de rigidité élémentaire k :

disp('formation de la matrice de rigidité élémentaire k pour le cas 2')

k2_av=B2'*D2*B2*1;

disp('on doit définir les bornes de l intervalle qui sont des droites:')
disp('on définit les bornes pour l axe y')
disp('pour la borne inférieure')
X1=[-12 5];
Y1=[-8 -7];
y1=polyfit(X1,Y1,1)*[x;1]; % polyfit a pour but de trouver les
constantes a et b pour écrire l'équation d'une droite

disp('pour la borne supérieure')

X2=[10 -10];
Y2=[10 6 ];
y2=polyfit(X2,Y2,1)*[x;1]

disp('on définit les bornes pour l axe x')

disp('pour la borne à gauche')
X3=[-12 -10];
Y3=[-8 6];
y3=polyfit(X3,Y3,1)*[x;1]

disp('pour la borne à droite')

6
Réalisation d’un programme de calcul de la matrice de rigidité d’un élément quadrilatère TP-3_BERBRI

X4=[5 10];
Y4=[-7 10];
y4=polyfit(X4,Y4,1)*[x;1]

%maintenant , on évalue les fonctions y1, y2, y3, y4 en fonction de x pour

pouvoir intégrer ==>quand on trace ces fonctions, chacune sur sa domaine de
définition, on obtient l'élément 2.
for t=-12:0.01:10 % t représente les valeurs des abscisses
if (t>=-12 && t<=5) % ici on définit le domaine de définition pour
la droite y1
y1=subs(polyfit(X1,Y1,1)*[x;1],x,t) ; % polyfit a pour but
de trouver les constantes a et b pour écrire l'équation d'une droite
else
y1=0;
end

if (t>=-10 && t<=10) % ici on définit le domaine de définition

pour la droite y2
y2=subs(polyfit(X2,Y2,1)*[x;1],x,t) ;
else
y2=0;
end

if (t>=-12 && t<=-10) % ici on définit le domaine de définition

pour la droite y3
y3=subs(polyfit(X3,Y3,1)*[x;1],x,t) ;
else
y3=0;
end

if (t>=5 && t<=10) % ici on définit le domaine de définition pour

la droite y4
y4=subs(polyfit(X4,Y4,1)*[x;1],x,t) ;
else
y4=0;
end
end
k2=vpa(simple(int(int(k2_av,x,y3,y4),y,y1,y2)))

Veuillez, S.V.P, exécuter le programme pour voir la matrice k car son expression est très longue.

Conclusion
Dans ce T.P. on a pu créer un code de calcul Mef pour un élément quadrilatère à 4 nœuds dont le
calcul a pris un temps énorme à cause des opérations mathématiques complexes comme la dérivation
et l’intégral. On propose d’utiliser les méthodes numériques couramment utilisées dans le calcul MEF,
comme la méthode de Gauss, pour éviter le temps énorme que le processeur prend au traitement de
programme.