.rst .pdf

Contents

Esempi: Lezione 3

3.0 inclusione di una classe di `ROOT`

/*
c++ -o main_00 `root-config --glibs --cflags` main_00.cpp
*/

#include "TH1F.h"

int main (int argc, char ** argv)
  {
    TH1F istogramma ("istogramma", "titolo", 10, -5., 5.) ;

    return 0 ;
  }

3.1 Riempimento di un `TH1F`

/*
c++ -o main_01 `root-config --glibs --cflags` main_01.cpp
*/

#include "TH1F.h"

int main (int argc, char ** argv)
  {
    TH1F istogramma ("istogramma", "istogramma", 10, -5., 5.) ;

    istogramma.Fill (2.2) ;

    return 0 ;
  }

3.2 Disegno di un `TH1F`

/*
c++ -o main_02 `root-config --glibs --cflags` main_02.cpp
*/

#include "TH1F.h"
#include "TCanvas.h"

int main (int argc, char ** argv)
  {
    TH1F istogramma ("istogramma", "titolo", 10, -5., 5.) ;

    istogramma.Fill (2.2) ;
    istogramma.Fill (2.1) ;
    istogramma.Fill (-1.4) ;

    TCanvas c1 ;
//    istogramma.SetFillColor (kOrange + 1) ;
    istogramma.Draw () ;
    c1.Print ("esempio.png", "png") ;

    return 0 ;
  }

3.3 Disegno di un `TH1F` con opzioni grafiche

/*
c++ -o main_03 `root-config --glibs --cflags` main_03.cpp
*/

#include "TH1F.h"
#include "TCanvas.h"

int main (int argc, char ** argv)
  {
    TH1F istogramma ("istogramma", "titolo", 10, -5., 5.) ;

    istogramma.Fill (2.2) ;
    istogramma.Fill (2.1) ;
    istogramma.Fill (-1.4) ;

    TCanvas c1 ;
    istogramma.SetFillColor (kOrange + 1) ;
    istogramma.GetXaxis ()->SetTitle ("asse x") ;
    istogramma.GetYaxis ()->SetTitle ("conteggi per bin") ;
    istogramma.Draw () ;
    c1.Print ("esempio.png", "png") ;

    return 0 ;
  }

3.4 Riempimento di un istogramma con numeri casuali

/*
c++ -o main_04 `root-config --cflags --glibs` main_04.cpp
*/

#include <cstdlib>
#include <iostream>
#include <cmath>

#include "TH1F.h"
#include "TCanvas.h"

float fgaus (float x) 
  {
    return exp (-0.5 * x * x) ; 
  }

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 

float rand_TCL (float xMin, float xMax, int N = 10)
  {
    double y = 0. ; 
    for (int i = 0 ; i < N ; ++i)
      y += rand_range (xMin, xMax) ;
    y /= N ;
    return y ;
  }

int main (int argc, char ** argv)
  {
    TCanvas c1 ("c1", "c1", 100, 100, 1000, 1000) ;

    TH1F h ("h", "eventi pseudo-casuali Gaussiani", 200, -1.5, 1.5) ;

    for (int j = 0 ; j < 1000000 ; ++j)
      h.Fill (rand_TCL (-1., 1., 10)) ;

    h.GetXaxis ()->SetTitle ("numeri generati") ;
    h.SetFillColor (kOrange + 1) ;
    h.Draw () ;

    c1.Print ("Gaussian.png", "png") ;

    return 0 ;
  }

3.5 Visualizzazione in scala logaritmica

/*
c++ -o main_05 `root-config --cflags --glibs` main_05.cpp
*/

#include <cstdlib>
#include <iostream>
#include <cmath>

#include "TH1F.h"
#include "TCanvas.h"

float fgaus (float x) 
  {
    return exp (-0.5 * x * x) ; 
  }

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 

float rand_TCL (float xMin, float xMax, int N = 10)
  {
    double y = 0. ; 
    for (int i = 0 ; i < N ; ++i)
      y += rand_range (xMin, xMax) ;
    y /= N ;
    return y ;
  }

int main (int argc, char ** argv)
  {
    TCanvas c1 ("c1", "c1", 100, 100, 1000, 1000) ;

    TH1F h ("h", "eventi pseudo-casuali Gaussiani", 200, -1.5, 1.5) ;

    for (int j = 0 ; j < 1000000 ; ++j)
      h.Fill (rand_TCL (-1., 1., 10)) ;

    h.GetXaxis ()->SetTitle ("numeri generati") ;
    h.SetFillColor (kOrange + 1) ;
    h.Draw () ;

    c1.SetLogy () ;
    c1.Print ("Gaussian.png", "png") ;

    return 0 ;
  }

3.6 Stampa delle statistiche di un istogramma

/*
c++ -o main_06 `root-config --cflags --glibs` main_06.cpp
*/

#include <cstdlib>
#include <iostream>
#include <cmath>

#include "TH1F.h"
#include "TCanvas.h"

float fgaus (float x) 
  {
    return exp (-0.5 * x * x) ; 
  }

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 

