ETUDE D’UN OSCILLATEUR

(cas du système masse-ressort)

Etudiants :

Grégoire BERAUD Valentin BION

Marine GIRARD Houda LAHLOU

Projet de Physique P6-3

STPI/P6-3/2010 – 046

Enseignant-responsable du projet :

Bernard GLEYSE

2

INSTITUT NATIONAL DES SCIENCES APPLIQUEES DE ROUEN

Département Sciences et Techniques Pour l’Ingénieur

BP 8 – place Emile Blondel - 76131 Mont-Saint-Aignan - tél : 33 2 35 52 83 00 - fax : 33 2 35 52 83 69

Date de remise du rapport : 18/06/10

Référence du projet : STPI/P6-3/2010 – 046

Intitulé du projet : Etude d’un oscillateur (cas du système masse-ressort)

Type de projet : Expérimental et simulation numérique

Objectifs du projet :

Etudier dans un premier temps par l’expérience le mouvement d’un solide masse-ressort, calculer les solutions théoriques, modéliser les solutions à l’aide de méthodes numériques et comparer les résultats.

TABLE DES MATIERES

1. Introduction ........................................................................................................................ 6

2. Méthodologie / Organisation du travail ............................................................................... 6

3. CORPS DU DOSSIER ....................................................................................................... 6

3.1. PARTIE THEORIQUE................................................................................................... 6

3.1.1. Système soumis uniquement aux forces de gravité ............................................... 6

3.1.2. Avec frottements fluides………………………………………………………………..7

3.1.3. Avec frottement fluide et entretenu

3.2. PARTIE PRATIQUE…………………………………………………………………………9

3.2.1. Avec masse (régime libre)……………………………………………………………..9

3.2.2. Avec frottement fluide…………………………………………………………………11

3.2.3. Avec frottement fluide et entretenu…………………………………………………..12

3.3. METHODE NUMERIQUE………………………………………………………………….13

3.3.1. Cauchy-Lipchitz…………………………………………………………………………13

3.3.1.1. Premier ordre ............................................................................................... 13

3.3.1.2 Généralisation au rang n…………………………………………………………..14

3.3.1.3 Application à la physique………………………………………………………….14

3.3.2. Runge-kutta 4…………………………………………………………………………..14

3.4. MODELISATION NUMERIQUE………………………………………………………….15

3.5 COMPARAISON DES RESULTATS…………………………………………………….17

4. Conclusions et perspectives ............................................................................................. 17

5. Bibliographie .................................................................................................................... 18

6. Annexes (non obligatoire) ................................................................................................. 19

6.2. Listings des programmes réalisés ............................................................................... 19

..............................................................................................................................................

5

NOTATIONS, ACRONYMES

6

1. INTRODUCTION

Notre projet physique porte sur l’étude du système masse-ressort. Cette étude est l’objet de trois situations particulières qui font intervenir des équations mathématiques. L’étude du mouvement masse ressort sera fait dans le cas du système soumis uniquement aux forces de gravitation, ensuite en présence de frottement fluide et enfin avec une oscillation forcée. Nous avons pour ce faire, réalisé une modélisation mathématique, permettant de résoudre nos équations différentielles linéaire d’ordre 2 par Maple et C++.

Nous allons dans un premier temps, à travers ce dossier, vous présenter l’étude théorique de ce système masse-ressort tout en vous expliquant comment sont établies les différentes équations différentielles, puis dans un second temps, vous présenter les études expérimentales qui ont été réalisées. Enfin, nous vous expliquerons les différentes méthodes numériques établies afin d’obtenir une solution approchée de nos équations différentielles, qui nous permettra de les modéliser numériquement et ensuite faire une comparaison entre les résultats de nos expériences, nos résultats théoriques et ceux obtenus numériquement.

2. METHODOLOGIE / ORGANISATION DU TRAVAIL

Ce sujet nous a été attribué après un sondage de préférence. Le groupe a donc été formé ne tenant pas compte des affinités. Nous avons du apprendre, tout d’abord, à nous connaitre puis, à travailler ensemble.

