Voir la source de Oscillation simple

== Description  ==

L'idée de cette première partie est de réaliser la simulation d'un mobile sur coussin d'air relié par un ressort à un point fixe. 

=== Construction de l'environnement  ===

<source lang="java">
int deplacement = 150;

void setup() {
  size(800, 300, P2D);
  smooth();
  frameRate(60);
}

void draw() {
  background(255);
  fill(255);
  translate(deplacement, deplacement);
  rect(0, -50, 50, 50);
  line(0, 0, 1020, 0);
}
</source>

=== Ajout des classes  ===

Nous avons donc figuré le plan où le mobile va se déplacer ainsi que le point d'appui du ressort. Pour la suite, nous allons construire deux classes, une pour le ressort et une autre pour le mobile. 

Le mobile est caractérisé par sa position sur l'axe. Nous aurions pu simplement n'utiliser qu'une valeur x pour le mobile, mais comme l'objectif est de l'améliorer dans le futur, nous allons utilisé un PVector. 

<source lang="java">
class Mobile {
  PVector position;

  Mobile (PVector pos) {
    position = pos;
  }
}
</source> 

Pour le ressort nous allons créer une classe Ressort qui se caractérise par son point d'ancrage, par le point où est accroché le mobile, sa constante de raideur et sa longueur au repos lorsqu'il n'est soumis à aucune force. 

<source lang="java">
class Ressort {
  PVector pointAncre;
  Mobile pointMobile;
  float longueurRepos = 200; // longueur au repos en pixel
  float forceK = 5; // Constant de raideur en N.m-1

  Ressort(PVector pointA, Mobile pointB) {
    pointAncre = pointA;
    pointMobile = pointB;
  }
}
</source> 

Maintenant il faut instancer ces classes dans le programme principal et les initialiser. 

<source lang="java">
Ressort ressort;
Mobile mobile;
int deplacement = 150;

void setup() {
  size(800, 300, P2D);
  smooth();
  frameRate(60);
  mobile = new Mobile(new PVector(250, -25));
  ressort = new Ressort(new PVector(50, -25), mobile);
}
</source> 

Pour pouvoir faire apparaître ces objets que nous venons de créer, il faut est nécessaire de créer des méthodes répondant à cette tâche. Le mobile n'est composé que d'un rectangle, ajouter ces lignes dans la classe Mobile&nbsp;: 
<source lang="java">
  void afficher() {
    rect(position.x, position.y - 25, 50, 50);
  }
</source> 

Le ressort est un peu plus complexe à simuler. Nous prenons le parti d'un ressort à 10 spires et chaque spire composée d'un zigzag réalisé à l'aide de vertex. Plus le ressort est comprimé plus l'intervalle de chaque spire est réduit. Ajouter ces lignes à la classe Ressort 

<source lang="java">
 void afficher() {
    float intervalle = (pointMobile.position.x - pointAncre.x) / 10;
    for (int i = 0; i < 10; i++) { // 10 spires de ressort
      noFill();
      beginShape();
      vertex(pointAncre.x + intervalle * i, -25);
      vertex(pointAncre.x + intervalle * i + intervalle / 4, -35);
      vertex(pointAncre.x + intervalle * i + 3 * intervalle / 4, -15);
      vertex(pointAncre.x + intervalle * i + intervalle, -25);
      endShape();
    }
  }
</source>

Il ne reste plus qu'à les afficher par ces méthodes dans la méthode draw du programme principal. 
<source lang="java">
mobile.afficher();
ressort.afficher();
</source>

=== Mise en oeuvre de l'intéractivité  ===

Avant de passer au calcul des forces, nous allons ajouter un peu d'interactivité, pour pouvoir déplacer le mobile avec la souris. Une première méthode de la classe Mobile permet de sélectionner le mobile si le bouton de la souris est cliquer et que le souris est au dessus du mobile. Nous introduisons aussi une nouvelle variable couleur qui permet de voir le mobile une fois sélectionner. La variable selectionRef permet de stocker la distance entre la souris le point de référence du mobile. 

<source lang="java">
  void selectionner(PVector PMouse) {
    if ((PMouse.x > deplacement + position.x) && (PMouse.x < deplacement + position.x + 50) && (PMouse.y > deplacement + position.y - 25) && (PMouse.y < deplacement + position.y + 25)) {
      selection = true;
      selectionRef = PVector.sub(position, PMouse);
      couleur = color(100);
    }
  }
</source>Il faut aussi déclarer ces variables dans la classe Mobile 
<source lang="java">
  PVector selectionRef;
  color couleur = color(255);
  boolean selection = false;
</source>

Il faut maintenant modifier la méthode afficher pour prendre en compte le changement de couleur du mobile&nbsp;: 
<source lang="java">
  void afficher() {
    fill(couleur);
    rect(position.x, position.y - 25, 50, 50);
  }
</source>

Ajouter la méthode suivante dans le programme principal, pour permettre les interruptions de la souris. 
<source lang="java">
void mousePressed() {
  mobile.selectionner(new PVector(mouseX, mouseY));
}
</source>

