Piccolo corso su ROOT e analisi dati

Piccolo corso su ROOT e analisi dati D. Cester v. 1.1 11/2013 Indice 1 Richiami di C/C++...2 1.1 Funzioni; passaggio di parametri...2 1.2 Puntatori...3 1.3 Strutture (struct)...3 1.4 Lettura e scrittura di files...4 1.4.1 Files di testo...4 1.4.2 Files binari...5 1.5 Classi e oggetti...5 2 Introduzione a ROOT...7 2.1 Che cos'è ROOT...7 2.2 La riga di comando e le macro...7 2.3 Lettura e scrittura di files ROOT...8 2.4 Le strutture dati...8 2.4.1 Trees, branches e leaves...8 2.4.2 N-tuple...11 2.5 Oggetti e metodi di uso generale...12 2.5.1 TFile...12 2.5.2 TTree...12 2.5.3 TNtuple...13 2.5.4 TCanvas...13 2.5.5 Istogrammi 1D...14 2.5.6 Istogrammi 2D...15 2.5.7 Grafici XY...15 2.5.8 Funzioni matematiche...15 3 Appendix: compiling ROOT under Linux...16

1 Richiami di C/C++ 1.1 Funzioni; passaggio di parametri La struttura tipica di una funzione è la seguente: tipo0 funzione(tipo1 param1, tipo2 param2,...) { } tipo0 variabile0; /* operazioni varie */ return variabile0; dove l'analogia con le funzioni matematiche a più parametri è evidente: a fronte di una serie di parametri in ingresso, viene eseguita una serie di operazioni che al termine produce un risultato numerico. Le funzioni si usano in massima parte per separare parti di codice che possono essere usate più volte nello stesso programma, possono essere condivise fra più programmi o semplicemente per chiarezza di organizzazione nel caso di programmi complessi. Velocemente accenniamo al problema della visibilità: ogni funzione ha in memoria un proprio spazio per scrivere le variabili, e generalmente non può accedere alle variabili del programma principale o delle altre funzioni, anche se hanno lo stesso nome, dal momento che appartengono a spazi diversi. Se una variabile del programma principale si chiama energia, è possibile definire una variabile energia anche dentro una funzione: le due variabili saranno completamente indipendenti e le modifiche fatte all'una non si riflettono sull'altra. Il maggiore limite delle funzioni è che restituiscono al massimo un singolo valore: per l'analisi matematica ad una variabile questo è generalmente sufficiente, mentre diventa rapidamente un limite per l'analisi di misure fisiche dove in genere si voglio estrarre vari dati contemporaneamente (posizione x/y/z, energia...). Ci sono tre strade per superare questo limite: 1. scrivere una funzione per ogni valore che si vuole ricavare (complicando l'analisi) 2. far vedere alle funzioni le variabili esterne (con i puntatori) 3. rendere più potente il passaggio dei dati in uscita (con le struct)

