3.15 Application

On se propose de modéliser la déformation en traction d'une pale d'éolienne en rotation. On assimile la pale à une poutre homogène de masse $M$, de longueur $L$ et de section équivalente $S$ tournant autour d'un point fixe $O$ avec un taux de rotation $\omega$.

On découpe la poutre en $N$ tronçons de longueur $l=L/N$, et de masse $m=M/N$. Chacun des tronçons est modélisé par le modèle masse ressort précédent.

3.15.1 algorithmes et programmes Matlab

3.15.1.1 fonction d'assemblage d'une matrice (2)

1. algorithme d'assemblage

   * { assemblage d'une matrice à partir de matrice élémentaire }

   * fonction assemblage(Ae,N): matrice A(N+1,N+1)

   * { calcul matrice A (N+1)^2 en fonction de Ke (2x2) }

   definir A(N+1,N+1)$\leftarrow$0 : matrice de N+1 reels

   pour l de 1 à N

   pour i de 0 à 1

   pour j de 0 à 1

   * A(l+i,l+j) $\leftarrow$A(l+i,l+j)+Ae(i+1,j+1)

   finpour

   finpour

   finpour

   * { application d'une C.L. sur la 1ere ligne }

   * A(1,.) $\leftarrow$0 , A(,1) $\leftarrow$0 , A(1,1) $\leftarrow$1

   * retour(A)

2. programme MATLAB (2)
   
   
   programme matlab 2: assemblage.m: programme d'assemblage
   
   

   function A=assemblage(Ae,N)
   % (C) M. BUFFAT, UFR de Mecanique
   % A=assemblage(Ae,N,cl) assemblage d'une matrice A 
   % a partir de N matrice elementaire Ae
   A=zeros(N+1,N+1);
   for l=1:N
       A(l:l+1,l:l+1)=A(l:l+1,l:l+1)+Ae;
   end;
   % application de la C.L. en 1
   A(1,:)=0; A(:,1)=0; A(1,1)=1;
   return;
   

   
   

3.15.1.2 fonction de calcul de la déformation (2)

1. algorithme de calcul de la déformée

   * { calcul la déformée d'une poutre en traction sous l'effet d'une rotation }

   * fonction traction(Ne,w,L,M,K): vecteur U(Ne+1),R(Ne+1) de réels, T0 réel

   * { paramètres: Ne nbre d'elements, w rotation instantanée (en tours/min)L longueur, M masse totale, K rigidité totale. On calcule la déformée U en fonction de la position R, et la tension T0 en r=0 }

   * $\omega$ $\leftarrow$$w\,2\pi/60$

   * l $\leftarrow$L/Ne, m $\leftarrow$M/Ne, k $\leftarrow$K*Ne

   * { matrices élémentaires }

   * Ke $\leftarrow$k*[[1 -1],[-1 1]] , Me $\leftarrow$m*[[1 0],[0 1]]

   * { assemblage des matrices }

   * Ka $\leftarrow$assemblage(Ke,Ne),  Ma $\leftarrow$assemblage(Me,Ne)

   * { calcul du second membre }

   * R $\leftarrow$ $[(i-1)l]_{l=1,Ne+1}$ , F $\leftarrow$$\omega$R*R

   * B $\leftarrow$M*F, B(1)$\leftarrow$0 { condition aux limites }

   * { résolution }

   * U $\leftarrow$Ka$^{-1}$B

   * { tension en r=0 }

   * T0 $\leftarrow$ $Ke_{1,1}u_{1}+Ke_{1,2}u_{2}$

   * retour (U,R,T0)

2. programme MATLAB (2)
   
   
   programme matlab 2: traction.m: calcul de la déformation
   
   

   function [U,R,T0]=traction(Ne,w,L,M,K)
   % (C) M. BUFFAT, UFR de Mecanique
   % [U,R,T0]=traction(Ne,w,L,M,K) calcul d'une poutre en traction 
   % sous l'effet de la rotation
   % calcul la deformee U en fonction de R et la tension en O T0
   % parametres
   % nbre d'elements Ne de discretisation
   % rotation w en tour/minute
   % masse M, longueur L, raideur totale K (ES/L)
   omega=w*2*pi/60;% rotation en rd/s
   l=L/Ne; % longueur d'un element
   m=M/Ne; % masse elementaire
   k=K*Ne; % raideur elementaire
   % variable deformation, position
   U=zeros(Ne+1,1);
   R=[0:l:L];
   F=omega*R.^2;
   % matrice de masse et de rigidite
   Ke=k*[1 -1; -1 1]; % matrice de rigidite
   Me=m/2*[1 0; 0 1]; % et de masse elementaire
   % assemblage
   Ka=assemblage(Ke,Ne);
   Ma=assemblage(Me,Ne);
   % resolution
   B=Ma*F'; B(1)=0; % second membre
   U=Ka\B;
   % tension en O
   T0=Ke(1,:)*[U(1) U(2)]';
   return;
   

   
   

3.15.1.3 programme principal (2)

1. algorithme

   * { choix des paramètres }

   * L=14 m , $\omega$= 40 tr/min , M=800 kg , $\rho$= 8000 $kg/m^{3}$ , E= $200\,10^{9}\, N/m^{2}$(acier)

   * K $\leftarrow$E*S/L

   * { étude de la précision en fonction du nbre d'éléments Ne }

   * Ne=5,10,20

   * U1,R1,T1 $\leftarrow$traction(5,$\omega$,L,M,K)

   * U2,R2,T2 $\leftarrow$traction(10,$\omega$,L,M,K)

   * U3,R3,T3 $\leftarrow$traction(20,$\omega$,L,M,K)

   * { tracer de U et de T en fonction de Ne }

2. programme MATLAB (2)
   
   
   programme matlab 2: eolienne.m: programme principal
   
   

   % (C) M. BUFFAT, UFR de Mecanique
   % modelisation d'une pale d'eolienne en traction 
   % sous l'effet de la rotation
   % calcul la deformee U en fonction de R et la tension en O T0
   
   % caracteristique de la pale
   L=14; % longueur
   M=800; % masse
   rho=8000; % densite
   S=M/(rho*L); % section equivalente
   E=200e09; % module d'Young
   K=E*S/L; % raideur totale
   % rotation en tours/minute
   w=40;
   % etude de la solution en fonction de Ne
   [U1,R1,T1]=traction(5,w,L,M,K);
   [U2,R2,T2]=traction(10,w,L,M,K);
   [U3,R3,T3]=traction(20,w,L,M,K);
   subplot(2,1,1);
   plot(R1,U1,'-+',R2,U2,'-x',R3,U3,'-o','LineWidth',1);
   legend('N=5','N=10','N=20');
   title('Deformation en fonction de R');
   xlabel('R'); ylabel('U');
   subplot(2,1,2);
   plot([5 10 20],[T1 T2 T3],'x','MarkerSize',16);
   title('Tension en O');
   xlabel('N'); ylabel('T0');
   

   
   

3. exécution sous MATLAB

Déformation d'une pale d'éolienne: execution avec Matlab