Devoir de maison :

Méthode des Eléments

Finis

UNSTIM-ENSTP-1

Groupe N° 3

Membres du groupe : Professeur :

Beaugrand LOKOSSOU GBAGUIDI Thomas Brice

Christian BOTON
Harrison KASSIN

Année Universitaire : 2019-2020

 Exercice1
1–
 Programme permettant de résoudre les équations différentielles de degré
1 et de degré 2. Les programmes principaux des questions 1 et 2 sont
réunis dans le code ci-|dessous :
%Programme principal
%Application
clc;
clear all;
disp('Programme pour la résolution des équations différentielles
');fprintf('\n');
disp('Ce programme permet d''avoir directement les solutions des
applications des questions 1 et 2');
disp('et également de résoudre n''importe quelle équation différentielle
du 1er ou du 2e ordre.');fprintf('\n');
disp('Faites donc un choix: Voulez-vous avoir les solutions des
appilcations de l''exercice ?');
de= input('Si oui taper 1 | Si vous voulez résoudre une équation
différentielle du 1er ou du 2e ordre taper 0\nDécision = ');
if de==1
Resultat_1;
elseif e==2
Resultat_2;
end
else
% Intervalle ]a,b]
fprintf('\n');
disp('Suivez donc les instructions ci-après pour la résolution de votre
équation différentielle qu''elle soit de degré 1 ou 2:');fprintf('\n');
disp('***************** Intervalle [x0, xn]
**********************************************');fprintf('\n');
x0 = input('Entrer la borne inferieure de l''intervale : \nx0=');
xn = input('Entrer la borne supérieure de l''intervale : \nxn=');
disp('____________ Degre
_________________________________________________________________');
d = input ('\nEntrer le degré de l''équation diff : \nd=');
disp('******************************************************************
******************');
if d==1
disp('Equation différentielle d''ordre 1 de la forme
dy/dx+alpha(x)y+beta(x)=0 \n');
disp('avec y(a)=y0 sur l''intervalle ]a,b] ');
% Les fonctions alpha(x) et beta(x)
disp('********* Fonctions d''entrées
*****************************************************');
alpha = input('Entrer la fonction alpha(x): \nalpha(x)=');
beta = input('Entrer la fonction beta(x): \nbeta(x)=');
if x0==0
a=1e-20;
else
a=x0;
end

b=xn;
%condition aux limites
disp('******** Conditions initiales
******************************************************');
y0=input('Entrer la valeur de y(x0): \ny0=');
% Nombre de subdivision de l'intervalle [x0,xn] pour la MEF
disp('** Nombre de subdivision de l''intervalle [x0,xn] pour la MEF
**********************');
ne = input('Entrer le nombre d''éléments: \nne='); % Nombre d'élément
nn = input('Entrer le nombre de noeuds d''interpolation: \nnn='); %
Nombre de noeuds d'interpolation
% resolution du problème avec la fonction Ode1dO1
[X,Y]=Ode1dO1(alpha,beta,a,b,y0,ne,nn);
% X et Y sont des vecteurs représentant respectivement les noeuds de
% discrétisation et les approximations nodales.
% Affichage
fprintf(' \n Résultats : \n')
fprintf(' \n Noeuds de discretisation et Approximations nodales: \n\n
');
fprintf('n° \t \t \t \tx \t \t \t \t y(x) ');
for i=1:length(X)
if i < 10
fprintf(' \n %d \t \t \t \t%f \t \t \t %f ', i,X(i),Y(i));
else
fprintf(' \n %d \t \t \t%f \t \t \t %f ', i,X(i),Y(i));
end
end
fprintf('\n\n');
disp('***** Merci d''avoir utiliser notre programme
**************************************');
elseif d==2
disp('Equation différentielle d''ordre 2 de la forme
d^2u/dx^2+a(x)du/dx+b(x)u = c(x),');
disp('x appartenant à ]x0,xn] avec des conditions de Robin:');
disp('alpha1*u(x0)+beta1*u''(x0)=gama1');
disp('alpha2*u(xn)+beta2*u''(xn)=gama2 \n');
% Les fonctions a(x) et b(x)
disp('********* Fonctions d''entrées
*************************************************');
a = input('Entrer la fonction a(x): \na(x)=');
b = input('Entrer la fonction b(x): \nb(x)=');
c = input('Entrer la fonction c(x): \nc(x)=');
if x0==0
x0=1e-20;
end
% Nombre de subdivision de l'intervalle [x0,xn] pour la MEF
disp('** Nombre de subdivision de l''intervalle [x0,xn] pour la MEF
******************');
ne = input('Entrer le nombre d''éléments: \nne='); % Nombre
d'élément
nn = input('Entrer le nombre de noeuds d''interpolation: \nnn='); %
Nombre de noeuds d'interpolation
disp('***** Conditions initiales

*****************************************************');
y0=input('Entrer la valeur de y(x0): \ny0=');
alpha1=input('Entrer la valeur de alpha1: \nalpha1=');
beta1=input('Entrer la valeur de beta1: \nbeta1=');
gama1=input('Entrer la valeur de gama1: \ngama1=');
alpha2=input('Entrer la valeur de alpha2: \nalpha2=');
beta2=input('Entrer la valeur de beta2: \nbeta2=');
gama2=input ('Entrer la valeur de gama2: \ngama2=');
 % resolution du problème avec la fonction Ode1dO1
[X,Y]=Ode1dO2(a,b,c,x0,xn,y0,ne,nn);
% X et Y sont des vecteurs représentant respectivement les noeuds de
% discrétisation et les approximations nodales.
% Affichage
fprintf(' \n Résultats : \n')
fprintf(' \n Noeuds de discretisation et Approximations nodales \n ');
fprintf('N° \t \t \t \t x \t \t \t \t y(x) ');
for i=1:length(X)
if i < 10
fprintf(' \n %d \t \t \t \t%f \t \t \t %f ', i,X(i), Y(i));
else
fprintf(' \n %d \t \t \t%f \t \t \t %f ', i,X(i),Y(i));
end
end
fprintf('\n\n');
disp('***** Merci d''avoir utiliser notre programme

**************************************');

else
disp('Non pris en compte, Merci de reprendre avec des équations diff
d''ordre 1 ou 2');
end
end

 Code pour l’application de la question 1 avec 𝛼(𝑥) = 𝑥𝑙𝑛(𝑥), 𝛽(𝑥) = 0, 𝑎 = 0,

𝑏 = 1, 𝑦0=1 :
%Programme principal
%Application
clear all;
% Les fonctions a(t) et b(t)
alpha=@(t)(t*log(abs(t)));
beta=@(t)(0);
% Intervalle ]a,b]
a=1e-20; b=1;
%condition aux limites
y0=1;
% Nombre de subdivision de l'intervalle [x0,xn] pour la MEF
ne=15; % Nombre d'élément
nn=4; % Nombre de noeuds d'interpolation
% resolution du problème avec la fonction Ode1dO1
[X,Y]=Ode1dO1(alpha,beta,a,b,y0,ne,nn);
% X et Y sont des vecteurs représentant respectivement les noeuds de
% discrétisation et les approximations nodales.
% Affichage
fprintf(' \n Resultats : \n')
fprintf(' \n Noeuds de discretisation et Approximations nodales \n ');
disp(sprintf('n° \t \t \t \tx \t \t \t \t y(x) '));
for i=1:length(X)
disp(sprintf(' \n %d \t \t \t \t%f \t \t \t %f ', i,X(i),Y(i)));
else
disp(sprintf(' \n %d \t \t \t%f \t \t \t %f ', i,X(i),Y(i)));
end
end
 Code pour l’application de la question 2 avec 𝑎(𝑥) = 𝑥𝑙𝑛(𝑥),𝑏(𝑥) = 0,𝑐(𝑥) = 0,
𝑥0 = 0,𝑥𝑛 = 1, (𝛼1,𝛽1,𝛾1) = (1,1,1), (𝛼2,𝛽2,𝛾2) = (1,2,0).
%Programme principal
%Application
clear all;
% Les fonctions a(t) et b(t)
a=@(t)(t*log(abs(t)));
b=@(t)(0);
c=@(t)(0);
% Intervalle ]a,b]
x0=1e-20; xn=1;
%condition aux limites
y0=2;
% Nombre de subdivision de l'intervalle [x0,xn] pour la MEF
ne=30; % Nombre d'élément
nn=10; % Nombre de noeuds d'interpolation
% resolution du problème avec la fonction Ode1dO1
[x,y] = Ode1dO2(a,b,c,x0,xn,y0,ne,nn)
% X et Y sont des vecteurs représentant respectivement les noeuds de
% discrétisation et les approximations nodales.
% Affichage
fprintf(' \n Resultats : \n')
fprintf(' \n Noeuds de discretisation et Approximations nodales \n ');
disp(sprintf('n° \t \t \t \tx \t \t \t \t y(x) '));
for i=1:length(x)
if i < 10
disp(sprintf(' \n %d \t \t \t \t%f \t \t \t %f ', i,x(i),y(i)));
else
disp(sprintf(' \n %d \t \t \t%f \t \t \t %f ', i,x(i),y(i)));
end
end

Les différentes fonctions utlisées dans le code principal sont :

 Fonction dLagMEF
function [y] = dLagMEF(X,t)
%=========================================================
% Dérivée première des fonctions de forme de type Jacobi
% Auteur: GBAGUIDI Thomas Brice
%=========================================================
N=length(X);
y1=zeros(N,1);
for i=1:N
y1(i,1)=0;
for j=1:N
if j<i
Xj=X;
Xj(j)=[];
xx=LagMEF(Xj,t);
y1(i,1)=y1(i,1)+xx(i-1)/(X(i)-X(j));
elseif j>i
Xj=X;
Xj(j)=[];
xx=LagMEF(Xj,t);
y1(i,1)=y1(i,1)+xx(i)/(X(i)-X(j));
end
end
end
y=y1';
end
 Fonction integrale

function y = integrale( f,a,b,n )

%=======================================================================
% Fonction pour le calcul d'intégrale par la méthode des trapèzes
% Entrées :
% f: fonction à intégrer
% a, b: borne inférieure et borne supérieure respectivement
% n: nombre de subdivision de l'intervalle d'intégration
% Sortie : l'intégrale calculée
% Auteur : GBAGUIDI Brice
%=======================================================================
h=(b-a)/n;
x0=f(a);
s=x0;
x0=f(b);
s=(s+x0)/2;
x0=a;
for i=1:n-1
x0=x0+h;
s=s+f(x0);
end
y=s*h;
end

 Fonction LagMEF
function [ y ] = LagMEF( X,t )
%=========================================================
% Fonctions de forme de type Jacobi
% Auteur: GBAGUIDI Thomas Brice
%=========================================================
N=length(X);
y1=zeros(N,1);
for i=1:N
y1(i,1)=1;
for k=1:N
if k~=i
y1(i,1)=y1(i,1)*(t-X(k))/(X(i)-X(k));
end
end
end
y=y1';
end

 Fonction Ode1dO1
function [X,y] = Ode1dO1(alpha,beta,a,b,y0,ne,nn)
%=======================================================================
===
% Programme pour la résolution des équations de
% la forme dy/dx+alpha(x)y+beta(x)=0 avec y(a)=y0
% par la méthode des éléments finis sur
% l'intervalle ]a,b]
% Fonctions de forme: polynôme d'interpolation de Lagrange
%=======================================================================
===
% Nombre de subdivision de l'intervalle [a,b] pour la MEF
n=20;
 % Nombre de subdivision de l'intervalle [a,b] pour les intégrales
Nint=1000;
% Subdivision
X=linspace(a,b,n+1);
% La matrice Ke et le vecteur Fe
Ke=zeros(n+1,n+1); % Initialisation de Ke à 0
Fe=zeros(n+1,1); % Initialisation de Fe à 0
XX=zeros(nn+1,n-nn+1);
for i=1:n-nn+1
for jj=1:nn+1
XX(jj,i)=X(i+jj-1);
end

ke=@(t)(LagMEF(XX(:,i),t)'*(dLagMEF(XX(:,i),t)+alpha(t)*LagMEF(XX(:,i),t
)));
fe=@(t)(LagMEF(XX(:,i),t)'*beta(t));
intke=integrale(ke,XX(1,i),XX(nn+1,i),Nint);
intfe=integrale(fe,XX(1,i),XX(nn+1,i),Nint);
Ke(i:i+nn,i:i+nn)=Ke(i:i+nn,i:i+nn)+intke; % Assemblage de Ke
Fe(i:i+nn,1)=Fe(i:i+nn,1)+intfe; % Assemblage de Fe
end

 Fonction Ode1dO2
function [x,y] = Ode1dO2(a,b,c,x0,xn,y0,ne,nn)
%=======================================================================
===
% Programme pour la résolution des problèmes aux limites
% de la forme d^2y/dx^2+a(x)dy/dx+b(x)y = c(x), x appartenant à ]x0,xn]
% avec des conditions de Robin:
% alpha1*y(x0)+beta1*y'(x0)=gama1
% alpha2*y(xn)+beta2*y'(xn)=gama2
% par la méthode des éléments finis sur
% Fonctions de forme: polynôme d'interpolation de Lagrange
%=======================================================================
===
%condition aux limites
al1=1;
be1=1;
ga1=1;
al2=1;
be2=2;
ga2=0;
n=(nn-1)*ne; %pas
h=(xn-x0)/n;
% Nombre de subdivision de l'intervalle [x0,xn] pour les intégrales
Nint=1000;

% Subdivision
x=linspace(x0,xn,n+1);
% La matrice Ke, Fe et XX
Ke=zeros(n+1,n+1);
Fe=zeros(n+1,1);
XX=zeros(nn,ne);
for i=1:ne
k1=(i-1)*(nn-1)+1;
k2=(i-1)*(nn-1)+nn;
for jj=1:nn
XX(jj,i)=x(k1+jj-1);
end
 dNTdN=@(t)(dLagMEF(XX(:,i),t)'*dLagMEF(XX(:,i),t));
NTdN=@(t)(LagMEF(XX(:,i),t)'*dLagMEF(XX(:,i),t));
NTN=@(t)(LagMEF(XX(:,i),t)'*LagMEF(XX(:,i),t));
ke=@(t)(-dNTdN(t)+a(t)*NTdN(t)+b(t)*NTN(t));
fe=@(t)(LagMEF( XX(:,i),t )'* (c(t)));
intke=integrale(ke,XX(1,i),XX(nn,i),Nint);
intfe=integrale(fe,XX(1,i),XX(nn,i),Nint);
Ke(k1:k2,k1:k2)=Ke(k1:k2,k1:k2)+intke;
Fe(k1:k2,1)=Fe(k1:k2,1)+intfe;
end
K=Ke;
F=Fe;
test1=al1*h-be1;
test2=al2*h+be2;
if(test1==0)
y2=ga1*h/be1;
if(test2==0)
ynm1=-ga2*h/be2;
F=F-y2*Ke(:,2)-ynm1*Ke(:,n);
K(:,n-1)=[];
K(2,:)=[];
F(2)=[];
K(n-1,:)=[];
F(n-1)=[];
y=K\F;
y=[y(1);y2;y(2:n-2);ynm1;y(n-1)];
else
F=F-y2*Ke(:,2)-ga2*h/test2*Ke(:,n+1);
K(:,n)=K(:,n)+be2/test2*K(:,n+1);
K(:,2)=[];
K(:,n)=[];
K(2,:)=[];
F(2)=[];
K(n,:)=[];
F(n)=[];
y=K\F;
yn=(be2*y(end)+ga2*h)/test2;
y=[y(1);y2;y(2:n-1);yn];
end
else
if(test2==0)
ynm1=-ga2*h/be2;
F=F-ga1*h/test1*Ke(:,1)-ynm1*Ke(:,n);
K(:,2)=K(:,2)-be1/test1*K(:,1);
K(:,1)=[];
K(:,n-1)=[];
K(1,:)=[];
F(1)=[];
K(n-1,:)=[];
F(n-1)=[];
y=K\F;
y1=(-be1*y(1)+ga1*h)/test1;
y=[y1;y(1:n-2);ynm1;y(n-1)];
else
F=F-ga1*h/test1*Ke(:,1)-ga2*h/test2*Ke(:,n+1);
K(:,n)=K(:,n)+be2/test2*K(:,n+1);
K(:,2)=K(:,2)-be1/test1*K(:,1);
K(:,1)=[];
F(1)=[];
 K(n,:)=[];
F(n)=[];
y=K\F;
y1=(-be1*y(1)+ga1*h)/test1;
yn=(be2*y(n-1)+ga2*h)/test2;
y=[y1;y(1:n-1);yn];
end
end
%x=X;
%y=u;%Solution MEF
% Solution analytique
eq=@(x1,y1)[y1(2); -a(x1).*y1(2)-b(x1).*y1(1)-c(x1)];
[x1,y1] = ode45(eq, x, [1; 2]);% Resolution de l'equation diff
plot(x,y,'r',x1,y1(:,1)); % Représentation graphique de la solution
legend('Solution MEF','Solution exacte');
legend('Solution MEF','Solution analytique');
grid on ;
end

 Fonction RK4expSys
function [x,y]=RK4expSys(f,a,b,u,N)
%============================================================
% Cette fonction est un solveur de problème aux valeurs
% initiales de la forme: y’=f(x,y) avec les conditions
% initiales : y(a)=u.
%---------------------------
% o
% o y1'=f1(x,y1,y2,...,yn)
% o y2'=f2(x,y1,y2,...,yn)
% o .
% < .
% o .
% o .
% o yn'=fn(x,y1,y2,...,yn)
% o
%---------------------------
% Utilisation: [x,y]=RK4expSys(f,a,b,u,N)
%
% Description des arguments :
% f : fonction de x et y définissant les seconds membres
% du problème. Elle retourne un vecteur colonne de n composantes
% a : borne inférieure de l’intervalle de résolution
% b : borne supérieure de l’intervalle de résolution
% u : vecteur colonne définissant la condition y(a)=u
% n : nombre de subdivision n de l’intervalle [a,b]
%
% Sortie
% x : vecteur des abscisses de la solution du problème
% y : matrice des ordonnées de la solution du problème
% elle comporte un nombre de lignes égal au nombre
% d'équations: n et un nombre de colonnes égal au
% nombre de points: N+1
% Auteur: GBAGUIDI T. Brice
%===========================================================
%------Pas de subdivision
h=(b-a)/N ;
%------Récupération du nombre d'équations
n=size(u,1);
 %------Création du vecteur x et initialisation de y1
x=linspace(a,b,N+1) ;
y1=zeros(n,N+1) ;
%------Conditions initiales
y1(:,1)=u ;
%------Boucle pour le calcul de y1 et y2
for n=1:N
K1=h*f(x(n),y1(:,n));
K2=h*f(x(n)+h/2,y1(:,n)+K1/2);
K3=h*f(x(n)+h/2,y1(:,n)+K2/2);
K4=h*f(x(n)+h,y1(:,n)+K3);
y1(:,n+1)=y1(:,n)+(K1+2*K2+2*K3+K4)/6 ;
end
y=y1 ;
end

Exercice 2
Ecriture d’un script pour le calcul des structures planes treillis
(déplacements nodaux, réactions aux appuis, tensions dans les
poutrelles, allongement) par les éléments finis (linéaires).
 Le programme principal est le suivant :

clc;
clear all;
disp('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++');
disp('Ce progamme vous permet d''efectuer le calcul des structures
planes treillis (déplacements nodaux,');
disp('réactions aux appuis, tensions dans les poutrelles, allongement)
par les éléments finis (linéaires).');
disp('Il vous permet également de visualiser un exemple de determination
des paramètres cités plus haut');
disp('pour un élément barre comportant deux barres.');
disp('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++');fprintf('\n');
var=input('Tapez 1 pour effectuer le calcul d''une structure treillis de
votre choix ou 0 pour visualiser l''exemple.\nChoix:');fprintf('\n');
if var==1
trussfem('expl2barre');
else
trussfem('expl2barres');
end

Les sous programmes ayant servis à le réaliser sont :

 AddDOFs
function B=AddDOFs(A,L)
%=======================================================================
===
%B=AddDOFs(A,L)
% ajout des DDL des noeuds encastré
%=======================================================================
===
 L=sort(L);
b=length(L);
a=length(A);
B=ones(b+a,1);
for i=1:b
B(L(i),1)=0;
end
pos=1;
for i=1:b+a
if B(i,1)~=0
B(i,1)=A(pos);
pos=pos+1;
end
end
end

 DelDOFs

function A=DelDOFs(A,L)
%=======================================================================
===
% A = DelDOFs(A,L)
% A : matrice globale après assemblage
% L : liste des degrés de liberté à éliminer
%=======================================================================
===
L=sort(L); % tri de la liste des DDL
n=length(L); % longueur de L
if (size(A,2)==1) % cas d’un vecteur
for i=n:-1:1 % parcourir L à partir du plus grand indice
A(L(i))=[]; % suppression de la composante associée au DDL
courant
end
else % cas d’un matrice
for i=n:-1:1
A(L(i),:)=[]; % suppression de la ligne L(i)
A(:,L(i))=[]; % suppression de la colonne
end
end

 EltLen

function [ds,c,s] = EltLen(XY)

%===================================================
% [ds,c,s] = Getcosine(XY)
% Calcul la longueur de l’élément, cos et sin pour la matrice
% de rotation d’un élément barre à deux noeuds (x1,y1) (x2,y2)
% ds: longueur de l’élément
% c : cosinus de l'angle entre l’axe de l’élément et l’axe x
% s : sinus de l'angle
% XY: cordonnées des noeuds XY = [x1,y1; x2,y2]
%===================================================
dx = XY(2,1) - XY(1,1);
dy = XY(2,2) - XY(1,2);
ds = sqrt(dx^2 + dy^2);
 c = dx/ds;
s = dy/ds;
end

 expl2barre

function [t,p,e,A,E,rho,F] = expl2barre

%================================================
%================================================
ne = input('Entrer le nombre d''éléments: \nne=');
% Connectivité des éléments
disp('*** Connectivité de éléments
**************************************');
t=eye(ne,2);
for i=1:ne
fprintf('Pour l''élément barre " %d ", entrer \n',i);
t(i,1)=input('son noeud 1: ');
t(i,2)=input('son noeud 2: ');
end

nn = input('Entrer le nombre de noeuds total: \nnn=');

% Coordonnées des noeuds
disp('*** Coordonnées des noeuds
****************************************');
p=eye(nn,2);
for i=1:nn
fprintf('Entrer les coordonnées de noeud %d suivant \n',i);
p(i,1)=input('l''axe X: ');
p(i,2)=input('l''axe Y: ');
end

nenc = input('Entrer le nombre de noeuds d''encatrements: \nnnenc=');

%Noeuds d'encastrements
disp('*** Noeuds d''encastrements
***************************************');
e=eye(nenc,1);
for i=1:nenc
fprintf('Noeud d''encastrement %d \n',i);
e(i,1)=input('il s''agit du noeud: ');
end

disp('*** Section des éléments

******************************************');
A=eye(1,ne);
for i=1:ne
fprintf('Pour l''élément barre " %d ", A(%d) ',i,i);
A(1,i)=input('= ');
end
% A = [ ] ; % sections de chaque élément barre enrégistrée dans une
matrice A
disp('*** Modules d''élasticités des éléments
***************************');
E=eye(1,ne);
for i=1:ne
fprintf('Pour l''élément barre " %d ", E(%d) ',i,i);
E(1,i)=input('= ');
end
% E = [ ] ; % module d'élasticité de chaque élément barre enregistré
dans une matrice E
 disp('*** Masse volumique des éléments
***********************************');
rho=eye(1,ne);
for i=1:ne
fprintf('Pour l''élément barre " %d ", rho(%d) ',i,i);
rho(1,i)=input('= ');
end
%rho=[ ] ; % masse volumique de chaque élément barre

disp('*** Chargement de la structure

*************************************');
% Charge de la structure
F=eye(nn,1);
for i=1:nn
fprintf('Chargement du noeud %d (en N) suivant \n',i);
F(i,1)=input('l''axe X: ');
F(i+1,1)=input('l''axe Y: ');
end
% F = [ % noeud 1 non chargé (encastrement)
% % noeud 2 non chargé (encastrement)
% % noeud 3 chargé dans la direction verticale
%
% ];
end

 expl2barres

function [t,p,e,A,E,rho,F] = expl2barres

t = [1 3 % connectivité de l'élément 1
2 3]; % connectivité de l'élément 2
p = [ 0.0 0.6 % coordonnées du noeud 1
1.6 0.6 % coordonnées du noeud 2
0.8 0.0]; % coordonnées du noeud 3
e = [ 1; 2 % noeud d'encastrement 1
3; 4] ; % noeud d'encastrement 2

A = [1 1] * 25e-4; % sections des éléments barres

E = [1 1] * 210e9; % module d'élasticité des éléments

rho=[1 1] * 2800 ; % masse volumique 2800 kg/m3

F = [ 0; 0 % noeud 1 non chargé (encastrement)

0; 0 % noeud 2 non chargé (encastrement)
0; -3.4e6]; % noeud 3 chargé dans la direction verticale
end

 Localise

function L = Localise(t)
%================================================
% L = Localise(t)
% t : table de connectivités de l'élément
% L : table de localisation
%================================================
nne = length(t);
 for i= 1:nne
L([2*i-1 2*i]) = [2*t(i)-1 2*t(i)];
end
end

 plotmesh_

function plotmesh_(T,P, NodeLabels, EltLabels,color)

%================================================
%================================================
% plotmesh(T, P, NodeLabels, EltLabels, color)
% % T = Table des connectivités (fem.mesh.t)
% P = Table des coordonnées (fem.mesh.p)
% NodeLabels : vaut true pour afficher les éléments
% EltLabels : vaut true pour afficher les noeuds
% color : couleur des lignes
Net = size(T,1);
for ie = 1:Net
XY = P(T(ie,:),:);
X = [XY(:,1); XY(1,1)];
Y = [XY(:,2); XY(1,2)];
line(X,Y,'color',color)
if(EltLabels)
x = mean(XY(:,1));
y = mean(XY(:,2));
text(x,y,num2str(ie),'color','b')
end
end
if(NodeLabels)
Np = size(P,1);
for i=1:Np
text(P(i,1),P(i,2),num2str(i),'color','m')
end
end
end

 truss2DKe

function ke = truss2DKe(XY,A,E)
%==========================================================
% ke = truss2dKe(XY,A,E)
% Calcul de la matrice elementaire pour un
% élément barre à deux noeuds (x1,y1) (x2,y2)
% A : section de la barre
% E : module d'élasticité du matériau
% XY: cordonnées des noeuds XY = [x1,y1; x2,y2]
%
%==========================================================
[c,s,L] = EltLen(XY); % longueur et orientation de l’élément
cc = c*c; % cos(angle)^2
cs = c*s; % cos(angle)*sin(angle)
ss = s*s; % sin(angle)^2
ke = (A*E/L) * [ cc cs -cc -cs % matrice élémentaire Ke
cs ss -cs -ss
-cc -cs cc cs
-cs -ss cs ss ];
end % fin de fonction
 truss2dKM

function [K,M] = truss2dKM(t,p,A,E,rho)

%================================================
% [K,M] = truss2dKM(t,p,A, rho)
% K : matrice de rigidité assemblée
% M : matrice masse assemblée
% t : table de connectivités des éléments
% p : table des coordonnées des noeuds
% A : sections des éléments (des barres)
% E : modules d'élasticité en vecteur des éléments
% rho: masse volumique
%
%================================================
net = size(t,1); % nombre d’éléments total
nnt = 2*size(p,1); % nombre de noeuds total
K = sparse(nnt,nnt); % initialisation des matrices K et M
M = sparse(nnt,nnt); % par des matrices creuses nulles
for i = 1:net % début de boucle sur les éléments
ti = t(i,:); % tables de connectivité et de
Li = Localise(ti); % localisation de l’élément courant
Ke = truss2DKe(p(ti,:),A(i),E(i)); % matrices de rigidité
Me = truss2dMe(p(ti,:),A(i),rho(i)); % et masse élémentaires
K(Li,Li) = K(Li,Li) + Ke; % assemblage de la matrice K
M(Li,Li) = M(Li,Li) + Me; % assemblage de la matrice M
end % fin de boucle end % fin de fonction
end

 truss2dMe

function Me = truss2dMe(XY,A,rho)
%==========================================================
% Me = truss2dMe(XY,A,rho)
% Calcul de la matrice masse elementaire Me pour un
% élément barre à deux noeuds (x1,y1) (x2,y2)
% A : section de l'élément
% rho : masse volumique de l'élément
% XY : cordonnées des noeuds XY = [x1,y1; x2,y2]
%==========================================================
L = EltLen(XY);
Me = 0.5*rho*A*L*eye(4);
end % fin de fonction

 trussfem

function []= trussfem(ffd)

% [U,P,T,phi] = trussfem(ffd)
% résolution des systèmes d'assemblage de barres bidimensionnels
% U : solution en déplacements nodaux
% P : forces axiales dans les barres
% R : réactions aux appuis
% T : périodes propres de la structure
% phi : modes propres de la structure
% ffd : fichier fonction de données du problème

[t,p,e,A,E,rho,F] = feval(str2func(ffd)); % fait appel au fichier

fonction [t,p,e,A,E,F]=feval(str2func(ffd));
 % contenant les données
plotmesh_(t,p,1,1,'b'); % affiche la structure chargée
[K,M] = truss2dKM(t,p,A,E,rho); % calcul des matrices K et M
K = DelDOFs(K,e); % Application des conditions
M = DelDOFs(M,e); % aux limites
F = DelDOFs(F,e);
U = K \ F; % solution statique
U = AddDOFs(U,e); % ajout des DDL des noeuds encastré
[P,R,Al,D] = TrussForces(t,p,A,E,U); % forces dans les barres et les
noeuds
[phi, omega2] = eigs(K,M); % modes propres
omega = sqrt(diag(omega2)); % pulsations
T = 2*pi./sort(omega); % périodes propres par ordre croissant
% affichage des résultats
net = size(t,1);
nnt = size(p,1);
disp(' Résultats de calcul de la structure d''assemblage de barres')
disp([' Fichier de données : ',ffd])
disp([' Nombre de barres : ',num2str(net)])
disp([' Nombre de noeuds : ',num2str(nnt)])
fprintf('\n Déplacements aux noeuds :\n')
fprintf(' Noeud\t\t Ux\t\t\t\t Uy \n')
for i=1:nnt
fprintf(' %d\t\t\t%+5.4f\t\t\t%+5.4f\n',i,U(Localise(i)))
end
fprintf('\n Efforts dans les barres :\n')
fprintf(' Barre \t\t P\n')
for i=1:net
fprintf(' %d\t\t\t%+1.4E\n',i,P(i))
end
fprintf('\n Réactions aux appuis :\n')
fprintf(' Appuis\t\t Rx\t\t\t\t\t Ry \n')
for i=1:nnt
L = Localise(i);
if find(e==L(1))
fprintf(' %d\t\t\t%+1.4E\t\t%+1.4E\n',i,R(L))
end
end
fprintf('\n Allongement de chaque membrure::')
fprintf('\n Pour le type d`allongement:\n.si D=0:pas allongement;\n.si
D=-1:Compression;\n.si D=1:Traction \n')
fprintf('Membrure\t\t\t Allongement\t\t\t Decision(D) \n')
for i=1:net
fprintf(' %d\t\t\t\t\t%+5.6f\t\t\t\t\t%+5.0f\n',i,Al(i),D(i))
end
fprintf('\n Périodes propres de la structure :\n')
fprintf(' mode\t\tT\n')
for i=1:size(T)
fprintf(' %d\t\t\t%5.4f\n',i,T(i))
end
end

 TrussForces

function [F,R,Al,D] = TrussForces(t,p,A,E,U)

% [F,R] = TrussForces(t,p,A,E,U)
% F : forces axiales dans les barres
% R : forces aux niveaux des noeuds = réactions dans le cas d’appuis
% t : table de connectivités des éléments
% p : table des coordonnées des noeuds
 % A : sections des éléments
% E : modules d'élasticité
% U : solution en déplacement
net = size(t,1); % nombre d’éléments total
nnt = 2*size(p,1); % nombre de noeuds total
R = zeros(2*nnt,1); % Forces aux noeuds
for ie = 1:net % boucle sur les éléments
L = Localise(t(ie,:)); % table de localisation
ke = truss2DKe(p(t(ie,:),:),A(ie),E(ie)); % matrice élémentaire
ue = U(L); % déplacements des noeuds
fe = ke*ue; % forces élémentaires dans (oxy)
[L,c,s] = EltLen(p(t(ie,:),:)); % les cosinus directeurs
F(ie,:) = -(c.*fe(1)+s.*fe(2)); % rotation au repère local
R(L) = R(L) + fe(L); % tous les éléments liés au noeud
Al(ie,:)=(1/L)*(c*(ue(1)-ue(3))+s*(ue(2)-ue(4))); %calcul du
déplacement
r=Al(ie,:);
if r==0
D(ie,:)=0;
end
if r<0
D(ie,:)=-1;
end
if r>0
D(ie,:)=1;
end
end % fin de boucle end
end

Exercice 3

En utilisant un ou des programmes appropriés, calculons

• Les déplacements nodaux,
• Les réactions aux appuis,
Δl
• L’allongement l de chaque membrure en précisant la nature de la
sollicitation ,
• La tension dans chaque membrure.
Resultats des calculs de la structure
Nombre de barres : 10
Nombre de noeuds : 6

Deplacements aux noeuds :

Noeud Ux Uy
1 +0.0000 +0.0000
2 -0.0010 +0.0000
3 +0.0005 -0.0001
4 +0.0010 -0.0030
5 -0.0014 -0.0030
6 -0.0017 -0.0073

Reactions aux appuis :

Appuis Rx Ry
1 +6.1846E-11 -2.0000E+04
2 -1.8190E-11 +3.0000E+04

Allongement de chaque membrure::

Pour le type d'allongement:
.si D=0:pas allongement;
.si D=-1:Compression;
.si D=1:Traction

Membrure Allongement Decision(D)

1 -0.000167 -1
2 +0.000133 +1
3 +0.000371 +1
4 +0.000223 +1
5 +0.000022 +1
6 -0.000380 -1
7 -0.000617 -1
8 -0.002009 -1
9 +0.001118 +1
10 -0.000779 -1

La tension dans les barres :

Barre p
1 -3.3333E+04
2 +2.6667E+04
3 +2.0833E+04
4 +7.2917E+03
5 -4.3750E+03
6 -9.3750E+03
7 -1.9167E+04
8 -4.3750E+03
9 +1.6667E+04
10 -1.3333E+04
 Figure de la structure

Exercice 4

Calculons
• Les déplacements nodaux,
• Les réactions aux appuis,
 Δl
• L’allongement de chaque membrure en précisant la nature de la
l
sollicitation,
• La tension dans chaque membrure.

Voici la fonction d’initialisation des données

 expl2barre4

function [t,p,nenc,EA,F]=expl2barre4
%connectivité des éléments
t=[ 1 5 % elemnt 1
2 5 % element 2
3 5 % ....
4 5
];
%coordonnee des Noeuds
p=[ 0 0 0 % coordon?e Noeud 1
1.25 3 0 % coordon?e Noeud 2
3.5 2 0 % .......
4 1 0
2 1.5 3
];
%Noeud d'encastrement ou deplacement nulle
nenc=[ 1;2;3 %noeud 1
4;5;6 %noeud 2
7;8;9
10;11;12
];
% charge de chaque Barre
EA=[1 1 1 1 ]*5e8 ; %vecteur contenant lemodule de young de chaque
barre(10 barres au totale de module 4e9 chacune dans notre cas)
% charge de la structure
F=[ 0;0;0 %noeud non chargee
0;0;0 %noeud non chargee
0;0;0 %.....
0;0;0
20000;-20000;30000 %noeud chargé suivant les trois directions(sens
oposé à Y)
];
end

Resultats des calculs de la structure

Nombre de barres : 4
Nombre de noeuds : 5

Deplacements aux noeuds :

Noeud Ux Uy Uz
1 +0.0000 +0.0000 +0.0000
2 +0.0000 +0.0000 +0.0000
3 +0.0000 +0.0000 +0.0000
4 +0.0000 +0.0000 +0.0000
5 +0.0069 -0.0107 +0.0006
Reaction aux appuis :
Appuis Rx Ry Rz
1 +6.9588E+04 +5.7990E+04 +6.7937E+04
2 +9.8694E+03 +5.5171E+03 -2.2614E+04
3 -1.5511E+05 -8.1748E+04 -5.8443E+04
4 +5.5649E+04 +3.8241E+04 -1.6880E+04

Allongement de chaque membrure::

Pour le type d'allongement:
.si D=0:pas allongement;
.si D=-1:Compression;
.si D=1:Traction

Membrure Allongement Decision(D)

1 -0.000610 -1
2 -0.001411 -1
3 +0.001256 +1
4 +0.002019 +1
La tension dans les barres :
Barre p
1 -1.0862E+05
2 +2.2842E+04
3 -7.3264E+03
4 +2.7280E+04

Figure de la structure