15ca240b5d711d57f29d172d40604abfb6f7cb2d
[u/mrichter/AliRoot.git] / AD / ADrec / AliADQADataMakerRec.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
17 //  Produces the data needed to calculate the quality assurance 
18 //  All data must be mergeable objects
19 //  Handles ESDs and Raws
20 //  Histos defined will be used for Raw Data control and monitoring
21
22 // --- ROOT system ---
23 #include <TClonesArray.h>
24 #include <TFile.h> 
25 #include <TF1.h> 
26 #include <TH1F.h> 
27 #include <TH1I.h> 
28 #include <TH2I.h> 
29 #include <TH2F.h> 
30 #include <TGraph.h> 
31 #include <TParameter.h>
32 #include <TTimeStamp.h>
33
34 // --- Standard library ---
35
36 // --- AliRoot header files ---
37 #include "AliESDEvent.h"
38 #include "AliLog.h"
39 #include "AliCDBManager.h"
40 #include "AliCDBStorage.h"
41 #include "AliCDBEntry.h"
42 #include "AliADQADataMakerRec.h"
43 #include "AliQAChecker.h"
44 #include "AliRawReader.h"
45 #include "AliADRawStream.h"
46 #include "AliADdigit.h"
47 #include "AliADConst.h"
48 #include "AliADReconstructor.h"
49 #include "AliADTrending.h"
50 #include "AliADCalibData.h"
51 #include "AliCTPTimeParams.h"
52 #include "event.h"
53
54 ClassImp(AliADQADataMakerRec)
55            
56 //____________________________________________________________________________ 
57 AliADQADataMakerRec::AliADQADataMakerRec() : 
58 AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kAD), "AD Quality Assurance Data Maker"),
59   fCalibData(0x0),
60   fTrendingUpdateTime(0), 
61   fCycleStartTime(0), 
62   fCycleStopTime(0),
63   fTimeSlewing(0)
64     
65 {
66   // Constructor
67    
68   AliDebug(AliQAv1::GetQADebugLevel(), "Construct AD QA Object");
69
70   for(Int_t i=0; i<16; i++){  
71     fEven[i] = 0;   
72     fOdd[i]  = 0;
73   }
74   
75   for(Int_t i=0; i<32; i++){  
76     fADCmean[i] = 0.0;   }      
77 }
78
79 //____________________________________________________________________________ 
80 AliADQADataMakerRec::AliADQADataMakerRec(const AliADQADataMakerRec& qadm) :
81   AliQADataMakerRec(),
82   fCalibData(0x0),
83   fTrendingUpdateTime(0), 
84   fCycleStartTime(0), 
85   fCycleStopTime(0),
86   fTimeSlewing(0)
87   
88 {
89   // Copy constructor 
90   
91   SetName((const char*)qadm.GetName()) ; 
92   SetTitle((const char*)qadm.GetTitle()); 
93 }
94
95 //__________________________________________________________________
96 AliADQADataMakerRec& AliADQADataMakerRec::operator = (const AliADQADataMakerRec& qadm )
97 {
98   // Equal operator
99   
100   this->~AliADQADataMakerRec();
101   new(this) AliADQADataMakerRec(qadm);
102   return *this;
103 }
104
105 //____________________________________________________________________________
106 AliADCalibData* AliADQADataMakerRec::GetCalibData() const
107
108 {
109   AliCDBManager *man = AliCDBManager::Instance();
110
111   AliCDBEntry *entry=0;
112
113   entry = man->Get("AD/Calib/Data",fRun);
114   if(!entry){
115     AliWarning("Load of calibration data from default storage failed!");
116     AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
117         
118     man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
119     entry = man->Get("AD/Calib/Data",fRun);
120   }
121   // Retrieval of data in directory AD/Calib/Data:
122
123   AliADCalibData *calibdata = 0;
124
125   if (entry) calibdata = (AliADCalibData*) entry->GetObject();
126   if (!calibdata)  AliFatal("No calibration data from calibration database !");
127
128   return calibdata;
129 }
130 //____________________________________________________________________________ 
131 void AliADQADataMakerRec::StartOfDetectorCycle()
132 {
133   // Detector specific actions at start of cycle
134   
135   // Reset of the histogram used - to have the trend versus time -
136  
137   fCalibData = GetCalibData();
138  
139   AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
140   if (!entry) AliFatal("CTP timing parameters are not found in OCDB !");
141   AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject();
142   Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0;
143
144   AliCDBEntry *entry1 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
145   if (!entry1) AliFatal("CTP time-alignment is not found in OCDB !");
146   AliCTPTimeParams *ctpTimeAlign = (AliCTPTimeParams*)entry1->GetObject();
147   l1Delay += ((Float_t)ctpTimeAlign->GetDelayL1L0()*25.0);
148   /*/
149   AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("AD/Calib/TimeDelays");
150   if (!entry2) AliFatal("AD time delays are not found in OCDB !");
151   TH1F *delays = (TH1F*)entry2->GetObject();
152
153   AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("AD/Calib/TimeSlewing");
154   if (!entry3) AliFatal("AD time slewing function is not found in OCDB !");
155   fTimeSlewing = (TF1*)entry3->GetObject();
156   /*/
157
158   for(Int_t i = 0 ; i < 16; ++i) {
159     //Int_t board = AliADCalibData::GetBoardNumber(i);
160     fTimeOffset[i] = (
161                       //        ((Float_t)fCalibData->GetTriggerCountOffset(board) -
162                       //        (Float_t)fCalibData->GetRollOver(board))*25.0 +
163                       //     fCalibData->GetTimeOffset(i) -
164                       //     l1Delay+
165                       //delays->GetBinContent(i+1)//+
166                       //      kADOffset
167                       0
168                       );
169     //                AliInfo(Form(" fTimeOffset[%d] = %f  kADoffset %f",i,fTimeOffset[i],kADOffset));
170   }
171
172  
173  
174   
175         
176   TTimeStamp currentTime;
177   fCycleStartTime = currentTime.GetSec();
178  
179   //  fNTotEvents = 0;
180 }
181 //____________________________________________________________________________ 
182 void AliADQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
183 {
184   // Detector specific actions at end of cycle
185   // Does the QA checking
186   ResetEventTrigClasses();
187   //
188   
189   
190   if(task == AliQAv1::kRAWS){
191     TTimeStamp currentTime;
192     fCycleStopTime = currentTime.GetSec();
193   }
194
195   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
196     if (! IsValidEventSpecie(specie, list)) continue ;
197     SetEventSpecie(AliRecoParam::ConvertIndex(specie));
198     if(task == AliQAv1::kRAWS) {
199     } else if (task == AliQAv1::kESDS) {
200     }
201   }
202   AliQAChecker::Instance()->Run(AliQAv1::kAD, task, list) ;
203 }
204
205 //____________________________________________________________________________ 
206 void AliADQADataMakerRec::InitESDs()
207 {
208   const Bool_t expert   = kTRUE ; 
209   const Bool_t image    = kTRUE ; 
210
211   TH1I * h0 = new TH1I("H1I_Cell_Multiplicity_ADA", "Cell Multiplicity in ADA;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;  
212   Add2ESDsList(h0, kCellMultiADA, !expert, image)  ;  
213                                                                                                         
214   TH1I * h1 = new TH1I("H1I_Cell_Multiplicity_ADC", "Cell Multiplicity in AD;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;  
215   Add2ESDsList(h1, kCellMultiADC, !expert, image)  ;  
216   
217   TH1F * h2 = new TH1F("H1D_BBFlag_Counters", "BB Flag Counters;Channel;Counts",16, 0, 16) ;  
218   Add2ESDsList(h2, kBBFlag, !expert, image)  ;  
219   
220   TH1F * h3 = new TH1F("H1D_BGFlag_Counters", "BG Flag Counters;Channel;Counts",16, 0, 16) ;  
221   Add2ESDsList(h3, kBGFlag, !expert, image)  ;  
222   
223   TH2F * h4 = new TH2F("H2D_Charge_Channel", "ADC Charge per channel;Channel;Charge (ADC counts)",16, 0, 16, 1024, 0, 1024) ;  
224   Add2ESDsList(h4, kChargeChannel, !expert, image)  ;  
225   
226   TH2F * h5 = new TH2F("H2D_Time_Channel", "Time per channel;Channel;Time (ns)",16, 0, 16, 400, -100, 100) ;  
227   Add2ESDsList(h5, kTimeChannel, !expert, image)  ;  
228   
229   TH1F * h6 = new TH1F("H1D_ADA_Time", "Mean ADA Time;Time (ns);Counts",1000, -100., 100.);
230   Add2ESDsList(h6,kESDADATime, !expert, image); 
231   
232   TH1F * h7 = new TH1F("H1D_ADC_Time", "Mean ADC Time;Time (ns);Counts",1000, -100., 100.);
233   Add2ESDsList(h7,kESDADCTime, !expert, image); 
234   
235   TH1F * h8 = new TH1F("H1D_Diff_Time", "Diff Time ADA - ADC;Diff Time ADA - ADC (ns);Counts",1000, -200., 200.);
236   Add2ESDsList(h8,kESDDiffTime, !expert, image); 
237   //
238   ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line    
239 }
240
241 //____________________________________________________________________________ 
242 void AliADQADataMakerRec::InitDigits()
243 {
244 // create Digits histograms in Digits subdir
245   const Bool_t expert   = kTRUE ; 
246   const Bool_t image    = kTRUE ; 
247
248   // create Digits histograms in Digits subdir
249   TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in AD;# of Digits;Entries", 17,-0.5,16.5) ; 
250   h0->Sumw2() ;
251   Add2DigitsList(h0, 0, !expert, image) ;
252      
253   TH2D * h1 = new TH2D("hDigitLeadingTimePerPM", "Leading time distribution per PM in AD;PM number;Leading Time [ns]",16,0,16, 1000, 200, 300); 
254   h1->Sumw2() ;
255   Add2DigitsList(h1, 1, !expert, image) ; 
256   
257   TH2D * h2 = new TH2D("hDigitTimeWidthPerPM", "Time width distribution per PM in AD;PM number;Time width [ns]",16,0,16, 1000, 0, 100); 
258   h2->Sumw2() ;
259   Add2DigitsList(h2, 2, !expert, image) ;
260   
261   TH2I * h3 = new TH2I("hDigitChargePerClockPerPM", "Charge array per PM in AD;PM number; Clock",16,0,16,21, -10.5, 10.5);
262   h3->Sumw2();
263   Add2DigitsList(h3, 3, !expert, image) ;
264   
265   TH1I * h4 = new TH1I("hDigitBBflagsAD","Number of BB flags in AD; # of BB flags; Entries",17,-0.5,16.5);
266   h4->Sumw2();
267   Add2DigitsList(h4, 4, !expert, image) ;
268   
269   TH1I * h5 = new TH1I("hDigitBBflagsADA","Number of BB flags in ADA; # of BB flags; Entries",9,-0.5,8.5);
270   h5->Sumw2();
271   Add2DigitsList(h5, 5, !expert, image) ;
272   
273   TH1I * h6 = new TH1I("hDigitBBflagsADC","Number of BB flags in ADC; # of BB flags; Entries",9,-0.5,8.5);
274   h6->Sumw2();
275   Add2DigitsList(h6, 6, !expert, image) ;
276   
277   TH2D * h7 = new TH2D("hDigitTotalChargePerPM", "Total Charge per PM in AD;PM number; Charge [ADC counts]",16,0,16,10000,0,10000);
278   h7->Sumw2();
279   Add2DigitsList(h7, 7, !expert, image) ;
280   
281   TH2I * h8 = new TH2I("hDigitMaxChargeClockPerPM", "Clock with maximum charge per PM in AD;PM number; Clock ",16,0,16,21, -10.5, 10.5);
282   h8->Sumw2();
283   Add2DigitsList(h8, 8, !expert, image) ;
284    
285   //
286   ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
287 }
288
289 //____________________________________________________________________________
290 void AliADQADataMakerRec::MakeDigits()
291 {
292  // makes data from Digits
293
294   FillDigitsData(0,fDigitsArray->GetEntriesFast()) ; 
295   TIter next(fDigitsArray) ; 
296     AliADdigit *ADDigit ; 
297     Int_t nBBflagsADA = 0;
298     Int_t nBBflagsADC = 0;
299     
300     while ( (ADDigit = dynamic_cast<AliADdigit *>(next())) ) {
301          Int_t totCharge = 0;
302          Int_t   PMNumber  = ADDigit->PMNumber();
303          if(PMNumber<8 && ADDigit->GetBBflag()) nBBflagsADC++;
304          if(PMNumber>7 && ADDigit->GetBBflag()) nBBflagsADA++;
305          
306          Short_t adc[21];
307          for(Int_t iClock=0; iClock<21; iClock++) { 
308          adc[iClock]= ADDigit->ChargeADC(iClock);
309          FillDigitsData(3, PMNumber,(float)iClock-10,(float)adc[iClock]);
310          totCharge += adc[iClock];
311          }
312             
313          FillDigitsData(1,PMNumber,ADDigit->Time()); 
314          FillDigitsData(2,PMNumber,ADDigit->Width());
315          FillDigitsData(7,PMNumber,totCharge);
316          FillDigitsData(8,PMNumber,TMath::LocMax(21,adc)-10); 
317          
318     }
319     FillDigitsData(4,nBBflagsADA+nBBflagsADC);
320     FillDigitsData(5,nBBflagsADA);
321     FillDigitsData(6,nBBflagsADC);  
322 }
323
324 //____________________________________________________________________________
325 void AliADQADataMakerRec::MakeDigits(TTree* digitTree)
326 {
327   // makes data from Digit Tree
328         
329   if (fDigitsArray)
330     fDigitsArray->Clear() ; 
331   else 
332     fDigitsArray = new TClonesArray("AliADdigit", 1000) ; 
333
334     TBranch * branch = digitTree->GetBranch("ADDigit") ;
335     if ( ! branch ) {
336          AliWarning("AD branch in Digit Tree not found") ; 
337     } else {
338          branch->SetAddress(&fDigitsArray) ;
339          branch->GetEntry(0) ; 
340          MakeDigits() ; 
341     }  
342     //
343     IncEvCountCycleDigits();
344     IncEvCountTotalDigits();
345     //    
346 }
347
348
349 //____________________________________________________________________________
350 void AliADQADataMakerRec::MakeESDs(AliESDEvent* esd)
351 {
352 // Creates QA data from ESDs
353   
354   UInt_t eventType = esd->GetEventType();
355
356   switch (eventType){
357   case PHYSICS_EVENT:
358     AliESDAD *esdAD=esd->GetADData();
359    
360     if (!esdAD) break;
361                   
362     FillESDsData(kCellMultiADA,esdAD->GetNbPMADA());
363     FillESDsData(kCellMultiADC,esdAD->GetNbPMADC());   
364         
365     for(Int_t i=0;i<16;i++) {
366       FillESDsData(kChargeChannel,(Float_t) i,(Float_t) esdAD->GetAdc(i));
367       if (i < 8) {
368         if(esdAD->BBTriggerADC(i)) FillESDsData(kBBFlag,(Float_t) i);
369         if(esdAD->BGTriggerADC(i)) FillESDsData(kBGFlag,(Float_t) i);
370       }
371       else {
372         if(esdAD->BBTriggerADA(i-8)) FillESDsData(kBBFlag,(Float_t) i);  
373         if(esdAD->BGTriggerADA(i-8)) FillESDsData(kBGFlag,(Float_t) i);
374       }                 
375       Float_t time = (Float_t) esdAD->GetTime(i);
376       FillESDsData(kTimeChannel,(Float_t) i,time);
377     }
378                                 
379     Float_t timeADA = esdAD->GetADATime();
380     Float_t timeADC = esdAD->GetADCTime();
381     Float_t diffTime;
382
383     if(timeADA<-1024.+1.e-6 || timeADC<-1024.+1.e-6) diffTime = -1024.;
384     else diffTime = timeADA - timeADC;
385
386     FillESDsData(kESDADATime,timeADA);
387     FillESDsData(kESDADCTime,timeADC);
388     FillESDsData(kESDDiffTime,diffTime);
389                 
390     break;
391   }  
392   //
393   IncEvCountCycleESDs();
394   IncEvCountTotalESDs();  
395   // 
396 }
397
398 //____________________________________________________________________________ 
399 void AliADQADataMakerRec::InitRaws()
400 {
401   // Creates RAW histograms in Raws subdir
402
403   const Bool_t expert   = kTRUE ; 
404   const Bool_t saveCorr = kTRUE ; 
405   const Bool_t image    = kTRUE ; 
406
407   const Int_t kNintegrator  =    2;
408  
409   const Int_t kNTdcTimeBins  = 1280;
410   const Float_t kTdcTimeMin    =    0.;
411   const Float_t kTdcTimeMax    = 75.;
412     const Int_t kNTdcWidthBins =  256;
413   const Float_t kTdcWidthMin   =    0;
414   const Float_t kTdcWidthMax   =  200.;
415   const Int_t kNChargeBins   = 1024;
416   const Float_t kChargeMin     =    0;
417   const Float_t kChargeMax     = 1024;
418   const Int_t kNChannelBins  =   16;
419   const Float_t kChannelMin    =    0;
420   const Float_t kChannelMax    =   16;
421   const Int_t kNPedestalBins =  200;
422   const Float_t kPedestalMin   =    0;
423   const Float_t kPedestalMax   =  200; 
424   const Int_t kNPairBins  =   8;
425   const Float_t kPairMin    =    0;
426   const Float_t kPairMax    =   8;
427
428   TH2I * h2i;
429   TH2F * h2d;
430   TH1I * h1i;
431   TH1F * h1d;
432
433   int iHisto =0;
434
435   // Creation of Cell Multiplicity Histograms
436   h1i = new TH1I("H1I_Multiplicity_ADA", "Number of fired cells in ADA;# of Cells;Entries", 10, 0, 10) ;  
437   Add2RawsList(h1i,kMultiADA, !expert, image, saveCorr);   iHisto++;
438   h1i = new TH1I("H1I_Multiplicity_ADC", "Number of fired cells in ADC;# of Cells;Entries", 10, 0, 10) ;  
439   Add2RawsList(h1i,kMultiADC, !expert, image, saveCorr);   iHisto++;
440  
441   // Creation of Total Charge Histograms
442   h1d = new TH1F("H1D_Charge_ADA", "Total Charge in ADA;Charge [ADC counts];Counts", 4000, 0, 30000) ;  
443   Add2RawsList(h1d,kChargeADA, !expert, image, saveCorr);   iHisto++;
444   h1d = new TH1F("H1D_Charge_ADC", "Total Charge in ADC;Charge [ADC counts];Counts", 4000, 0, 50000) ;  
445   Add2RawsList(h1d,kChargeADC, !expert, image, saveCorr);   iHisto++;
446   h1d = new TH1F("H1D_Charge_AD", "Total Charge in AD;Charge [ADC counts];Counts", 4000, 0, 80000) ;  
447   Add2RawsList(h1d,kChargeAD, !expert,  image, saveCorr);   iHisto++;
448    
449
450   // Creation of Charge EoI histogram 
451   h2d = new TH2F("H2D_ChargeEoI", "Charge Event of Interest;Channel Number;Charge [ADC counts]"
452                  ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, 2.*kChargeMax);
453   Add2RawsList(h2d,kChargeEoI, !expert, image, saveCorr); iHisto++;
454
455   for(Int_t iInt=0;iInt<kNintegrator;iInt++){
456     // Creation of Pedestal histograms 
457     h2i = new TH2I(Form("H2I_Pedestal_Int%d",iInt), Form("Pedestal (Int%d);Channel;Pedestal [ADC counts]",iInt)
458                    ,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
459     Add2RawsList(h2i,(iInt == 0 ? kPedestalInt0 : kPedestalInt1), !expert, image, saveCorr); iHisto++;
460         
461
462     // Creation of Charge EoI histograms 
463     h2i = new TH2I(Form("H2I_ChargeEoI_Int%d",iInt), Form("Charge EoI (Int%d);Channel;Charge [ADC counts]",iInt)
464                    ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
465     Add2RawsList(h2i,(iInt == 0 ? kChargeEoIInt0 : kChargeEoIInt1), !expert, image, saveCorr); iHisto++;
466     
467   }     
468   
469   // Creation of Time histograms 
470   h2i = new TH2I("H2I_Width", "HPTDC Width;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
471   Add2RawsList(h2i,kWidth, !expert, image, saveCorr); iHisto++;
472   
473   h2i = new TH2I("H2I_Width_BB", "HPTDC Width w/ BB Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
474   Add2RawsList(h2i,kWidthBB, !expert, image, saveCorr); iHisto++;
475
476   h2i = new TH2I("H2I_Width_BG", "HPTDC Width w/ BG Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
477   Add2RawsList(h2i,kWidthBG, !expert, image, saveCorr); iHisto++;
478
479   h2i = new TH2I("H2I_HPTDCTime", "HPTDC Time;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
480   Add2RawsList(h2i,kHPTDCTime, !expert, image, saveCorr); iHisto++;
481   
482   h2i = new TH2I("H2I_HPTDCTime_BB", "HPTDC Time w/ BB Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
483   Add2RawsList(h2i,kHPTDCTimeBB, !expert, image, !saveCorr); iHisto++;
484
485   h2i = new TH2I("H2I_HPTDCTime_BG", "HPTDC Time w/ BG Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
486   Add2RawsList(h2i,kHPTDCTimeBG, !expert, image, !saveCorr); iHisto++;
487         
488   h1d = new TH1F("H1D_ADA_Time", "ADA Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
489   Add2RawsList(h1d,kADATime, !expert, image, saveCorr); iHisto++;
490         
491   h1d = new TH1F("H1D_ADC_Time", "ADC Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
492   Add2RawsList(h1d,kADCTime, !expert, image, saveCorr); iHisto++;
493         
494   h1d = new TH1F("H1D_Diff_Time","Diff ADA-ADC Time;Time [ns];Counts",kNTdcTimeBins, -50., 50.);
495   Add2RawsList(h1d,kDiffTime, !expert, image, saveCorr); iHisto++;
496
497   h2d = new TH2F("H2D_TimeADA_ADC", "Mean Time in ADC versus ADA;Time ADA [ns];Time ADC [ns]", kNTdcTimeBins/8, kTdcTimeMin,kTdcTimeMax,kNTdcTimeBins/8, kTdcTimeMin,kTdcTimeMax) ;  
498   Add2RawsList(h2d,kTimeADAADC, !expert, image, saveCorr);   iHisto++;
499   
500   //Creation of pair coincidence histograms
501   h1i = new TH1I("H1I_MultiCoincidence_ADA", "Number of coincidences in ADA;# of Coincidences;Entries", 5, 0, 5) ;  
502   Add2RawsList(h1i,kNCoincADA, !expert, image, saveCorr);   iHisto++;
503   h1i = new TH1I("H1I_MultiCoincidence_ADC", "Number of coincidences in ADC;# of Coincidences;Entries", 5, 0, 5) ;  
504   Add2RawsList(h1i,kNCoincADC, !expert, image, saveCorr);   iHisto++;
505   
506   h2d = new TH2F("H2D_Pair_Diff_Time","Diff Pair Time;Pair number;Time [ns]",kNPairBins, kPairMin, kPairMax,kNTdcTimeBins, -50., 50.);
507   Add2RawsList(h2d,kPairDiffTime, !expert, image, saveCorr); iHisto++;
508   
509   h2d = new TH2F("H2D_Pair_Diff_Charge","Diff Pair Charge;Pair number;Charge [ADC counts]",kNPairBins, kPairMin, kPairMax, 2*kNChargeBins, -kChargeMax, kChargeMax);
510   Add2RawsList(h2d,kPairDiffCharge, !expert, image, saveCorr); iHisto++;
511
512   //Creation of Clock histograms
513   h2d = new TH2F("H2D_BBFlagVsClock", "BB-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
514   Add2RawsList(h2d,kBBFlagVsClock, !expert, image, saveCorr); iHisto++;
515         
516   h2d = new TH2F("H2D_BGFlagVsClock", "BG-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
517   Add2RawsList(h2d,kBGFlagVsClock, !expert, image, saveCorr); iHisto++;
518
519   for(Int_t iInt=0;iInt<kNintegrator;iInt++){
520         h2d = new TH2F(Form("H2D_ChargeVsClock_Int%d",iInt), Form("Charge Versus LHC-Clock (Int%d);Channel;LHCClock;Charge [ADC counts]",iInt),kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
521         Add2RawsList(h2d,(iInt == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), !expert, image, saveCorr); iHisto++;
522         }
523   
524   h2d = new TH2F("H2D_BBFlagPerChannel", "BB-Flags Versus Channel;Channel;BB Flags Count",kNChannelBins, kChannelMin, kChannelMax,22,-0.5,21.5);
525   Add2RawsList(h2d,kBBFlagsPerChannel, !expert, image, saveCorr); iHisto++;
526   
527   h2d = new TH2F("H2D_BGFlagPerChannel", "BG-Flags Versus Channel;Channel;BG Flags Count",kNChannelBins, kChannelMin, kChannelMax,22,-0.5,21.5);
528   Add2RawsList(h2d,kBGFlagsPerChannel, !expert, image, saveCorr); iHisto++;
529   
530   AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto));
531   //
532   ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
533 }
534
535 //____________________________________________________________________________
536 void AliADQADataMakerRec::MakeRaws(AliRawReader* rawReader)
537 {
538   // Fills histograms with Raws, computes average ADC values dynamically (pedestal subtracted)
539                   
540                                           
541   // Check id histograms already created for this Event Specie
542   if ( ! GetRawsData(kPedestalInt0) )
543     InitRaws() ;
544
545   rawReader->Reset() ; 
546   AliADRawStream* rawStream  = new AliADRawStream(rawReader); 
547   if(!(rawStream->Next())) return;  
548  
549   eventTypeType eventType = rawReader->GetType();
550
551   Int_t    mulADA = 0 ; 
552   Int_t    mulADC = 0 ; 
553   Double_t timeADA =0., timeADC = 0.;
554   Double_t weightADA =0., weightADC = 0.;
555   UInt_t   itimeADA=0, itimeADC=0;
556   Double_t chargeADA=0., chargeADC=0.;
557
558   Double_t diffTime=-100000.;
559   
560   Int_t    pmulADA = 0;
561   Int_t    pmulADC = 0;
562   Double_t pDiffTime =-100000.;
563
564   
565   switch (eventType){
566   case PHYSICS_EVENT:
567   
568     //    fNTotEvents++; // Use framework counters instead
569
570     Int_t  iFlag=0;
571     Int_t  pedestal;
572     Int_t  integrator[16];
573     Bool_t flagBB[16];   
574     Bool_t flagBG[16];   
575     Float_t charge;
576     Int_t  offlineCh;
577     Float_t adc[16], time[16], width[16], timeCorr[16]; 
578     Int_t  iPair=0;
579
580     for(Int_t iChannel=0; iChannel<16; iChannel++) { // BEGIN : Loop over channels
581                    
582       offlineCh = kOfflineChannel[iChannel];
583                    
584       // Fill Pedestal histograms
585            
586       for(Int_t j=15; j<21; j++) {
587         if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++;
588       }
589
590       if(iFlag == 0){ //No Flag found
591         for(Int_t j=15; j<21; j++){
592           pedestal= (Int_t) rawStream->GetPedestal(iChannel, j);
593           integrator[offlineCh] = rawStream->GetIntegratorFlag(iChannel, j);
594
595           FillRawsData((integrator[offlineCh] == 0 ? kPedestalInt0 : kPedestalInt1),offlineCh,pedestal);
596         }
597       }
598
599       // Fill Charge EoI histograms
600            
601       adc[offlineCh]    = 0.0;
602
603       // Search for the maximum charge in the train of 21 LHC clocks 
604       // regardless of the integrator which has been operated:
605       Float_t maxadc = 0;
606       Int_t imax = -1;
607       Float_t adcPedSub[21];
608       for(Int_t iClock=0; iClock<21; iClock++){
609         Bool_t iIntegrator = rawStream->GetIntegratorFlag(iChannel,iClock);
610         Int_t k = offlineCh+16*iIntegrator;
611
612         adcPedSub[iClock] = rawStream->GetPedestal(iChannel,iClock) - fCalibData->GetPedestal(k);
613         //                              if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) {
614         if(adcPedSub[iClock] <= 2.*fCalibData->GetSigma(k)) {
615           adcPedSub[iClock] = 0;
616           continue;
617         }
618         //                              if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue;
619         if(iClock < 8 || iClock > 12) continue;
620         if(adcPedSub[iClock] > maxadc) {
621           maxadc = adcPedSub[iClock];
622           imax   = iClock;
623         }
624       }
625       //printf(Form("Channel %d (online), %d (offline)\n",iChannel,j)); 
626       if (imax != -1) {
627         //                              Int_t start = imax - GetRecoParam()->GetNPreClocks();
628         Int_t start = imax - 2;
629         if (start < 0) start = 0;
630         //                              Int_t end = imax + GetRecoParam()->GetNPostClocks();
631         Int_t end = imax + 1;
632         if (end > 20) end = 20;
633         for(Int_t iClock = start; iClock <= end; iClock++) {
634           adc[offlineCh] += adcPedSub[iClock];
635         }
636       }
637         
638                 
639       Int_t iClock  = imax;
640       charge = rawStream->GetPedestal(iChannel,iClock); // Charge at the maximum 
641
642       integrator[offlineCh]    = rawStream->GetIntegratorFlag(iChannel,iClock);
643       flagBB[offlineCh]  = rawStream->GetBBFlag(iChannel, iClock);
644       flagBG[offlineCh]  = rawStream->GetBGFlag(iChannel,iClock );
645       Int_t board = AliADCalibData::GetBoardNumber(offlineCh);
646       time[offlineCh] = rawStream->GetTime(iChannel)*fCalibData->GetTimeResolution(board);
647       width[offlineCh] = rawStream->GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
648
649       if (time[offlineCh] >= 1e-6) FillRawsData(kChargeEoI,offlineCh,adc[offlineCh]);
650
651       FillRawsData((integrator[offlineCh] == 0 ? kChargeEoIInt0 : kChargeEoIInt1),offlineCh,charge);
652
653       Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator[offlineCh]);
654                   
655       if((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)){ 
656         if(offlineCh<8) {
657           mulADC++;
658           chargeADC += adc[offlineCh];
659           
660         } else {
661           mulADA++;
662           chargeADA += adc[offlineCh];
663         }
664       }
665                    
666   
667       // Fill HPTDC Time Histograms
668       //timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]);
669       timeCorr[offlineCh] = time[offlineCh];
670
671       //const Float_t p1 = 2.50; // photostatistics term in the time resolution
672       //const Float_t p2 = 3.00; // sleewing related term in the time resolution
673       if(timeCorr[offlineCh]>-1024 + 1.e-6){
674         //Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
675         Float_t timeErr = 1;
676         /*/
677         if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
678                                               p1*p1/nphe+
679                                               p2*p2*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*
680                                               TMath::Power(adc[offlineCh]/fCalibData->GetCalibDiscriThr(offlineCh,kTRUE),2.*(fTimeSlewing->GetParameter(1)-1.))/
681                                               (fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)*fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)));/*/
682
683         if (timeErr>1.e-6) {
684           if (offlineCh<8) {
685             itimeADC++;
686             timeADC += timeCorr[offlineCh]/(timeErr*timeErr);
687             weightADC += 1./(timeErr*timeErr);
688           }else{
689             itimeADA++;
690             timeADA += timeCorr[offlineCh]/(timeErr*timeErr);
691             weightADA += 1./(timeErr*timeErr);
692           }
693         }
694       }
695       
696       // Fill Flag and Charge Versus LHC-Clock histograms
697       Int_t nbbFlag = 0;
698       Int_t nbgFlag = 0;
699       
700       for(Int_t iEvent=0; iEvent<21; iEvent++){
701         charge = rawStream->GetPedestal(iChannel,iEvent);
702         Int_t intgr = rawStream->GetIntegratorFlag(iChannel,iEvent);
703         Bool_t bbFlag     = rawStream->GetBBFlag(iChannel, iEvent);
704         Bool_t bgFlag     = rawStream->GetBGFlag(iChannel,iEvent );
705         if(bbFlag) nbbFlag++;
706         if(bgFlag) nbgFlag++;
707         
708         FillRawsData((intgr == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), offlineCh,(float)iEvent-10,(float)charge);
709         FillRawsData(kBBFlagVsClock, offlineCh,(float)iEvent-10,(float)bbFlag);
710         FillRawsData(kBGFlagVsClock, offlineCh,(float)iEvent-10,(float)bgFlag);
711         
712       }
713       FillRawsData(kBBFlagsPerChannel, offlineCh,nbbFlag);
714       FillRawsData(kBGFlagsPerChannel, offlineCh,nbgFlag);
715       
716       FillRawsData(kHPTDCTime,offlineCh,timeCorr[offlineCh]);
717       FillRawsData(kWidth,offlineCh,width[offlineCh]);
718       //if(flagBB[offlineCh]) {
719       if(nbbFlag > 0){
720         FillRawsData(kHPTDCTimeBB,offlineCh,timeCorr[offlineCh]);
721         FillRawsData(kWidthBB,offlineCh,width[offlineCh]);
722       }
723       //if(flagBG[offlineCh]) {
724       if(nbgFlag > 0){
725         FillRawsData(kHPTDCTimeBG,offlineCh,timeCorr[offlineCh]);
726         FillRawsData(kWidthBG,offlineCh,width[offlineCh]);
727       }
728       
729
730     }// END of Loop over channels
731     
732     for(Int_t iChannel=0; iChannel<4; iChannel++) {//Loop over pairs ADC
733         offlineCh = kOfflineChannel[iChannel];
734         Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator[offlineCh]);
735         Float_t sigma4 = fCalibData->GetSigma(offlineCh+4+16*integrator[offlineCh]);            
736         if( ((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)) && ((adc[offlineCh+4] > 2.*sigma4) && !(time[offlineCh+4] <1.e-6)) ){ 
737                 pmulADC++;
738                 if(timeCorr[offlineCh]<-1024.+1.e-6 || timeCorr[offlineCh+4]<-1024.+1.e-6) pDiffTime = -1024.;
739                 else pDiffTime = timeCorr[offlineCh+4] - timeCorr[offlineCh]; 
740                 FillRawsData(kPairDiffTime,iPair,pDiffTime);
741                 }
742         FillRawsData(kPairDiffCharge,iPair,TMath::Abs(adc[offlineCh]-adc[offlineCh+4]));
743         iPair++;
744         }
745     for(Int_t iChannel=8; iChannel<12; iChannel++) {//Loop over pairs ADA
746         offlineCh = kOfflineChannel[iChannel];
747         Float_t sigma = fCalibData->GetSigma(offlineCh+16*integrator[offlineCh]);
748         Float_t sigma4 = fCalibData->GetSigma(offlineCh+4+16*integrator[offlineCh]);
749         if( ((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)) && ((adc[offlineCh+4] > 2.*sigma4) && !(time[offlineCh+4] <1.e-6)) ){ 
750                 pmulADA++;
751                 if(timeCorr[offlineCh]<-1024.+1.e-6 || timeCorr[offlineCh+4]<-1024.+1.e-6) pDiffTime = -1024.;
752                 else pDiffTime = timeCorr[offlineCh+4] - timeCorr[offlineCh]; 
753                 FillRawsData(kPairDiffTime,iPair,pDiffTime);
754                 }
755         FillRawsData(kPairDiffCharge,iPair,TMath::Abs(adc[offlineCh]-adc[offlineCh+4]));
756         iPair++;        
757         }
758     FillRawsData(kNCoincADA,pmulADA);
759     FillRawsData(kNCoincADC,pmulADC);
760         
761         
762     if(weightADA>1.e-6) timeADA /= weightADA; 
763     else timeADA = -1024.;
764     if(weightADC>1.e-6) timeADC /= weightADC;
765     else timeADC = -1024.;
766     if(timeADA<-1024.+1.e-6 || timeADC<-1024.+1.e-6) diffTime = -1024.;
767     else diffTime = timeADA - timeADC;
768     
769
770                 
771     FillRawsData(kADATime,timeADA);
772     FillRawsData(kADCTime,timeADC);
773     FillRawsData(kDiffTime,diffTime);
774     FillRawsData(kTimeADAADC,timeADA,timeADC);
775
776     FillRawsData(kMultiADA,mulADA);
777     FillRawsData(kMultiADC,mulADC);
778
779     FillRawsData(kChargeADA,chargeADA);
780     FillRawsData(kChargeADC,chargeADC);
781     FillRawsData(kChargeAD,chargeADA + chargeADC);
782             
783     break;
784   } // END of SWITCH : EVENT TYPE 
785         
786   TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiADA)->GetName()))) ; 
787   if (p) p->SetVal((double)mulADA) ; 
788
789   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiADC)->GetName()))) ; 
790   if (p) p->SetVal((double)mulADC) ;                     
791
792   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeADA)->GetName()))) ; 
793   if (p) p->SetVal((double)chargeADA) ; 
794
795   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeADC)->GetName()))) ; 
796   if (p) p->SetVal((double)chargeADC) ;                     
797
798   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeAD)->GetName()))) ; 
799   if (p) p->SetVal((double)(chargeADA + chargeADC)) ;                     
800                                 
801   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kADATime)->GetName()))) ; 
802   if (p) p->SetVal((double)timeADA) ; 
803         
804   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kADCTime)->GetName()))) ; 
805   if (p) p->SetVal((double)timeADC) ;                     
806         
807   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ; 
808   if (p) p->SetVal((double)diffTime) ;                     
809         
810   delete rawStream; rawStream = 0x0;      
811   //
812   IncEvCountCycleRaws();
813   IncEvCountTotalRaws();
814   //
815 }
816
817 //____________________________________________________________________________ 
818 Float_t AliADQADataMakerRec::CorrectLeadingTime(Int_t /*i*/, Float_t time, Float_t /*adc*/) const
819 {
820   // Correct the leading time
821   // for slewing effect and
822   // misalignment of the channels
823   if (time < 1e-6) return -1024;
824
825   // Channel alignment and general offset subtraction
826   //  time -= fTimeOffset[i];
827   //AliInfo(Form("time-offset %f", time));
828
829   // In case of pathological signals
830   //if (adc < 1e-6) return time;
831
832   // Slewing correction
833   //Float_t thr = fCalibData->GetCalibDiscriThr(i,kTRUE);
834   //AliInfo(Form("adc %f thr %f dtime %f ", adc,thr,fTimeSlewing->Eval(adc/thr)));
835   //time -= fTimeSlewing->Eval(adc/thr);
836
837   return time;
838 }
839