float rand_TCL (float xMin, float xMax, int N = 10)
  {
    double y = 0. ; 
    for (int i = 0 ; i < N ; ++i)
      y += rand_range (xMin, xMax) ;
    y /= N ;
    return y ;
  }

int main (int argc, char ** argv)
  {
    TCanvas c1 ("c1", "c1", 100, 100, 1000, 1000) ;

    TH1F h ("h", "eventi pseudo-casuali Gaussiani", 200, -1.5, 1.5) ;

    for (int j = 0 ; j < 1000000 ; ++j)
      h.Fill (rand_TCL (-1., 1., 10)) ;

    std::cout << "numero di eventi:    " << h.GetEntries () << std::endl ;
    std::cout << "media:               " << h.GetMean ()    << std::endl ;
    std::cout << "deviazione standard: " << h.GetRMS ()     << std::endl ;

    return 0 ;
  }

3.7 Test di una classe per il calcolo delle statistiche

• La classe statistiche

#ifndef statistiche_h
#define statistiche_h

#include <cmath>

class statistiche
{
  public:

    statistiche () :
      m_sum (0.),
      m_sumSq (0.),
      m_N (0)
      {}

    ~statistiche () {}

    // aggiunge un elemento al campione
    long long int addEvent (double value) 
      {
        m_sum += value ;
        m_sumSq += value * value ;
        ++m_N ;
        return m_N ;
      }

    // restituisce la media
    double getMean () const
      {
        if (m_N == 0) return 0. ; 
        return m_sum / static_cast<double> (m_N) ;
      }

    // restituisce la varianza
    double getVariance (bool correct = false) const
      {
        if (m_N == 0) return 0. ; 
        double sigma = m_sumSq / static_cast<double>  (m_N) 
                       - (m_sum * m_sum) / static_cast<double> (m_N * m_N) ;
        if (correct && m_N > 1) sigma = sigma * m_N / static_cast<double> (m_N - 1) ;         
        return sigma ;
      }

    // restituisce la sigma
    double getSigma (bool correct = false) const
      {
        return sqrt (getVariance (correct)) ;
      }

    // restituisce la varianza della media
    double getVarianceMean (bool correct = false) const
      {
        return getVariance (correct) / m_N ;
      }

    // restituisce la sigma della media
    double getSigmaMean (bool correct = false) const
      {
        return sqrt (getVarianceMean (correct)) ;
      }
    
    // restituisce il numero di eventi
    double getN () const
      {
        return m_N ;
      }
    
    // annulla tutti i membri
    void reset () 
      {
        m_sum = 0. ;
        m_sumSq = 0. ;
        m_N = 0 ;
        return ;
      }

  private:  

    // somma dei numeri del campione
    double m_sum ;
    // somma quadrata dei numeri del campione
    double m_sumSq ;
    // numero di elementi del campione
    long long int m_N ;

} ;


#endif

• il test

/*
c++ -o main_07 main_07.cpp
*/

#include <cstdlib>
#include <iostream>
#include "statistiche.h"

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 


int main (int argc, char ** argv)
  {
    statistiche s_eventi ;

    int i = 0 ;
    while (i++ < 1000) s_eventi.addEvent (rand_range (-3., 3.)) ;

    std::cout << "media               : " << s_eventi.getMean () << std::endl ;
    std::cout << "sigma               : " << s_eventi.getSigma () << std::endl ;
    std::cout << "sigma (corr)        : " << s_eventi.getSigma (true) << std::endl ;
    std::cout << "dev st. mean        : " << s_eventi.getSigmaMean () << std::endl ;
    std::cout << "dev st. mean (corr) : " << s_eventi.getSigmaMean (true) << std::endl ;

    return 0 ;
  }

3.8 Calcolo della varianza all’aumentare del numero di punti

/*
c++ -o main_08 main_08.cpp
*/

#include <cstdlib>
#include <iostream>
#include "statistiche.h"

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 


int main (int argc, char ** argv)
  {
    if (argc < 2) 
      {
        std::cerr << "uso del programma: " << argv[0] << " NMAX" << std::endl ;
        return 1 ;
      }

    int NMAX = atoi (argv[1]) ;
    statistiche s_eventi ;

    for (int N = 1 ; N < NMAX ; N = N * 2)
      {
        int i = 0 ;
        while (i++ < N) s_eventi.addEvent (rand_range (-3., 3.)) ;
        std::cout << N 
                  << "\t" << s_eventi.getMean () 
                  << "\t" << s_eventi.getSigma ()
                  << "\t" << s_eventi.getSigmaMean () << "\n" ;
        s_eventi.reset () ;
      }

    return 0 ;
  }

3.9 Disegno della varianza all’aumentare del numero di punti con TGraph

/*
c++ -o main_09 `root-config --glibs --cflags` main_09.cpp
*/

#include <cstdlib>
#include <iostream>
#include "TH1F.h"
#include <TGraph.h>
#include <TCanvas.h>
#include "statistiche.h"

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 