1.2 Puntatori Dal punto di vista del calcolatore, per salvare un dato in una variabile abbiamo bisogno di due numeri: il valore da salvare, e l'indirizzo di memoria a cui salvarlo, bit dopo bit. Il tipo della variabile specifica il numero fisso di bit che il valore dovrà occupare, a partire dall'indirizzo specificato. Il numero 5 ad esempio si scrive 101 in codice binario; il computer però salverà 00000101 se il tipo di dato è di 8 bit (char), mentre salverà 00000000000000101 se il tipo di dato è di 16 bit (short). Se il tipo è int, da 32 bit: 00000000000000000000000000000101. Generalmente le variabili si usano con interesse verso il valore che esse contengono, lasciando che il calcolatore gestisca in modo automatico l'indirizzo a cui piazzare i bit; è però possibile anche ottenere e manipolare direttamente l'indirizzo di una variabile, anteponendo il simbolo & al nome: int a = 5; // una variabile normale che occupa 32 bit cout << &a << endl; // l'indirizzo a cui è scritto il valore '5' Usare le variabili in questo modo standard porta presto ad emergere i limiti nel flusso dei dati cui si accennava in precedenza; per questo nel linguaggio C sono stati introdotti i puntatori. Mentre una variabile normale è associata ad un valore, e per recuperare l'indirizzo serve una simbologia particolare (la &), un puntatore contiene direttamente l'indirizzo di memoria. Anche nel caso dei puntatori, bisogna dichiarare un tipo che specifichi quanti bit di memoria occupa il dato. int v è una variabile normale: v contiene il valore &v rappresenta l'indirizzo di memoria a cui si trova v int *p è un puntatore p contiene l'indirizzo di memoria a cui si trova p (*p) è il valore L'uso dei puntatori permette di superare i limiti di visibilità delle funzioni: se usiamo un puntatore come parametro di una funzione, stiamo passando alla funzione l'indirizzo di memoria di una variabile del programma principale; la funzione potrà quindi leggere e scrivere direttamente da quella posizione, di fatto condividendo la variabile con il resto del software. Se vogliamo che una funzione restituisca più valori, invece di usare il tipo in uscita che è uno solo possiamo passare in ingresso tanti puntatori quanti sono i valori desiderati; la funzione riempirà le locazioni di memoria con i risultati, ed il programma potrà proseguire con i dati aggiornati. Esempi: esempio_puntatori.c, esempio_analisi_puntatori.c 1.3 Strutture (struct) Una struct è un insieme di variabili che sono raggruppate sotto un unico nome; generalmente queste variabili corrispondono a diverse misure di uno stesso evento fisico: se i diversi valori vanno trattati sempre insieme, e magari c'è bisogno di passarli da una parte all'altra di un programma, spesso è comodo raggrupparli in una struct. Una struct si definisce elencando le singole variabili che la compongono; ad esempio:

struct inc_data_t { }; unsigned int unsigned int unsigned short int counter; timetag; samples[4096]; Le struct, una volta definite, si utilizzano come fossero un tipo (int, float...): int inc_data_t contatore; inc_data; Esiste anche la notazione sintetica in cui una variabile di tipo struct viene dichiarata insieme alla struct stessa: struct inc_data_t { /* vari campi... */ } inc_data; Le variabili interne ad una struct si raggiungono usando un punto; il punto è sostituito da una freccina nel caso la struct sia dichiarata come puntatore: // struct e puntatore ad una struct: evento_t evento; evento.tempo = 200; // puntatore: evento_t *evento; evento->tempo = 200; Esempi: esempio_analisi_struct.c 1.4 Lettura e scrittura di files 1.4.1 Files di testo Esempio di scrittura su file di testo: ofstream outfile; outfile.open(fname_txt,ios::trunc); // la freccia al posto del punto outfile << value1 << "\t" << value2 << endl; outfile.close(); Esempio di lettura da file di testo: ifstream infile; infile.open(fname_txt); infile >> ch >> inc_data.counter >> inc_data.timetag; infile.close();

1.4.2 Files binari Esempio di scrittura su file binario: ofstream outfile; outfile.open(fname_bin,ios::binary); outfile.write((char*)&ch, 2); outfile.close(); Esempio di lettura da file binario: ifstream infile; infile.open(fname_bin,ios::in ios::binary); infile.read((char*)&variable, 4); infile.close(); Esempi: txt2bin.c, bin2txt.c 1.5 Classi e oggetti Una classe è un tipo di dato ancora più complesso delle struct: non solo può contenere diversi valori al suo interno, ma è possibile includere anche le funzioni che operano su quei valori; queste funzioni prendono il nome di metodi. Un oggetto è una variabile che ha una classe come tipo. Un esempio tipico in ROOT è la classe istogramma TH1F: dato che un istogramma è un grafico delle frequenze, i valori contenuti nella classe istogramma sono gli intervalli delle frequenze e le frequenze stesse. Questo elenco di valori potrebbe essere contenuto anche da una semplice struct; ma la classe che rappresenta gli istogrammi include già i metodi per riempire gli istogrammi, modificare gli intervalli, disegnare il diagramma delle frequenze, e così via. In pratica, così come possiamo definire una variabile energia di tipo float, possiamo dichiarare un oggetto histo della classe TH1F: float TH1F energia; histo; Senza essere costretti a scrivere noi da zero le funzioni che ci interessano, la classe TH1F fornisce già molti metodi utili, ad esempio: histo.fill(valore) trova l'intervallo in cui cade 'valore' ed aumenta di 1 la frequenza relativa; oppure histo.getmaximum() calcola la frequenza più alta, o ancora histo.getentries() calcola il numero di eventi su cui abbiamo calcolato la frequenza. In sostanza una volta dichiarato un oggetto di una data classe, abbiamo a disposizione sia

