15 minutes interval for calculation of drift correction
[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   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),
101   fNanoSec(0),
102   fArrCurrentPhaseDist(4),
103   fArrCurrentPhase(kNRCU),
104   fArrFailEventNumber(100),
105   fArrALTROL1Phase(100000),
106   fArrALTROL1PhaseEvent(kNRCU),
107   fArrALTROL1PhaseFailEvent(kNRCU),
108   fHnDrift(0x0),
109   fVOccupancyEvent(100000),
110   fVSignalSumEvent(100000),
111   fVOccupancySenEvent(100000),
112   fVSignalSumSenEvent(100000),
113   fVNfiredPadsSenEvent(100000),
114   fVTimeStampEvent(100000)
115 {
116   //
117   // Default ctor
118   //
119   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
120   CreateDVhist();
121   for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
122   fFirstTimeBin=850;
123   fLastTimeBin=1020;
124 }
125 //_____________________________________________________________________
126 AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) :
127 AliTPCCalibRawBase(),
128 fPeakDetMinus(1),
129 fPeakDetPlus(2),
130 fNFailL1Phase(0),
131 fNFailL1PhaseEvent(0),
132 fFirstTimeStamp(0),
133 fNSecTime(600), //default 10 minutes
134 fNBinsTime(60), //default 60*10 minutes = 10 hours
135 fPadProcessed(kFALSE),
136 fCurrentChannel(-1),
137 fCurrentSector(-1),
138 fLastSector(-2),
139 fCurrentRow(-1),
140 fCurrentPad(-1),
141 fLastTimeBinProc(0),
142 fPeakTimeBin(0),
143 fLastSignal(0),
144 fNOkPlus(0),
145 fNOkMinus(0),
146 fNanoSec(0),
147 fArrCurrentPhaseDist(4),
148 fArrCurrentPhase(kNRCU),
149 fArrFailEventNumber(100),
150 fArrALTROL1Phase(100000),
151 fArrALTROL1PhaseEvent(kNRCU),
152 fArrALTROL1PhaseFailEvent(kNRCU),
153 fHnDrift(0x0),
154 fVOccupancyEvent(100000),
155 fVSignalSumEvent(100000),
156 fVOccupancySenEvent(100000),
157 fVSignalSumSenEvent(100000),
158 fVNfiredPadsSenEvent(100000),
159 fVTimeStampEvent(100000)
160 {
161   //
162   // Default ctor
163   //
164   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
165   CreateDVhist();
166   for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
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();
171   if (config->GetValue("DebugLevel")) fDebugLevel = ((TObjString*)config->GetValue("DebugLevel"))->GetString().Atoi();
172 }
173
174 //_____________________________________________________________________
175 AliTPCCalibRaw::~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 //_____________________________________________________________________
195 Int_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();
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   //
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);
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;
270 }
271 //_____________________________________________________________________
272 void AliTPCCalibRaw::UpdateDDL(){
273   //
274   // fill ALTRO L1 information
275   //
276   
277   //set nanoseconds
278   if (!fNanoSec) {
279     TTimeStamp s;
280     fNanoSec=s.GetNanoSec();
281   }
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]);
288   
289 }
290 //_____________________________________________________________________
291 void AliTPCCalibRaw::ResetEvent()
292 {
293   //
294   // Reset event counters
295   //
296
297   fCurrentChannel=-1;
298   fCurrentRow=-1;
299   fCurrentPad=-1;
300   fArrCurrentPhaseDist.Zero();
301 }
302 //_____________________________________________________________________
303 void 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
321   if (fArrALTROL1Phase.GetNrows()-1<=GetNevents())
322     fArrALTROL1Phase.ResizeTo(GetNevents()+10000);
323   (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
324   
325   //loop over RCUs and test failures
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);
332       if (arr->GetNrows()-1<=(Int_t)fNFailL1PhaseEvent) arr->ResizeTo(arr->GetNrows()+100);
333       (arr->GetMatrixArray())[fNFailL1PhaseEvent]=phase;
334       ++fNFailL1Phase;
335       fail=1;
336       }
337     //reset current phase information
338     fArrCurrentPhase[ircu]=-1;
339   }
340   if (fail){
341     if (fArrFailEventNumber.GetNrows()-1<=(Int_t)fNFailL1PhaseEvent) fArrFailEventNumber.ResizeTo(fArrFailEventNumber.GetNrows()+100);
342     fArrFailEventNumber.GetMatrixArray()[fNFailL1PhaseEvent]=GetNevents();
343   }
344   fNFailL1PhaseEvent+=fail;
345   //time stamps
346   fVTimeStampEvent.GetMatrixArray()[GetNevents()]=GetTimeStamp()-fFirstTimeStamp+fNanoSec*1e-9;
347   fNanoSec=0;
348   //occupance related
349   if (fVOccupancyEvent.GetNrows()-1<=GetNevents()){
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   }
357   IncrementNevents();
358 }
359 //_____________________________________________________________________
360 TH2C *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
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;
374     if ((UInt_t)(v->GetNrows())==fNFailL1PhaseEvent){
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);
381   Int_t add=0;
382   for (Int_t ircu=0;ircu<kNRCU;++ircu) {
383     const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu);
384     if (type==0){
385       add=1;
386       h2->SetMinimum(0);
387       h2->SetMaximum(2);
388     } else if (type==1) {
389       add=0;
390       h2->SetMinimum(0);
391       h2->SetMaximum(4);
392     }
393     if (!v) continue;
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);
403     }
404   }
405   return h2;
406 }
407 //_____________________________________________________________________
408 TH1F *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 //_____________________________________________________________________
422 TVectorF *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 //_____________________________________________________________________
435 TH2C *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) {
448       h2->SetBinContent(ircu+1,iev+1,(*v)(iev));
449     }
450   }
451   return h2;
452 }
453 //_____________________________________________________________________
454 TH2C *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());
461   for (Int_t ircu=72;ircu<kNRCU;++ircu) {
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) {
467       h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev));
468     }
469   }
470   return h2;
471 }
472 //_____________________________________________________________________
473 void 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
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};
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 //_____________________________________________________________________
488 void AliTPCCalibRaw::Analyse()
489 {
490   //
491   // Analyse Data
492   //
493
494   //resize arrays
495   fArrALTROL1Phase.ResizeTo(GetNevents());
496   for (Int_t ircu=0;ircu<kNRCU;++ircu){
497     TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu);
498     if (!arr) continue;
499     arr->ResizeTo(fNFailL1PhaseEvent);
500     fArrFailEventNumber.ResizeTo(fNFailL1PhaseEvent);
501 //    TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu);
502 //     arrF->ResizeTo(1);
503   }
504   //resize occupancy arrays only save event occupancy in sensitive regions by default
505   //save the rest in debub mode
506   fVOccupancySenEvent.ResizeTo(GetNevents());
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   }
520   //Analyse drift velocity TODO
521   
522 }
523 //_____________________________________________________________________
524 TGraph* 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
541   // type=14:  sample occupancy
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());
553   if (fVSignalSumEvent.GetNrows()==0&&!(type==10||type==14)) return 0;
554   TVectorF *vOcc=&fVOccupancyEvent;
555   TVectorF *vSum=&fVSignalSumEvent;
556   TVectorF *vPads=&fVNfiredPadsSenEvent;
557   Double_t norm=557568.;
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   }
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];
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     }
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 //_____________________________________________________________________
612 // TGraph* AliTPCCalibRaw::MakeGraphNoiseEvents()
613 // {
614   //
615   // Not implemented for the moment
616   //
617 //   return 0;  
618 // }
619 //_____________________________________________________________________
620 TCanvas* 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 }
654
655 //_____________________________________________________________________
656 void 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 //_____________________________________________________________________
672 Long64_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