int main (int argc, char ** argv)
  {
    if (argc < 2) 
      {
        std::cerr << "uso del programma: " << argv[0] << " NMAX" << std::endl ;
        return 1 ;
      }

    int NMAX = atoi (argv[1]) ;
    statistiche s_eventi ;

    TGraph g_sigma ;
    TGraph g_sigmaMedia ;
    for (int N = 10 ; N < NMAX ; N = N * 2)
      {
        int i = 0 ;
        while (i++ < N) s_eventi.addEvent (rand_range (-3., 3.)) ;

        g_sigma.SetPoint (g_sigma.GetN (), N, s_eventi.getSigma ()) ;
        g_sigmaMedia.SetPoint (g_sigmaMedia.GetN (), N, s_eventi.getSigmaMean ()) ;

        s_eventi.reset () ;
      }

    TCanvas c1 ("c1", "c1", 100, 100, 1000, 1000) ;
    c1.SetLogx () ;

    g_sigma.SetMarkerStyle (20) ;
    g_sigma.SetMarkerColor (kAzure - 1) ;
    g_sigma.SetLineColor (kGray + 1) ;
    g_sigma.SetMarkerSize (2) ;
    g_sigma.GetHistogram ()->GetYaxis ()->SetRangeUser (0., 2.) ;
    g_sigma.GetHistogram ()->GetXaxis ()->SetTitle ("numero di eventi nel campione") ;
    g_sigma.GetHistogram ()->GetYaxis ()->SetTitle ("deviazione standard") ;
    g_sigma.Draw ("ALP") ;
    c1.Print ("sigmaTrend.png", "png") ;

    g_sigmaMedia.SetMarkerStyle (20) ;
    g_sigmaMedia.SetMarkerColor (kAzure - 1) ;
    g_sigmaMedia.SetLineColor (kGray + 1) ;
    g_sigmaMedia.SetMarkerSize (2) ;
    g_sigmaMedia.GetHistogram ()->GetXaxis ()->SetTitle ("numero di eventi nel campione") ;
    g_sigmaMedia.GetHistogram ()->GetYaxis ()->SetTitle ("deviazione standard dalla media") ;
    g_sigmaMedia.Draw ("ALP") ;
    c1.Print ("sigmaMediaTrend.png", "png") ;


    return 0 ;
  }

3.10 Riempimento e disegno di un `TH2F` con numeri casuali

/*
c++ -o main_10 `root-config --cflags --glibs` main_10.cpp
*/

#include <cstdlib>
#include <iostream>
#include <cmath>

#include "TH2F.h"
#include "TCanvas.h"

float fgaus (float x) 
  {
    return exp (-0.5 * x * x) ; 
  }

float rand_range (float min, float max)
  {
    return min + (max - min) * rand () / static_cast<float> (RAND_MAX) ;
  } 

float rand_TCL (float xMin, float xMax, int N = 10)
  {
    double y = 0. ; 
    for (int i = 0 ; i < N ; ++i)
      y += rand_range (xMin, xMax) ;
    y /= N ;
    return y ;
  }

int main (int argc, char ** argv)
  {
    TCanvas c1 ("c1", "c1", 100, 100, 1000, 1000) ;

    TH2F h2 ("h2", "eventi pseudo-casuali Gaussiani", 200, -1.5, 1.5, 200, -1.5, 1.5) ;

    for (int j = 0 ; j < 1000000 ; ++j)
      h2.Fill (rand_TCL (-1., 1., 10), rand_TCL (-1., 1., 10)) ;

    h2.GetXaxis ()->SetTitle ("numeri generati") ;
    h2.GetYaxis ()->SetTitle ("numeri generati") ;
    h2.Draw ("LEGO") ;

    c1.Print ("Gaussian2D.png", "png") ;

    return 0 ;
  }

3.11 Utilizzo di un oggetto della classe `TApplication`

/*
c++ -o main_11 `root-config --glibs --cflags` main_11.cpp
*/

#include "TH1F.h"
#include "TCanvas.h"
#include "TApplication.h"

int main (int argc, char ** argv)
  {

    TH1F istogramma ("istogramma", "istogramma", 10, -5., 5.) ;

    istogramma.Fill (2.2) ;

    TApplication theApp ("theApp", &argc, argv) ;
    TCanvas c1 ;
    istogramma.Draw ("hist") ;

    theApp.Run () ;

    return 0 ;
  }

3.12 utilizzo di un oggetto della classe `TString`

/*
c++ -o main_12 `root-config --glibs --cflags` main_12.cpp
*/

#include "TH1F.h"
#include "TString.h"
#include "TCanvas.h"
#include "TApplication.h"

int main (int argc, char ** argv)
  {
    int num = atoi (argv[1]) ;
    TString titolo = "ci sono " ;
    titolo += num ;
    titolo += " eventi" ;
    TH1F istogramma ("istogramma", titolo, 10, -5., 5.) ;
    for (int i = 0 ; i < num ; ++i) istogramma.Fill (2.2) ;

    TApplication theApp ("theApp", &argc, argv) ;
    TCanvas c1 ;
    istogramma.Draw () ;
    theApp.Run () ;

    return 0 ;
  }

previous

Lezione 3: visualizzazione di dati con ROOT

next

Esercizi per la lezione 3