Introduzione a ROOT

Introduzione a ROOT
C. Genta
Analisi Dati
a.a. 2009/10
ROOT
ROOT è un framework per analisi dati creato
come successore di PAW (stessi autori)
Homepage: http://root.cern.ch
Molto diffuso in fisica alte energie , ma anche in
altre applicazioni (Astronomia, Finanza)
Supporta molti sistemi operativi ed è capace di
gestire grandi quantità di dati (basti pensare a
LHC...)
L'utilizzo della programmazione a oggetti lo
rende facilmente estendibile con librerie
esterne, sia “fatte in casa” che disponibili in rete.
C.Genta – Analisi dati
2
Caratteristiche di ROOT
E' un insieme di librerie scritte in C++
Fornisce classi gia' pronte per Ntuple,
Istogrammi, Fit etc.
Interprete C++ CINT
Formato per archiviazione dati
Possibilità di usare lo stesso codice per
programmi compilati e macro interattive.
Compilazione automatica di macro (ACLIC)
Può essere usato interattivamente o come
libreria da programmi esterni
C.Genta – Analisi dati
3
Getting started
Se root è gia installato:
– Su linux occorre avere settate alcune variabili di
ambiente (bash):
$ROOTSYS è la directory dove è installato. Potete provare a fare:
echo $ROOTSYS
da teminale per vedere se è settata. Se non lo è:
export ROOTSYS= /usr/local/ROOT
export PATH=$PATH:$ROOTSYS/bin (eseguibile)
export LD_LIBRARY_PATH=
$ROOTSYS/lib:$LD_LIBRARY_PATH (librerie
dinamiche caricate a run time)
– Per far partire il programma: root
C.Genta – Analisi dati
4
CINT
CINT è l'interprete dei comandi
Supporta quasi tutti i comandi C++. Esempio:
int i = 5;
cout << "hello world" << endl;
I comandi speciali di CINT iniziano con .
–
–
–
–
.L macro_name
.x macro_name
.q
.h
load macro
execute macro
exit root
print help
Comandi di più righe e macro devono essere inclusi in { ... } (una
macro non è altro che un insieme di comandi in C++)
Ideale per testare programmi: una macro interattiva può essere
integrata in un programma in un secondo tempo.
E' meglio in ogni caso usare programmi compilati perché molto più
veloci.
C.Genta – Analisi dati
5
CINT
Completamento automatico (premendo TAB) sia delle variabili che dei
metodi:
root [] TH1F *h = new TH1F( TAB
→ CINT suggerisce:
TH1F TH1F()
TH1F TH1F(const char* name, const char* ...
TH1F TH1F(const char* name, const char* ...
TH1F TH1F(const char* name, const char* ...
TH1F TH1F(const TVector& v)
TH1F TH1F(const TH1F& h1f)
C.Genta – Analisi dati
6
Convenzioni
Le classi di ROOT iniziano per “T”
Sono definite alcune variabili globali (iniziano per
“g”)
–
–
–
–
gFile
gROOT
gDirectory
gStyle
I metodi iniziano per maiuscola e i metodi per
accedere/settare una variabile iniziano con
Get/Set
I variabili interne delle classi iniziano con “f”
C.Genta – Analisi dati
7
ROOT: struttura classi
TObject
Buona parte degli oggetti di ROOT ereditano
da TObject, che fornisce vari metodi a basso
livello
TNamed
SetName(), SetTitle()
TH1
TF1
TH2
TNtuple
TGraph
Molti oggetti di uso comune
(istogrammi, ntuple, grafici, canvas,...)
discendono da TNamed che fornisce:
- titolo : stringa che viene visualizzata
- nome: nome interno per riconoscere
l'oggetto in memoria o quando viene
scritto su disco
ROOT: classi più comuni
TH1
TH2
TProfile
TF1
TLine
TMarker
TGraph
TLatex
TLegend
TFile
TCanvas
TTree
TRandom
Istogamma 1D (TH1S, TH1F, TH1D)
Istogramma 2D
Istogramma profilo
Funzioni 1D
Linea nel piano
Marker
Vettore di punti nel piano
Scrittura testo
Legenda
File ROOT
Finestra grafica di disegno
Ntuple dati
Numeri casuali
Istogrammi
Le classi istogramma sono TH1I (interi), TH1F (float), TH2F (2D)...:
create
fill
draw
TH1F *hist = new TH1F("name","title",20,0.5,20.5);
for(int i=1; i<=20; ++i){
hist->Fill(i,i/2.0); }
hist->Draw();
# bin
weight
range
value
Risultato:
C.Genta – Analisi dati
10
}
// prendere un oggetto dal file: sappiamo che si chiama
// “name” e che e' un TH1F
TH1F *h1=(TH1F*) f_in->Get("name");
// create a new file:
TFile *f_out=new TFile("myfile.root", "RECREATE");
// h1 viene salvato col suo nome attuale dentro myfile.root
h1->Write();
// h1 viene salvato col nome "h2" dentro myfile.root
h1->Write("h2");
// save & close
f_out->Write();f_out->Close();
h1->Draw(); // ERRORE: SEGMENTATION FAULT
// chiudendo il file "spariscono"
// dalla memoria gli oggetti contenuti nel file
GUIDA: http://root.cern.ch/root/html/TFile.html
TFile *f_in=new TFile("file.root");
if( f_in->IsZombie())
{
printf("ERROR opening file!\n"); return;
// list file contents...
f_in.ls();
gFile->ls(); // identico al precedente
TFile
TFile & TObject
Cosa vuol dire:
TH1F * h1 = (TH1F*) file­>Get(“myhisto”) Gli oggetti scritti nei file .root ereditano da TObject.
Il metodo TFile::Get(const char *name) restituisce un puntatore a
un oggetto con un certo nome (“myhisto”): di default quindi
restituisce il padre cioe' un TObject *
L'utente però sa che l'oggetto non è solo TObject , ma anche
TH1F (ereditarietà) e quindi “forza” il compilatore a costruire un
puntatore a TH1F. Questo permette di usare i metodi della classe
figlio (TH1F) e non solo quelli della classe padre (TObject).
TTree
TTree servono per immagazzinare e processare dati
”per evento” (stessa struttura dati ripetuta più volte)
Event 1
float vis_energy;
int ntracks, nclusters;
float px[max_tracks], py[...
Event 2
float vis_energy;
int ntracks, nclusters;
float px[max_tracks], py[...
...
C.Genta – Analisi dati
13
Trees
I TTree sono la generalizzazione delle ntuple di paw
Possono immagazzinare dati strutturati in maniera arbitraria
Possono contenere variabili di tutti i tipi, anche oggetti C++
void tree1w() {
//create a tree file tree1.root - create the file, the
//Tree and a few branches
TFile f("tree1.root","recreate");
TTree t1("t1","a simple Tree with simple variables");
Float_t px, py, pz;
Double_t random;
Int_t ev;
t1.Branch("px",&px,"px/F");
t1.Branch("py",&py,"py/F");
t1.Branch("pz",&pz,"pz/F");
t1.Branch("ev",&ev,"ev/I");
C.Genta – Analisi dati
14
TTree
for (Int_t
i=0; i<10000; i++) {
gRandom->Rannor(px,py);
pz = px*px + py*py;
random = gRandom->Rndm();
ev = i;
t1.Fill();
}
//save the Tree; the file will be automatically closed
//when going out of the function scope
t1.Write();
}
C.Genta – Analisi dati
15
TTree
void tree1r() {
TFile *f = new TFile("tree1.root");
TTree *t1 = (TTree*)f->Get("t1");
Float_t px, py, pz;
Double_t random;
Int_t ev;
t1->SetBranchAddress("px",&px);
t1->SetBranchAddress("py",&py);
t1->SetBranchAddress("pz",&pz);
t1->SetBranchAddress("ev",&ev);
//create a histogram
TH1F *hpx = new TH1F("hpx","px distribution",100,-3,3);
//read all entries and fill the histogram
Int_t nentries = (Int_t)t1->GetEntries();
for (Int_t i=0; i<nentries; i++) {
t1->GetEntry(i);
hpx->Fill(px);
}
}
Per rileggere un TTree e' molto utile il metodo MakeClass
C.Genta – Analisi dati
16
TCanvas *c1=new TCanvas("c1","My canvas");
hist­>Draw();
c1­>Clear();
c1­>Divide(Nx, Ny); TCanvas
// apriamo un'altra finestra:
TCanvas *c2=new TCanvas("c2","My canvas 2");
hist2­>Draw(); // disegnato anche in c2.
// ri­disegnamo in c1:
c1­>cd(1); // oppure c1­>cd() se non e' diviso
hist2­>Draw(“same”);
// scala logaritmica (gPad=puntatore al riquadro corrente):
gPad­>SetLogy(); // attivata
gPad­>SetLogy(0); // disattivata
c1­>Modified(); c1­>Update(); // FORZA IL REFRESH
GUIDA: http://root.cern.ch/root/html/TCanvas.html
c1­>cd(1); // la numerazione dei pad inizia da 1 !!!!!!!
hist­>Draw();
c1­>cd(2);
hist2­>Draw();
TCanvas
Opzioni statistiche:
gStyle->SetOptStat(1111111);
histogram name
number of entries
mean value
RMS
underflows
Nota:
– 1 will give 1111
– use 10000001 if you want 1
overflows
sum of bins
C.Genta – Analisi dati
18
Canvas e istogrammi
Titolo assi:
hist->SetXTitle("#sqrt{s}");
Legenda:
leg = new TLegend(0.1,0.5,0.3,0.8);
leg->AddEntry(hist1,"backgr. 1");
leg->AddEntry(hist2,"backgr. 2");
leg->Draw();
Salvataggio:
gPad->SaveAs("test.ps");
Possono essere salvati anche in altri formati compresi file
binari di root e macro di root.
Molte operazioni possono essere fatte anche con il mouse
cliccando con il tasto destro sull'oggetto da modificare
C.Genta – Analisi dati
19
Mouse pulsante destro
Cliccando col pulsante destro del mouse si ha accesso a un menu
aggiuntivo con varie opzioni
ATTENZIONE: il menu dipende dall'oggetto cliccato!! alcuni
esempi:
TPaveText
TAxis
TCanvas
TH1F
TFrame
TF1
Funzione di una variabile: Classe TF1
parametri
Esempio:
func = new TF1("func",
"exp(-(x-[0])*(x-[0])/(2*[1]*[1]))",-5,5);
variabile
formula
x range
func->SetParameter(0,1);
func->SetParameter(1,1.5);
func->Draw();
Analogamente esistono le classi TF2 e TF3
Esistono funzioni predefinite tipo gaussiana, landau,
polinomi...
C.Genta – Analisi dati
21
Fit istogrammi
Definire la funzione di fit:
lf = new TF1("func","[0]+x*[1]",0,20);
lf->SetParName(0,"const");
lf->SetParName(1,"lin");
Fit istogramma:
hist->Fit(lf);
Risultato:
FCN=1.51829e-025 FROM MIGRAD STATUS=CONVERGED 34 CALLS
EDM=3.03915e-025 STRATEGY= 1 ERROR MATRIX ACCURATE
EXT PARAMETER
STEP
NO.
NAME VALUE
ERROR
SIZE
1 const
2.11676e-013 5.44668e-001 2.19664e-013
2 lin
5.00000e-001 7.12764e-002 2.38257e-005
C.Genta – Analisi dati
...
...
...
...
...
22
Fit Istogrammi
Il risultato è disegnato sopra l'istogramma:
C.Genta – Analisi dati
23
TBrowser
Per farlo partire: new TBrowser;
open root
files
histogram
in the file
(double click
to view it)
C.Genta – Analisi dati
24
Per compilare le macro
Metodo facile: ACLIC (The Automatic Compiler of
Libraries for CINT)
.L mymacro.C+
invoke ACLIC
compila se la macro e' stata
modificata
forza la ricompilazione
.L mymacro.C++
Attenzione: rispetto alle macro:
– occorre aggiungere tutti gli #include che servono
– codice C++ senza “scorciatoie” interprete
Metodo non interattivo: occorre generare un
dizionario usando rootcint (non ne parlero')
C.Genta – Analisi dati
25