Concernant l’organisation de notre travail, nous avons mis un certain temps avant de bien comprendre le sujet qui nous était donné. En effet, comme dit précédemment, ce dernier n’avait jamais été traité les années précédentes et donc aucunes pistes ne nous ont été proposées.

7

3. CORPS DU DOSSIER

3.1. PARTIE THEORIQUE

3.1.1. Système soumis uniquement aux forces de gravité

On cherche dans cette partie à établir les équations différentielles du mouvement du solide masse-ressort dans différents cas et de trouver les solutions exactes.

On établit premièrement la liste des forces s’appliquant au système dans le cas d’une équation sans second membre et sans frottement:

Poids:

Force de rappel:

Deuxièmement on applique la deuxième loi de Newton, le principe fondamental de la dynamique. Remarque : on se situe dans un référentiel galiléen.

où a est le vecteur accélération.

Alors

Et en projetant sur Ux (ex) on obtient :

On trouve donc :

8

3.1.2. Avec frottement fluide

Maintenant on prend le cas d’un mouvement avec frottement fluide :

On a donc en plus dans notre bilan des forces, la force des frottements fluides. Nous prendrons:

. Avec = *S . étant la masse volumique du fluide, ici la masse volumique de l’eau. S est ici la surface de

frottement (la surface qui va faire impact avec l’eau.

Remarque : Normalement, les frottements fluides sont proportionnels à la vitesse au carré.

De plus dépend de nombre de Reynolds Re. Cependant pour une simplification on prend F proportionnel à la vitesse (sinon on aurait une équation différentielle non linéaire). On ne prend pas non plus en compte ici le nombre de Reynolds.

Alors :

Ainsi on a

Et on obtient donc:

Et la solution :

3.1.3. Avec frottement fluide et entretenu

Enfin prenons le cas du mouvement avec un frottement fluide mais entretenu avec une force sinusoïdale de la forme cos(wt) :

Alors on obtient :

9

Et après calcul on obtient la solution :

Maintenant on dispose de nos 3 équations ainsi que de leurs solutions. On va pouvoir ainsi utiliser ces solutions dans des programmes informatiques afin de traiter le problème de manière numérique. On utilisera alors la méthode numérique Runge-Kutta 4 qui nous permettra d’avoir alors des solutions très approchées.

3.2 PARTIE EXPERIMENTALE

3.2.1 Avec masse (régime libre)

Dans un premier temps, nous avons mesuré la masse totale 0,165Kg et la constante de raideur k.

Le ressort étant à spires jointives, on mesure k à l'aide d'une surcharge en utilisant la relation

k= df/dl=25,34

On prend donc une masse m=0,165Kg et on contient une longueur de

ressort l= 0.07mètres .

Soit k=m*g/l=25.34N/m

On configure Synchronie pour au moins 20s d'enregistrement sur 2000 points, avec verticalement -1V a 12V.

En enregistrant quelques oscillations , on mesure la fréquence Noexp =1/T0=1.25Hz , avec T0=0.8s.

10

Or théoriquement, on sait Wotheo =

et Woexp =2π N 0exp

Notheo = *1/2π=1.9/Hz.

Voici le graphique obtenu à l'issue de cette expérience:

11

3.2.2. Avec frottements fluides

Désormais, on propose de rajouter de l'eau dans le dispositif et on fait un lâcher libre, on enregistre ou synchronie les oscillations.

On utilise m=0,165Kg

On cherche les variations des tensions.

Or le mouvement y(t) de la masse pour un essai de lâcher consistant à décaler la masse de la valeur Yo de l'instant initial est donné par

.

Cette formule nous permet d'obtenir le coefficient d'amortissement 'a'.

12

On a donc :

On cherche donc les variations des tensions U0 et U1.

U1- Uorigine =y1=U0- Uorigine

et U0- Uorigine =y0=UO- Uorigine

Or Uorigine =5,7V

U0=4V

U1=7,6 V

Application numérique: y1=7,6-5,7=1,9V ;y0=4-5,7=-1,7V.

Donc avec le calcul de a, on obtient a=0,03.

3.2.3. Avec frottement fluide + Entretenue

13

Dans cette expérience, on se propose d'utiliser une oscillation forcée grâce à un moteur.

On remarque sur ce graphique que les oscillations sont entretenues, on a des oscillations périodiques.

3.3. METHODE NUMERIQUE

3.3.1 Cauchy Lipchitz

3.3.1.1 Premier ordre :

Soit une fonction de deux variables :

Soit l’équation différentielle du 1er odre :

avec une condition initiale x(t0)=x0 où t0 et x0 (1)

14

si f est continu et k-lipchitzienne 1 en x alors il existe une unique solution x(t) de l’équation

différentielle définie pour tout t . I étant un intervalle centré sur t0 vérifiant la condition initiale donnée.

3.3.1.2. Généralisation au rang n :

Dans le cas général, une équation différentielle d’ordre n est du type :

(2)

cette équation peut se lire comme une équation de variable :

(2) devient :

avec

3.3.1.3. Application à la physique :

Soit l’équation différentielle du 2ème ordre :

(3)

On a donc

On pose

donc

)()('

)('

)('),(,

)('

)("

)('

)",,(

)",,()('),(,'