dei contenitori strutturati per i dati, che una serie di funzioni per operare su di essi. Nota: gli oggetti possono essere dichiarati sia come variabili che come puntatori: TH1F histo(parametri); // variabile TH1F *histo = new TH1F(parametri); // puntatore nel caso di programmi semplici il comportamento pratico è identico per i due casi. Come accade per le struct, se l'oggetto è un puntatore la freccia -> sostituisce il punto.

2 Introduzione a ROOT In questa sezione si prende familiarità con ROOT e gli oggetti che mette a disposizione. 2.1 Che cos'è ROOT ROOT è un ambiente (framework) per l'analisi dati; i suoi componenti principali sono le librerie che definiscono gli oggetti, e l'interprete C (chiamato CINT). Insieme consentono di scrivere programmi per l'analisi dati utilizzando il linguaggio standard C/C++ e avendo a disposizione una quantità di automatismi statistici e grafici. 2.2 La riga di comando e le macro Una volta lanciato, ROOT presenta un prompt, o riga di comando, simile alla console dei sistemi Unix-like. Questa console accetta alcuni comandi di sistema, nonché i vari comandi C/C++ che coinvolgono gli oggetti di ROOT e le operazioni con essi. Alcuni comandi interni a ROOT:.x nomemacro.c(params) esegue nomemacro.c con i parametri fra parentesi.l nomelibreria carica la libreria nomelibreria.ls.q esce da ROOT elenca gli oggetti attualmente in memoria I vari comandi che operano sugli oggetti possono essere uniti a comporre le macro: una macro è in pratica un programma in C (o C++) che opera sugli oggetti di ROOT. Dato che è molto scomodo immettere un programma riga per riga, ci limiteremo a considerare l'uso delle macro, tenendo presente che ogni operazione può essere fatta (con minime correzioni) anche da riga di comando. Questa rimane utile nei casi in cui ad esempio si voglia disegnare al volo un singolo oggetto già in memoria senza dover far girare daccapo una macro. La struttura essenziale di una macro è costituita da una sola funzione avente lo stesso nome del file; ad esempio prova_macro.c dovrà contenere la funzione prova_macro(), eventualmente con parametri. Questa funzione, analoga al main() del C, è scritta in linguaggio C/C++ di cui rispetta (con poche eccezioni) le convenzioni. Il file può contenere anche altre funzioni esterne alla principale, così come la dichiarazione di struct e variabili; le regole di visibilità locale e globale sono in buona parte le stesse del C.

Quasi tutti gli esempi che seguono riguardano l'uso di macro. 2.3 Lettura e scrittura di files ROOT Esempio di scrittura di oggetti su file ROOT: TFile *output_file = new Tfile(fileName,"RECREATE"); output_file->cd(); generic_object->write(); output_file->close(); Esempio di lettura di oggetti da file ROOT: TFile *input_file = new Tfile(fileName,"READ"); TTree *input_tree = (Ttree*)input_file->Get("datatree"); // (!) cast esplicito --^ input_file->close(); Esempi: root2txt.c, root2bin.c 2.4 Le strutture dati ROOT utilizza le stesse strutture dati di base del linguaggio C/C++. Quasi tutti i tipi di dato sono definiti più di una volta con nomi diversi, ad esempio int e Int_t; questo per motivi legati all'utilizzo dello stesso codice su sistemi molto diversi. RIferimenti: http://root.cern.ch/root/html/listoftypes.html 2.4.1 Trees, branches e leaves Un tree ( albero ) è una struttura dati gerarchica, come sottintende il nome. Un tree si divide in branches ( rami ) ognuno dei quali contiene svariate leaves ( foglie ); infine ogni leaf è composta di diversi valori, secondo quanto dichiarato al momento della costruzione del tree. Un esempio di tree, con un possibile significato fisico dei vari livelli, è in figura; rappresenta la struttura dati a Tree del programma Slimport: ad ogni Branch corrisponde un rivelatore, ognuno dei quali contiene diversi eventi. La decisione su come strutturare la gerarchia è arbitraria, almeno per quanto riguarda ROOT. Nel caso di Slimport il numero di rivelatori corrisponde al numero di canali di una scheda di acquisizione, ed è fisso per ogni run, mentre il numero di eventi dipende dall'efficienza del singolo rivelatore, e può variare anche di diversi ordini di grandezza. Potrebbe accadere però che in altri tipi di acquisizione si voglia attuare una divisione per evento, ognuno dei quali può avere hit in alcuni o tutti i rivelatori, a seconda della cinematica; in quel caso i branch saranno associati agli eventi, e le leaf ai rivelatori. In ogni caso, l'importante è che i dati abbiano una struttura regolare che si ripete per ogni evento. NOTA: i vari branch non devono per forza avere lo stesso numero di eventi; dipende da come vengono riempiti. A seconda della fisica in gioco può essere utile riempire sempre tutti i branch, eventualmente con eventi vuoti, oppure riempire solo quelli corrispondenti a degli eventi reali. A seconda dei vari casi la gerarchia del tree potrà rendere più o meno immediata

