Wiki du LAMA (UMR 5127) - Contributions [fr]

PHYS710 : Simulation et modélisation en physique

2008-09-22T16:58:36Z

Lfall : /* Résumé du 1er cours : rappel sur le langage C */

[[Projet: Evolution d'une galaxie]]

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 [http://root.cern.ch 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 [http://root.cern.ch '''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 ====
* [http://cpp.developpez.com/cours/polyCpp/ cours de C++ à partir du C].
* [http://cpp.developpez.com/cours/cpp/ "mégacours" de C/C++].
* [http://www.siteduzero.com/tutoriel-3-11406-apprenez-a-programmer-en-c.html Cours sur "le site du zéro"]
* Ce qu'il ne faut pas faire : [http://fr.wikipedia.org/wiki/Antipattern les anti-patrons]

=== Bibliothèques ===

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

==== Résumé du 1er cours : rappel sur le langage C ====

;Variables
: int (entier)
: float (réel 4 octets)
: double (réel 8 octets)
: char (caractère 1 octet)
: ...

;Déclaration des variables
=> ''int i,j,k;''
 Pour déclarer un tableau qui va de 0 à 99 : ''float a[100];''
<br\>Puis initialisation : ''a[i]=0;

;Boucles
=> for, while, do...
 Exemple avec la boucle for : ''for (i=1 ; i<36 ; i++) {......}''

;Tests
''if (i<35 && i>27 && i!=30) {......} else if (...) {...}''
 On peut avoir :
:&& "et"
:== "égal"
:|| "ou"
:!= "différent"

;Commentaires
:en C : '''/*....*/'''
:en C++ : '''//'''

;Pointeurs
Déclaration : ''float* a;''
 Utilisation : ''(*a)=18'';
 Exemple :
::''z=23;''
::''a=&z;''
::''*a=18;''
:On obtient donc au final que z=18

;Place réservée
''à venir''

== Outils de travail collaboratif ==

'''Ce wiki''' : Pour réaliser des pages sur ce wiki, il faut utiliser la [http://fr.wikipedia.org/wiki/Aide:Syntaxe_wikip%C3%A9dia syntaxe habituelle des wikis]
ce qui inclut des formules LaTeX encadrées par <nowiki><math>...</math></nowiki>

'''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 : [[http://www.lapp.in2p3.fr/~buskulic/Disque.h Disque.h]] et [[http://www.lapp.in2p3.fr/~buskulic/Disque.C 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;
}

=== Utilisation de la classe dans ROOT ===

Avant de l'inclure dans un programme, il est bon de voir ce que l'on peut faire avec cette classe dans ROOT et comment on appelle chacune des méthodes. Comme ROOT contient un interpréteur C/C++, chaque ligne que nous écrirons sur la ligne de commande sera identique à ce que nous ferons plus tard dans un programme complet.

Première chose, il faut charger la classe dans ROOT (une fois celui-ci lancé dans le répertoire où se trouvent Disque.h et Disque.C, bien sûr). Pour celà, on utilise la commande ROOT ".L" :
root[0] .L Disque.C
Construisons ensuite un objet de la classe "Disque". On va utiliser la commande "new" pour créer l'objet et récupérer un pointeur sur cet objet :
root[1] d = new Disque(0.5, 0.5, 0.1, 0.1)
Ce faisant, on a appelé le constructeur de la classe disque. Ce constructeur, nous l'avons déclaré et défini pour qu'il prenne 4 paramètres en entrée et qu'il mette ces paramètres dans les variables privées de la classe. Si vous regardez le code, vous verrez que nous venons de définir un objet "Disque" de coordonnées du centre (0.5, 0.5), d'épaisseur 0.1 et de rayon 0.1.

Si l'on appelle maintenant la méthode de tracé, ce disque va se tracer tout seul :
root[2] d->Trace()

Et voilà ! On voit apparaître un disque dans une fenêtre, appelée "Canvas" dans ROOT. Si on demande la surface du disque en appelant la méthode "Surface()", on obtient :
root [3] d->Surface()
'''(double)3.14159265358979339e-02'''
Là encore, on a appelé la méthode de l'objet d qui renvoie la valeur de la surface. Remarquez l'emploi de l'opérateur "->" (signe "-" suivi du signe supérieur ">" ). On appelle cet opérateur l'opérateur de déréférencement et il est employé pour indiquer "la méthode de l'objet pointé par ...". "d" est un pointeur, donc la méthode "Surface()" de l'objet pointé par "d" est appelée en utilisant "->".

=== Analyse d'une macro ROOT ===

On appelle "macro" ou "script" un programme ou morceau de programme que ROOT va interpréter. Analysons la macro suivante "graph.C" :

void graph() {
//Draw a simple graph
//Author: Rene Brun

TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);

c1->SetFillColor(42);
c1->SetGrid();

const Int_t n = 20;
double x[n], y[n];

for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
printf(" i %i %f %f \n",i,x[i],y[i]);
}

gr = new TGraph(n,x,y);

gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");

// TCanvas::Update() draws the frame, after which one can change it
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(12);
c1->Modified();
}

Vous pouvez l'exécuter dans ROOT, c'est une macro "standard" présente dans le répertoire ROOT. Faites simplement :
root[4] .x $ROOTSYS/tutorials/graphs/graph.C

Reprenons les lignes principales. Vous pouvez tester l'effet de certaines en recopiant le fichier chez vous et en enlevant la ou les lignes correspondantes avant de lancer la macro.

d'abord, la déclaration de la fonction. Elle ne prend pas d'argument :
void graph()
{

Ensuite, on construit un objet "TCanvas" qui est une fenêtre graphique dans laquelle on va dessiner :
TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);

On en profite pour appeler des méthodes de cet objet "TCanvas" qui remplissent le fond d'une certaine couleur
c1->SetFillColor(42);
et qui activent une option traçant une grille pointillée
c1->SetGrid();

viennent ensuite les déclarations de variables que l'on va utiliser. Ici, on a besoin de déclarer deux tableaux qui vont représenter des coordonnées de points à tracer. n est le nombre de points.
const Int_t n = 20;
double x[n], y[n];

ces points, il faut bien leur donner des valeurs, d'où la boucle ci-dessous :
for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
printf(" i %i %f %f \n",i,x[i],y[i]);
}

ensuite, on construit un objet "graphique" défini dans ROOT qui s'appelle "TGraph". On passe les pointeurs "x" et "y" sur les tableaux qu'on vient de remplir à ce constructeur, ainsi que le nombre de points :
gr = new TGraph(n,x,y);

et on rend le graphe "joli". Les noms des méthodes parlent d'eux-même :
gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");

enfin, l'auteur a décidé de changer encore un peu le fond, libre à lui...
// TCanvas::Update() draws the frame, after which one can change it
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(12);
c1->Modified();
}

Amusez-vous à modifier le code ci-dessus et à tester vos modifications dans ROOT. Par exemple, mettre plus de points ou changer certaines caractéristiques de couleur. C'est la meilleure manière d'apprendre ou de vérifier que vous avez bien compris. La classe TGraph est documentée sur le site de ROOT à la page : [[http://root.cern.ch/root/html520/TGraph.html http://root.cern.ch/root/html520/TGraph.html]]

Il y a beaucoup de méthodes. Regardez certaines d'entre elles pour voir si vous comprenez leur utilité.

Il y a même un exemple encore plus simple de macro au début de cette page.

Il y a dans ROOT un très grand nombre de classes différentes, nous verrons celles dont nous aurons besoin au fur et à mesure.

PHYS710 : Simulation et modélisation en physique

2008-09-22T16:55:26Z

Lfall : /* Résumé du 1^er cours : rappel sur le langage C */

[[Projet: Evolution d'une galaxie]]

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 [http://root.cern.ch 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 [http://root.cern.ch '''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 ====
* [http://cpp.developpez.com/cours/polyCpp/ cours de C++ à partir du C].
* [http://cpp.developpez.com/cours/cpp/ "mégacours" de C/C++].
* [http://www.siteduzero.com/tutoriel-3-11406-apprenez-a-programmer-en-c.html Cours sur "le site du zéro"]
* Ce qu'il ne faut pas faire : [http://fr.wikipedia.org/wiki/Antipattern les anti-patrons]

=== Bibliothèques ===

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

==== Résumé du 1er cours : rappel sur le langage C ====

;Variables
: int (entier)
: float (réel 4 octets)
: double (réel 8 octets)
: char (caractère 1 octet)
: ...

;Déclaration des variables
=> ''int i,j,k;''
 Pour déclarer un tableau qui va de 0 à 99 : ''float a[100];''
<br\>Puis initialisation : ''a[i]=0;

;Boucles
=> for, while, do...
 Exemple avec la boucle for : ''for (i=1 ; i<36 ; i++) {......}''

;Tests
''if (i<35 && i>27 && i!=30) {......} else if (...) {...}''
 On peut avoir :
:&& "et"
:== "égal"
:|| "ou"
:!= "différent"

;Commentaires
:en C : '''/*....*/'''
:en C++ : '''//'''

;Pointeurs
Déclaration : ''float* a;''
 Utilisation : ''(*a)=18'';
 Exemple :
::''z=23'';
::''a=&z'';
::''*a=18;''
:On obtient donc au final que z=18

== Outils de travail collaboratif ==

'''Ce wiki''' : Pour réaliser des pages sur ce wiki, il faut utiliser la [http://fr.wikipedia.org/wiki/Aide:Syntaxe_wikip%C3%A9dia syntaxe habituelle des wikis]
ce qui inclut des formules LaTeX encadrées par <nowiki><math>...</math></nowiki>

'''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 : [[http://www.lapp.in2p3.fr/~buskulic/Disque.h Disque.h]] et [[http://www.lapp.in2p3.fr/~buskulic/Disque.C 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;
}

=== Utilisation de la classe dans ROOT ===

Avant de l'inclure dans un programme, il est bon de voir ce que l'on peut faire avec cette classe dans ROOT et comment on appelle chacune des méthodes. Comme ROOT contient un interpréteur C/C++, chaque ligne que nous écrirons sur la ligne de commande sera identique à ce que nous ferons plus tard dans un programme complet.

Première chose, il faut charger la classe dans ROOT (une fois celui-ci lancé dans le répertoire où se trouvent Disque.h et Disque.C, bien sûr). Pour celà, on utilise la commande ROOT ".L" :
root[0] .L Disque.C
Construisons ensuite un objet de la classe "Disque". On va utiliser la commande "new" pour créer l'objet et récupérer un pointeur sur cet objet :
root[1] d = new Disque(0.5, 0.5, 0.1, 0.1)
Ce faisant, on a appelé le constructeur de la classe disque. Ce constructeur, nous l'avons déclaré et défini pour qu'il prenne 4 paramètres en entrée et qu'il mette ces paramètres dans les variables privées de la classe. Si vous regardez le code, vous verrez que nous venons de définir un objet "Disque" de coordonnées du centre (0.5, 0.5), d'épaisseur 0.1 et de rayon 0.1.

Si l'on appelle maintenant la méthode de tracé, ce disque va se tracer tout seul :
root[2] d->Trace()

Et voilà ! On voit apparaître un disque dans une fenêtre, appelée "Canvas" dans ROOT. Si on demande la surface du disque en appelant la méthode "Surface()", on obtient :
root [3] d->Surface()
'''(double)3.14159265358979339e-02'''
Là encore, on a appelé la méthode de l'objet d qui renvoie la valeur de la surface. Remarquez l'emploi de l'opérateur "->" (signe "-" suivi du signe supérieur ">" ). On appelle cet opérateur l'opérateur de déréférencement et il est employé pour indiquer "la méthode de l'objet pointé par ...". "d" est un pointeur, donc la méthode "Surface()" de l'objet pointé par "d" est appelée en utilisant "->".

=== Analyse d'une macro ROOT ===

On appelle "macro" ou "script" un programme ou morceau de programme que ROOT va interpréter. Analysons la macro suivante "graph.C" :

void graph() {
//Draw a simple graph
//Author: Rene Brun

TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);

c1->SetFillColor(42);
c1->SetGrid();

const Int_t n = 20;
double x[n], y[n];

for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
printf(" i %i %f %f \n",i,x[i],y[i]);
}

gr = new TGraph(n,x,y);

gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");

// TCanvas::Update() draws the frame, after which one can change it
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(12);
c1->Modified();
}

Vous pouvez l'exécuter dans ROOT, c'est une macro "standard" présente dans le répertoire ROOT. Faites simplement :
root[4] .x $ROOTSYS/tutorials/graphs/graph.C

Reprenons les lignes principales. Vous pouvez tester l'effet de certaines en recopiant le fichier chez vous et en enlevant la ou les lignes correspondantes avant de lancer la macro.

d'abord, la déclaration de la fonction. Elle ne prend pas d'argument :
void graph()
{

Ensuite, on construit un objet "TCanvas" qui est une fenêtre graphique dans laquelle on va dessiner :
TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);

On en profite pour appeler des méthodes de cet objet "TCanvas" qui remplissent le fond d'une certaine couleur
c1->SetFillColor(42);
et qui activent une option traçant une grille pointillée
c1->SetGrid();

viennent ensuite les déclarations de variables que l'on va utiliser. Ici, on a besoin de déclarer deux tableaux qui vont représenter des coordonnées de points à tracer. n est le nombre de points.
const Int_t n = 20;
double x[n], y[n];

ces points, il faut bien leur donner des valeurs, d'où la boucle ci-dessous :
for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
printf(" i %i %f %f \n",i,x[i],y[i]);
}

ensuite, on construit un objet "graphique" défini dans ROOT qui s'appelle "TGraph". On passe les pointeurs "x" et "y" sur les tableaux qu'on vient de remplir à ce constructeur, ainsi que le nombre de points :
gr = new TGraph(n,x,y);

et on rend le graphe "joli". Les noms des méthodes parlent d'eux-même :
gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");

enfin, l'auteur a décidé de changer encore un peu le fond, libre à lui...
// TCanvas::Update() draws the frame, after which one can change it
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(12);
c1->Modified();
}

Amusez-vous à modifier le code ci-dessus et à tester vos modifications dans ROOT. Par exemple, mettre plus de points ou changer certaines caractéristiques de couleur. C'est la meilleure manière d'apprendre ou de vérifier que vous avez bien compris. La classe TGraph est documentée sur le site de ROOT à la page : [[http://root.cern.ch/root/html520/TGraph.html http://root.cern.ch/root/html520/TGraph.html]]

Il y a beaucoup de méthodes. Regardez certaines d'entre elles pour voir si vous comprenez leur utilité.

Il y a même un exemple encore plus simple de macro au début de cette page.

Il y a dans ROOT un très grand nombre de classes différentes, nous verrons celles dont nous aurons besoin au fur et à mesure.

PHYS710 : Simulation et modélisation en physique

2008-09-22T16:26:20Z

Lfall :

[[Projet: Evolution d'une galaxie]]

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 [http://root.cern.ch 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 [http://root.cern.ch '''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 ====
* [http://cpp.developpez.com/cours/polyCpp/ cours de C++ à partir du C].
* [http://cpp.developpez.com/cours/cpp/ "mégacours" de C/C++].
* [http://www.siteduzero.com/tutoriel-3-11406-apprenez-a-programmer-en-c.html Cours sur "le site du zéro"]
* Ce qu'il ne faut pas faire : [http://fr.wikipedia.org/wiki/Antipattern les anti-patrons]

=== Bibliothèques ===

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

==== Résumé du 1^er cours : rappel sur le langage C ====

* Variables : ** int (entier)
** float (réel 4 octets)
** double (réel 8 octets)
** char (caractère 1 octet)
** ...

* Déclaration des variables : ''int i,j,k;''
Pour déclarer un tableau qui va de 0 à 99 : ''float a[100];''
Puis initialisation : ''a[i]=0;

* Boucles : for, while, do...
Exemple avec la boucle for : ''for (i=1 ; i<36 ; i++) { ...... }''

== Outils de travail collaboratif ==

'''Ce wiki''' : Pour réaliser des pages sur ce wiki, il faut utiliser la [http://fr.wikipedia.org/wiki/Aide:Syntaxe_wikip%C3%A9dia syntaxe habituelle des wikis]
ce qui inclut des formules LaTeX encadrées par <nowiki><math>...</math></nowiki>

'''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 : [[http://www.lapp.in2p3.fr/~buskulic/Disque.h Disque.h]] et [[http://www.lapp.in2p3.fr/~buskulic/Disque.C 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;
}

=== Utilisation de la classe dans ROOT ===

Avant de l'inclure dans un programme, il est bon de voir ce que l'on peut faire avec cette classe dans ROOT et comment on appelle chacune des méthodes. Comme ROOT contient un interpréteur C/C++, chaque ligne que nous écrirons sur la ligne de commande sera identique à ce que nous ferons plus tard dans un programme complet.

Première chose, il faut charger la classe dans ROOT (une fois celui-ci lancé dans le répertoire où se trouvent Disque.h et Disque.C, bien sûr). Pour celà, on utilise la commande ROOT ".L" :
root[0] .L Disque.C
Construisons ensuite un objet de la classe "Disque". On va utiliser la commande "new" pour créer l'objet et récupérer un pointeur sur cet objet :
root[1] d = new Disque(0.5, 0.5, 0.1, 0.1)
Ce faisant, on a appelé le constructeur de la classe disque. Ce constructeur, nous l'avons déclaré et défini pour qu'il prenne 4 paramètres en entrée et qu'il mette ces paramètres dans les variables privées de la classe. Si vous regardez le code, vous verrez que nous venons de définir un objet "Disque" de coordonnées du centre (0.5, 0.5), d'épaisseur 0.1 et de rayon 0.1.

Si l'on appelle maintenant la méthode de tracé, ce disque va se tracer tout seul :
root[2] d->Trace()

Et voilà ! On voit apparaître un disque dans une fenêtre, appelée "Canvas" dans ROOT. Si on demande la surface du disque en appelant la méthode "Surface()", on obtient :
root [3] d->Surface()
'''(double)3.14159265358979339e-02'''
Là encore, on a appelé la méthode de l'objet d qui renvoie la valeur de la surface. Remarquez l'emploi de l'opérateur "->" (signe "-" suivi du signe supérieur ">" ). On appelle cet opérateur l'opérateur de déréférencement et il est employé pour indiquer "la méthode de l'objet pointé par ...". "d" est un pointeur, donc la méthode "Surface()" de l'objet pointé par "d" est appelée en utilisant "->".

=== Analyse d'une macro ROOT ===

On appelle "macro" ou "script" un programme ou morceau de programme que ROOT va interpréter. Analysons la macro suivante "graph.C" :

void graph() {
//Draw a simple graph
//Author: Rene Brun

TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);

c1->SetFillColor(42);
c1->SetGrid();

const Int_t n = 20;
double x[n], y[n];

for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
printf(" i %i %f %f \n",i,x[i],y[i]);
}

gr = new TGraph(n,x,y);

gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");

// TCanvas::Update() draws the frame, after which one can change it
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(12);
c1->Modified();
}

Vous pouvez l'exécuter dans ROOT, c'est une macro "standard" présente dans le répertoire ROOT. Faites simplement :
root[4] .x $ROOTSYS/tutorials/graphs/graph.C

Reprenons les lignes principales. Vous pouvez tester l'effet de certaines en recopiant le fichier chez vous et en enlevant la ou les lignes correspondantes avant de lancer la macro.

d'abord, la déclaration de la fonction. Elle ne prend pas d'argument :
void graph()
{

Ensuite, on construit un objet "TCanvas" qui est une fenêtre graphique dans laquelle on va dessiner :
TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);

On en profite pour appeler des méthodes de cet objet "TCanvas" qui remplissent le fond d'une certaine couleur
c1->SetFillColor(42);
et qui activent une option traçant une grille pointillée
c1->SetGrid();

viennent ensuite les déclarations de variables que l'on va utiliser. Ici, on a besoin de déclarer deux tableaux qui vont représenter des coordonnées de points à tracer. n est le nombre de points.
const Int_t n = 20;
double x[n], y[n];

ces points, il faut bien leur donner des valeurs, d'où la boucle ci-dessous :
for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
printf(" i %i %f %f \n",i,x[i],y[i]);
}

ensuite, on construit un objet "graphique" défini dans ROOT qui s'appelle "TGraph". On passe les pointeurs "x" et "y" sur les tableaux qu'on vient de remplir à ce constructeur, ainsi que le nombre de points :
gr = new TGraph(n,x,y);

et on rend le graphe "joli". Les noms des méthodes parlent d'eux-même :
gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");

enfin, l'auteur a décidé de changer encore un peu le fond, libre à lui...
// TCanvas::Update() draws the frame, after which one can change it
c1->Update();
c1->GetFrame()->SetFillColor(21);
c1->GetFrame()->SetBorderSize(12);
c1->Modified();
}

Amusez-vous à modifier le code ci-dessus et à tester vos modifications dans ROOT. Par exemple, mettre plus de points ou changer certaines caractéristiques de couleur. C'est la meilleure manière d'apprendre ou de vérifier que vous avez bien compris. La classe TGraph est documentée sur le site de ROOT à la page : [[http://root.cern.ch/root/html520/TGraph.html http://root.cern.ch/root/html520/TGraph.html]]

Il y a beaucoup de méthodes. Regardez certaines d'entre elles pour voir si vous comprenez leur utilité.

Il y a même un exemple encore plus simple de macro au début de cette page.

Il y a dans ROOT un très grand nombre de classes différentes, nous verrons celles dont nous aurons besoin au fur et à mesure.