TP MEF – Master 01 1

Partie 1 : Modélisation

Objectif : L’objectif de cette partie est de consolider les notions fondamentales de la MEF données
au cours, notamment les différentes étapes de calcul par la MEF.
Cette partie du TP s’appuie sur des problèmes basiques, à savoir :
 Les systèmes composés de poutres soumises à une flexion simple,
 Les structures en treillis en 2D,
 Les portiques en 2D.

Outils : Le travail demandé est basé sur des programmes (modules) déjà élaborés.

Les modules EF utilisés :

 Module EF1 : Un module qui permet de traiter les systèmes composés de

poutres soumises à une flexion simple. Deux exemples sont donnés, à titre
indicatif, pour le cas :
 D’une poutre soumise à une force nodale (Module_EF1 _ex01.m)
 D’une poutre soumise à une charge répartie (Module_EF1 _ex02.m)
 Module EF2 : Un module qui permet de traiter les structures en treillis en 2D.
Exemple d’une structure en treillis est donné au Module_EF2 _ex01.m.
 Module EF3 : Un module qui permet de traiter les portiques en 2D en tenant
compte des efforts normaux. Un exemple d’un portique soumis à une force
nodale est donné au Module_EF3 _ex01.m.

Ces modules seront donnés sous forme numérique (*.m).

La maitrise de l’outil Matlab est considérée comme acquise.

Travail 1. En se basant sur les modules fournis, il est demandé de choisir et d’étudier trois
demandé : types de structures (problèmes), soit une structure par module.
Les modélisations et les résultats obtenus des différents systèmes traités
doivent être validés par un calcul manuel.
Il est demandé aussi de répondre à des questions sur le volet modélisation et/ou
programmation.
Compte rendu : 2. Ce travail doit être sanctionné par un rapport avec tous les détails de
modélisation, calcul manuel et les résultats de validation.

