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