Guida all'uso di ROOT per il Laboratorio di Fisica Nucleare

 

 

M. Lunardon
Novembre 2003

Indice

1. Introduzione

2. Il pacchetto software ROOT

3. ROOT per il Laboratorio di Fisica Nucleare

4. CINT

5. Gli oggetti di ROOT

5.1 Costruttori
5.2 Accesso interattivo alle proprieta' dell'oggetto
5.3 Gli operatori new e delete e l'operatore ->
5.4 Il tasto TAB

6. La finestra grafica

7. La finestra grafica del Laboratorio di Fisica Nucleare (LNCanvas)

7.1 Menu associato al tasto centrale del mouse
7.2 Fit Gaussiano Multiplo
7.3 Integrale
7.4 Contenuto di un singolo canale
7.5 Calibrazione in energia

8. Esempi commentati di macro

8.1 Grafico del 60Co calibrato in energia
8.2 Fit di un grafico con una funzione particolare

9. Bugs

 

1. Introduzione

Lo scopo di questa guida e' quello di fornire le indicazioni essenziali per utilizzare il programma ROOT nel Laboratorio di Fisica Nucleare al fine di acquisire gli spettri dal multicanale o da altri moduli di elettronica utilizzati, e fare una prima analisi degli spettri (posizione, area e larghezza dei picchi con e senza sottrazione del fondo, stampa degli spettri...).
ROOT e' un programma molto vasto e complesso e in questa guida si accennera' solamente alle cose indispensabili per il suo utilizzo pratico in Laboratorio. Per chi volesse imparare qualcosa di piu' su questo software e' disponibile un'ampia letteratura in rete. In particolare segnaliamo la guida The ROOT Cheat Sheet by Steve Beach, in formato di domande e risposte, molto utile per iniziare.

Questa guida è stata scritta in formato html ed è disponibile al sito: http://www.pd.infn.it/explodet/labnuc/index.html. In questo documento sono presenti infatti diversi link alle informazioni on-line che facilitano molto l’utilizzo di ROOT.

 

2. Il pacchetto software ROOT

ROOT e' un potente software Object-Oriented, scritto principalmente per Fisica delle Alte Energie, ma estremamente utile anche per applicazioni di Fisica Nucleare delle Basse Energie e Fisica Applicata. Una completa descrizione di ROOT puo' essere trovata al seguente sito:
http://root.cern.ch .
Da un punto di vista molto semplificativo ROOT puo' essere pensato come una grande libreria Object-Oriented di classi C++ insieme ad un interprete C++ (CINT) che rappresenta una semplice interfaccia per l'utente che puo' eseguire istruzioni C++ o semplici programmi (macro) direttamente da linea di comando. Le librerie contengono funzioni per la grafica e l'analisi dei dati.

 

3. ROOT per il Laboratorio di Fisica Nucleare

Come gia' detto, ROOT si compone essenzialmente di un insieme di classi scritte in linguaggio C++ (oggetti) e di un interprete (CINT) in grado di eseguire, da linea di comando, oltre il 90% delle istruzioni C++. E' possibile eseguire sequenze di istruzioni (in pratica dei veri e propri programmi) salvate su files. Questi files sono chiamati macro (tipicamente con estensione .C). Questo e' un esempio di semplice macro:

// si possono introdurre commenti
{
    // la macro comincia e si chiude con una parentesi graffa
    gROOT->Reset(); // azzera tutte le variabili
    int i=10;
    printf("il valore di i e' %d\n",i);
}


Per accedere all'interprete si digita root dalla riga di comando. Si apre la finestra principale per il Laboratorio Nucleare

                       


fig. 0 a                                                                                       fig.0 b                    

Dalla finestra principale si può in particolare:

Aprire la finestra grafica  [LNCanvas]: si veda il par.7.
Importare uno spettro dal multicanale [Leggi MCA]: chiamando questa funzione viene richiesto il nome del file su cui si vuole salvare lo spettro dopodiche' il programma rimane in attesa che i dati vengano spediti dal multicanale. I dati sono scritti nel file come colonna di numeri ASCII.
Impostare le opzioni per la lettura dei moduli [Opzioni]: si può settare la seriale, il  modello di MCA e altre opzioni. La configurazione di default è comunque già quella giusta.

Nel terminale appare un messaggio di benvenuto del tipo:


******************************************
*        W E L C O M E  to  R O O T      *
*                                        *
*   Version   2.25/03 15 September 2000  *
*                                        *
*  You are welcome to visit our Web site *
*          http://root.cern.ch           *
*                                        *
******************************************

FreeType Engine v1.x used to render TrueType fonts.
Compiled with thread support.

CINT/ROOT C/C++ Interpreter version 5.14.50, Sep 2 2000
Type ? for help. Commands must be C++ statements.
Enclose multiple statements between { }.
root [0] _

da cui si possono lanciare comandi o eseguire macro.



 

4. CINT

Oltre alle istruzioni C++, il CINT accetta altri comandi, che iniziano sempre col punto '.' . I piu' utili sono i seguenti:

.q                                            per uscire
.x nomemacro.C                    per eseguire la macro
.!comandounix                       per eseguire un comando unix
.ls                                           per vedere la lista degli oggetti presenti in memoria
.help                                       per vedere la lista di tutti i comandi

 

5. Gli oggetti di ROOT

L'utente di ROOT dovra' utilizzare singole istruzioni C++ o semplici programmi (macro). La conoscenza del C++ facilita dunque notevolmente chi intende usare questo programma. E' tuttavia possibile fare molte cose in modo interattivo (e intuitivo) anche avendo nozioni limitate di programmazione, grazie ai numerosi esempi disponibili (si provi ad esempio con .x demos.C, i cui sorgenti si trovano in $ROOTSYS/tutorials).
Illustreremo qui brevemente uno dei concetti base, la creazione e distruzione di oggetti, assimilato il quale risultera' piu' chiara la comprensione degli esempi e dei punti spiegati in seguito.
 

Supponiamo di essere appena entrati in ROOT: l'area di memoria a nostra disposizione e' tutta libera (fig. 1a). Se definiamo una variabile intera:

int i;

riserviamo alcuni bytes di memoria per il dato associato a i (fig.1b). Analogamente possiamo definire oggetti piu' complessi, come ad esempio un istogramma a una dimensione (classe TH1F):

 (*)  TH1F hist;

in hist saranno contenuti i dati (canali e loro contenuto, tipo di istogramma, colore della linea etc...) e tutte le funzioni che operano su quei dati. Le funzioni si richiamano con l'operatore punto '.' :

 float max = hist.Maximum();

ritorna il massimo valore dei dati contenuti in hist.
La lista delle funzioni disponibili per ogni oggetto si trova all'indirizzo http://root.cern.ch/root/html/ClassIndex.html .

5.1 Costruttori

L'istruzione (*) si trova piu' spesso nella forma:

TH1F  hist("hist","titolo",1024,0,100);

dove al momento della "costruzione" di hist vengono anche passati i dati fondamentali (qui il nome, un titolo, il numero di canali e il range (da 0 a 100 su 1024 canali)). Per ogni oggetto sono possibili piu' costruttori, sempre ritrovabili a http://root.cern.ch/root/html/ClassIndex.html .

5.2 Accesso interattivo alle proprieta' dell'oggetto

Molti oggetti di ROOT possono essere disegnati nella finestra grafica (classe TCanvas) tramite la funzione Draw() :

root[1] hist.Draw();


fig. 2