la successiva analisi. La lettura e scrittura dei tree avviene tramite delle struct appositamente dichiarate che riflettono la struttura interna dei branch. In pratica ad ogni branch viene associata una struct, ed ogni volta che viene letta (o scritta) una leaf, i dati corrispondenti vengono caricati (o letti) nei vari campi della struct. Dichiarazione di un TTree La dichiarazione di un TTree è molto semplice: TFile *output_file = new TFile( filename,"recreate"); TTree *datatree = new TTree("internalName","Tree description"); perchè dichiarare anche un TFile? Se un TTree viene dichiarato da solo, esso è residente in memoria, mentre se viene dichiarato mentre un TFile è aperto (non importa a quante istruzioni di distanza) allora è considerato residente su file; nel secondo caso si può sfruttare la funzione di recovery in caso di blocco del programma/macro, perdendo pochi o nulli dati prima del crash. Inoltre un TTree residente su disco ha limitazioni in memoria molto meno stringenti (300-500 GB su disco contro 4-8 GB di RAM - in media). La residenza di un TTree può essere modificata utilizzando il metodo SetDirectory(n) dove n corrisponde all'identificativo della destinazione: 0 rappresenta la memoria, ogni altro oggetto che può contenere un TTree (come i TFile) ha il suo valore univoco e un metodo per recuperarlo. I programmatori di ROOT consigliano caldamente di dichiarare un TTree solo dopo aver aperto un TFile. Esempio: creazione e salvataggio di un TTree residente in memoria: TTree *datatree = new TTree("internalName","Tree description");

[...] TFile *output_file = new TFile(fileName,"RECREATE"); output_file->cd(); // rende il TFile la destinazione corrente datatree->write(); datatree->setdirectory(0); // riporta in memoria il tree output_file->close(); Esempio: creazione e salvataggio di un TTree residente su disco: TFile *output_file = new TFile(fileName,"RECREATE"); TTree *datatree = new TTree("internalName","Tree description"); [...] datatree->write(); [...] output_file->close(); Dichiarazione dei Branches Un modo comodo per dichiarare i Branch è partendo dal Tree: TBranch *branch = existing_tree->branch(branchname, address, leaflist, bufsize); dove branchname è il nome interno del Branch address è l'indirizzo di una struttura leaflist è l'elenco delle foglie bufsize può essere omesso Per leggere e riempire i TBranch si utilizzano delle strutture dati, nel nostro caso le struct, che corrispondono alla struttura interna del branch; i dati di una singola leaf non sono infatti accessibili singolarmente, ma vanno trasferiti in blocco. Ad esempio: struct evt_data_t { UInt_t UInt_t evcounter; timestamp; UShort_t samples[8]; } out_data; TBranch *branch = tree->branch("evbranch", &out_data.evcounter, "counter/i:time:samples[8]/s");

