Soluzioni: Lezione 9
Contents
Soluzioni: Lezione 9¶
9.1 generazione di toy experiment¶
esercizio_01.cpp
/*
c++ -o esercizio_01 casual.cc esercizio_01.cpp
*/
#include <iostream>
#include <vector>
#include "casual.h"
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 3)
{
cerr << "uso: " << argv[0] << " tau nnumero_di_eventi" << endl ;
exit (1) ;
}
double t_zero = atof (argv[1]) ;
vector<double> campione ;
for (int i = 0 ; i < atoi (argv[2]) ; ++i)
{
campione.push_back (rand_exp (t_zero)) ;
}
cout << "generati: " << campione.size () << " numeri pseudo-casuali\n" ;
return 0 ;
}
casual.h
#ifndef casual_h
#define casual_h
double rand_range (double min, double max) ;
float rand_exp (double t_zero) ;
float rand_pois (double media) ;
#endif
casual.cc
#include "casual.h"
#include <cstdlib>
#include <cmath>
double rand_range (double min, double max)
{
return min + (max - min) * rand () / static_cast<double> (RAND_MAX);
}
float rand_exp (double t_zero)
{
return -1. * log (1 - rand_range (0., 1.)) * t_zero ;
}
float rand_pois (double media)
{
double t_tot = rand_exp (1.) ;
int N_evt = 0 ;
while (t_tot < media)
{
++N_evt ;
t_tot += rand_exp (1.) ;
}
return N_evt ;
}
9.2 disegno di toy experiment¶
esercizio_02.cpp
/*
c++ -o esercizio_02 `root-config --glibs --cflags` utils.cc casual.cc esercizio_02.cpp
*/
#include <iostream>
#include <vector>
#include "TH1F.h"
#include "TCanvas.h"
#include "utils.h"
#include "casual.h"
#include "statistiche.h"
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 3)
{
cerr << "uso: " << argv[0] << " tau nnumero_di_eventi" << endl ;
exit (1) ;
}
double t_zero = atof (argv[1]) ;
vector<double> campione ;
for (int i = 0 ; i < atoi (argv[2]) ; ++i)
{
campione.push_back (rand_exp (t_zero)) ;
}
TH1F * histo = crea_histo ("h_exp", campione) ;
TCanvas c1 ;
histo->SetFillColor (kBlue) ;
histo->Draw () ;
c1.Print ("esercizio_02.png", "png") ;
delete histo ;
return 0 ;
}
statistiche.h
#ifndef statistiche_h
#define statistiche_h
#include <cmath>
#include <vector>
template <class T>
double media (std::vector<T> const & inputV)
{
double sum = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i) sum += inputV.at (i) ;
return sum / inputV.size () ;
}
template <class T>
double varianza (std::vector<T> const & inputV)
{
double sum = 0. ;
double sumSq = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i)
{
sum += inputV.at (i) ;
sumSq += inputV.at (i) * inputV.at (i) ;
}
return sumSq / inputV.size () - (sum * sum) / (inputV.size () * inputV.size ()) ;
}
template <class T>
double sigma (std::vector<T> const & inputV)
{
return sqrt (varianza (inputV)) ;
}
template <class T>
double asimmetria (std::vector<T> const & inputV)
{
double mediaV = media (inputV) ;
double asimmV = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i)
{
asimmV += pow ((inputV.at (i) - mediaV), 3.) ;
}
return asimmV / (inputV.size () * pow (sigma (inputV),3.)) ;
}
template <class T>
double curtosi (std::vector<T> const & inputV)
{
double mediaV = media (inputV) ;
double curtosiV = 0. ;
for (int i = 0 ; i < inputV.size () ; ++i)
{
curtosiV += pow ((inputV.at (i) - mediaV), 4.) ;
}
return curtosiV / (inputV.size () * varianza (inputV) * varianza (inputV)) - 3. ;
}
#endif
utils.h
#ifndef L9_utils_h
#define L9_utils_h
#include "TH1F.h"
#include <string>
#include <vector>
TH1F * crea_histo (const std::string & histo_name, const std::vector<double> & campione) ;
#endif
utils.cc
#include "utils.h"
#include "statistiche.h"
using namespace std ;
TH1F * crea_histo (const string & histo_name, const vector<double> & campione)
{
double m = media (campione) ;
double s = sigma (campione) ;
double N = campione.size () ;
double minimo_campione = *min_element (campione.begin (), campione.end ()) ;
double massimo_campione = *max_element (campione.begin (), campione.end ()) ;
double minimo_histo = max (minimo_campione, m - 5 * s) ;
double massimo_histo = min (massimo_campione, m + 5 * s) ;
int Nbin = 10 * log (N/10) ;
TH1F * histo = new TH1F (
histo_name.c_str (), histo_name.c_str (),
Nbin,
minimo_histo,
massimo_histo
) ;
for (int i = 0 ; i < campione.size () ; ++i)
{
histo->Fill (campione.at (i)) ;
}
return histo ;
}
9.3 disegno di una funzione implementata in `C++`¶
esercizio_03.cpp
/*
c++ -o esercizio_03 `root-config --glibs --cflags` funzioni.cc esercizio_03.cpp
*/
#include <iostream>
#include <vector>
#include "TCanvas.h"
#include "TF1.h"
#include "funzioni.h"
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 2)
{
cerr << "uso: " << argv[0] << " tau" << endl ;
exit (1) ;
}
double t_zero = atof (argv[1]) ;
TF1 f_exp ("f_exp", exp_R, 0, 5 * t_zero, 1) ;
f_exp.SetParameter (0, t_zero) ;
f_exp.SetParName (0, "t_0") ;
f_exp.SetLineColor (kBlue) ;
f_exp.SetLineWidth (2) ;
TCanvas c1 ;
f_exp.Draw () ;
c1.Print ("esercizio_03.png", "png") ;
return 0 ;
}
funzioni.h
#ifndef L9_funzioni_h
#define L9_funzioni_h
#include "TF1.h"
double esponenziale (double x, double tau) ;
Double_t exp_R (Double_t * x, Double_t * par) ;
Double_t loglikelihood (Double_t * x, Double_t * par) ;
#endif
9.4 disegno di una funzione di verosimiglianza¶
esercizio_04.cpp
/*
c++ -o esercizio_04 `root-config --glibs --cflags` casual.cc funzioni.cc esercizio_04.cpp
*/
#include <iostream>
#include <vector>
#include "TF1.h"
#include "TH1F.h"
#include "TCanvas.h"
#include "casual.h"
#include "funzioni.h"
#include "statistiche.h"
using namespace std ;
int main (int argc, char ** argv)
{
if (argc < 3)
{
cerr << "uso: " << argv[0] << " tau nnumero_di_eventi" << endl ;
exit (1) ;
}
double t_zero = atof (argv[1]) ;
vector<double> campione ;
for (int i = 0 ; i < atoi (argv[2]) ; ++i)
{
campione.push_back (rand_exp (t_zero)) ;
}
double m = media (campione) ;
double s = sigma (campione) ;
vector<double> dati_forTF1 ;
dati_forTF1.push_back (campione.size ()) ;
dati_forTF1.insert (dati_forTF1.end (), campione.begin (), campione.end ()) ;
TF1 f_ll ("f_ll", loglikelihood, max (0.1 * m, m - 3 * s), m + 3 * s, dati_forTF1.size ()) ;
f_ll.SetParameters (&dati_forTF1[0]) ;
f_ll.SetLineColor (kRed) ;
f_ll.SetLineWidth (2) ;
TCanvas c1 ;
f_ll.Draw () ;
c1.Print ("esercizio_04.png", "png") ;
return 0 ;
}