Appendice V: Sistema di acquisizione

Appendice V: Sistema di acquisizione
M. Lunardon, S. Moretto e S. Pesente
Il sistema di acquisizione utilizzato per gli esperimenti del Laboratorio di Fisica A è basato sull’ uso di una
specifica card, la Flash ADC NuDAQ PCI-9812 sviluppata dalla ADLink Technology Inc., TAIWAN
(http://www.adlink.com.tw/). Una foto della card è mostrata in Fig.V.1. Il vantaggio principale di questa card
rispetto a sistemi di acquisizione tradizionali basati su ADC che ricercano e digitalizzano il valore della
V=V(t) corrispondente al massimo del segnale, è la possibilità di ottenere un sampling del segnale analogico
di ingresso fino ad un sampling rate di 20 MHz, il che significa che potete digitalizzare il vostro segnale in
ingresso per finestre temporali strette fino a 50 ns. Per ciascuna di queste finestre di campionamento l’ ADC
fornisce il valore digitale di V=V(t) nella finestra temporale di sampling. Il Flash ADC permette quindi una
“lettura” del segnale analogico variabile nel tempo, come quella ottenibile per esempio con un oscilloscopio,
ma fornendo direttamente i valori digitalizzati del campionamento del vostro segnale.
Fig. V.1. La card PCI-9812 (ADLink Technology Inc., TAIWAN).
Il sistema utilizzato ha la particolarità di permettere la lettura fino a 4 canali ad un prezzo relativamente
basso (circa 0.5 kEuro/canale). Le caratteristiche principali della card sono:
• La card PCI-9812 è equipaggiata con 4 convertitori Analogico Digitali a l2 bit (4096 canali) che lavorano
simultaneamente ad una velocità di campionamento di 20 MHz.
• La card ospita una memoria FIFO di 32k word dove le sequenze di campionatura sono immagazzinate
prima di essere trasferite alla memoria del PC tramite un bus tipo DMA.
• In questo tipo di strumenti è essenziale definire quando il sistema farà partire la campionatura, cioè il
trigger della card. La PCI-9812 Card può essere operata in differenti modi di trigger, utilizzando sia i
segnali che vengono inviati in un canale (trigger interno sia positive che negative) che un trigger esterno.
Questo modo di operazione è quello raccomandato e si deve utilizzare come trigger esterno un segnale
positivo TTL (cioè un’ onda quadra positiva di almeno 2 Volt di ampiezza).
• Ci sono sulla card 5 connettori BNC: 4 di essi servono per i segnali (analogici) che si vogliono analizzare
e l’ ultimo viene usato per dare un segnale di trigger esterno. Il range della ddp che puo’ essere analizzato
può essere selezionato come ± 1 Volt o ± 5 Volt collegando opportune pads sulla card. Allo stesso modo
possono essere selezionate impedenze di ingresso di 50 Ω, 1.25 kΩ o 15 MΩ.
Insieme alla card, ADLink fornisce un kit di sviluppo (PCIS-DASK) per applicazioni con MS Visual C++
sotto sistema operativo Windows. Utilizzando queste librerie è stato sviluppato in passato un sofware
dedicato per l’ acquisizione ed il processamento automatico dei segnali chiamato PJMCA. Recentemente il
software è stato trasferito sotto sistema operativo LINUX ed è quest’ ultima versione che sarà utilizzata in
laboratorio. Quest’ ultima versione utilizza il programma ROOT per presentazione ed analisi dei dati
(http://root.cern.ch/).
Una schermata completa del programma di acquisizione PJMCA è presentata in Fig.V.2.
Fig. V.2 Il programma di acquisizione PJMCA nella versione LINUX.
Per il corso di Laboratorio di Fisica A il sistema di acquisizione sara’ utilizzato per registrare:
1) segnali formati da uno shaping amplifier nel caso dell’ esperimento Compton;
2) segnali di output di convertitori tempo-ampiezza nel caso dell’ esperimento con i raggi cosmici.
Il sistema di acquisizione verrà operato in modo da campionare dopo trigger esterno i canali in uso e di
analizzare on-line il risultato del campionamento in modo da scrivere su disco per ogni evento il valore di
massimo di V=V(t) in ciascun canale nell’ intervallo di conversione prescelto.
In questo modo di operazione è possibile ottenere on-line l’ istogrammazione dei dati (lo spettro)
corrispondente a ciascun canale per poter controllare in linea l’ andamento della misura.
35000
a)
152
800
30000
600
25000
400
counts
channel
1000
200
Eu source
b)
20000
15000
0
10000
-200
5000
-400
0
500
1000
time (ns)
1500
2000
0
200
400
600
800
1000 1200 1400
Eγ (keV)
Fig. V.3. Tipico risultato ottenuto facendo il sampling dell’ uscita di uno shaping-amplifier (a) e spettro di
una sorgente gamma di 152Eu ottenuto con un rivelatore HPGe (b).
A titolo di esempio riportiamo in Fig V.3 un tipico segnare bipolare in uscita ad uno shaping amplifier come
quello che sarà da voi utilizzato ed il corrispondente istogramma ottenuto per i valori di Vmax misurati.
E’ importante ricordare che:
1) nel caso di shaping amplifier il massimo di V=V(t) è proporzionale alla carica totale prodotta dalla
radiazione ionizzante in un dato rivelatore e quindi è direttamente proporzionale all’ energia
rilasciata all’ interno del rivelatore stesso.
2) Nel caso di convertitori tempo-ampiezza il valore del massimo del segnale (in questo caso il segnale
si presenta come un’ onda quadra) è proporzionale al tempo intercorso tra l’ arrivo del segnale di
start al convertitore e del corrispondente segnale di stop.
Per ciascuna forma d’ onda è opportuno selezionare l’ algoritmo che fornisce il miglior valore di massimo
del segnale campionato come indicato nel manuale di operazione.
100
1 µs acquisition time
ACQUIRED / INPUT signals (%)
90
80
Linux
70
60
WinNT
50
40
30
0
2
4
6
8
rate of INPUT signals (kHz)
10
12
Fig. V.4 Frazione dei segnali acquisiti in funzione del rate di acquisizione. I parametri del sistema sono :
tempo totale di campionamento di ogni evento 1 µs, rate di campionamento 20 MHz. I risultati sono
mostrati per il programma di acquisizione sia sotto LINUX che sotto WINDOWS NT e per uno o quattro
canali (linea inferiore e superiore per ciascun set di dati.
Un ultimo punto importante è la definizione della capacità del sistema di processare segnali a differenti
velocità. Come per ogni sistema di trattamento ed analisi dati, ogni evento richiede un tempo minimo di
processamento e normalmente durante il processamento di ciascun evento, il sistema non accetta nuovi
segnali in input. Questa situazione si traduce nel cosiddetto tempo morto del sistema, che e’ definito come la
frazione degli eventi che vengono persi ed è ovviamente funzione del rate con cui gli eventi vengono rivelati
da un dato apparato sperimentale. Come esempio si riporta in Fig. V.4 la frazione degli eventi processati in
funzione del rate in input al sistema di acquisizione per una determinata configurazione del sistema stesso.
Si nota che fino a rate inferiori a 2 kHz vengono processati 80-90% dei dati in ingresso. Questo vuol dire
che il tempo morto del sistema varia tra il 10% ed il 20%. Il tempo morto aumenta all’ aumentare del rate in
input raggiungendo il 50% a circa 10-12 kHz. Questo vuol dire che l’ uso di questo sistema è ottimizzato per
rate di segnali fino ad 1-2 kHz, valore bel al di sopra delle velocità di acquisizione in Laboratorio.
Manuale del sistema di acquisizione
ACCENSIONE DEL PC E LANCIO DEL PROGRAMMA MCA
Dopo aver acceso il pc, digitare login e password
login: labo
password: ratori
e quando compare il prompt
pclabn5>
digitare startx per far partire la sessione grafica
pclabn5> startx
Aprire un terminale cliccando una volta sull’icona corrispondente.
Scegliere la directory di lavoro a seconda dell’esperimento che state facendo;
pclabn5> cd Compton (oppure “cd Cosmici”)
Digitare il nome del programma dell’acquisizione, mca,
pclabn5> mca
Appare quindi la schermata mostrata in Fig.V.5.
Fig. V.5: PJMCA MAIN
INIZIALIZZAZIONE SCHEDA:
Prima di tutto bisogna abilitare la scheda che si vuole utilizzare.
- Premere su OPTIONS: compare la schermata mostrata in Fig. V.6;
Fig. V.6: OPTIONS
- Selezionare LOAD.
Scegliere il file di configurazione nella directory di lavoro corrente: “configura.conf”;
- Selezionare la carta da attivare da selected card (di default la carta selezionata e’ la card 0);
- Selezionare ADC SETTINGS, si apre quindi la finestra di Fig.V.7;
- Selezionare le impostazioni per il campionamento dei segnali:
Fig.V.7: ADC
CONTROL
Card Range:
range delle ampiezze dei segnali in ingresso
alla carta Flash ADC
5 V
Trigger Mode
POST
Trigger Source
canale del trigger all’acquisizione; il trigger
puo’ essere fornito o da uno dei 4 canali
d’ingresso o preferibilmente da un trigger
esterno che deve essere un segnale TTL
Trigger Slope:
pendenza del segnale di trigger
Pre Trigger Time:
Trigger Level:
soglia sul segnale di trigger
Enabled Channels:
canali abilitati all’acquisizione
Sampling Rate:
rate di campionamento del segnale d’ingresso
Acquisition Time:
tempo di acquisizione del segnale
EXT (o CHX)
POSITIVE
500 ns
100mV
4
20 MHz
4000ns
- Cliccare su Apply e successivamente su ACTIVATE/SET CARD;
- cliccare su O.K.;
- Eventualmente per salvare in un nuovo file le opzioni appena impostate, selezionare OPTIONSSAVE e digitare il nome del file da salvare (es: prova.conf).
VISUALIZZAZIONE DEI DATI
- Tornare sulla finestra principale PJMCA MAIN, selezionare Mode-ADC (oscilloscope mode) e
Apply, in questo modo vengono visualizzati i segnali d’ingresso.
- Aprire una DAQ CANVAS e premere START per vedere i segnali.
- Per visualizzare solamente i segnali di determinati canali, selezionare le corrispondenti caselle su
DISPLAY.
- Premendo AutoXY, i segnali vengono riplottati su tutta la grandezza della canvas e come
segnale di riferimento viene preso quello settato in selected channel.
- Per visualizzare i segnali in modo continuo, selezionare OPTIONS-MCA e su
- Premere START sulla finestra PJMCA MAIN.
- Premere STOP per fermare l’acquisizione.
ACQUISIZIONE DEI DATI SU FILE
- Dopo aver guardato tutti i segnali d’ingresso, si possono settare nel modo corretto i parametri
dell’acquisizione;
- cliccando su
OPTIONS --> SIGNAL CONVERSION, si apre la schermata mostrata
in Fig.V.8. In questa finestra e’ possibile stabilire i parametri per il processamento del segnale.
Fig.V.8: SIGNAL OPTIONS
- selezionare il canale interessato (Channel);
- Controllare che le impostazioni siano:
a. Nel caso di segnali amplificati, selezionare l’algoritmo di conversione
Eval max with: maximum;
b. Nel caso di segnali logici utilizzare l’opzione
Eval max with: logic signal;
- Dopo aver settato i parametri per il primo canale, cliccare su Apply to this channel.
- Selezionare un altro canale e ripetere la procedura sopra descritta.
- Ripetere la stessa procedura per tutti i canali e chiudere la finestra.
- Tornare alla finestra PJMCA MAIN e selezionare SOURCE-FlashADC.
- Selezionare Mode-MCA (Multi-Channel Analyzer mode) per visualizzare gli spettri;
- Eventualmente salvare le opzioni impostate su un file .conf: su PJMCA MAIN cliccare su
OPTIONS-SAVE, dare un nome al file e cliccare su O.K..
- E’ conveniente salvare i dati in formato binario su un file “.out” : Destination-File: File
- Per salvare i dati su file, cliccare su File e su Open/Close OUTPUT PJMCA file e dare un
nome al file son il suffisso .out.
- Aprire una DAQ CANVAS.
- Premere START, selezionare la carta e i canali che interessano e results only. Per registrare non
solo il massimo del segnale ma tutti i punti campionati results only non va selezionato.
- Premere REFRESH per aggiornare la DAQ CANVAS.
- Cliccando su INFO si hanno informazioni sul tempo ed i rate di acquisizione.
- Per finire l’acquisizione premere STOP e CHIUDERE IL FILE!!!
IMPORTANTE: ricordarsi di chiudere il file una volta terminata la misura!
- Per una nuova misura aprire un altro file, fare il RESET ed il REFRESH della canvas e premere
START.
LETTURA DEI DATI DA FILE e SCRITTURA DI UN FILE IN FORMATO ROOT
Per rileggere i dati acquisiti in precedenza su di un file
Aprire un altro terminale.
Lanciare il programma mca.
- Nella finestra PJMCA MAIN selezionare SOURCE- File
- In questo caso pero’ non bisogna attivare la scheda
- Selezionare Mode-MCA (Multi-Channel Analyzer mode) per visualizzare gli spettri;
- Per l’analisi dei dati vera e propra e’ opportuno salvare i dati in formato “root”:
- Selezionare FILE:
su Open/Close INPUT PJMCA file - Selezionare il file da leggere;
su Open/Close OUTPUT T-file – Scrivere il nome del file di output con suffisso root,
“nome.root”
- Selezionare START per far partire la lettura del file
- Per finire l’acquisizione premere STOP e CHIUDERE IL FILE ROOT!!!
IMPORTANTE: ricordarsi di chiudere il file una volta terminata la misura!
- Selezionare REWIND per ritornare all’inizio del file.
- Per un nuovo file aprire un altro file, fare il RESET ed il REFRESH della canvas e premere
START.
ANALISI DATI
Aprire un nuovo terminale.
Dal prompt lanciare il programma ROOT (per i dettagli sul programma ROOT vedere il paragrafo
successivo), comparira’
root [0] _
Per prima cosa aprire il file costruito come dal paragrafo “LETTURA DEI DATI DA FILE e
SCRITTURA DI UN FILE IN FORMATO ROOT”.
root [0] Tfile f(“nome.root”)
root [0] .ls
//guardo il contenuto del file
root [0] pjmca->Print()
root [0] pjmca->Draw(“ch0”)
//guardo la struttura del tree
//si esegue l’istogramma del n-tupla “cho”
Per maggiori informazioni riguardo alla lettura e all’analisi di un rootfile,
http://root.cern.ch/root/HowtoReadTree.html
http://root.cern.ch/root/html/examples/ntuple1.C.html
Guida all'uso di ROOT per il Laboratorio di
Fisica A (LS)
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 A(LS) 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 A(LS)
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?)
TH1
TH1D
TH1C
TH1S
TH1F
root [0] TH1
TAB!
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:
•
•
•
•
creazione: TCanvas *c1 = new TCanvas("c1"); // almeno il nome deve essere
specificato
selezione canvas attiva: c1->cd();
creazione file postscript: dal menu File -> Save As -> si seleziona il tipo Postscript
editor: dal menu Edit -> Editor -> si apre una finestra che aiuta a creare vari oggetti, tipo un
testo (TLatex) o un riquadro (TPave)
7. La finestra grafica del Laboratorio di Fisica A (LNCanvas)
Per il Laboratorio di Fisica A 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:
•
•
•
Modificare le opzioni: la figura 3.b mostra la finestra delle opzioni associate alla
LNCanvas: e’ possibile scegliere alcune opzioni per il fit gaussiano (si veda il prossimo
paragrafo), scegliere se disegnare l’istogramma o il grafico dopo averlo caricato da file e
altre cose.
Salvare un istogramma o un grafico su file ASCII (Save to File): l'istogramma o il
grafico disegnato nella finestra e' salvato su file come colonna di numeri (TH1F) o doppia
colonna di numeri (TGraph: x e y) o quadrupla (TGraphErrors: x, y, ex, ey). Le prime righe,
che cominciano col simbolo #, contengono delle informazioni sul colore della linea e altre
caratteristiche. Rimuovendo queste righe e' possibile leggere questi file direttamente anche
da EXCEL. Occorre posizionarsi sopra l'istogramma o il grafico prima della pressione del
tasto centrale del mouse. Si puo' verificare di aver agganciato l'oggetto giusto premendo, ad
esempio, il tasto destro del mouse (come in fig. 2).
Caricare un istogramma o un grafico da file ASCII (Load TH1F / TGraph /
TGraphErrors from File): legge un file ASCII costituito da una colonna di numeri
(istogramma) o una doppia colonna (x e y) o quattro colonne (x, y, ex ed ey) e crea nella
memoria l'oggetto di ROOT relativo (classe TH1F, TGraph, TGraphErrors). A seconda della
selezione (draw after loading ...) disegna l'oggetto nella finestra in un frame nuovo, lo
disegna su un frame preesistente (per sovrapporre due spettri, per esempio) o non lo disegna.
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: N ( x ) = N (0) exp( − µ ⋅ x ) + const
//
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
**********
**********
**
5 **MIGRAD
**********
1
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: [email protected].
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.