out_data.evcounter =... out_data.timestamp =... out_data_samples[k] =... branch->fill(); per la scrittura di un nuovo branch, e struct evt_data_t { UInt_t UInt_t evcounter; timestamp; UShort_t samples[8]; } inc_data; TBranch *branch = input_tree->getbranch("evbranch"); branch->setaddress(&inc_data.evcounter); branch->getentry(i); cout << out_data.evcounter; nel caso di lettura. La leaflist è un elenco testuale (fra virgolette) delle variabili che compongono ogni singola leaf; ogni variabile è indicata dal nome e dal tipo, secondo il formato nome/tipo:nome/tipo:... etc. I nomi possono essere diversi da quelli della struct associata, i tipi e la sequenza invece devono combaciare. Se due variabili consecutive hanno lo stesso tipo, il tipo della seconda può essere omesso: così count/i:tempo/i:valore/f può diventare count/i:tempo:valore/f. NOTA: l'indirizzo della struct nella dichiarazione del TBranch (quello preceduto da &) deve corrispondere alla prima variabile della struct; le variabili della struct e quella della leaflist devono avere lo stesso ordine e lo stesso tipo, anche se non necessariamente lo stesso nome. La documentazione di TBranch è un ottimo riferimento per i vari tipi di variabili nella leaflist e la loro corrispondenza con i tipi di dato presenti in ROOT. Esempi: Riferimenti: scrivitree.c, leggitree.c http://root.cern.ch/root/html/ttree.html http://root.cern.ch/root/html/tbranch.html 2.4.2 N-tuple Una N-tupla è un tree ridotto a contenere solamente dati di tipo float. La N-tupla viene dichiarata insieme all'elenco delle variabili, che corrisponde alla leaflist dei branch; per riempire un evento della N-tupla si passano tutte le variabili dichiarate in elenco. In fase di lettura, ogni variabile della N-tupla deve essere associata ad una variabile normale tramite il metodo SetBranchAddress; ad ogni chiamata di GetEntry le variabili associate vengono riempite con i dati.

Dichiarazione e scrittura di una N-tupla TNtuple nt = new TNtuple("internalname", "title", "var1:var2:var3"); var1 =...; var2 =...; var3 =...; nt->fill(value1,value2,value3...); Lettura di una N-tupla TNtuple *nt= (TNtuple*)input_file->Get("ntuple_name"); // repeat for each variable: nt->setbranchaddress("varname",&variable); // loop on entries: nt->getentry(numentry); Riferimenti: http://root.cern.ch/root/html/tntuple.html 2.5 Oggetti e metodi di uso generale ROOT fornisce una quantità sterminata di oggetti utilizzabili; di seguito vedremo i più comuni, utili per l'analisi dati in laboratorio. NOTA: non è fornita una documentazione completa dei metodi presentati, solo un cenno alla loro esistenza. 2.5.1 TFile Costruttore: TFile( filename.root,"options"); Metodi di uso comune: iszombie() cd() Get() Close() verifica che esista/sia stato correttamente aperto seleziona il file per la scrittura restituisce un oggetto generico chiude il file Riferimenti: http://root.cern.ch/root/html/tfile.html 2.5.2 TTree Costruttore: TTree *tree = new TTree("internalname","Extended name of the tree"); Metodi di uso comune: Branch() dichiara un branch associato al tree

Print() Write() stampa a terminale la struttura del tree scrive il tree sulla destinazione attiva Riferimenti: http://root.cern.ch/root/html/ttree.html 2.5.3 TNtuple Costruttore: TNtuple(const char* name, const char* title, const char* varlist) Metodi di uso comune: GetEntries() restituisce il numero di entrate SetBranchAddress() associa un branch ad una variabile Print() stampa a terminale la struttura della N-tupla Fill() inserisce una entrata GetEntry() legge una entrata e la carica nelle variabili associate Riferimenti: http://root.cern.ch/root/html/tntuple.html 2.5.4 TCanvas Gli oggetti grafici di ROOT hanno bisogno di un supporto su cui essere disegnati, appunto la canvas ( tela ). Una TCanvas può essere divisa in più settori indipendenti; prima di disegnare un oggetto è buona norma specificare la canvas su cui andrà disegnato (o almeno dichiararne una che sarà poi usata di default). Costruttori: TCanvas canv( internal_name, title ); canv.cd(); TCanvas *canv = new TCanvas( internal_name, title ); canv->cd(); Metodi di uso comune: cd() Clear() Close() seleziona la canvas svuota la canvas chiude la canvas Divide(cols,rows) divide la canvas in rows righe e cols colonne. Le singole celle possono essere rese attive con cd(n) dove n=0 indica la canvas madre e n=1..rows*cols sono le varie celle. Print() stampa la canvas (eventualmente su file) SetLogx() imposta la scala logaritmica sull'asse X (Y, Z) Riferimenti: http://root.cern.ch/root/html/tcanvas.html

