Guida
all'uso
di ROOT per il Laboratorio di Fisica Nucleare
M. Lunardon
Novembre 2003
Indice
3. ROOT per il
Laboratorio
di Fisica Nucleare
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
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.1 Grafico del 60Co calibrato in energia
8.2
Fit di un grafico con una funzione particolare
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.
CINT/ROOT C/C++ Interpreter version 5.14.50, Sep 2 2000
Compiled with thread support.
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:
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:
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.
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.