Informations Afin de vous faciliter la lecture des programmes, notamment la partie introduction des
utiles données, les exemples traités seront fournis pendant la séance du TP.
Il est possible d’effectuer ce travail par groupe de 02 étudiants, maximum.
Les exemples traités doivent être différents d’un binome à l’autre.
La séance du TP sera considérée comme séance de consultation. Le travail accompli sera
suivi périodiquement par une fiche de suivi réservée à chaque binome.
function [depl]=Module_EF1_ex01() Ei=mat(elem(i,4),2);
% Ce module permet de calculer les déplacements des b=mat(elem(i,4),3); 2
structures composées de h=mat(elem(i,4),4);
% Poutres soumises à la flexion pure - 2D - Charge Iy=h*b^3/12;
concentrée dx=node(elem(i,3),2)-node(elem(i,2),2);
dy=node(elem(i,3),3)-node(elem(i,2),3);
% L’algorithme de la méthode des éléments pour ce Li=sqrt(dx^2+dy^2);
type de problème peut être résumé comme suit :
% Etape 1 : Discrétisation et introduction des k=rigidite_poutre(k,Ei,Iy,Li);
données du problème KG=assemblage(i,elem,KG,k,NNE,NDN);
% Etape 2 : Calcul de la matrice de rigidité end
locale (k), %Conditions aux limites
% Etape 3 : Assemblage de la matrice de [KG,F]=climites(KG,F,CL);
rigidité (K_T),
% Etape 4 : Introduction des conditions aux %Solution du problème
limites, depl=KG\F;
% Etape 5 : Résolution de l’équation : [K_T end
]{?}={F} function k=rigidite_poutre(k,E,I,L)
% la matrice de rigidité locale
% Les efforts normaux sont négligés k(1,1)=12*E*I/L^3;
% Le repère local xy est le même XY: pas de k(1,2)=6*E*I/L^2;
transformation k(1,3)=-k(1,1);
k(1,4)=k(1,2);
% Les données du programme, i.e., les k(2,2)=4*E*I/L;
caractéristiques des poutres et leur k(2,3)=-k(1,2);
%connexion, sont données par: k(2,4)=2*E*I/L;
k(3,3)=k(1,1);
%mat=[n# E b h] k(3,4)=-k(1,2);
mat=[1 210000 300 300]; k(4,4)=k(2,2);
%node=[n# x y] % Triangle inférieur par symétrie
node=[1 0 0; for i=1:3
2 900 0; for j=i+1:4
3 1800 0]; k(j,i)=k(i,j);
%elem=[n# noeudi noeudj mat] end
elem=[1 1 2 1; end
2 2 3 1]; end
%vecteur des forces F function
F=[0;0;0;0;-1500;0]; KG=assemblage(ielem,elem,KG,K,NNE,NDN)
%conditions aux limites par noeud % KG est la matrice de rigidité assemblée de la
% 0 libre 1 bloqué structure
%n# v tetha % Elle représente la somme des matrices de rigidité
CL=[1 1 1; de chaque élement
2 1 0; % D'une manière formelle on peut écrire:
3 0 0]; % [KG]=?i Ki
%Nombre de DDL par noeud for i=1:NNE
NDN=2; ideb=NDN*(i-1)+1;
%nombre de noeud par élément ifin=NDN*i;
NNE=2; I=elem(ielem,i+1);
%nombre d'élement barre dans la structure IDEB=NDN*(I-1)+1;
n=size(elem,1); IFIN=NDN*I;
%nombre de noeud for j=1:NNE
m=size(node,1); jdeb=NDN*(j-1)+1;
%nomdre de DDL jfin=NDN*j;
DDL=NDN*m; J=elem(ielem,j+1);
%Initialiser la matrice de rigidité globale JDEB=NDN*(J-1)+1;
KG=zeros(DDL); JFIN=NDN*J;
KG(IDEB:IFIN,JDEB:JFIN)=KG(IDEB:IFIN,JDEB:
for i=1:n JFIN)+K(ideb:ifin,jdeb:jfin);
% Initialiser la matrice de rigidité end
k=zeros(4); end
end n=size(elem,1);
function [KG,F]=climites(KG,F,CL) %nombre de noeud 3
CL=CL(:,2:end); m=size(node,1);
ind=find(CL'); %nomdre de DDL
KG(ind,:)=[]; DDL=NDN*m;
KG(:,ind)=[]; %Initialiser la matrice de rigidité globale
F(ind)=[]; KG=zeros(DDL);
end for i=1:n
function [depl]=Module_EF1_ex02() % Initialiser la matrice de rigidité
% Ce module permet de calculer les déplacements des k=zeros(4);
structures composées de Ei=mat(elem(i,4),2);
% Poutres soumises à la flexion pure - 2D - Charge b=mat(elem(i,4),3);
répartie h=mat(elem(i,4),4);
Iy=h*b^3/12;
% L’algorithme de la méthode des éléments pour ce dx=node(elem(i,3),2)-node(elem(i,2),2);
type de problème peut être résumé comme suit : dy=node(elem(i,3),3)-node(elem(i,2),3);
% Etape 1 : Discrétisation et introduction des Li=sqrt(dx^2+dy^2);
données du problème
% Etape 2 : Calcul de la matrice de rigidité k=rigidite_poutre(k,Ei,Iy,Li);
locale (k), KG=assemblage(i,elem,KG,k,NNE,NDN);
% Etape 3 : Assemblage de la matrice de end
rigidité (K_T), %Conditions aux limites
% Etape 4 : Introduction des conditions aux [KG,F]=climites(KG,F,CL);
limites, %Solution du problème
% Etape 5 : Résolution de l’équation : [K_T depl=KG\F;
]{?}={F} end
function k=rigidite_poutre(k,E,I,L)
% Les efforts normaux sont négligés % la matrice de rigidité locale
% Le repère local xy est le même XY: pas de k(1,1)=12*E*I/L^3;
transformation k(1,2)=6*E*I/L^2;
k(1,3)=-k(1,1);
% Les données du programme, i.e., les k(1,4)=k(1,2);
caractéristiques des poutres et leur k(2,2)=4*E*I/L;
%connexion, sont données par: k(2,3)=-k(1,2);
k(2,4)=2*E*I/L;
%mat=[n# E b h] k(3,3)=k(1,1);
mat=[1 210000 300 300]; k(3,4)=-k(1,2);
%node=[n# x y] k(4,4)=k(2,2);
node=[1 0 0; % Triangle inférieur par symétrie
2 900 0; for i=1:3
3 1800 0]; for j=i+1:4
%elem=[n# noeudi noeudj mat] k(j,i)=k(i,j);
elem=[1 1 2 1; end
2 2 3 1]; end
%vecteur des forces F end
%pour une charge uniformément répartie function
%f_poutre=p*L/12*[6 L 6 -L] KG=assemblage(ielem,elem,KG,K,NNE,NDN)
F=[0;0;0;+2000*900^2/6- % KG est la matrice de rigidité assemblée de la
2000*900^2/12;0;2000*900^2/12]; structure
%conditions aux limites par noeud % Elle représente la somme des matrices de rigidité
% 0 libre 1 bloqué de chaque élement
%n# v tetha % D'une manière formelle on peut écrire:
CL=[1 1 1; % [KG]=?i Ki
2 1 0; for i=1:NNE
3 1 0]; ideb=NDN*(i-1)+1;
%Nombre de DDL par noeud ifin=NDN*i;
NDN=2; I=elem(ielem,i+1);
%nombre de noeud par élément IDEB=NDN*(I-1)+1;
NNE=2; IFIN=NDN*I;
%nombre d'élement barre dans la structure for j=1:NNE
 jdeb=NDN*(j-1)+1; 2 0 0;
jfin=NDN*j; 3 0 0; 4
J=elem(ielem,j+1); 4 1 1];
JDEB=NDN*(J-1)+1; %Nombre de DDL par noeud
JFIN=NDN*J; NDN=2;
KG(IDEB:IFIN,JDEB:JFIN)=KG(IDEB:IFIN,JDEB: %nombre de noeud par élément
JFIN)+K(ideb:ifin,jdeb:jfin); NNE=2;
end %nombre d'élement barre dans la structure
end n=size(elem,1);
end %nombre de noeud
function [KG,F]=climites(KG,F,CL) m=size(node,1);
CL=CL(:,2:end); %nomdre de DDL
ind=find(CL'); DDL=NDN*m;
KG(ind,:)=[]; %Initialiser la matrice de rigidité globale
KG(:,ind)=[]; KG=zeros(DDL);
F(ind)=[];
end for i=1:n
function [depl]=Module_EF2_ex01() % Initialiser la matrice de rigidité
% Ce module permet de calculer les déplacements des k=zeros(2);
structures en treillis 2D Ei=mat(elem(i,4),2);
Ai=mat(elem(i,4),3);
% L’algorithme de la méthode des éléments pour ce dx=node(elem(i,3),2)-node(elem(i,2),2);
type de problème peut être résumé comme suit : dy=node(elem(i,3),3)-node(elem(i,2),3);
% Etape 1 : Discrétisation et introduction des Li=sqrt(dx^2+dy^2);
données du problème alpha=atan2(dy,dx);
% Etape 2 : Calcul de la matrice de rigidité
locale (k), k=rigidite_barre(k,Ei,Ai,Li);
% Etape 3 : Transformation (passage du repère K=trans(k,alpha);
local au repère global) en utilisant la matrice R, KG=assemblage(i,elem,KG,K,NNE,NDN);
% Etape 4 : Assemblage de la matrice de end
rigidité (K_T), %Conditions aux limites
% Etape 5 : Introduction des conditions aux [KG,F]=climites(KG,F,CL);
limites,
% Etape 6 : Résolution de l’équation : [K_T %Solution du problème
]{?}={F} depl=KG\F;
end
% Les données du programme, i.e., les
caractéristiques des barres et leur function k=rigidite_barre(k,E,A,L)
%connexion, sont données par: % la matrice de rigidité locale
k(1,1)=E*A/L;
%mat=[n# E A] k(1,2)=-E*A/L;
mat=[1 210000 120]; k(2,1)=k(1,2);
%node=[n# x y] k(2,2)=k(1,1);
node=[1 0 0; end
2 0 100; function K=trans(k,alpha)
3 100 100; % Transformation du repère local au repère global
4 100 0]; % K=R'*k*R
%elem=[n# noeudi noeudj mat] R=[cos(alpha) sin(alpha) 0 0;
elem=[1 1 2 1; 0 0 cos(alpha) sin(alpha)];
2 1 4 1; K=R'*k*R;
3 1 3 1; end
4 2 3 1; function
5 2 4 1; KG=assemblage(ielem,elem,KG,K,NNE,NDN)
6 3 4 1]; % KG est la matrice de rigidité assemblée de la
%vecteur des forces F structure
F=[0;0;1000;1000;0;0;0;0]; % Elle représente la somme des matrices de rigidité
%conditions aux limites par noeud de chaque élement
% 0 libre 1 bloqué % D'une manière formelle on peut écrire:
%n# deltax deltay % [KG]=?i Ki
CL=[1 1 1; for i=1:NNE
 ideb=NDN*(i-1)+1; 3 3 4 1];
ifin=NDN*i; %vecteur des forces F 5
I=elem(ielem,i+1); %pour une charge uniformément répartie
IDEB=NDN*(I-1)+1; %f_poutre=p*L/12*[6 L 6 -L]
IFIN=NDN*I; F=[0;0;0;2000;0;0;0;0;0;0;0;0];
for j=1:NNE %conditions aux limites par noeud
jdeb=NDN*(j-1)+1; % 0 libre 1 bloqué
jfin=NDN*j; %n# u v tetha
J=elem(ielem,j+1); CL=[1 1 1 0;
JDEB=NDN*(J-1)+1; 2 0 0 0;
JFIN=NDN*J; 3 0 0 0;
KG(IDEB:IFIN,JDEB:JFIN)=KG(IDEB:IFIN,JDEB: 4 1 1 1];
JFIN)+K(ideb:ifin,jdeb:jfin); %Nombre de DDL par noeud
end NDN=3;
end %nombre de noeud par élément
end %NNE=2;
function [KG,F]=climites(KG,F,CL) %nombre d'élement barre dans la structure
CL=CL(:,2:end); n=size(elem,1);
ind=find(CL'); %nombre de noeud
KG(ind,:)=[]; m=size(node,1);
KG(:,ind)=[]; %nomdre de DDL
F(ind)=[]; DDL=NDN*m;
end %Initialiser la matrice de rigidité globale
KG=zeros(DDL);
function [depl]=Module_EF3_ex01() %DDL de chaque noeud dans le système
% Ce module permet de traiter les portiques en 2D en ID=zeros(m,NDN);
tenant compte des efforts normaux. NEQ=1;
for i=1:m
% L’algorithme de la méthode des éléments pour ce for j=1:NDN
type de problème peut être résumé comme suit : ID(i,j)=NEQ;
% Etape 1 : Discrétisation et introduction des NEQ=NEQ+1;
données du problème end
% Etape 2 : Calcul de la matrice de rigidité end
locale (k),
% Etape 3 : Transformation (passage du repère for i=1:n
local au repère global) en utilisant la matrice R, % Initialiser la matrice de rigidité
% Etape 4 : Assemblage de la matrice de k=zeros(6);
rigidité (K_T), Ei=mat(elem(i,4),2);
% Etape 5 : Introduction des conditions aux b=mat(elem(i,4),3);
limites, h=mat(elem(i,4),4);
% Etape 6 : Résolution de l’équation : [K_T Iy=h*b^3/12;
]{?}={F} dx=node(elem(i,3),2)-node(elem(i,2),2);
dy=node(elem(i,3),3)-node(elem(i,2),3);
Li=sqrt(dx^2+dy^2);
% Exemple d'un portique avec une charge horizontale alpha=atan2(dy,dx);

% Les données du programme, i.e., les k=rigidite_poutre(k,Ei,b,h,Iy,Li);

caractéristiques des poutres et leur K=trans(k,alpha);
%connexion, sont données par: KG=assemblage(i,elem,KG,K,ID);
end
%mat=[n# E b h] %Conditions aux limites
mat=[1 200000 300 300]; [KG,F]=climites(KG,F,CL);
%node=[n# x y]
node=[1 0 0; %Solution du problème
2 0 4000; depl=KG\F;
3 5000 4000; end
4 5000 0];
%elem=[n# noeudi noeudj mat] function k=rigidite_poutre(k,E,b,h,I,L)
elem=[1 1 2 1; % la matrice de rigidité locale
2 2 3 1; A=b*h;
k(1,1)=E*A/L; 0 0 0 0 0 1];
k(1,4)=-E*A/L; K=R'*k*R; 6
k(2,2)=12*E*I/L^3; end
k(2,3)=6*E*I/L^2;
k(2,5)=-k(2,2); function KG=assemblage(ielem,elem,KG,K,ID)
k(2,6)=k(2,3); % KG est la matrice de rigidité assemblée de la
k(3,3)=4*E*I/L; structure
k(3,5)=-k(2,3); % Elle représente la somme des matrices de rigidité
k(3,6)=2*E*I/L; de chaque élement
k(4,4)=k(1,1); % D'une manière formelle on peut écrire:
k(5,5)=k(2,2); % [KG]=?i Ki
k(5,6)=-k(2,3); KG(ID(elem(ielem,2),:),ID(elem(ielem,2),:))=KG(ID
k(6,6)=k(3,3); (elem(ielem,2),:),ID(elem(ielem,2),:))+K(1:3,1:3);
% Triangle inférieur par symétrie KG(ID(elem(ielem,3),:),ID(elem(ielem,3),:))=KG(ID
for i=1:5 (elem(ielem,3),:),ID(elem(ielem,3),:))+K(4:6,4:6);
for j=i+1:6 KG(ID(elem(ielem,2),:),ID(elem(ielem,3),:))=KG(ID
k(j,i)=k(i,j); (elem(ielem,2),:),ID(elem(ielem,3),:))+K(1:3,4:6);
end KG(ID(elem(ielem,3),:),ID(elem(ielem,2),:))=KG(ID
end (elem(ielem,3),:),ID(elem(ielem,2),:))+K(4:6,1:3);
end end

function K=trans(k,alpha) function [KG,F]=climites(KG,F,CL)

% Transformation du repère local au repère global CL=CL(:,2:end);
% K=R'*k*R ind=find(CL');
R=[cos(alpha) sin(alpha) 0 0 0 0; KG(ind,:)=[];
-sin(alpha) cos(alpha) 0 0 0 0; KG(:,ind)=[];
0 0 1 0 0 0; F(ind)=[];
0 0 0 cos(alpha) sin(alpha) 0; end
0 0 0 -sin(alpha) cos(alpha) 0;