2.5.5 Istogrammi 1D Costruttore: TH1F("internalname","title",numBins,lowerValue,upperValue); Metodi di uso comune: Add() somma un altro istogramma, moltiplicato per un fattore Clone() copia l'istogramma Draw() disegna l'istogramma Fill() riempie l'istogramma con un dato FindBin() trova l'indice del bin corrispondente ad un dato valore FindFirstBinAbove() trova il primo bin sopra una certa soglia FindLastBinAbove() trova l'ultimo bin sopra una certa soglia GetBinCenter() restituisce il centroide del bin GetBinContent() restituisce il contenuto (altezza) del bin GetEntries() restituisce il numero di ingressi GetMaximum() restituisce l'altezza massima dei bin GetMaximumBin() restituisce l'indice del bin con altezza massima GetMinimum() restituisce l'altezza minima dei bin GetMinimumBin() restituisce l'indice del bin con altezza minima GetMean() restituisce il valor medio dell'istogramma GetMeanError() restituisce l'errore sul valor medio dell'istogramma GetNbinsX() restituisce il numero di bin sull'asse X GetXaxis() restituisce l'oggetto TAxis corrispondente all'asse X Integral() restituisce l'integrale in un certo intervallo di bin ResetStats() resetta le statistiche SetBinContent() modifica il contenuto di un singolo bin SetLineColor() modifica il colore della linea SetTitle() modifica il titolo dell'istogramma Write() scrive l'istogramma Riferimenti: http://root.cern.ch/root/html/th1f.html http://root.cern.ch/root/html/thistpainter.html http://root.cern.ch/root/html/tattline.html

2.5.6 Istogrammi 2D Costruttore: TH2F("name","title",numBinsX,lowerX,upperX,numBinsY,lowerY,upperY); Metodi di uso comune: Praticamente gli stessi di TH1F; maggiori opzioni per Draw(). Riferimenti: http://root.cern.ch/root/html/th2f.html http://root.cern.ch/root/html/thistpainter.html 2.5.7 Grafici XY Costruttori: TGraph(); // see more options on web reference Metodi di uso comune: Clear() svuota il TGraph Draw() disegna il grafico GetMaximum() restituisce il valore massimo GetMinimum() restituisce il valore minimo GetN() restituisce il numero di punti InsertPoint() aggiunge un punto al grafico RemovePoint() rimuove un punto dal grafico Riferimenti: http://root.cern.ch/root/html/tgraph.html 2.5.8 Funzioni matematiche Riferimenti: http://root.cern.ch/root/html/tf1.html

3 Appendix: compiling ROOT under Linux I strongly recommend to install ROOT from official sources rather than using the official packages of your distribution; they are often out-of-date or incomplete. This guide has been tested up to version 5.34/23 on several versions of Ubuntu. Download ROOT from root.cern.ch; you will also need the following packages: make gcc g++ binutils dpkg-dev libx11-dev libxpm-dev libxft-dev libxext-dev (list taken from http://root.cern.ch/drupal/content/build-prerequisites) Extract the ROOT archive, enter the newly created directory and execute: $./configure $ make (If you have a multi-core system you can speed up the compilation with make -jn where N is the number of cores in your CPU). Before you actually can install ROOT you have to set up system variables; open (or create) hidden file.bashrc in your user home directory (or /etc/bash.bashrc) to affect all user profiles) and add the following lines at the end: # ROOT environment source /usr/local/root/bin/thisroot.sh then go as root user, set ROOT environment variable, install and switch back to your user: $ sudo su $ export ROOTSYS=/usr/local/root $ make install $ exit Now close and reopen all your terminals. You might want to add the line alias root='root -l' to ~/.bashrc or to /etc/bash.bashrc to suppress ROOT splash screen at startup.