2

1

tbztaz

tz

tztztg

tz

tz

tz

zztf

zztftztztfy

3.3.2. RUNGE KUTTA 4

1 f est dite k-lipchitzienne si

2

15

Soit (E) : )('" tfkxhxmx , avec et

On pose l’équation devient donc )(' tfkxhumu avec

)((''

'

),,(

),,('

12

1

tgrukx

u

u

u

u

x

uxtf

uxtfX

m

);;(1 iiijj uxthfk 2;1j

);;(22221211 k

i

k

ih

ijj uxthfk

2;1j

);;(22232221 k

i

k

ih

ijj uxthfk

2;1j

);;(22243231 k

i

k

ih

ijj uxthfk

2;1j

6

)22( 41312111

1

kkkkxx i

i

6

)22( 42322212

1

kkkkuu i

i

3.4 MODELISATION NUMERIQUE

On modélise nos équations grâce à la méthode Runge-Kutta 4. On écrit ainsi deux programmes décrivant Runge-Kutta 4. En effet dans cette partie, on part d'un programme de base que l'on modifie pour modéliser chaque équation, c'est à dire premièrement l'équation représentant le mouvement sans frottement fluide ni second membre, deuxièmement l'équation qui représente le mouvement avec frottement fluide et finalement celle qui représente le mouvement avec frottement fluide et second membre sinusoïdale. Le programme de base modélise le mouvement sans frottement ni second membre. Les constantes du programme k11, k12, k21, k22, k31, k32, k41, k42 sont obtenues grâce à la méthode numérique de Runge-Kutta 4. De plus la fonction y[] du programme a été obtenue avec la partie 1.

16

On a reporté nos résultats dans un tableur (non reporté ici, car le fichier fait 1000 lignes) et on a obtenue cette courbe pour la première équation.

Pour la deuxième équation (frottements fluides), on obtiens ces résultats mis en tableur et modélisés ainsi :

Cependant nous n’avons pas reussi à modeliser correctement la dernière a courbe à cause de problème de programmes et de la solution de l’équation différentielle.

17

3.5. COMPARAISON DES RESULTATS:

Dans cette partie, nous allons enfin comparer nos résultats obtenus par différentes méthodes.

Nous avons eu ceux des expériences que nous avons faites en début de projet. Et finalement nos derniers résultats ont été obtenus par la méthode numérique Runge-Kutta 4 modélisée en C++. Faute de quelques erreurs de programmation et de résolution d'équations différentielles, nous pouvons qu'effectuer une comparaison avec la situation d'oscillation libre avec la masse.

Nous remarquons qu'il ya une similitude du tracé pour la première équation entre ces deux courbes mais que cependant sur la courbe obtenue théoriquement, les oscillations sont entretenues du fait de la négligence des forces de frottement de l'air et du système qui n'est pas parfait.

Pour la deuxième équation, les courbes sont similaires ce qui correspondait aux résultats attendus et que le modèle mathématique est recevable.

4. CONCLUSIONS ET PERSPECTIVES

Ce projet physique nous a beaucoup appris tant au niveau physique, que pédagogique.

Il nous a permis d'approcher de plus près le fonctionnement du système masse-ressort dans différentes situations. Même si ce projet était axé sur de la physique, il nous a fallu revoir de nombreuses notions mathématiques tels que la résolution des équations différentielles.

De plus, pour la résolution modélisée de nos équations, il nous a fallu revoir les notions étudiées en C++ et apprendre le langage Maple.

Bien évidemment, il n'est pas à nier que cela nous a pris du temps et que cela n'a pas été des plus faciles, mais grâce à un travail de groupe et une ambiance de travail agréable, cela s'est passé sans problèmes majeurs.

D'un autre côté, ce projet qui présente de nombreux avantages tant au niveau mathématique que personnel, a été perçu par la plupart d'entre nous comme un projet plus mathématique donc abstrait sachant que le but de ce genre de projet se doit d'être physique, c'est à dire vraiment concret où l'on verrait des évolutions.

Il pourrait être aussi intéressant de calculer d’autres paramètres tels que les frottements fluides qui s’exercent sur la masse, la poussé d’Archimède exercée sur la masse …

5. BIBLIOGRAPHIE

http://www.ac-nancy-metz.fr/enseign/physique/divers/MethodNum/Schw-doc/RK4_02.pdf

http://www.developpez.net/forums/d370936/autres-langages/algorithmes/contribuez/methode-runge-

kutta/

http://www.apsq.org/sautquantique/telechargement/GuideProgrammationMaple.pdf

http://fr.wikipedia.org/wiki/Syst%C3%A8me_masse-ressort

http://www.sciences.univ-nantes.fr/physique/perso/gtulloue/Meca/Oscillateurs/ressort_rsf.html

http://ufrmeca.univ-lyon1.fr/~buffat/COURS/MATLAB_HTML/node31.html

Tous ces sites sont encore valides.

6. ANNEXES (NON OBLIGATOIRE)

Listings des programmes réalisés :

Programme s’adaptant à chaque équation :

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

typedef struct vect2f {

double composante_0;

double composante_1;

}vect2f;

// z" = G(t, z, z')

// G(t, z, z') = bz' + cz

// y = (z, z')

// y' = (z', z")

// y' = F(t, y)

// y' = (z', G(t, z, z'))

// F(t, y) = (z', G(t, z, z'))

// F(t, (z, z')) = (z', bz' + cz)

vect2f f(double t, vect2f v, double g, double a, double b){

vect2f resultat;

resultat.composante_0 = v.composante_1;

resultat.composante_1 = a*v.composante_1 + b*v.composante_0 + g;

return resultat;

}

vect2f add(vect2f a, vect2f b){

vect2f resultat;

resultat.composante_0 = a.composante_0 + b.composante_0;

resultat.composante_1 = a.composante_1 + b.composante_1;

return resultat;

}

vect2f mult(double factor, vect2f v){

vect2f resultat;

resultat.composante_0 = factor * v.composante_0;

resultat.composante_1 = factor * v.composante_1;

return resultat;

}

vect2f divi( vect2f v, double d){

vect2f resultat;

resultat.composante_0 = v.composante_0 / d;

resultat.composante_1 = v.composante_1 / d;

return resultat;

}

int main(int argc, char** argv){

// Coefficients

// z" = az' + bz +g(t)

//

double t = 0;

double m = 0.165 ;

double k = 25.34 ;

double r = 8.1 ;

double a = -(r/m) ;

double b = -(k/m) ;

double g = cos(7.8*t); ;

// Conditions initiales

double z0 =0.13;

double z0_deriv1 = 0;

// Pas du calcul

double z = 0;

double z_deriv;

double h = 0.001;

// Solution théorique

double th ;

vect2f k1;

vect2f k2;

vect2f k3;

vect2f k4;

vect2f y;

y.composante_0 =z0;

y.composante_1 =z0_deriv1;

int i;

for(i=0; i< 1000; i++){

//printf("i= %d \n" , i+1);

k1 = f(t, y, g, a, b);

k2 = f(t + h/2, add(y, mult(h/2 , k1)), g, a, b);

k3 = f(t + h/2, add(y, mult(h/2, k2)), g, a, b);

k4 = f(t + h, add(y, mult(h, k3)), g, a, b);

vect2f tmp = add(k1, k4);

tmp = add(tmp, mult(2, k2));

tmp = add(tmp, mult(2, k3));

tmp = mult(h, tmp);

tmp = divi(tmp, 6);

tmp = add(tmp, y);

y = tmp;

z = y.composante_0;

z_deriv = y.composante_1;

t = t + h;

th = (-1/10323009200.)*exp((2/33.)*(-405 + sqrt(122214))*t)*(135*sqrt(122214) + 40738)*(-16471 + 5000*cos(7.8*t)) + (1/10323009200.)*exp((-2/33.)*(405 + sqrt(122214))*t)*(135*sqrt(122214) - 40738)*(-16471 + 5000*cos(7.8*t)) + (50/1267.)*cos(7.8*t);

printf("%.12f %.12f %.12f\n", z, th, (fabs((th - z)/th))*100);

//printf("%.12f \n", z);

}

return 0;

}

Programme pour la première équation :

#include <iostream> using namespace std; #include <math.h> //equa diff sans second membre sans frottement int main(int argc, char** argv) { int i; double t,k11,k12,k21,k22,k31,k32,k41,k42,h=0.1,k=25.34,m=0.165; double y[100]; double u[100]; y[0]=0.13; u[0]=0; for (i=1;i<=99;i++) { t=((double(i-1))*h); k11=h*(u[i-1]); k12=h*((-k/m)*y[i-1]); k21=h*(u[i-1]+k12/2); k22=h*(-k/m)*(y[i-1]+k11/2); k31=h*(u[i-1]+k22/2); k32=h*(-k/m)*(y[i-1]+k21/2); k41=h*(u[i-1]+k32); k42=h*(-k/m)*(y[i-1]+k31); y[i]=y[i-1]+(k11+2*k21+2*k31+k41)/6; u[i]=u[i-1]+(k12+2*k22+2*k32+k42)/6; cout << y[i-1] <</*" "<< (1/25.)*cos(25*sqrt(2)*t) <<" " << y[i-1]-((1/25.)*cos(25*sqrt(2)*t))<< */endl; } }

Programme pour la troisième équation : #include <iostream>

using namespace std; #include <math.h> //equa diff sans second membre et avec frottement int main(int argc, char** argv) { int i; double t,k11,k12,k21,k22,k31,k32,k41,k42,h=0.1,k=25.34,m=0.165,g=9.8,r=0.2833; //a est l'amplitude de la fonction cos, ici a=0 car pas de second membre double y[11]; double u[11]; y[0]=0.04; u[0]=0; for (i=1;i<=10;i++) { t=((double(i-1))*h); k11=h*(u[i-1]); k12=(h/m)*(((-k)*y[i-1])-(r*u[i-1])+cos(t*7.8)); k21=h*(u[i-1]+k12/2); k22=(h/m)*((-k)*(y[i-1]+k11/2)-r*(u[i-1]+k12/2)+cos((t+h/2)*7.8)); k31=h*(u[i-1]+k22/2); k32=(h/m)*((-k)*(y[i-1]+k21/2)-r*(u[i-1]+k22/2)+cos((t+h/2)*7.8)); k41=h*(u[i-1]+k32); k42=(h/m)*((-k)*(y[i-1]+k31/2)-r*(u[i-1]+k32)+cos((t+h)*7.8)); y[i]=y[i-1]+(k11+2*k21+2*k31+k41)/6; u[i]=u[i-1]+(k12+2*k22+2*k32+k42)/6; cout << y[i-1] <<" "<< (exp(0.858484*t))*((0.01100629*cos(12.36*t))+(0.01004494*sin(12.36*t)))+(0.01100629*cos(7.8*t))+(0.01188*sin(7.8*t) <<" " << -y[i-1]-((exp(0.858484*t))*((0.01100629*cos(12.36*t))+(0.01004494*sin(12.36*t)))+(0.01100629*cos(7.8*t))+(0.01188*sin(7.8*t))<< endl; } }

Code Maple :