PHYS710 : Simulation et modélisation en physique

Le but de ce cours est d'initier les étudiants au développement d'un logiciel de simulation ou de modélisation en physique. Ce logiciel sera modulaire et composé de sous-ensembles interagissant entre eux. Chaque module ou sous-ensemble sera développé par un binôme qui en aura la responsabilité. Le but sous-jacent est l'initiation à un travail collaboratif.

Dans cet esprit, la première séance consistera en une introduction succinte à l'environnement de développement et au langage choisis, en l'occurence ROOT et le C/C++. Les séances suivantes, espacées de 2 à 3 semaines seront des occasions de faire le point, chaque binôme expliquant aux autres l'évolution de leur travail et les points d'accès pour que tous puissent faire des tests entre les modules. Entre temps, les étudiants communiqueront avec l'enseignant et leurs camarades à travers un ensemble d'outils tels cette page wiki et une liste de diffusion. L'enseignant collectera les contributions (et suggérera/demandera éventuellement des modifications) de telle sorte qu'elles soient disponibles pour tous.

Autant que faire se peut, on envisagera une utilisation ultérieure du logiciel, soit dans le cadre des exercices "WIMS" de première année, soit pour servir de point de départ aux projets des années suivantes.

Introduction, outils de développement

Cadre général

• Simulation, modélisation en physique
• Développement d'un logiciel de modélisation
• Contraintes, travail en groupe
• Exemple: un système mécanique complexe, le moteur à explosion

Environnement

On utilisera ROOT.

• Rappel de quelques commandes Unix (si nécessaire)
• Utilisation de ROOT
• Compilation d'un petit code C
• Compilation d'un code intégrant des fonctionnalités ROOT

Langage

Nous utiliserons le C/C++. Les notions générales de C seront supposées connues (petit rappel rapide). On introduira les notions suivantes avec à chaque fois l'analyse de petits exemples de macros ROOT.

• Rappels de C : variables, fonctions, structures de contrôle, exemple de programme complet
• Pointeurs
• Le préprocesseur
• Allocation dynamique en C
• Le langage C++
• Classes, objets
  • Héritage
  • Constructeurs, destructeurs
  • Encapsulation
• Allocation dynamique en C++

Petit programme complet à la fin de cette page. Essayez-le dans ROOT.

En règle générale, on donnera les informations nécessaires pour comprendre les macros ROOT présentées. Il reste beaucoup d'auto-formation à faire de la part des étudiants !

Quelques références

• cours de C++ à partir du C.
• "mégacours" de C/C++.
• Cours sur "le site du zéro"
• Ce qu'il ne faut pas faire : les anti-patrons

Bibliothèques

gsl, modules ROOT, bibliothèques trouvées ou produites par les étudiants

Outils de travail collaboratif

Ce wiki : Pour réaliser des pages sur ce wiki, il faut utiliser la syntaxe habituelle des wikis ce qui inclut des formules LaTeX encadrées par <math>...</math>

Liste de diffusion : en cours de mise au point

Outil de gestion de versions : cvs ou svn. Accessible seulement à l'enseignant.

Sujets proposés

Evolution d'une galaxie

Système mécanique composé

...

Programme en C++ montrant les diverses notions vues en cours

En cours d'écriture

Vous n'êtes pas forcés de tout réécrire, vous pouvez télécharger les fichiers ici : [Disque.h] et [Disque.C]. Une fois que vous les avez téléchargés, suivez les instructions à la fin de ce paragraphe pour les utiliser dans ROOT. Avant, il faut comprendre ce qu'ils contiennent.

Les commentaires (après les //) devraient donner pas mal d'explications.

Voyons d'abord le fichier en-tête, déclarant les classes, fonctions, etc... des différents programmes. On met toujours ces déclarations dans un fichier séparé pour pouvoir les réutiliser. On nomme ce fichier "Disque.h" :

// La classe suivante definit un objet "disque" que l'on manipulera plus tard

// Declaration de la classe

class Disque
{
   private:
      // Definition des variables privees
      double mXC;        // coordonnees du centre
      double mYC;
      double mEpaisseur;  // Epaisseur si en 3D
      double mR;            // rayon du disque

   public:
      
      // Methodes "getter" pour acceder aux variables privees 
      double GetXC();
      double GetYC();
      double GetEpaisseur();
      double GetRayon();
      // Methodes "setter" pour initialiser les variables privees
      void SetXC(double x);
      void SetYC(double x);
      void SetEpaisseur(double x);
      void SetRayon(double x);
     
      // Methodes autres
      void Trace();                            // trace le disque
      void Deplace(double vX, double vY);  // Deplace le disque de (vX, vY)
      double Surface();                       // Renvoie la surface du disque
};

Voici le contenu du fichier "Disque.C". On commence par utiliser la directive "#include" pour inclure les fichiers d'en-tête.

#include "Disque.h"
#include "TCanvas.h"
#include "TEllipse.h"

Ensuite, on écrit le contenu des différentes méthodes de la classe en commençant par le constructeur

// ======================
//    Constructeur
// ======================
Disque::Disque(double xC, double yC, double epaisseur, double R)
{
   mXC = xC;
   mYC = yC;
   mEpaisseur = epaisseur;
   mR = R;
} 

Les fonctions qui permettent de récupérer les informations "privées" de la classe. Ces fonctions ne sont pas absolument indispensables pour faire tourner le programme, sauf si on a besoin d'accéder à des données privées. On est en plein dans les conséquences de la notion "d'encapsulation".

// ===========================
//    "Getter" et "Setter"
// ===========================

double Disque::GetXC()
{
   return mXC;
}

double Disque::GetYC()
{
   return mYC;
}

double Disque::GetEpaisseur()
{
   return mEpaisseur;
}

double Disque::GetRayon()
{
   return mR;
}

void Disque::SetXC(double x)
{
   mXC = x;
}

void Disque::SetYC(double x)
{
   mYC = x;
}

void Disque::SetEpaisseur(double x)
{
   mEpaisseur = x;
}

void Disque::SetRayon(double x)
{
   mR = x;
}

On passe maintenant aux méthodes spécifiques à la classe. Ici, on définit une méthode de tracé, une de déplacement et une de calcul simple.

// =========================================================
//     Methodes de visualisation, deplacement
// =========================================================

void Disque::Trace()
{
// trace le disque dans un canvas
   TEllipse* ell;
   
// **** ATTENTION, fuite de memoire !!!! ****
// on ne detruit jamais l'ellipse "ell" !
   ell = new TEllipse(mXC,mYC,mR);
   ell->Draw();
}

void Disque::Deplace(double vX, double vY)
{
// Deplace le disque de (vX, vY)
   mXC += vX;
   mYC += vY;
// Probleme : on n'est pas lie a l'objet ellipse cree dans la methode "Trace"
}

// ============================
//     Methodes de calcul
// ============================
double Disque::Surface()
{
// Renvoie la surface du disque
   double surf;
   double PI = 4*atan(1);
   
   surf = PI*mR*mR;
   return surf;
}