La méthode suivante toujours dans le programme principal a pour objectif de faire appel à la méthode de désélection du mobile lorsque le bouton de la souris est relâchée. 
<source lang="java">
void mouseReleased() {
  mobile.deSelectionner();
}
</source>

Cette méthode de la classe Mobile change simplement la couleur du mobile. 
<source lang="java">
  void deSelectionner() {
    selection = false;
    couleur = color(255);
  }
</source>

Maintenant nous pouvons créer une méthode de la classe Mobile pour permettre de glisser le mobile avec le curseur de la souris. 
<source lang="java">
  void glisser(PVector PMouse) {
    if (selection) {
      position = PVector.add(selectionRef, PMouse);
      if (position.x  < 70) { // limite de compression du ressort
        position.x = 70;
      }
      position.y = -25; // impose le déplacement sur l'axe des X
    }
  }
</source>

Pour visualiser les déplacements, il faut faire appel à cette méthode dans le programme principal. Insérer ces lignes avant les méthodes d'affichage. 
<source lang="java">
  PVector souris = new PVector(mouseX, mouseY);
  mobile.glisser(souris);
</source>

A présent le mobile bouge au rythme de la souris mais n'est pas du tout soumis à la force du ressort. 

=== Mise en oeuvre de la force de rappel  ===

Pour le cas d'un ressort la force résultante est proportionnelle à son allongement relatif<ref>[http://fr.wikipedia.org/wiki/Force_(physique)#Forces_.C3.A9lastiques Forces élastiques]</ref>. Donc nous allons créer une méthode pour la classe Ressort qui calcule cette force. 

<source lang="java">
  void calculForce() {
    PVector rappel = PVector.sub(pointMobile.position, pointAncre); // Vecteur du déplacement
    float longueur = rappel.mag();
    float etirement = longueur - longueurRepos; // Calcul de l'étirement
    rappel.normalize();
    rappel.mult((-1) * forceK * etirement / correction); // Calcul de la force de rappel
    pointMobile.force = rappel;
  }

</source>

Nous avons introduit une variable "correction" dans la méthode Ressort parce qu'il faut faire correspondre le nombre de pixel en mètre de déplacement. Ce nombre est empirique et il faudrait regarder de manière plus pousser cette relation( à faire). 
<source lang="java">
  int correction = 60; 
</source>

Dans la méthode Mobile, il faut introduire une variable "force" et l'initialiser. Cette variable prendra la valeur de toute les forces qui feront bouger le mobile. 

<source lang="java">
  PVector force = new PVector(0, 0);
</source>

Dans le programme principal, il faut faire calculer à chaque frame la force résultante de l'action du ressort. 
<source lang="java">
  ressort.calculForce();
</source>

=== Mise en oeuvre du déplacement en fonction des forces  ===

Pour calculer les positions successives du mobile en fonction du temps et des forces qui agissent sur lui, nous utilisons l'intégration Verlet<ref>[http://ressources.mediabox.fr/tutoriaux/flashplatform/math_physique/utiliser_les_forces_physiques_pour_mouvoir_des_objets_partie_ii Intégration Verlet] </ref> qui permet de simuler au mieux ceci. Intégration Verlet x(t+1) = 2 * x(t) - x(t-1) + a * ∆T * ∆T 
Pour effectuer ce calcul il nous faut intégrer la position précédente du mobile par la variable positionPrec qui sera un PVector, il faut aussi l'initialiser dans le constructeur de la class Mobile.
<source lang="java">
 positionPrec = pos;
</source>

Pour le calcul de la nouvelle position du mobile nous allons créer une méthode, actualiser() pour le réaliser. Nous passons le ∆T en paramètre.
Pour la calcul de la nouvelle position, nous utilisons une variable temporaire calcul. 
Pour déterminer l'accélération, il faut utiliser la deuxième loi de Newton<ref>Soit un corps de masse m (constante) : l'accélération subie par ce corps dans un référentiel galiléen est proportionnelle à la résultante des forces qu'il subit, et inversement proportionnelle à sa masse m. [http://fr.wikipedia.org/wiki/Lois_du_mouvement_de_Newton#Deuxi.C3.A8me_loi_de_Newton_ou_principe_fondamental_de_la_dynamique_de_translation Lien]</ref>. A = F / M. Auparavant il faut déclarer et initialiser la variable masse pour les besoins du calcul.
Nous prenons toujours garde que la position lors de la compression reste dans la limite du ressort.

<source lang="java">
  void actualiser(float deltaT) {
    PVector calcul = PVector.mult(position, 2);  // Intégration Verlet x(t+1) = 2 * x(t) - x(t-1) + a * ∆T * ∆T
    calcul.sub(positionPrec);
    PVector acceleration = PVector.div(force, masse); // Loi de Newton : F = M * A
    acceleration.mult(deltaT * deltaT);
    calcul.add(acceleration);
    positionPrec = position.get();
    position = calcul.get();
    if (position.x < 70) {
      position.x = 70; // Limite minimale de compression du ressort
    }
  }
</source>

