]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TPC/AliTPCCalibRaw.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Split task for ITS tracks: 1. ITS tracks with TPC partner, 2. pure ITS standalone
[u/mrichter/AliRoot.git] / TPC / AliTPCCalibRaw.cxx
CommitLineData
ddeb9c4f 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id: $ */
17
18////////////////////////////////////////////////////////////////////////////////////////
19// //
20// Implementation of the TPC Raw drift velocity and Altro L1 Phase calibration //
21// //
22// Origin: Jens Wiechula, J.Wiechula@gsi.de //
23// //
24////////////////////////////////////////////////////////////////////////////////////////
25//
26//
27// *************************************************************************************
28// * Class Description *
29// *************************************************************************************
30/*
31
32----example---
33TFile f("CalibAltro.root");
34AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
35{
36TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
37if (!c1) c1=new TCanvas("c1","c1");
38c1->Clear();
39
40TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
41Bool_t first=kTRUE;
42Int_t i,iev;
43for (i=0;i<216;++i) {
44 TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
45 if (!v) continue;
46 for (iev=0;iev<al->GetNevents();++iev) {
47 h2f->SetBinContent(i+1,iev+1,(*v)(iev));
48 }
49// TH1F h(*v);
50// h.SetLineColor(i/216.*50+50);
51// ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
52// c1->Modified();
53// c1->Update();
54 first=kFALSE;
55}
56h2f->Draw("col");
57}
58
59*/
60
61
62
63//Root includes
1d32f273 64#include <TROOT.h>
ddeb9c4f 65#include <TH2C.h>
be3dbaa0 66#include <TH1F.h>
f113dfeb 67#include <TMap.h>
1d32f273 68#include <TGraph.h>
f113dfeb 69#include <TObjString.h>
1d32f273 70#include <TTimeStamp.h>
71#include <TCanvas.h>
ddeb9c4f 72//AliRoot includes
73#include "AliTPCCalROC.h"
74#include "AliAltroRawStream.h"
75#include "AliLog.h"
ddeb9c4f 76//class header
77#include "AliTPCCalibRaw.h"
78
79ClassImp(AliTPCCalibRaw)
80
81AliTPCCalibRaw::AliTPCCalibRaw() :
82 AliTPCCalibRawBase(),
83 fPeakDetMinus(1),
84 fPeakDetPlus(2),
85 fNFailL1Phase(0),
be3dbaa0 86 fNFailL1PhaseEvent(0),
ddeb9c4f 87 fFirstTimeStamp(0),
88 fNSecTime(600), //default 10 minutes
89 fNBinsTime(60), //default 60*10 minutes = 10 hours
90 fPadProcessed(kFALSE),
91 fCurrentChannel(-1),
92 fCurrentSector(-1),
93 fLastSector(-2),
94 fCurrentRow(-1),
95 fCurrentPad(-1),
96 fLastTimeBinProc(0),
97 fPeakTimeBin(0),
98 fLastSignal(0),
99 fNOkPlus(0),
100 fNOkMinus(0),
1d32f273 101 fNanoSec(0),
ddeb9c4f 102 fArrCurrentPhaseDist(4),
be3dbaa0 103 fArrCurrentPhase(kNRCU),
104 fArrFailEventNumber(100),
1d32f273 105 fArrALTROL1Phase(100000),
be3dbaa0 106 fArrALTROL1PhaseEvent(kNRCU),
107 fArrALTROL1PhaseFailEvent(kNRCU),
1d32f273 108 fHnDrift(0x0),
109 fVOccupancyEvent(100000),
110 fVSignalSumEvent(100000),
111 fVOccupancySenEvent(100000),
112 fVSignalSumSenEvent(100000),
113 fVNfiredPadsSenEvent(100000),
114 fVTimeStampEvent(100000)
ddeb9c4f 115{
116 //
117 // Default ctor
118 //
119 SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
120 CreateDVhist();
be3dbaa0 121 for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
ddeb9c4f 122 fFirstTimeBin=850;
f113dfeb 123 fLastTimeBin=1020;
ddeb9c4f 124}
f113dfeb 125//_____________________________________________________________________
126AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) :
127AliTPCCalibRawBase(),
128fPeakDetMinus(1),
129fPeakDetPlus(2),
130fNFailL1Phase(0),
be3dbaa0 131fNFailL1PhaseEvent(0),
f113dfeb 132fFirstTimeStamp(0),
133fNSecTime(600), //default 10 minutes
134fNBinsTime(60), //default 60*10 minutes = 10 hours
135fPadProcessed(kFALSE),
136fCurrentChannel(-1),
137fCurrentSector(-1),
138fLastSector(-2),
139fCurrentRow(-1),
140fCurrentPad(-1),
141fLastTimeBinProc(0),
142fPeakTimeBin(0),
143fLastSignal(0),
144fNOkPlus(0),
145fNOkMinus(0),
1d32f273 146fNanoSec(0),
f113dfeb 147fArrCurrentPhaseDist(4),
be3dbaa0 148fArrCurrentPhase(kNRCU),
149fArrFailEventNumber(100),
1d32f273 150fArrALTROL1Phase(100000),
be3dbaa0 151fArrALTROL1PhaseEvent(kNRCU),
152fArrALTROL1PhaseFailEvent(kNRCU),
1d32f273 153fHnDrift(0x0),
154fVOccupancyEvent(100000),
155fVSignalSumEvent(100000),
156fVOccupancySenEvent(100000),
157fVSignalSumSenEvent(100000),
158fVNfiredPadsSenEvent(100000),
159fVTimeStampEvent(100000)
f113dfeb 160{
161 //
162 // Default ctor
163 //
164 SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
165 CreateDVhist();
be3dbaa0 166 for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
f113dfeb 167 fFirstTimeBin=850;
168 fLastTimeBin=1020;
169 if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
170 if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
cc65e4f5 171 if (config->GetValue("DebugLevel")) fDebugLevel = ((TObjString*)config->GetValue("DebugLevel"))->GetString().Atoi();
f113dfeb 172}
173
ddeb9c4f 174//_____________________________________________________________________
175AliTPCCalibRaw::~AliTPCCalibRaw()
176{
177 //
178 // dtor
179 //
180 delete fHnDrift;
181}
182//_____________________________________________________________________
183// AliTPCCalibRaw& AliTPCCalibRaw::operator = (const AliTPCCalibRaw &source)
184// {
185// //
186// // assignment operator
187// //
188// if (&source == this) return *this;
189// new (this) AliTPCCalibRaw(source);
190//
191// return *this;
192// }
193
194//_____________________________________________________________________
195Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
196 const Int_t iTimeBin, const Float_t signal)
197{
198 //
199 // Data filling method
200 //
201 if (iRow<0) return 0;
202 if (iPad<0) return 0;
203 if (iTimeBin<0) return 0;
204 if (!fFirstTimeStamp) fFirstTimeStamp=GetTimeStamp();
1d32f273 205 //
206 Int_t iChannel = fROC->GetRowIndexes(isector)[iRow]+iPad; // global pad position in sector
207 //occupancy
208 fVOccupancyEvent.GetMatrixArray()[GetNevents()]++;
209 fVSignalSumEvent.GetMatrixArray()[GetNevents()]+=signal;
210 //occupancy in sensitive regions
211 Int_t npads=(Int_t)fROC->GetNPads(isector,iRow);
212 Int_t cpad=iPad-npads/2;
213 if (isector<(Int_t)fROC->GetNInnerSector()){
214 //IROC case (spot)
215 if ( iRow>19 && iRow<46 ){
216 if ( TMath::Abs(cpad)<7 ){
217 fVOccupancySenEvent.GetMatrixArray()[GetNevents()]++;
218 fVSignalSumSenEvent.GetMatrixArray()[GetNevents()]+=signal;
219 if (iChannel!=fCurrentChannel) fVNfiredPadsSenEvent.GetMatrixArray()[GetNevents()]++;
220 }
221 }
222 } else if ( iRow>75 ){
223 //OROC case (outer corners and last three rows are sensitive)
224 Int_t padEdge=(Int_t)TMath::Min(iPad,npads-iPad);
225 Int_t nrows=(Int_t)fROC->GetNRows(isector);
226 if ((nrows-iRow-1)<3 || padEdge<((((Int_t)iRow-76)/4+1))*2){
227 fVOccupancySenEvent.GetMatrixArray()[GetNevents()]++;
228 fVSignalSumSenEvent.GetMatrixArray()[GetNevents()]+=signal;
229 if (iChannel!=fCurrentChannel) fVNfiredPadsSenEvent.GetMatrixArray()[GetNevents()]++;
230 }
231 }
232 //
ddeb9c4f 233 if ( (iTimeBin>fLastTimeBin) || (iTimeBin<fFirstTimeBin) ) return 0;
234 //don't process edge pads
235 if (IsEdgePad(isector,iRow,iPad)) return 0;
236// Double_t x[kHnBinsDV]={1,isector,0};
237// fHnDrift->Fill(x);
ddeb9c4f 238 if (fCurrentChannel==iChannel){
239 if (fPadProcessed) return 0;
240 } else {
241 fPadProcessed=kFALSE;
242 fNOkPlus=0;
243 fNOkMinus=0;
244 fPeakTimeBin=0;
245 fLastSignal=0;
246 }
247// Double_t x2[kHnBinsDV]={2,isector,0};
248// fHnDrift->Fill(x2);
249
250
251 if (signal>fLastSignal) ++fNOkPlus;
252 else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
253 ++fNOkMinus;
254 if (!fPeakTimeBin) fPeakTimeBin=fLastTimeBinProc;
255 if ( fNOkMinus>=fPeakDetMinus ) {
256 Double_t x[kHnBinsDV]={fPeakTimeBin,isector,(fTimeStamp-fFirstTimeStamp)/fNSecTime};
257 fHnDrift->Fill(x);
258 }
259 } else {
260 fNOkPlus=0;
261 fNOkMinus=0;
262 fPeakTimeBin=0;
263 fLastSignal=0;
264 }
265
266 fLastTimeBinProc=iTimeBin;
267 fLastSignal=TMath::Nint(signal);
268 fCurrentChannel = iChannel;
269 return 0;
5312f439 270}
271//_____________________________________________________________________
272void AliTPCCalibRaw::UpdateDDL(){
273 //
274 // fill ALTRO L1 information
275 //
be3dbaa0 276
1d32f273 277 //set nanoseconds
278 if (!fNanoSec) {
279 TTimeStamp s;
280 fNanoSec=s.GetNanoSec();
281 }
be3dbaa0 282 // current phase
283 Int_t phase=(Int_t)(GetL1PhaseTB()*4.);
284 //Fill pahse information of current rcu and event
285 fArrCurrentPhase.GetMatrixArray()[fCurrDDLNum]=phase;
286 //increase phase counter
287 ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
5312f439 288
ddeb9c4f 289}
290//_____________________________________________________________________
291void AliTPCCalibRaw::ResetEvent()
292{
293 //
294 // Reset event counters
295 //
296
297 fCurrentChannel=-1;
1d32f273 298 fCurrentRow=-1;
299 fCurrentPad=-1;
ddeb9c4f 300 fArrCurrentPhaseDist.Zero();
301}
302//_____________________________________________________________________
303void AliTPCCalibRaw::EndEvent()
304{
305 //
306 // End event analysis
307 //
308
309
310 //find phase of the current event
311 Int_t phaseMaxEntries=-1;
312 Int_t maxEntries=0;
313 for (Int_t i=0;i<fArrCurrentPhaseDist.GetNrows();++i){
314 Int_t entries=(Int_t)fArrCurrentPhaseDist[i];
315 if (maxEntries<entries) {
316 maxEntries=entries;
317 phaseMaxEntries=i;
318 }
319 }
320 // store phase of current event
cc65e4f5 321 if (fArrALTROL1Phase.GetNrows()-1<=GetNevents())
1d32f273 322 fArrALTROL1Phase.ResizeTo(GetNevents()+10000);
ddeb9c4f 323 (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
324
325 //loop over RCUs and test failures
be3dbaa0 326 UInt_t fail=0;
327 for (Int_t ircu=0;ircu<kNRCU;++ircu){
328 Int_t phase=(Int_t)fArrCurrentPhase[ircu];
329 if (phase<0) continue;
330 if (phase!=phaseMaxEntries){
331 TVectorF *arr=MakeArrL1PhaseRCU(fCurrDDLNum,kTRUE);
cc65e4f5 332 if (arr->GetNrows()-1<=(Int_t)fNFailL1PhaseEvent) arr->ResizeTo(arr->GetNrows()+100);
be3dbaa0 333 (arr->GetMatrixArray())[fNFailL1PhaseEvent]=phase;
ddeb9c4f 334 ++fNFailL1Phase;
be3dbaa0 335 fail=1;
ddeb9c4f 336 }
be3dbaa0 337 //reset current phase information
338 fArrCurrentPhase[ircu]=-1;
339 }
340 if (fail){
cc65e4f5 341 if (fArrFailEventNumber.GetNrows()-1<=(Int_t)fNFailL1PhaseEvent) fArrFailEventNumber.ResizeTo(fArrFailEventNumber.GetNrows()+100);
be3dbaa0 342 fArrFailEventNumber.GetMatrixArray()[fNFailL1PhaseEvent]=GetNevents();
ddeb9c4f 343 }
be3dbaa0 344 fNFailL1PhaseEvent+=fail;
1d32f273 345 //time stamps
346 fVTimeStampEvent.GetMatrixArray()[GetNevents()]=GetTimeStamp()-fFirstTimeStamp+fNanoSec*1e-9;
347 fNanoSec=0;
348 //occupance related
cc65e4f5 349 if (fVOccupancyEvent.GetNrows()-1<=GetNevents()){
1d32f273 350 fVOccupancyEvent.ResizeTo(GetNevents()+10000);
351 fVSignalSumEvent.ResizeTo(GetNevents()+10000);
352 fVOccupancySenEvent.ResizeTo(GetNevents()+10000);
353 fVSignalSumSenEvent.ResizeTo(GetNevents()+10000);
354 fVTimeStampEvent.ResizeTo(GetNevents()+10000);
355 fVNfiredPadsSenEvent.ResizeTo(GetNevents()+10000);
356 }
ddeb9c4f 357 IncrementNevents();
358}
359//_____________________________________________________________________
360TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
361{
362 // Create a 2D histo RCU:Events indicating the there was a deviation
363 // from the mean L1 phase of the event
364 //
365 //type: 0=Failures, 1=Phases
be3dbaa0 366
367 //number of relavant events, depending on version
368 Int_t nevents=GetNevents();
369 //check version
370 Bool_t newVersion=kFALSE;
371 for (Int_t ircu=0; ircu<kNRCU; ++ircu){
372 const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu);
373 if (!v) continue;
7390f655 374 if ((UInt_t)(v->GetNrows())==fNFailL1PhaseEvent){
be3dbaa0 375 newVersion=kTRUE;
376 nevents=fNFailL1PhaseEvent;
377 }
378 break;
379 }
380 TH2C *h2 = new TH2C("hL1FailRCUEvents","L1 Failures;RCU;Event",kNRCU,0,kNRCU,nevents,0,nevents);
5312f439 381 Int_t add=0;
be3dbaa0 382 for (Int_t ircu=0;ircu<kNRCU;++ircu) {
383 const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu);
5312f439 384 if (type==0){
5312f439 385 add=1;
386 h2->SetMinimum(0);
387 h2->SetMaximum(2);
388 } else if (type==1) {
5312f439 389 add=0;
390 h2->SetMinimum(0);
391 h2->SetMaximum(4);
392 }
ddeb9c4f 393 if (!v) continue;
be3dbaa0 394 for (Int_t iev=0;iev<nevents;++iev) {
395 Float_t val=(*v)(iev);
396 Float_t phase=fArrALTROL1Phase.GetMatrixArray()[iev];
397 if (newVersion) {
398 Int_t event=(Int_t)fArrFailEventNumber.GetMatrixArray()[iev];
399 phase=fArrALTROL1Phase.GetMatrixArray()[event];
400 }
401 if (type==0) val=(val!=phase);
402 h2->SetBinContent(ircu+1,iev+1,val+add);
ddeb9c4f 403 }
404 }
405 return h2;
406}
407//_____________________________________________________________________
be3dbaa0 408TH1F *AliTPCCalibRaw::MakeHistL1PhaseDist()
409{
410 //
411 // L1 phase distribution. Should be flat in ideal case
412 //
413 TH1F *h=new TH1F("L1phaseDist","Normalized L1 phase distribution;phase;fraction of events",4,0,4);
414 h->Sumw2();
415 for (Int_t iev=0;iev<GetNevents();++iev) h->Fill(fArrALTROL1Phase.GetMatrixArray()[iev]);
416 if (GetNevents()>0) h->Scale(1./GetNevents());
417 h->SetMinimum(0);
418 h->SetMaximum(1);
419 return h;
420}
421//_____________________________________________________________________
422TVectorF *AliTPCCalibRaw::MakeVectL1PhaseDist()
423{
424 //
425 // L1 phase distribution. Should be flat in ideal case
426 //
427 TVectorF *v=new TVectorF(4);
428 for (Int_t iev=0;iev<GetNevents();++iev) {
429 Int_t phase=(Int_t)fArrALTROL1Phase.GetMatrixArray()[iev];
430 ((v->GetMatrixArray())[phase])+=1./GetNevents();
431 }
432 return v;
433}
434//_____________________________________________________________________
ddeb9c4f 435TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
436{
437 //
438 // Create a 2D histo RCU:Events indicating the there was a deviation
439 // from the mean L1 phase of the event
440 //
441 TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
442 for (Int_t ircu=0;ircu<72;++ircu) {
443 const TVectorF *v=0;
444 if (type==0) v=GetALTROL1PhaseFailEventsRCU(ircu);
445 else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
446 if (!v) continue;
447 for (Int_t iev=0;iev<GetNevents();++iev) {
5312f439 448 h2->SetBinContent(ircu+1,iev+1,(*v)(iev));
ddeb9c4f 449 }
450 }
451 return h2;
452}
453//_____________________________________________________________________
454TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
455{
456 //
457 // Create a 2D histo RCU:Events indicating the there was a deviation
458 // from the mean L1 phase of the event
459 //
460 TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
be3dbaa0 461 for (Int_t ircu=72;ircu<kNRCU;++ircu) {
ddeb9c4f 462 const TVectorF *v=0;
463 if (type==0) v=GetALTROL1PhaseFailEventsRCU(ircu);
464 else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
465 if (!v) continue;
466 for (Int_t iev=0;iev<GetNevents();++iev) {
5312f439 467 h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev));
ddeb9c4f 468 }
469 }
470 return h2;
471}
472//_____________________________________________________________________
473void AliTPCCalibRaw::CreateDVhist()
474{
475 //
476 // Setup the HnSparse for the drift velocity determination
477 //
478 if (fHnDrift) return;
479 //HnSparse bins
480 //time bin, roc, time
f113dfeb 481 Int_t bins[kHnBinsDV] = {fLastTimeBin-fFirstTimeBin, 72, fNBinsTime};
482 Double_t xmin[kHnBinsDV] = {fFirstTimeBin,0,0};
483 Double_t xmax[kHnBinsDV] = {fLastTimeBin,72,fNBinsTime};
ddeb9c4f 484 fHnDrift=new THnSparseI("fHnDrift",Form("Drift velocity using last time bin;time bin[#times 100ns];ROC;Time bin [#times %us]",fNSecTime),kHnBinsDV, bins, xmin, xmax);
485
486}
487//_____________________________________________________________________
488void AliTPCCalibRaw::Analyse()
489{
490 //
491 // Analyse Data
492 //
493
494 //resize arrays
495 fArrALTROL1Phase.ResizeTo(GetNevents());
be3dbaa0 496 for (Int_t ircu=0;ircu<kNRCU;++ircu){
ddeb9c4f 497 TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu);
498 if (!arr) continue;
be3dbaa0 499 arr->ResizeTo(fNFailL1PhaseEvent);
500 fArrFailEventNumber.ResizeTo(fNFailL1PhaseEvent);
501// TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu);
502// arrF->ResizeTo(1);
ddeb9c4f 503 }
cc65e4f5 504 //resize occupancy arrays only save event occupancy in sensitive regions by default
505 //save the rest in debub mode
1d32f273 506 fVOccupancySenEvent.ResizeTo(GetNevents());
cc65e4f5 507 if (fDebugLevel>0){
508 fVOccupancyEvent.ResizeTo(GetNevents());
509 fVSignalSumEvent.ResizeTo(GetNevents());
510 fVSignalSumSenEvent.ResizeTo(GetNevents());
511 fVNfiredPadsSenEvent.ResizeTo(GetNevents());
512 fVTimeStampEvent.ResizeTo(GetNevents());
513 } else {
514 fVOccupancyEvent.ResizeTo(0);
515 fVSignalSumEvent.ResizeTo(0);
516 fVSignalSumSenEvent.ResizeTo(0);
517 fVNfiredPadsSenEvent.ResizeTo(0);
518 fVTimeStampEvent.ResizeTo(0);
519 }
1d32f273 520 //Analyse drift velocity TODO
ddeb9c4f 521
522}
1d32f273 523//_____________________________________________________________________
524TGraph* AliTPCCalibRaw::MakeGraphOccupancy(const Int_t type, const Int_t xType)
525{
526 //
527 // create occupancy graph (of samples abouve threshold)
528 // type=0: number of samples
529 // type=1: mean data volume (ADC counts/sample)
530 // type=2: data volume (ADC counts)
531 // type=3: samples per ADC count
532 // type=4: sample occupancy
533 //
534 // type=5: number of sample sensitive / number of samples
535 //
536 // same in sensitive regions:
537 // type=10: number of samples
538 // type=11: mean data volume (ADC counts/sample)
539 // type=12: data volume (ADC counts)
540 // type=13: samples per ADC count
cc65e4f5 541 // type=14: sample occupancy
1d32f273 542 //
543 // type=16: number of samples sensitive / number of pads sensitive
544 // type=17: pad occupancy in sensitive regions
545 // xType=0: vs. time stamp
546 // xType=1: vs. event counter
547 //
548
549 TString title("Event occupancy");
550 TString xTitle("Time");
551 TString yTitle("number of samples");
552 TGraph *gr=new TGraph(GetNevents());
cc65e4f5 553 if (fVSignalSumEvent.GetNrows()==0&&!(type==10||type==14)) return 0;
1d32f273 554 TVectorF *vOcc=&fVOccupancyEvent;
555 TVectorF *vSum=&fVSignalSumEvent;
556 TVectorF *vPads=&fVNfiredPadsSenEvent;
557 Double_t norm=557568.;
7c4ee1e1 558 if (type!=14&&fVOccupancyEvent.GetNrows()==0){
559 AliWarning("In non debug mode only occupancy in sensitive regions vs. event awailable!!!");
560 return 0;
561 }
1d32f273 562 if (type>=10){
563 vOcc=&fVOccupancySenEvent;
564 vSum=&fVSignalSumSenEvent;
565 vPads=&fVNfiredPadsSenEvent;
566 norm=33012.;
567 }
568 for (Int_t i=0;i<GetNevents(); ++i){
569 Double_t nAboveThreshold=vOcc->GetMatrixArray()[i];
7c4ee1e1 570
571 Double_t nSumADC =1;
572 Double_t timestamp =1;
573 Double_t nPads =1;
574
575 if (fVOccupancyEvent.GetNrows()>0){
576 nSumADC =vSum->GetMatrixArray()[i];
577 timestamp =fVTimeStampEvent.GetMatrixArray()[i]+fFirstTimeStamp;
578 nPads =vPads->GetMatrixArray()[i];
579 }
1d32f273 580 Double_t x=timestamp;
581 Double_t y=0;
582 //
583 if (xType==1) x=i;
584 //
585 if (type%10==0) y=nAboveThreshold;
586 if (type%10==1&&nAboveThreshold>0) y=nSumADC/nAboveThreshold;
587 if (type%10==2) y=nSumADC;
588 if (type%10==3&&nSumADC>0) y=nAboveThreshold/nSumADC;
589 if (type%10==4) y=nAboveThreshold/(norm*(fLastTimeBin-fFirstTimeBin));
590 if (type==5) y=fVOccupancySenEvent.GetMatrixArray()[i]/fVOccupancyEvent.GetMatrixArray()[i];
591 if (type==16&&nPads>0) y=nAboveThreshold/nPads;
592 if (type==17) y=nPads/norm;
593 //
594 gr->SetPoint(i,x,y);
595 }
596 if (xType==1) xTitle="Event";
597 if (type%10==1) yTitle="Mean ADC counts/sample";
598 else if (type%10==2) yTitle="Data volume [ADC counts]";
599 else if (type%10==3) yTitle="samples per ADC count";
600 else if (type%10==4) yTitle="sample occupancy";
601 if (type==5) yTitle="N samples (sensitive) / N samples";
602 if (type%10==6) yTitle="N samples / N pads";
603 if (type==17) yTitle="Pad Occupancy";
604 if (type>=10) yTitle+=" (sensitive)";
605 title=yTitle+":"+xTitle;
606 title+=";"+xTitle+";"+yTitle;
607 gr->SetTitle(title.Data());
608 gr->SetEditable(kFALSE);
609 return gr;
610}
611//_____________________________________________________________________
7442bceb 612// TGraph* AliTPCCalibRaw::MakeGraphNoiseEvents()
613// {
1d32f273 614 //
7442bceb 615 // Not implemented for the moment
1d32f273 616 //
7442bceb 617// return 0;
618// }
1d32f273 619//_____________________________________________________________________
620TCanvas* AliTPCCalibRaw::MakeCanvasOccupancy(const Int_t xType, Bool_t sen)
621{
622 //
623 // Create a canvas with occupancy information of all 'type's (see MakeGraphOccupancy)
624 // xType=0: vs. timestamp
625 // xType=1: vs. event number
626 //
627 // sen=kTRUE: for sensitive regions
628 //
629
630 TString name("RawOccupancy_");
631 TString title("Raw Occupancy vs. ");
632 if (xType==0){
633 name+="Time";
634 title+="time";
635 } else if (xType==1){
636 name+="Event";
637 title+="event";
638 }
639 if (sen){
640 name+="Sen";
641 title+=" (sensitive)";
642 }
643 TCanvas *c=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(name.Data());
644 if (!c) c=new TCanvas(name.Data(),title.Data());
645 c->Clear();
646 c->Divide(2,2);
647 for (Int_t i=0;i<4;++i){
648 c->cd(i+1);
649 TGraph *gr=MakeGraphOccupancy(i+10*(Int_t)sen,xType);
650 gr->Draw("alp");
651 }
652 return c;
653}
ddeb9c4f 654
7442bceb 655//_____________________________________________________________________
656void AliTPCCalibRaw::Merge(AliTPCCalibRaw * const sig)
657{
658 //
659 // Merge sig with this instance
660 //
661
662 if (!sig) return;
663
664 //Add last time bin distribution histogram
665 fHnDrift->Add(sig->fHnDrift);
666
667 //Add occupancy data
668
669}
670
671//_____________________________________________________________________
672Long64_t AliTPCCalibRaw::Merge(TCollection * const list)
673{
674 //
675 // Merge all objects of this type in list
676 //
677
678 Long64_t nmerged=1;
679
680 TIter next(list);
681 AliTPCCalibRaw *ce=0;
682 TObject *o=0;
683
684 while ( (o=next()) ){
685 ce=dynamic_cast<AliTPCCalibRaw*>(o);
686 if (ce){
687 Merge(ce);
688 ++nmerged;
689 }
690 }
691
692 return nmerged;
693}
694