Avant toute chose, veuillez installer ROOT ou configurer VirtualBox pour vous placer dans un environnement où vous pouvez l'utiliser. Pour installer VirtualBox, vous pouvez télécharger les deux fichiers suivants (attention, le fichier d'image disque virtuelle .vhd fait 7 Go).
Sauvegardez les deux fichiers dans le même répertoire. Si vous avez installé VirtualBox (en téléchargeant le programme à partir du site), il suffit de lancer le fichier .vbox pour démarrer votre machine virtuelle.
Dans tous les cas, testez que votre installation de ROOT fonctionne. Pour ce faire, veuillez suivre les instructions contenues dans ce document.
#include <iostream>
#include <TH1.h>
#include <TF1.h>
#include <TFile.h>
#include <TCanvas.h>
using namespace std;
void test(){
cout << "Hello world!" << endl;
TH1F *histoTest = new TH1F("histoTest","histo;x;y",10,0,10);
histoTest->Fill(2.53);
histoTest->Fill(5.24);
histoTest->Fill(2.02);
histoTest->Fill(8.93);
TF1 *funcTest = new TF1("funcTest","[0] + [1]*x",0.,10.);
funcTest->SetParameters(1,1);
histoTest->Fit("funcTest");
histoTest->Draw();
}
#include <iostream>
#include <TH1.h>
#include <TH2.h>
#include <TFile.h>
#include <TCanvas.h>
using namespace std;
// Nous allons générer des nombres aléatoires grâce à
// l algorithme de congruence linéaire.
// La structure du programme sera la suivante:
// - une fonction principale: genCL
// - déclaration de toutes les variables et histogrammes (voir http://root.cern.ch/root/html/TH1F.html)
// - une boucle pour générer les nombres aléatoires
// - on dessine les histos et on les sauve dans un fichier .root
// On définit la fonction genCL qui prend un argument: npoints
// Par défaut, npoints = 10000.
// Lorsqu on appelle la fonction, on peut lui donner l argument
// que l on veut: genCL(1000000) par exemple.
void genCL(int npoints = 10000)
{
// Pour afficher du texte à l ecran, on utilise: cout << "Mon texte" << endl;
cout << "Generateur congruentiel lineaire" << endl;
// Déclarer toutes les variables nécessaires ici:
int nBinX = 100, nBinY = 100;
double xlow = 0., xup = 1., ylow = 0., yup = 1.;
// Déclarer les histogrammes ici.
// Pour déclarer un histogramme, la syntaxe est la suivante:
TH1F *monHisto = new TH1F("monHisto", "Titre complet de mon histo;Titre axe x;Titre axe y", nBinX, xlow, xup);
// Pour un histogramme a 2 dim, la syntaxe devient:
TH2F *monHisto2D = new TH2F("monHisto2D", "Titre complet de mon histo;Titre axe x;Titre axe y", nBinX, xlow, xup, nBinY, ylow, yup);
// On introduit la boucle qui va générer les npoints nombres aléatoires
for (int i = 0; i < npoints; i++) {
// Ecrivez ici la formule de congruence linéaire
// Remplissez les histogrammes. La syntaxe est la suivante:
monHisto->Fill(0.5);
// Pour un histo 2D, cela devient:
monHisto2D->Fill(0.5, 0.5);
}// fin de la boucle
// Le reste du code est destiné à afficher les histogrammes.
// On réserve un canvas que l on divise en deux.
TCanvas *can = new TCanvas();
can->Divide(1, 2);
// Dans la 1ère partie, dessinez la distribution des nombres aléatoires
can->cd(1);
monHisto->SetMinimum(0.0);
monHisto->Draw();
// Dans la 2ème partie, dessinez l histogramme de corrélation
can->cd(2);
monHisto2D->Draw();
}
#include <iostream>
#include <TH1.h>
#include <TH2.h>
#include <TFile.h>
#include <TCanvas.h>
using namespace std;
// Nous allons générer des nombres aléatoires grâce à
// l algorithme de congruence linéaire.
// La structure du programme sera la suivante:
// - une fonction principale: genCL
// - déclaration de toutes les variables et histogrammes (voir http://root.cern.ch/root/html/TH1F.html)
// - une boucle pour générer les nombres aléatoires
// - on dessine les histos et on les sauve dans un fichier .root
// On définit la fonction genCL qui prend un argument: npoints
// Par défaut, npoints = 10000.
// Lorsqu on appelle la fonction, on peut lui donner l argument
// que l on veut: genCL(1000000) par exemple.
void genCL(int npoints = 10000)
{
// Pour afficher du texte à l ecran, on utilise: cout << "Mon texte" << endl;
cout << "Generateur congruentiel lineaire" << endl;
// Déclarer toutes les variables nécessaires ici:
int nBinX = 100, nBinY = 100;
double xlow = 0., xup = 1., ylow = 0., yup = 1.;
double xCoor = 0., yCoor = 0.;
int a = 205, c = 29573, m = 139968, last = 4711; // La variable last représente I_0, la dernière valeur calculée.
// Déclarer les histogrammes ici.
// Pour déclarer un histogramme, la syntaxe est la suivante:
// TH1F *monHisto = new TH1F("monHisto", "Titre complet de mon histo;Titre axe x;Titre axe y", nBin, xmin, xmax);
// Pour un histogramme a 2 dim, la syntaxe devient:
// TH2F *monHisto2D = new TH2F("monHisto2D", "Titre complet de mon histo;Titre axe x;Titre axe y", nBinX, xmin, xmax, nBinY, ymin, ymax);
TH1F *h_Dist = new TH1F("h_Dist", "Distribution selon un generateur congruentiel lineaire;R_{j};N", nBinX, xlow, xup);
TH2F *h_Corr = new TH2F("h_Corr", "Correlation n, n+1;R_{j};R_{j+1}", nBinX, xlow, xup, nBinY, ylow, yup);
// On introduit la boucle qui va générer les npoints nombres aléatoires
for (int i = 0; i < npoints; i++) {
// Ecrivez ici la formule de congruence linéaire
last = (a * last + c) % m;
xCoor = last * 1. / m;
last = (a * last + c) % m;
yCoor = last * 1. / m;
// Remplissez les histogrammes. La syntaxe est la suivante:
h_Dist->Fill(xCoor);
// Pour un histo 2D, cela devient:
h_Corr->Fill(xCoor, yCoor);
}// fin de la boucle
// Le reste du code est destiné à afficher les histogrammes.
// On réserve un canvas que l on divise en deux.
TCanvas *can = new TCanvas();
can->Divide(1, 2);
// Dans la 1ère partie, dessinez la distribution des nombres aléatoires
can->cd(1);
h_Dist->SetMinimum(0.0);
h_Dist->Draw("e");
// Dans la 2ème partie, dessinez l histogramme de corrélation
can->cd(2);
h_Corr->Draw();
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// Nous allons générer des nombres aléatoires grâce au
// générateur de la classe TRandom3.
// La structure du programme reste la même:
// - une fonction principale: genTRandom3
// - déclaration de toutes les variables et histogrammes (voir http://root.cern.ch/root/html/TH1F.html)
// - une boucle pour générer les nombres aléatoires
// - on dessine les histos
// On définit la fonction genTRandom3 qui prend un argument: npoints
// Par défaut, npoints = 10000.
// Lorsqu on appelle la fonction, on peut lui donner l argument
// que l on veut: genTRandom3(1000000) par exemple.
void genTRandom3(int npoints = 10000)
{
// Déclarez toutes les variables nécessaires ici:
// Déclarez les histogrammes, pour la distribution sur [0,1],
// pour la corrélation (2D), et pour la distribution [-1000,1000]
// Il faut maintenant déclarer le générateur TRandom3.
TRandom3 generateur;
// Décommentez l instruction suivante pour avoir différents
// résultats a chaque fois que vous lancez le programme.
// NB: on génère un nombre aléatoires uniforme sur [0,1]
// grâce a la méthode Rndm() de la classe TRandom3
//generateur.SetSeed(time(NULL));
// On introduit la boucle qui va générer les npoints nombres aléatoires
for (int i=0; i < npoints; i++) {
// Remplissez les histogrammes pour l exercice a)
// Générer entre -1000 et 1000 et remplissez l histogramme pour l exercice b)
}// fin de la boucle
// Réservez un 1er canvas pour la distribution sur [0, 1] et la corrélation.
cout << "Generateur TRandom3 " << endl;
TCanvas *can1 = new TCanvas();
can1->Divide(1, 2);
// Dessinez le 1er histo
can1->cd(1);
// Dessinez l histo de corrélation
can1->cd(2);
// Reservez un 2eme canvas pour la distribution sur (-1000, 1000).
TCanvas *can2 = new TCanvas("can2", "can2", 100, 0, 700, 500);
// Dessinez la distribution sur (-1000, 1000)
can2->cd();
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// Nous allons generer des nombres aleatoires grace au
// generateur de la classe TRandom3.
// La structure du programme reste la meme:
// - une fonction principale: genTRandom3
// - declaration de toutes les variables et histogrammes (voir http://root.cern.ch/root/html/TH1F.html)
// - une boucle pour generer les nombres aleatoires
// - on dessine les histos
// On definit la fonction genTRandom3 qui prend un argument: npoints
// Par defaut, npoints = 10000.
// Lorsqu on appelle la fonction, on peut lui donner l argument
// que l on veut: genTRandom3(1000000) par exemple.
void genTRandom3(int npoints = 10000)
{
// Declarez toutes les variables necessaires ici:
int nBinX = 100, nBinY = 100;
double xlow = 0., xup = 1., ylow = 0., yup = 1., xCoor = 0., yCoor = 0.;
// Declarez les histogrammes, pour la distribution sur [0,1],
// pour la correlation (2D)
TH1F *h_Dist = new TH1F("h_Dist", "Distribution selon TRandom3;R_{j};N", nBinX, xlow, xup);
TH2F *h_Corr = new TH2F("h_Corr", "Correlation entre 2 nombres TRandom3;R_{j};R_{j+1}",nBinX, xlow, xup, nBinY, ylow, yup);
// Il faut maintenant declarer le generateur TRandom3.
TRandom3 generateur;
// Decommentez l instruction suivante pour avoir differents
// resultats a chaque fois que vous lancez le programme.
// NB: on genere un nombre aleatoire uniforme sur [0,1]
// grace a la methode Rndm() de la classe TRandom3
//generateur.SetSeed(time(NULL));
generateur.SetSeed(123456);
// On introduit la boucle qui va generer les npoints nombres aleatoires
for (int i=0; i < npoints; i++) {
// Remplissez les histogrammes pour l exercice a)
xCoor = generateur.Rndm();
yCoor = generateur.Rndm();
h_Dist->Fill(xCoor);
h_Corr->Fill(xCoor, yCoor);
}// fin de la boucle
// Reservez un 1er canvas pour la distribution sur [0, 1] et la correlation.
cout << "Generateur TRandom3 " << endl;
TCanvas *can1 = new TCanvas();
can1->Divide(1, 2);
// Dessinez le 1er histo
can1->cd(1);
h_Dist->SetMinimum(0.0);
h_Dist->Draw("e");
// Dessinez l histo de correlation
can1->cd(2);
h_Corr->Draw();
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// Toujours grâce a la classe TRandom3, nous allons générer
// des nombres aléatoires suivant une loi Normale de moyenne mu
// et de variance sigma2.
// La structure du programme est la suivante:
// - une fonction principale: loiNormale (avec deux arguments: mu et sigma2)
// - déclaration de toutes les variables et histogrammes
// - une boucle pour générer les nombres aléatoires
// - on dessine les histos
// On définit la fonction loiNormale qui prend deux arguments: mu ( = 0 par défaut) et sigma2 ( = 1 par défaut)
void loiNormale(double mu = 0, double sigma2 = 1)
{
// Déclarez toutes les variables nécessaires ici:
// nombre de points, xlow, xup...
int npoints = 5000;
// Déclarez les histogrammes
// Il faut maintenant déclarer le générateur TRandom3.
TRandom3 generateur;
// Décommentez l instruction suivante pour avoir différents
// résultats a chaque fois que vous lancez le programme.
//generateur.SetSeed(time(NULL));
// La boucle commence ici, pour chaque passage, deux nombres
// suivant la loi Normale seront génères
for (int i = 0; i < npoints; i++) {
// Gênerez deux nombres aléatoires uniformes sur [0,1]
// Construisez les deux nombres gaussiens a partir des deux précédents
// Modifiez le code pour une gaussienne de moyenne mu et de variance sigma2
// Remplissez l'histogramme
}// fin de la boucle
cout << "Loi Normale - N(" << mu << ", " << sigma2 << ")" << endl;
TCanvas *can = new TCanvas();
can->cd();
// Dessinez l'histogramme
// Pour la partie b), fittez l'histogramme avec une gaussienne
// grâce a la méthode Fit() de la classe TH1.
// ( https://root.cern.ch/root/htmldoc/guides/users-guide/FittingHistograms.html )
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// Toujours grace a la classe TRandom3, nous allons generer
// des nombres aleatoires suivant une loi Normale de moyenne mu
// et de variance sigma2.
// La structure du programme est la suivante:
// - une fonction principale: loiNormale (avec deux arguments: mu et sigma2)
// - declaration de toutes les variables et histogrammes
// - une boucle pour generer les nombres aleatoires
// - on dessine les histos
// On definit la fonction loiNormale qui prend deux arguments: mu ( = 0 par defaut) et sigma2 ( = 1 par defaut)
void loiNormale(double mu = 0, double sigma2 = 1)
{
// Declarez toutes les variables necessaires ici:
// nombre de points, xlow, xup...
int npoints = 5000;
int nbins = 100;
double pi = 3.141592, xlow = -8., xup = 8., U1 = 0., U2 = 0., T1 = 0., T2 = 0.;
// Declarez les histogrammes
TH1F *h_Dist = new TH1F("h_Dist", "Distribution Normale;R_{J};N", nbins, xlow, xup);
// Il faut maintenant declarer le genrateur TRandom3.
TRandom3 generateur;
// Decommentez l instruction suivante pour avoir differents
// resultats a chaque fois que vous lancez le programme.
//generateur.SetSeed(time(NULL));
// La boucle commence ici, pour chaque passage, deux nombres
// suivant la loi Normale seront generes
for (int i = 0; i < npoints; i++) {
// Generez deux nombres aleatoires uniformes sur [0,1]
U1 = generateur.Rndm();
U2 = generateur.Rndm();
// Construisez les deux nombres gaussiens a partir des deux precedents
T1 = sqrt(-2 * log(U1)) * cos(2 * pi * U2);
T2 = sqrt(-2 * log(U1)) * sin(2 * pi * U2);
// Modifiez le code pour une gaussienne de moyenne mu et de variance sigma2
T1 = mu + T1 * sqrt(sigma2);
T2 = mu + T2 * sqrt(sigma2);
// Remplissez l'histogramme
h_Dist->Fill(T1);
h_Dist->Fill(T2);
}// fin de la boucle
cout << "Loi Normale - N(" << mu << ", " << sigma2 << ")" << endl;
TCanvas *can = new TCanvas();
can->cd();
// Dessinez l'histogramme
h_Dist->SetMinimum(0.0);
h_Dist->DrawCopy();
// Pour la partie b), fittez l'histogramme avec une gaussienne
// grace a la methode Fit() de la classe TH1.
// ( https://root.cern.ch/root/htmldoc/guides/users-guide/FittingHistograms.html )
h_Dist->Fit("gaus");
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TF1.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// La fonction myFunc sera utilisee pour fitter la distribution
// que nous allons generer. Il faut donc y inserer la forme de
// la fonction a fitter
// ( http://root.cern.ch/root/html/TF1.html#F3 )
double myFunc(double *x, double *par)
{
double result = -1.;
// Ecrivez ici la forme de la pdf avec les parametres a fitter:
// result = par[0] * (1 + par[1] * x[0]) par exemple
// result = .......
return result;
}
// Les lignes suivantes permettent d'utiliser la fonction
// myFunc avec des parametres deja initialises.
// VOUS NE DEVEZ RIEN Y CHANGER
double myFunc(double x)
{
double arg[1], par[2];
arg[0] = x;
par[0] = 1.;
par[1] = 1.;
return myFunc(arg, par);
}
// Voici la fonction principale.
// Elle prend en argument tau, qui est par défaut mis à 1.
void invTransform(double tau = 1.)
{
cout << "Methode de la transformée inverse" << endl;
// Nombre de points
int npoints = 100000;
double u = 0., x = 0., xlow = 0., xup = 10.;
TH1F *h_Dist = new TH1F("h_Dist", "Distribution exp(-x);x;N", 200, xlow, xup);
// Il faut maintenant declarer le generateur TRandom3.
TRandom3 generateur;
// Decommentez l instruction suivante pour avoir differents
// resultats a chaque fois que vous lancez le programme.
//generateur.SetSeed(time(NULL));
// Debut de la boucle for.
for (int i = 0; i < npoints; i++) {
// Generez ici les variables aleatoires necessaires
}// fin de la boucle for
TCanvas *can = new TCanvas();
can->cd();
// Dessinez et fittez la distribution obtenue
h_Dist->SetMinimum(0.);
h_Dist->Draw();
// On declare un objet function TF1 basé sur notre
// fonction myFunc. La fonction TF1 est définie sur (0, 10)
// et possède 2 parametres: normalisation et temps de vie
TF1 *f = new TF1("f", myFunc, 0, 10, 2);
// On donne la valeur 1 a la normalisation et tau au temps de vie
f->SetParameters(1., tau);
// On repondère notre histogramme pour que
// l'intégrale soit égale à 1
// (plus facile d'interpréter les résultats du fit)
h_Dist->Scale(1. / h_Dist->Integral("width"));
// ("width" indique qu'on multiplie par la largeur du bin.)
h_Dist->Fit("f");
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TF1.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// La fonction myFunc sera utilisee pour fitter la distribution
// que nous allons generer. Il faut donc y inserer la forme de
// la fonction a fitter
// ( http://root.cern.ch/root/html/TF1.html#F3 )
double myFunc(double *x, double *par)
{
double result = -1.;
// Ecrivez ici la forme de la pdf avec les parametres a fitter:
// result = par[0] * (1 + par[1] * x[0]) par exemple
// result = .......
return result;
}
// Les lignes suivantes permettent d'utiliser la fonction
// myFunc avec des parametres deja initialises.
// VOUS NE DEVEZ RIEN Y CHANGER
double myFunc(double x)
{
double arg[1], par[2];
arg[0] = x;
par[0] = 0.375;
par[1] = 1.;
return myFunc(arg, par);
}
// Voici la fonction principale.
void rejMethode()
{
cout << "Methode de rejection" << endl;
// Nombre de points et nombre de points acceptes
int npoints = 100000, nAccepted = 0, nTotal = 0;
double x = 0., y = 0., xlow = -1., xup = 1., fmax = 0.75;
TH1F *h_Dist = new TH1F("h_Dist", "Distribution 1 + x^{2} - methode de rejection", 200, xlow, xup);
// Il faut maintenant declarer le generateur TRandom3.
TRandom3 generateur;
// Decommentez l instruction suivante pour avoir differents
// resultats a chaque fois que vous lancez le programme.
//generateur.SetSeed(time(NULL));
// Debut de la boucle. Attention, c'est une boucle while.
// On effectue les instructions JUSQU'A CE QUE le nombre
// de points acceptes = npoints
while (nAccepted < npoints) {
// Generez ici les variables aleatoires necessaires
// Testez si le point (x, y) genere est accepte ou non.
// Si il est accepte, remplissez l histogramme et incrementez
// le compteur
}// fin du while
cout << "Efficacite: " << "......" << endl;
TCanvas *can = new TCanvas();
can->cd();
// Dessinez et fittez la distribution obtenue
h_Dist->Draw();
TF1 *f = new TF1("f", myFunc, -1, 1, 2);
f->SetParameters(0.375, 1.);
h_Dist->Scale(1. / h_Dist->Integral("width"));
h_Dist->Fit("f");
h_Dist->SetMinimum(0.);
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TF1.h>
#include <TF2.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// La fonction myFunc sera utilisee pour fitter la distribution
// que nous allons generer. Il faut donc y inserer la forme de
// la fonction a fitter
// ( http://root.cern.ch/root/html/TF1.html#F3 )
double myFunc(double *x, double *par)
{
double result = -1.;
// Ecrivez ici la forme de la pdf avec les parametres a fitter:
// result = par[0] * (1 + par[1] * x[0]) par exemple
// result = .......
return result;
}
// Les lignes suivantes permettent d'utiliser la fonction
// myFunc avec des parametres deja initialises.
// VOUS NE DEVEZ RIEN Y CHANGER
double myFunc(double x, double y)
{
double arg[2], par[4];
arg[0] = x;
arg[1] = y;
par[0] = 1./12.;
par[1] = 1.;
par[2] = 3.;
par[3] = 1.;
return myFunc(arg, par);
}
// Voici la fonction principale.
void rejMethode()
{
cout << "Methode de rejection" << endl;
// Nombre de points et nombre de points acceptes
int npoints = 10000000, nAccepted = 0, nTotal = 0;
double x = 0., y = 0., z = 0., xlow = -1., xup = 1., ylow = 0., yup = 3., fmax = 0.5;
TH2F *h_Dist = new TH2F("h_Dist", "Distribution (3-y)(1+x^{2}) - meth rej;x;y", 200, xlow, xup, 30, ylow, yup);
// Il faut maintenant declarer le genrateur TRandom3.
TRandom3 generateur;
// Decommentez l instruction suivante pour avoir differents
// resultats a chaque fois que vous lancez le programme.
//generateur.SetSeed(time(NULL));
// Debut de la boucle. Attention, c'est une boucle while.
// On effectue les instructions JUSQU'A CE QUE le nombre
// de points acceptes = npoints
while (nAccepted < npoints) {
// Generez ici les variables aleatoires necessaires
// Testez si le point (x, y, z) genere est accepte ou non.
// Si il est accepte, remplissez l histogramme et incrementez
// le compteur
}// fin du while
cout << "Efficacite : " << "......" << endl;
TCanvas *can = new TCanvas();
can->cd();
// Dessinez et fittez la distribution obtenue
h_Dist->SetMinimum(0.);
TF2 *f = new TF2("f", myFunc, -1., 1., 0., 3., 4);
f->SetParameters(800, 1., 3., 1.);
h_Dist->Fit("f");
h_Dist->Draw("lego");
}
#include <iostream>
#include <time.h>
#include <TH1.h>
#include <TH2.h>
#include <TF1.h>
#include <TF2.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TRandom3.h>
using namespace std;
// La fonction myFunc sera utilisee pour fitter la distribution
// que nous allons generer. Il faut donc y inserer la forme de
// la fonction a fitter
// ( http://root.cern.ch/root/html/TF1.html#F3 )
double myFunc(double *x, double *par)
{
double result = 0.;
// Ecrivez ici la forme de la pdf avec les parametres a fitter:
// result = par[0] * (1 + par[1] * x[0]) par exemple
// result = .......
return result;
}
// Les lignes suivantes permettent d'utiliser la fonction
// myFunc avec des parametres deja initialises.
// VOUS NE DEVEZ RIEN Y CHANGER
double myFunc(double x)
{
double arg[1], par[1];
arg[0] = x;
par[0] = 1.;
return myFunc(arg, par);
}
// Voici la fonction principale.
void rejMethode()
{
cout << "Methode de rejection" << endl;
// Nombre de points et nombre de points acceptes
int npoints = 10000000, nAccepted = 0, nTotal = 0;
double x = 0., y = 0., xlow = 0, xup = 4, fmax = 7./3.;
TH1F *h_Dist = new TH1F("h_Dist", "Distribution exercice 3 - meth rej", 200, xlow, xup);
// Il faut maintenant declarer le genrateur TRandom3.
TRandom3 generateur;
// Decommentez l instruction suivante pour avoir differents
// resultats a chaque fois que vous lancez le programme.
//generateur.SetSeed(time(NULL));
// Debut de la boucle. Attention, c'est une boucle while.
// On effectue les instructions JUSQU'A CE QUE le nombre
// de points acceptes = npoints
while (nAccepted < npoints) {
// Generez ici les variables aleatoires necessaires
// Testez si le point (x, y) genere est accepte ou non.
// Si il est accepte, remplissez l histogramme et incrementez
// le compteur
}// fin du while
cout << "Efficacite : " << "......" << endl;
TCanvas *can = new TCanvas();
can->cd();
// Dessinez et fittez la distribution obtenue
h_Dist->SetMinimum(0.);
h_Dist->Scale(1./h_Dist->Integral("width"));
TF1 *f = new TF1("f", myFunc, 0., 4., 1);
f->SetParameter(0, 1.);
f->SetNpx(10000);
h_Dist->Fit("f");
h_Dist->Draw();
}
Remarque: le code ci-dessous est inutilement complexe pour la partie algorithme de Jade + algorithme anti-kT. En effet, dans votre cas vous pouvez y arriver avec un code beaucoup plus simple puisque vous n'avez que 3 particules. J'ai tenu à laisser la version complète pour vous montrer un exemple plus "complexe" de code C++, mais il n'était évidemment pas attendu que vous trouviez cela pendant le TP.