Pour finir, il faut appeler cette dernière méthode dans le programme principal après le calcul des forces après avoir déclarer et initialiser la variable delta.

[[Image:Physique 1.png|thumb]] 

== Script Processing principal  ==

<source lang="java">
//-----------------------------------------------------------------------------
// Projet               : La physique amusante
// Programme            : Physique_1.pde
// Auteur               : Sylvain Blocquaux
// Date                 : 11 avril 2011
// Version              : 1.0
//-----------------------------------------------------------------------------

Ressort ressort;
Mobile mobile;
int deplacement = 150;
float delta;

void setup() {
  size(800, 300, P2D);
  smooth();
  frameRate(60);
  delta = 1 / frameRate;
  mobile = new Mobile(new PVector(250, -25));
  ressort = new Ressort(new PVector(50, -25), mobile);
}

void draw() {
  background(255);
  fill(255);
  translate(deplacement, deplacement);
  rect(0, -50, 50, 50);
  line(0, 0, 1020, 0);
  PVector souris = new PVector(mouseX, mouseY);
  mobile.glisser(souris);
  ressort.calculForce();
  mobile.actualiser(delta);
  mobile.afficher();
  ressort.afficher();
}

void mousePressed() {
  mobile.selectionner(new PVector(mouseX, mouseY));
}

void mouseReleased() {
  mobile.deSelectionner();
}

</source>

== Script Processing class Mobile  ==

<source lang="java">
//-----------------------------------------------------------------------------
// Projet               : La physique amusante
// Classe               : Mobile.pde
// Auteur               : Sylvain Blocquaux
// Date                 : 11 avril 2011
// Version              : 1.0
//-----------------------------------------------------------------------------

class Mobile {
  PVector position;
  PVector positionPrec;
  PVector selectionRef;
  color couleur = color(255);
  boolean selection = false;
  PVector force = new PVector(0, 0);
  float masse = 0.5; // Masse en kg

  Mobile (PVector pos) {
    position = pos;
    positionPrec = pos;
  }

  void afficher() {
    fill(couleur);
    rect(position.x, position.y - 25, 50, 50);
  }

  void actualiser(float deltaT) {
    PVector calcul = PVector.mult(position, 2);  // Intégration Verlet x(t+1) = 2 * x(t) - x(t-1) + a * ∆T * ∆T
    calcul.sub(positionPrec);
    PVector acceleration = PVector.div(force, masse); // Loi de Newton : F = M * A
    acceleration.mult(deltaT * deltaT);
    calcul.add(acceleration);
    positionPrec = position.get();
    position = calcul.get();
    if (position.x < 70) {
      position.x = 70; // Limite minimale de compression du ressort
    }
  }

  void selectionner(PVector PMouse) {
    if ((PMouse.x > deplacement + position.x) && (PMouse.x < deplacement + position.x + 50) && (PMouse.y > deplacement + position.y - 25) && (PMouse.y < deplacement + position.y + 25)) {
      selection = true;
      selectionRef = PVector.sub(position, PMouse);
      couleur = color(100);
    }
  }

  void glisser(PVector PMouse) {
    if (selection) {
      position = PVector.add(selectionRef, PMouse);
      if (position.x  < 70) { // limite de compression du ressort
        position.x = 70;
      }
      position.y = -25; // impose le déplacement sur l'axe des X
    }
  }

  void deSelectionner() {
    selection = false;
    couleur = color(255);
  }
}
</source>

== Script Processing class Ressort  ==

<code java>
//-----------------------------------------------------------------------------
// Projet               : La physique amusante
// Classe               : Ressort.pde
// Auteur               : Sylvain Blocquaux
// Date                 : 11 avril 2011
// Version              : 1.0
//-----------------------------------------------------------------------------

class Ressort {
  PVector pointAncre;
  Mobile pointMobile;
  float longueurRepos = 200; // longueur au repos en pixel
  float forceK = 5; // Constant de raideur en N.m-1
  int correction = 60; 

  Ressort(PVector pointA, Mobile pointB) {
    pointAncre = pointA;
    pointMobile = pointB;
  }

  void calculForce() {
    PVector rappel = PVector.sub(pointMobile.position, pointAncre); // Vecteur du déplacement
    float longueur = rappel.mag();
    float etirement = longueur - longueurRepos; // Calcul de l'étirement
    rappel.normalize();
    rappel.mult((-1) * forceK * etirement / correction); // Calcul de la force de rappel
    pointMobile.force = rappel;
  }

  void afficher() {
    float intervalle = (pointMobile.position.x - pointAncre.x) / 10;
    for (int i = 0; i < 10; i++) { // 10 spires de ressort
      noFill();
      beginShape();
      vertex(pointAncre.x + intervalle * i, -25);
      vertex(pointAncre.x + intervalle * i + intervalle / 4, -35);
      vertex(pointAncre.x + intervalle * i + 3 * intervalle / 4, -15);
      vertex(pointAncre.x + intervalle * i + intervalle, -25);
      endShape();
    }
  }
}
</source>

== Notes  ==

== Archive du projet  ==

[[Image:Physique 1.zip]]

[[Catégorie:Processing]]