Lezione 2: Grafici e istogrammi con ROOT

Transcript

1 Corso di Laboratorio I Laurea Specialistica Dott. Corrado Cicalò a.a. 2009/2010 Introduzione all'analisi dei dati sperimentali con il framework ROOT Università di Cagliari & INFN Università di Cagliari Corso di Laurea Specialistica in Fisica

2 Sommario Brevissimi richiami sul C++ Cos'è ROOT? Scrivere una macro in ROOT Creare un istogramma in ROOT Creare un grafico in ROOT 2/35

3 Due parole prima di iniziare NON sono un esperto di C++ (nè di alcun altro linguaggio di programmazione...) NON sono un esperto di ROOT NON occorre che diventiate esperti di C++ NON occorre che diventiate esperti di ROOT In queste lezioni non andremo oltre le competenze minime di C++ e di ROOT che occorrono per gestire l'analisi dei dati raccolti nelle semplici esperienze di laboratorio 3/35

4 Brevissimi richiami sul C++

5 Alcune regole generali [Ci concentriamo sulle regole utili ad usare il C++ nell'ambito di ROOT] Il C++ è case-sensitive ( Pippo è diverso da pippo ) Ogni variabile va dichiarata, e possibilmente inizializzata Per ogni variabile, avete accesso anche al suo indirizzo di memoria (puntatore), e spesso è comodo lavorare con i puntatori delle variabili piuttosto che con le variabili stesse Ogni blocco di istruzioni va compreso fra parentesi graffe: {... } Al termine di ogni istruzione va posto il carattere punto e virgola ; 5/35

6 Operatori utili Operatori matematici: + * / Operatori composti: += (a += b a = a+b) = (a = b a = a b) *= (a *= b a = a*b) /= (a /= b a = a/b) ++ (a++ a = a+1) (a a = a 1) Operatori relazionali: == (uguale a)!= (diverso da) > (maggiore di) < (minore di) >= (maggiore o uguale a) <= (minore o uguale a) Operatori logici: && (AND) (OR) 6/35

7 Tipi di variabile predefiniti Poche regole, senza alcuna pretesa di completezza: Usiamo il tipo double (o Double_t in ROOT) per variabili numeriche non intere Usiamo il tipo int (o Int_t in ROOT) per variabili numeriche intere Usiamo il tipo bool (o Bool_t in ROOT) per variabili di tipo Booleano (vero/falso) Potete inizializzare le variabili al momento stesso della dichiarazione. Per esempio: Double_t a = ; Int_t b = 4 ; Bool_t c = 0 ; 7/35

8 Array Per definire una variabile come array di valori, si deve specificare la dimensione fra parentesi quadre: Double_t a[26] ; Int_t b[2] ; Bool_t c[82] ; Il contenuto dell'array può essere inizializzato tutto insieme al momento della definizione, oppure elemento per elemento: Double_t a[3] = {2.998e8, 6.626e 34, 6.67e 11} ; Int_t b[2] ; b[0] = 19 ; b[1] = 23 ; Consiglio: inizializzate sempre tutti gli array. Per inizializzare a zero basta usare: a[...] = {0} 8/35

9 Stringhe di caratteri Le stringhe di caratteri possono essere trattate come array di caratteri. Per definirle e inizializzarle si possono usare varie alternative: Char_t a[4] = ciao ; Char_t a[] = ciao ; Char_t *a = ciao ; Char_t a[4] = {'c', 'i', 'a', 'o'} ; Char_t a[4] ; sprintf(a, ciao ) ; 9/35

10 Cicli Ciclo for: esegue un blocco di istruzioni un numero definito di volte (in questo caso 100) for (Int_t i = 0; i < 100; i++) {... ;... ; } Ciclo while: esegue un blocco di istruzioni fino a quando una condizione è vera while (i < 100) {... ;... ; } 10/35

11 Strutture di controllo La più importante è la condizione di controllo if...else : esegue un certo blocco di istruzioni se è verificata la condizione tra parentesi if (a > b) {... ;... ; } else if (a < b) {... ;... ; } else {... ;... ; Eseguito quando a == b } 11/35

12 Output su schermo Per l'output su schermo si può usare la funzione printf(...) printf ( ciao ) ; Scrive ciao printf ( ciao\n ) ; Scrive ciao e va a capo printf ( %d\n, a) ; Scrive il valore di a (se a è un intero) printf ( %g\n, a) ; Scrive il valore di a (se a è un double) printf ( %s\n, a) ; Scrive il valore di a (se a è una stringa di caratteri) 12/35

13 Classi Nel C++ è possibile definire nuovi tipi di variabili. Un nuovo tipo di variabile è chiamato CLASSE, e va definito secondo regole precise Se si vuole usare un oggetto (variabile) appartenente ad una classe non predefinita, la definizione va inclusa all'inizio del programma NON ci interessa sapere come creare nuove classi, perché sfrutteremo sempre classi aggiuntive già pronte da usare Le uniche cose che dobbiamo sapere sugli oggetti di una classe sono: come vanno creati quali operazioni possiamo fare con/su di essi 13/35

14 Classi Per esempio, se si è creata la classe Istogramma, un oggetto di questa classe va dichiarato come: Istogramma hist ; Oppure come puntatore: Istogramma *hist ; D'ora in poi useremo questa opzione Le operazioni che è possibile fare con/sugli oggetti della classe sono specificate nella sua definizione. Ciascuna operazione è associata a un metodo della classe, che: ha un nome ben preciso accetta una lista di argomenti (anche vuota) esegue una serie di istruzioni restituisce un output (opzionale) 14/35

15 Classi La classe Istogramma potrebbe ad esempio possedere un metodo chiamato Riempi(Double_t A), che: accetta come argomenti un numero decimale A identifica il bin dell'istogramma nel quale è compreso il valore A aumenta di un'unità il contenuto del bin non restituisce alcun output Istogramma *hist ; hist -> Riempi(0.9) ; Qui andranno inserite le istruzioni per definire il range dell'istogramma e la suddivisione in bin (tramite altri metodi) 15/35

16 Classi La classe Istogramma potrebbe ad esempio possedere un metodo chiamato Riempi(Double_t A), che: accetta come argomenti un numero decimale A identifica il bin dell'istogramma nel quale è compreso il valore A aumenta di un'unità il contenuto del bin non restituisce alcun output Istogramma *hist ; La combinazione tratto-maggiore (freccia) esegue il metodo specificato alla sua destra sull'oggetto presente alla sua sinistra hist -> Riempi(0.9) ; 16/35

17 ROOT

18 ROOT ROOT è un framework per l'analisi dati basato sul linguaggio C++ Per quanto ci riguarda, esso si compone di: un interprete (anche interattivo) di comandi C++ una collezione di classi utili per l'analisi dati (e non solo!) Trovate tutte le informazioni e la risposta a tutti i possibili dubbi su: ROOT è fra i pacchetti predefiniti in alcune recenti distribuzioni di Linux!!! 18/35

19 ROOT Per avviare ROOT digitate root nel terminale: 19/35

20 ROOT L'interprete dei comandi C++ è già pronto. Possiamo provare a digitare qualche comando C++ 20/35

21 ROOT Le macro L'interprete dei comandi C++ può essere più utilmente usato per processare interi blocchi di istruzioni, anziché una singola istruzione alla volta I blocchi di istruzioni vengono scritti in un programma chiamato MACRO, memorizzato su un file esterno Il nostro obbiettivo è imparare a scrivere delle MACRO che possano essere eseguite da ROOT per eseguire l'analisi dei nostri dati Le macro che useremo hanno una struttura fissata: le istruzioni sono raggruppate in metodi ogni metodo possiede un nome, una lista di argomenti, una serie di istruzioni e restituisce (opzionalmente) un output 21/35

22 ROOT Una macro semplice semplice void PrimaProva(Int_t a) { for (Int_t i=0; i<10; i++) { Int_t b = a*i; printf("%d\n", b); } } Qualche commento: la macro è costituita da un solo metodo, che accetta un intero come variabile input il metodo è di tipo void, cioè non restituirà alcun argomento Per caricare la macro in root:.l <nome-del-file> Una volta caricata, digitare il nome del metodo specificando il valore dell'argomento fra parentesi, e premere INVIO 22/35

23 ROOT Una macro un po' meno semplice void PrimaProva(Double_t a) { for (Int_t i=0; i<10; i++) { Double_t b = Funzione(a*i); printf("%g\n", b); } } Double_t Funzione(Double_t argument) { return 3.0*argument + 4.2; } Qualche commento: la macro è costituita da due metodi una volta caricata la macro, possiamo eseguire entrambi i metodi, independentemente il primo metodo fa uso del secondo: il calcolo di b risulta in questo modo decentrato 23/35

24 ROOT Struttura generale di una macro Non ci sono particolari prescrizioni sulla scrittura di una macro di ROOT a parte il rispetto della sintassi del C++ Tipicamente, tuttavia, nelle macro si distingue fra: metodo principale : un metodo void, cioè che esegue operazioni senza restituire alcun risultato (spesso il suo nome è quello stesso del file della macro). È il metodo che viene eseguito dopo aver caricato la macro metodi ausiliari : metodi dedicati all'esecuzione di particolari operazioni richieste all'interno del motodo principale La presenza dei metodi ausiliari permette di avere dei moduli di codice dedicati ad operazioni specifiche riutilizzabili da macro a macro!!! 24/35

25 ROOT Le classi ROOT mette a disposizione una grande quantità di classi, per la definizione degli oggetti da usare nella nostra analisi Tutto quello che dovete sapere per creare un oggetto appartenente ad una classe è: come si chiama la classe come si usa il metodo di creazione dell'oggetto come si usano i metodi per operare sull'oggetto Nelle prossime slide impareremo a usare due classi di ROOT: la classe per gli istogrammi e la classe per i grafici 25/35

26 Gestire istogrammi in ROOT

27 Creare un istogramma Per la gestione degli istogrammi useremo la classe TH1D. Per creare un istogramma occorre specificare: nome dell'oggetto titolo dell'istogramma numero di bin valore minimo della variabile valore massimo della variabile Come modello, potete assumere l'istruzione: TH1D *hist = new TH1D("Histogram", "My Title", 10, -3.0, 7.0) ; che crea un [puntatore ad un] oggetto di classe TH1D avente Histogram come nome, My Title come titolo (in un immane sforzo di fantasia!) e diviso in 10 bin fra -3.0 e /35

28 Riempire e disegnare un istogramma Una volta creato l'istogramma, lo vogliamo riempire con i valori dalle misurazioni. Per esempio, se abbiamo ottenuto il valore -1.5, questo ricade nell'intervallo del quinto bin: dunque vogliamo che il contenuto del quinto bin venga aumentato di una unità La classe TH1D fa tutto in automatico. Il metodo corrispondente si chiama Fill, e chiede come argomento il valore da inserire, in formato Double_t: hist -> Fill(1.5) ; Possiamo ovviamente riempire l'istogramma quante volte vogliamo, inserendo tutti i valori ottenuti nelle misurazioni. Quando avete terminato la fase di riempimento, potete disegnare l'istogramma con il metodo Draw: hist -> Draw() ; 28/35

29 Istogrammi Riassunto void MacroIstogramma() { TH1D *hist = new TH1D("Histogram", "My Title", 10, -3.0, 7.0) ; hist -> Fill(1.5) ; hist -> Fill(1.1) ; hist -> Fill(-2) ; hist -> Fill(4.8) ; hist -> Fill(6.2) ; hist -> Fill(0.3) ; hist -> Fill(1.2) ; hist -> Fill(-2.3) ; hist -> Draw() ; } 29/35

30 Gestire grafici in ROOT

31 Creare un grafico (metodo 1) Per la gestione dei grafici useremo la classe TGraphErrors. Per creare un grafico occorre specificare: numero di punti del grafico array contenente le coordinate x di ciascun punto array contenente le coordinate y di ciascun punto array contenente gli errori sulla x di ciascun punto array contenente gli errori sulla y di ciascun punto! NOTA BENE per gli istogrammi, prima si crea l'oggetto (vuoto) e poi lo si riempie con i dati per i grafici, con il metodo 1 i dati devono essere a disposizione in array numerici PRIMA della creazione del grafico 31/35

32 Creare un grafico (metodo 1) Ecco un esempio completo per la creazione di un grafico con cinque punti: void MacroGrafico() { const Int_t npoints = 5 ; Double_t x[npoints] = {0.1, 0.6, 1.8, 2.4, 3.1} ; Double_t y[npoints] = {0.09, 0.47, 0.93, 1.12, 1.21} ; Double_t errx[npoints] = {0.05, 0.07, 0.10, 0.12, 0.13} ; Double_t erry[npoints] = {0.05, 0.05, 0.08, 0.09, 0.10} ; TGraphErrors *graph = new TGraphErrors(nPoints, x, y, errx, erry) ; graph -> SetName("Graph") ; graph -> SetTitle("My Title") ; graph -> Draw("ap") ; } 32/35

33 Creare un grafico (metodo 1) Ecco un esempio completo per la creazione di un grafico con cinque punti: void MacroGrafico() { const Int_t npoints = 5 ; Double_t x[npoints] = {0.1, 0.6, 1.8, 2.4, 3.1} ; Double_t y[npoints] = {0.09, 0.47, 0.93, 1.12, 1.21} ; Double_t errx[npoints] = {0.05, 0.07, 0.10, 0.12, 0.13} ; Double_t erry[npoints] = {0.05, 0.05, 0.08, 0.09, 0.10} ; TGraphErrors *graph = new TGraphErrors(nPoints, x, y, errx, erry) ; graph -> SetName("Graph") ; graph -> SetTitle("My Title") ; graph -> Draw("ap") ; } 33/35

34 Creare un grafico (metodo 2) Un metodo alternativo per creare un grafico consiste nel: creare un grafico vuoto aggiungere i punti uno ad uno [Potete ovviamente anche aggiungere un punto ad un grafico creato con il metodo 1 ] Ecco come si imposta il primo punto del grafico visto nella slide predente: TGraphErrors *graph = new TGraphErrors() ; graph -> SetPoint(0, 0.1, 0.09) ; graph -> SetPointError(0, 0.05, 0.05) ; Il primo argomento dei due metodi identifica il punto che state creando. Iniziate sempre dal punto numero 0. Lo stesso metodo permette di modificare le coordinate o gli errori di un punto già impostato 34/35

35 Creare un grafico Istruzioni complementari Qualche commento sul codice per la creazione del grafico (per entrambi i metodi ) Le istruzioni: graph -> SetName("Graph") ; graph -> SetTitle("My Title") ; permettono di specificare rispettivamente il nome e il titolo del grafico (nel caso dell'istogramma sono specificati alla creazione dell'oggetto) L'istruzione: graph -> Draw("ap") ; specifica che nel disegno dovranno comparire gli assi del grafico (lettera a ) e i punti (lettera p ). Non so perché, ma l'opzione predefinita (Draw senza argomenti) NON prevede il disegno degli assi e dei punti!!! 35/35

36 Backup Slides

37 Variabili e puntatori Nel C++ si può accedere all'indirizzo di memoria di una variabile tramite il suo puntatore. Il puntatore è identificato da una stringa di caratteri, per esempio 0x80cb700 Se A è una variabile, il suo puntatore si ottiene chiedendo &A Se A è il puntatore di una variabile, la variabile si ottiene chiedendo *A SE A = ALLORA &A = 0x80cb700 SE B = &A ALLORA *B = Se definiamo: Double_t *A = allora A è un puntatore, perché la variabile è *A 37/35