Quando la freccetta del mouse si trova sulla canvas, viene automaticamente riconosciuto l'oggetto sottostante. Premendo il tasto destro del mouse appare un menu del tipo di quello di fig. 2, dove nella pima riga e' scritto il tipo di oggetto su cui ci si trova e il suo nome (TH1F::hist e' un oggetto di tipo TH1F con nome hist ) e una serie di funzioni associate a quell'oggetto. Nell'esempio di fig. 2, selezionando SetLineAttributes e poi il colore rosso (2) si otterra' uno spettro rosso.

NOTA: tutte queste operazioni possono sempre essere eseguite da linea di comando o inserite in una macro
                hist.SetLineColor(2);

 

5.3 Gli operatori new e delete e l'operatore ->

L'altro modo per creare un oggetto (consigliabile, a mio avviso) e' quello di usare l'operatore new:

TH1F *hist = new TH1F("hist","titolo",1024,0,100);

questa riga costruisce un TH1F esattamente come la (*), ma ora hist e' il puntatore dell'oggetto creato. Per accedere alle funzioni e ai dati, al posto dell'operatore punto (.) si usa l'operatore freccia (->):

hist->Draw();

col puntatore e' possibile anche distruggere l'oggetto quando non serve piu':

delete hist;

 

5.4 Il tasto TAB

Un aiuto estremamente utile in CINT e' fornito dal tasto TAB.
Il tasto TAB si puo' usare per:

completare i nomi degli oggetti:

root [0] TH1... (e adesso?)  TAB!
TH1
TH1D
TH1C
TH1S
TH1F
root [0] TH1

e si ottiene la lista degli oggetti che iniziano per TH1

sapere che parametri passare alle funzioni:

root [1] TH1F *hist = new TH1F(             TAB!
TH1F TH1F()
TH1F TH1F(const char* name, const char* title, Int_t nbinsx, Axis_t xlow, Axis_txup)
TH1F TH1F(const char* name, const char* title, Int_t nbinsx, Float_t* xbins)
TH1F TH1F(const char* name, const char* title, Int_t nbinsx, Double_t* xbins)
TH1F TH1F(const TH1F& h1f)
root [1] TH1F *hist = new TH1F(

dove vengono elencati i 5 possibili costruttori per TH1F. O ancora:

root [4] hist->Integral(             TAB!
Stat_t Integral()
Stat_t Integral(Int_t binx1, Int_t binx2)
Stat_t Integral(Int_t, Int_t, Int_t, Int_t)
Stat_t Integral(Int_t, Int_t, Int_t, Int_t, Int_t, Int_t)
root [4] hist->Integral(

ci sono 4 modi possibili per utilizzare la funzione Integral().

 

6. La finestra grafica

Molti oggetti di ROOT (grafici, istogrammi,...) possono essere disegnati in opportune finestre. Anche in questo caso la finestra grafica e' un oggetto (classe TCanvas) che viene creato dall'apposito costruttore. Si possono aprire contemporaneamente piu' finestre, dando loro nomi diversi. Per una descrizione dettagliata delle funzioni della canvas si rimanda all' help online. Qui ci limiteremo a ricordare alcune cose essenziali:

 

 

 

 

 

 

 

 

7. La finestra grafica del Laboratorio di Fisica Nucleare (LNCanvas)

Per il Laboratorio Nucleare e' disponibile la classe LNCanvas, derivata da TCanvas, cui sono state aggiunte alcune funzioni particolari. Il fatto che LNCanvas sia derivata da TCanvas significa che possiede tutte le funzioni di TCanvas piu' qualcosa d'altro. La finestra LNCanvas si richiama direttamente dal bottone sulla finestra principale (fig. 0).
Vediamo ora in dettaglio le cose principali:

 

   


                                               fig. 3.a                                                                       fig 3.b             

7.1 Menu associato al tasto centrale del mouse

Premendo il tasto centrale del mouse si accede al menu mostrato in fig. 3.a  Da qui e' possibile:

 


NOTA BENE: se dopo aver richiamato il menu' col tasto centrale non vengono piu' riconosciuti gli oggetti sotto al cursore si puo' riattivare il riconoscimento degli oggetti premendo il tasto destro in un punto qualsiasi della canvas.

 

 

7.2 Fit Gaussiano Multiplo


 

fig. 4


E' possibile fittare fino a 10 gaussiane contemporaneamente con un fondo lineare o esponenziale. In fig. 4 e' mostrato un esempio di fit: in questo caso si tratta di un fit a due gaussiane con fondo esponenziale (fittato) con larghezza variabile dei picchi . La procedura per eseguire il fit e' la seguente:

  1. markers del fondo (blu): per definire il fondo occorre piazzare due coppie di markers di fondo, la prima coppia prima del picco (o dei picchi) e la seconda dopo il picco. Il programma calcola le medie dei canali nella regione delimitata dalle due coppie e traccia un fondo lineare o esponenziale tra questi due punti. I markers si mettono premendo il tasto 'b' con il mouse posizionato nel punto voluto. Premendo i tasti 'c' e 'b' in sequenza si puo' quindi vedere che tipo di fondo sara' sottratto. Per cancellare i markers premere in sequenza 'z' e 'b'.
  2. regione di fit (rosso): la regione di fit si delimita coi markers 'r'. Anche qui 'z' e 'r' per rimuoverli.
  3. picchi da fittare (magenta): occorre indicare la posizione approssimata e il numero dei picchi che si vuole fittare. Questi markers si mettono premendo il tasto 'g' ('z' e 'g' per cancellarli) e devono stare all'interno della regione di fit.

Il fit si esegue premere in sequenza i tasti 'c' e 'g'. Nell'esempio in figura compare quindi il seguente output:

 

--- GAUSSIAN FIT: peak n.1 -----------
     peak = 386.4253 + 0.0589
     fwhm = 22.6023 + 0.1515      resol.(perc.) = 5.8491
     area = 55088.7 + 456.1
--- GAUSSIAN FIT: peak n.2 -----------
     peak = 437.7176 + 0.0531
     fwhm = 24.1453 + 0.3520      resol.(perc.) = 5.5162
     area = 50861.2 + 490.6
---------------------------------------
     reduced chisquare: 1.311
---------------------------------------

 

Per cambiare la posizione dei markers occorre cancellarli e riposizionarli. Usare i tasti 'z' e 'z' in sequenza per cancellare tutti i markers.

La finestra delle opzioni (fig. 3.b) permette di scegliere il tipo di fondo (esponenziale o lineare), se fittare o meno il fondo e se fittare i picchi con differenti larghezze o fissare una larghezza predefinita ( 0 = larghezza libera).

7.3 Integrale

E' la versione semplificata del fit gaussiano: selezionare la regione da integrare coi markers 'i', quindi usare 'ci' per calcolare l'integrale o 'cj' per calcolare l'integrale con fondo sottratto (definito prima coi markers 'b').

7.4 Contenuto di un singolo canale

Si puo' vedere il contenuto di un singolo canale premendo il tasto 'v'.

7.5 Calibrazione in energia

Si puo' calibrare l'asse delle ascisse (numero di canale) in modo da avere direttamente la lettura in energia. Supposto che l'istogramma disegnato nella canvas si chiami hist, l' istruzione e' la seguente:

hist->GetXaxis()->Set(nbins,a,b);

dove  nbins  e'  il  numero  di  canali  dell' istogramma  ( eventualmente   recuperabile   con   hist->GetNbinsX()), a e' l'energia corrispondente al canale 0 e b quella corrispondente all'ultimo canale. Per vedere la scala cambiata occorre fare un refresh della canvas

(menu Options -> Refresh ).

 
A queso proposito e' utile osservare che, sempre nel menu Options, e' presente la voce Event Status, selezionando la quale compariranno le coordinate del mouse nel sistema di riferimento selezionato, cioe' direttamente il valore in energia.

 

8. Esempi commentati di macro

In questo paragrafo vedremo dettagliatamente alcune macro.

 8.1 Grafico del 60Co calibrato in energia

La macro seguente (file esempio1.C) carica uno spettro della sorgente di 60Co preso con uno scintillatore di Ioduro di Sodio (NaI(Tl)) da tre pollici:

{ // le istruzioni di una macro sono racchiuse tra parentesi graffe

 

gROOT->Reset(); // azzera tutte le variabili non indispensabili

 

LNCanvas *ln1 = new LNCanvas("ln1"); // definisce un puntatore di tipo

// LNCanvas di nome 'ln1' e gli assegna l'indirizzo del nuovo oggetto

// LNCanvas creato con lo stesso nome 'ln1'.

 

PInput p; // definisce un oggetto ti tipo PInput e nome 'p'. Questa classe

// non fa parte della distribuzione standard di ROOT

 

TH1F *hist; // definisce un puntatore di tipo TH1F di nome 'hist' senza

// dargli alcun valore particolare

 

hist = p.inpHist("60Co.dat"); // l'oggetto 'p' contiene la funzione

// inpHist() che legge il file "60Co.dat", scritto come colonna di numeri,

// e crea un istogramma (classe TH1F). La funzione inpHist() ritorna

// l'indirizzo dell'istogramma appena creato che viene assegnato a hist.

// Si noti che il file "60Co.dat" contiene anche le informazioni (non

// necessarie) del titolo, spessore e colore della linea...

 

float a0 = -29.9;

float a1 = 3.111; // supponiamo di aver gia' fittato le posizioni dei

// picchi (par. 7.2) e calcolato i coefficienti a0 e a1 della calibrazione

// lineare (cioe' E = a0 + a1*ch , in keV) ...

 

hist->GetXaxis()->Set(2048, a0, a0+a1*2048); // questa istruzione e' in

// realta' la composizione delle due istruzioni:

// ax = hist->GetXaxis() che recupera il puntatore dell'oggetto 'asse X'

// e ax->Set() che definisce la nuova scala che vogliamo utilizzare. In

// particolare: 2048 e' il numero di canali e la corrispettiva regione di

// energia va da a0 (ch=0) a a0+a1*2048 (ch=2048)

 

hist->GetXaxis()->SetRange(100,900); // simile a prima, fa uno zoom dello

// spettro tra i canali 100 e 900 (si faccia attenzione che sono canali e

// non energia)

 

hist->Draw(); // disegna l'istogramma hist nella canvas, senza particolari

// opzioni (per disegnare questo spettro sopra un altro si usa

// hist->Draw("same"))

 

TLatex *tex = new TLatex(80,1075,"counts"); // definisce un

// puntatore di tipo TLatex e lo inizializza con l'indirizzo del nuovo

// oggetto TLatex (il testo 'counts') appena creato

 

tex->SetTextSize(0.043); // setta alcuni attributi

tex->SetTextAngle(90);

tex->SetLineWidth(2);

 

tex->Draw(); // scrive il testo

 

tex = new TLatex(1230,-260,"gamma energy (keV)");

// come prima, con la differenza che ora non c'e' bisogno di ridefinire

// il puntatore 'tex' dato che era stato definito in precedenza

tex->SetTextSize(0.043);

tex->SetLineWidth(2);

tex->Draw();

tex = new TLatex(1080,2600,"1173");

tex->SetTextSize(0.035);

tex->SetLineWidth(2);

tex->Draw();

tex = new TLatex(1260,2150,"1332");

tex->SetTextSize(0.035);

tex->SetLineWidth(2);

tex->Draw();

tex = new TLatex(2350,150,"sum peak");

tex->SetTextSize(0.035);

tex->SetLineWidth(2);

tex->Draw();

 

ln1->Modified();

ln1->cd(); // dice all'X server che la finestra 'ln1' e' stata modificata

// e ha bisogno di essere ridisegnata. Queste istruzioni non sono

// generalmente necessarie

 

}

 

e qui sotto vediamo l'output della macro esempio1.C:

 

8.2 Fit di un grafico con una funzione particolare

La macro seguente (file esempio2.C) carica un set di dati con errore che simula una misura di assorbimento di gamm in uno spessore variabile (x) di un certo materiale. Si vuole ottenere un fit dei dati utilizzando una formula del tipo:

//    fit con la funzione: N(x) = N(0)*exp[-mu*x] + bck 

//

// Per prima cosa occorre definire la funzione che si usera' per il fit.

// Essa puo' avere un nome qualsiasi (in questo caso 'fitf') ma deve avere

// una forma ben precisa: riceve come argomenti un array di numeri in

// doppia precisione (x) e un array di parametri (par) e ritorna un valore

// in doppia precisione. x[0] e' il contenuto del generico canale  e

// par[0...2] sono i tre parametri liberi che si vuole fittare. fitval e'

// in questo caso il valore della nostra funzione nel punto x[0].

Double_t fitf(Double_t *x, Double_t *par) {

  Double_t fitval = par[0]*TMath::Exp(-par[1]*x[0]) + par[2];

  return fitval;

}

 

void esempio2() { // a differenza dell'esempio 1, il corpo principale

// della macro si trova racchiuso in una funzione di nome 'esempio2', lo

// stesso nome del file che la contiene (esempio2.C). Il nome deve essere

// necessariamente quello del file: questa informazione viene infatti

// utilizzata da CINT per capire qual e' il pezzo principale della macro

// (che non e' la funzione fitf che abbiamo definito sopra). Nell'esempio

// precedente questo non era necessario  in quanto era presente un solo

// blocco di istruzioni.

  gROOT->Reset();

  LNCanvas *ln1 = new LNCanvas("ln1");

  PInput p;

  TGraphErrors *gr = p.inpGraphErrors("assorb.dat"); // con la classe

  // PInput si puo' caricare anche un grafico con errori in x e y scritto

  // in colonne ASCII. L'oggetto di ROOT corrispondente si chiama

  // TGraphErrors. Date le dimensioni ridotte riportiamo qui il file

  // "assorb.dat":

  //

  //  # graph options:

  //  #   Name         assorb

  //  #   Title       

  //  #   LineColor    2

  //  #   LineWidth    1

  //  #   MarkerStyle  20

  //  #   MarkerColor  4

  //  #   MarkerSize   0.80000

  //  # graph data:

  //  2.0   28420 0.02  700

  //  5.0   24960 0.02  600

  //  10.0  20130 0.02  550

  //  15.0  16270 0.02  500

  //  20.0  13130 0.02  400

  //  30.0  8780  0.02  300

  //  50.0  4160  0.02  200

  //

  // dove si puo' vedere che, oltre ai dati, ci sono anche altre

  // informazioni. Queste proprieta' possono essere anche settate dopo

  // aver costruito il grafico (es. gr->SetMarkerStyle(20)). Salvando il

  // grafico attraverso la LNCanvas (par. 7.1) si ottiene un file di

  // questo tipo

 

  TF1 *func = new TF1("fit",fitf,1,60,3); // definisce un puntatore di

  // tipo TF1 con nome 'func' e lo inizializza con l'inidirizzo

  // dell'oggetto TF1 appena creato: i parametri passati al costruttore

  // sono i seguenti:

  //        nome: fit

  //        funzione: fitf (quella scritta in precedenza)

  //        regione: da 1 a 60

  //        parametri liberi: 3

 

  func->SetLineWidth(1); // la funzione verra' disegnata con una linea di

  // larghezza 1

 

  func->SetParameters(20000,0.01,0.0); // si settano i parametri iniziali:

  // i risultati del fit dipendono in modo consistente dai parametri

  // iniziali. Per valori iniziali piu' prossimi a quelli giusti il fit e'

  // migliore.

  

  func->SetParNames("N(0)","mu","background"); // attribuisce un nome ai 3

  // parametri definiti

    

  gr->Fit("fit","R"); // esegue il fit utilizzando la funzione di nome

  // "fit". L'opzione 'R' dice di fittare tutta la regione in cui la

  //funzione e' stata definita (tra 1 e 60)

   

  gr->Draw("AP"); // disegna il grafico. L'opzione 'A' indica che deve

  // essere disegnato anche il frame e 'P' che va disegnato a punti.

 

  // come prima, aggiungiamo alcuni commenti al grafico: in questo caso un

  // TPaveText giallo su sfondo blu...

  TPaveText *pt = new TPaveText(-4,32000,24,35000,"br");

  pt->SetFillColor(9);

  pt->SetTextColor(5);

  TText *text = pt->AddText("Gamma Absorption");

  pt->Draw();

  tex = new TLatex(27,22000,"#mu = 0.045 #pm 0.003");

  tex->SetTextSize(0.05);

  tex->SetLineWidth(2);

  tex->Draw();

  ln1->Modified();

  ln1->cd();

}

Eseguendo la macro si ottiene la seguente uscita nella finestra grafica:

e la seguente nella finestra testuale:

root [0] .x esempio2.C

 **********

 **    1 **SET ERR           1

 **********

 **********

 **    5 **MIGRAD        5000       1.692

 **********

 MIGRAD MINIMIZATION HAS CONVERGED.

 MIGRAD WILL VERIFY CONVERGENCE AND ERROR MATRIX.

 FCN=0.0194962 FROM MIGRAD    STATUS=CONVERGED     125 CALLS         126 TOTAL

                     EDM=4.87712e-07    STRATEGY= 1      ERROR MATRIX ACCURATE

  EXT PARAMETER                                   STEP         FIRST  

  NO.   NAME      VALUE            ERROR          SIZE      DERIVATIVE

   1  N(0)         2.99862e+04   5.75190e+02   1.75381e-01  -3.89195e-07

   2  mu           4.52086e-02   2.90480e-03   3.52890e-07   8.22321e-01

   3  background   1.03446e+03   5.89976e+02   6.67734e-02  -5.01308e-06

 FCN=0.0194962 FROM MIGRAD    STATUS=CONVERGED     125 CALLS         126 TOTAL

                     EDM=4.87712e-07    STRATEGY= 1      ERROR MATRIX ACCURATE

  EXT PARAMETER                                   STEP         FIRST  

  NO.   NAME      VALUE            ERROR          SIZE      DERIVATIVE

   1  N(0)         2.99862e+04   5.75190e+02   1.75381e-01  -3.89195e-07

   2  mu           4.52086e-02   2.90480e-03   3.52890e-07   8.22321e-01

   3  background   1.03446e+03   5.89976e+02   6.67734e-02  -5.01308e-06

in cui le ultime tre righe mostrano i risultati del fit: N(0)=29986 ± 575 ...

 

 

9. Bugs

Quella installata in laboratorio e' una delle prime versioni del software, per cui e' naturale aspettarsi problemi e cose da migliorare. Per ogni commento o suggerimento  in proposito scrivete al seguente indirizzo: lunardon@pd.infn.it.

NOTA: mentre ROOT, utilizzato come libreria di funzioni, e' molto solido,  l'interprete CINT puo' dare dei problemi legati all'utilizzo della memoria (soprattutto in seguito a operazioni non corrette o eseguendo ripetutamente certe macro). Questo e' un  problema  intrinseco del linguaggio interpretato ed e'  percio' probabile che sara' presente anche nelle future versioni di ROOT. Si consiglia di salvare sempre gli istogrammi e, possibilmente, di utilizzare macro che permettano di ripetere le operazioni effettuate in qualsiasi momento. Ogni tanto e' anche utile uscire dal programma (.q) e rientrare, in modo da liberare completamente la memoria.

torna all'inizio