VZERO/AliVZEROQADataMakerRec.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 <TH2D.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 "AliVZEROQADataMakerRec.h"
  43 #include "AliQAChecker.h"
  44 #include "AliRawReader.h"
  45 #include "AliVZERORawStream.h"
  46 #include "AliVZEROdigit.h"
  47 #include "AliVZEROConst.h"
  48 #include "AliVZEROReconstructor.h"
  49 #include "AliVZEROTrending.h"
  50 #include "AliVZEROCalibData.h"
  51 #include "AliCTPTimeParams.h"
  52 #include "event.h"
  53
  54  const Float_t kMinBBA = 68. ;
  55  const Float_t kMaxBBA = 100. ;
  56  const Float_t kMinBBC = 75.5 ;
  57  const Float_t kMaxBBC = 100. ;
  58  const Float_t kMinBGA = 54. ;
  59  const Float_t kMaxBGA = 58. ;
  60  const Float_t kMinBGC = 69.5 ;
  61  const Float_t kMaxBGC = 74. ;
  62
  63
  64
  65
  66
  67 ClassImp(AliVZEROQADataMakerRec)
  68
  69 //____________________________________________________________________________
  70   AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() :
  71         AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"),
  72         fCalibData(0x0),
  73         fEvent(0),
  74         fNTotEvents(0),
  75         fNSubEvents(0),
  76         fTrendingUpdateEvent(0),
  77         fNTrendingUpdates(0),
  78         fTrendingUpdateTime(0),
  79         fCycleStartTime(0),
  80         fCycleStopTime(0),
  81                 fTimeSlewing(0)
  82
  83 {
  84    // Constructor
  85
  86       AliDebug(AliQAv1::GetQADebugLevel(), "Construct VZERO QA Object");
  87
  88    for(Int_t i=0; i<64; i++){
  89        fEven[i] = 0;
  90        fOdd[i]  = 0;
  91   }
  92
  93    for(Int_t i=0; i<128; i++){
  94        fADCmean[i] = 0.0;   }
  95 }
  96
  97 //____________________________________________________________________________
  98   AliVZEROQADataMakerRec::AliVZEROQADataMakerRec(const AliVZEROQADataMakerRec& qadm) :
  99   AliQADataMakerRec(),
 100         fCalibData(0x0),
 101         fEvent(0),
 102         fNTotEvents(0),
 103         fNSubEvents(0),
 104         fTrendingUpdateEvent(0),
 105         fNTrendingUpdates(0),
 106         fTrendingUpdateTime(0),
 107         fCycleStartTime(0),
 108         fCycleStopTime(0),
 109                 fTimeSlewing(0)
 110
 111 {
 112   // Copy constructor
 113
 114    SetName((const char*)qadm.GetName()) ;
 115    SetTitle((const char*)qadm.GetTitle());
 116 }
 117
 118 //__________________________________________________________________
 119 AliVZEROQADataMakerRec& AliVZEROQADataMakerRec::operator = (const AliVZEROQADataMakerRec& qadm )
 120 {
 121   // Equal operator
 122
 123   this->~AliVZEROQADataMakerRec();
 124   new(this) AliVZEROQADataMakerRec(qadm);
 125   return *this;
 126 }
 127
 128 //____________________________________________________________________________
 129 AliVZEROCalibData* AliVZEROQADataMakerRec::GetCalibData() const
 130
 131 {
 132    AliCDBManager *man = AliCDBManager::Instance();
 133
 134    AliCDBEntry *entry=0;
 135
 136    entry = man->Get("VZERO/Calib/Data",fRun);
 137    if(!entry){
 138         AliWarning("Load of calibration data from default storage failed!");
 139         AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
 140
 141         man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 142         entry = man->Get("VZERO/Calib/Data",fRun);
 143    }
 144    // Retrieval of data in directory VZERO/Calib/Data:
 145
 146    AliVZEROCalibData *calibdata = 0;
 147
 148    if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
 149    if (!calibdata)  AliFatal("No calibration data from calibration database !");
 150
 151    return calibdata;
 152 }
 153
 154
 155
 156 //____________________________________________________________________________
 157 void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
 158 {
 159   // Detector specific actions at end of cycle
 160   // Does the QA checking
 161
 162   AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
 163
 164   if(task == AliQAv1::kRAWS){
 165         TTimeStamp currentTime;
 166         fCycleStopTime = currentTime.GetSec();
 167   }
 168
 169   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
 170     if (! IsValidEventSpecie(specie, list))
 171       continue ;
 172     SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
 173     if(task == AliQAv1::kRAWS){
 174     } else if (task == AliQAv1::kESDS) {
 175     }
 176   }
 177 }
 178
 179 //____________________________________________________________________________
 180 void AliVZEROQADataMakerRec::InitESDs()
 181 {
 182   // Creates histograms to control ESDs
 183
 184   const Bool_t expert   = kTRUE ;
 185   const Bool_t image    = kTRUE ;
 186
 187   TH2D * h2d;
 188   TH1I * h1i;
 189   TH1D * h1d;
 190
 191   h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;
 192   Add2ESDsList(h1i, kCellMultiV0A, !expert, image)  ;
 193
 194   h1i = new TH1I("H1I_Cell_Multiplicity_V0C", "Cell Multiplicity in V0;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;
 195   Add2ESDsList(h1i, kCellMultiV0C, !expert, image)  ;
 196
 197   h1d = new TH1D("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
 198   Add2ESDsList(h1d, kMIPMultiV0A, !expert, image)  ;
 199
 200   h1d = new TH1D("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
 201   Add2ESDsList(h1d, kMIPMultiV0C, !expert, image)  ;
 202
 203   h2d = new TH2D("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel;Channel;Multiplicity (Nb of MIP)",64, 0, 64, 100, 0, 100) ;
 204   Add2ESDsList(h2d, kMIPMultiChannel, !expert, image)  ;
 205
 206   h1d = new TH1D("H1D_BBFlag_Counters", "BB Flag Counters;Channel;Counts",64, 0, 64) ;
 207   Add2ESDsList(h1d, kBBFlag, !expert, image)  ;
 208
 209   h1d = new TH1D("H1D_BGFlag_Counters", "BG Flag Counters;Channel;Counts",64, 0, 64) ;
 210   Add2ESDsList(h1d, kBGFlag, !expert, image)  ;
 211
 212   h2d = new TH2D("H2D_Charge_Channel", "ADC Charge per channel;Channel;Charge (ADC counts)",64, 0, 64, 1024, 0, 1024) ;
 213   Add2ESDsList(h2d, kChargeChannel, !expert, image)  ;
 214
 215   h2d = new TH2D("H2D_Time_Channel", "Time per channel;Channel;Time (ns)",64, 0, 64, 820, 0, 410) ;
 216   Add2ESDsList(h2d, kTimeChannel, !expert, image)  ;
 217
 218   h1d = new TH1D("H1D_V0A_Time", "Mean V0A Time;Time (ns);Counts",2048, 0., 409.6);
 219   Add2ESDsList(h1d,kESDV0ATime, !expert, image);
 220
 221   h1d = new TH1D("H1D_V0C_Time", "Mean V0C Time;Time (ns);Counts",2048, 0., 409.6);
 222   Add2ESDsList(h1d,kESDV0CTime, !expert, image);
 223
 224   h1d = new TH1D("H1D_Diff_Time", "Diff Time V0A - V0C;Diff Time V0A - V0C (ns);Counts",2*2048, -409.6, 409.6);
 225   Add2ESDsList(h1d,kESDDiffTime, !expert, image);
 226
 227 }
 228
 229 //____________________________________________________________________________
 230  void AliVZEROQADataMakerRec::InitRaws()
 231  {
 232    // Creates RAW histograms in Raws subdir
 233
 234    const Bool_t expert   = kTRUE ;
 235    const Bool_t saveCorr = kTRUE ;
 236    const Bool_t image    = kTRUE ;
 237
 238   const Int_t kNintegrator  =    2;
 239
 240   const Int_t kNTdcTimeBins  = 1280;
 241   const Float_t kTdcTimeMin    =    0.;
 242   const Float_t kTdcTimeMax    = 125.;
 243   const Int_t kNTdcWidthBins =  128;
 244   const Float_t kTdcWidthMin   =    0;
 245   const Float_t kTdcWidthMax   =  50.;
 246   const Int_t kNChargeBins   = 1024;
 247   const Float_t kChargeMin     =    0;
 248   const Float_t kChargeMax     = 1024;
 249   const Int_t kNChannelBins  =   64;
 250   const Float_t kChannelMin    =    0;
 251   const Float_t kChannelMax    =   64;
 252   const Int_t kNPedestalBins =  200;
 253   const Float_t kPedestalMin   =    0;
 254   const Float_t kPedestalMax   =  200;
 255   const Float_t kTimeMin       =   0;
 256   const Float_t kTimeMax       = 100;
 257   const Int_t kNMIPBins      = 512;
 258   const Float_t kMIPMin        =   0;
 259   const Float_t kMIPMax        = 16;
 260
 261   TH2I * h2i;
 262   TH2D * h2d;
 263   TH1I * h1i;
 264   TH1D * h1d;
 265
 266   int iHisto =0;
 267     // Creation of Trigger Histogram
 268   h1d = new TH1D("H1D_Trigger_Type", "V0 Trigger Type;;Counts", 4,0 ,4) ;
 269   Add2RawsList(h1d,kTriggers, !expert, image, saveCorr);   iHisto++;
 270         h1d->SetFillColor(29);
 271         h1d->SetLineWidth(2);
 272         h1d->GetXaxis()->SetLabelSize(0.06);
 273     h1d->GetXaxis()->SetNdivisions(808,kFALSE);
 274         h1d->GetXaxis()->SetBinLabel(1, "V0-AND");
 275         h1d->GetXaxis()->SetBinLabel(2, "V0-OR");
 276         h1d->GetXaxis()->SetBinLabel(3, "V0-BGA");
 277         h1d->GetXaxis()->SetBinLabel(4, "V0-BGC");
 278
 279    // Creation of Cell Multiplicity Histograms
 280   h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A;# of Cells;Entries", 35, 0, 35) ;
 281   Add2RawsList(h1i,kMultiV0A, expert, image, saveCorr);   iHisto++;
 282   h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C;# of Cells;Entries", 35, 0, 35) ;
 283   Add2RawsList(h1i,kMultiV0C, expert, image, saveCorr);   iHisto++;
 284
 285   // Creation of Total Charge Histograms
 286   h1d = new TH1D("H1D_Charge_V0A", "Total Charge in V0A;Charge [ADC counts];Counts", 2000, 0, 10000) ;
 287   Add2RawsList(h1d,kChargeV0A, expert, !image, saveCorr);   iHisto++;
 288   h1d = new TH1D("H1D_Charge_V0C", "Total Charge in V0C;Charge [ADC counts];Counts", 2000, 0, 10000) ;
 289   Add2RawsList(h1d,kChargeV0C, expert, !image, saveCorr);   iHisto++;
 290   h1d = new TH1D("H1D_Charge_V0", "Total Charge in V0;Charge [ADC counts];Counts", 2000, 0, 20000) ;
 291   Add2RawsList(h1d,kChargeV0, expert, !image, saveCorr);   iHisto++;
 292
 293   // Creation of MIP Histograms
 294   h1d = new TH1D("H1D_MIP_V0A", "Total MIP in V0A;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ;
 295   Add2RawsList(h1d,kRawMIPV0A, expert, !image, saveCorr);   iHisto++;
 296   h1d = new TH1D("H1D_MIP_V0C", "Total MIP in V0C;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ;
 297   Add2RawsList(h1d,kRawMIPV0C, expert, !image, saveCorr);   iHisto++;
 298   h1d = new TH1D("H1D_MIP_V0", "Total MIP in V0;Multiplicity [MIP];Counts", 2*kNMIPBins,kMIPMin ,64*kMIPMax) ;
 299   Add2RawsList(h1d,kRawMIPV0, expert, !image, saveCorr);   iHisto++;
 300   h2d = new TH2D("H2D_MIP_Channel", "Nb of MIP per channel;Channel;# of Mips", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ;
 301   Add2RawsList(h2d,kRawMIPChannel, expert, !image, !saveCorr);   iHisto++;
 302
 303
 304
 305   // Creation of Charge EoI histogram
 306    h2d = new TH2D("H2D_ChargeEoI", "Charge Event of Interest;Channel Number;Charge [ADC counts]"
 307                 ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
 308    Add2RawsList(h2d,kChargeEoI, !expert, image, !saveCorr); iHisto++;
 309
 310  for(Int_t iInt=0;iInt<kNintegrator;iInt++){
 311     // Creation of Pedestal histograms
 312     h2i = new TH2I(Form("H2I_Pedestal_Int%d",iInt), Form("Pedestal (Int%d);Channel;Pedestal [ADC counts]",iInt)
 313                 ,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
 314     Add2RawsList(h2i,(iInt == 0 ? kPedestalInt0 : kPedestalInt1), expert, !image, !saveCorr); iHisto++;
 315
 316
 317    // Creation of Charge EoI histograms
 318     h2i = new TH2I(Form("H2I_ChargeEoI_Int%d",iInt), Form("Charge EoI (Int%d);Channel;Charge [ADC counts]",iInt)
 319                 ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
 320     Add2RawsList(h2i,(iInt == 0 ? kChargeEoIInt0 : kChargeEoIInt1), expert, image, !saveCorr); iHisto++;
 321
 322     h2i = new TH2I(Form("H2I_ChargeEoI_BB_Int%d",iInt), Form("Charge EoI w/ BB Flag (Int%d);Channel;Charge [ADC counts]",iInt)
 323                 ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
 324     Add2RawsList(h2i,(iInt == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1), expert, !image, !saveCorr); iHisto++;
 325
 326     h2i = new TH2I(Form("H2I_ChargeEoI_BG_Int%d",iInt), Form("Charge EoI w/ BG Flag (Int%d);Channel;Charge [ADC counts]",iInt)
 327                 ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
 328     Add2RawsList(h2i,(iInt == 0 ?  kChargeEoIBGInt0: kChargeEoIBGInt1), expert, !image, !saveCorr); iHisto++;
 329
 330     // Creation of Charge versus LHC Clock histograms
 331     h2d = new TH2D(Form("H2D_ChargeVsClock_Int%d",iInt), Form("Charge Versus LHC-Clock (Int%d);Channel;LHCClock;Charge [ADC counts]",iInt)
 332                 ,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
 333     Add2RawsList(h2d,(iInt == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), expert, !image, !saveCorr); iHisto++;
 334
 335     // Creation of Minimum Bias Charge histograms
 336     for(Int_t iBB=0;iBB<2;iBB++){
 337                 for(Int_t iBG=0;iBG<2;iBG++){
 338                         h2i = new TH2I(Form("H2I_ChargeMB_BB%d_BG%d_Int%d",iBB,iBG,iInt), Form("MB Charge (BB=%d, BG=%d, Int=%d);Channel;Charge [ADC counts]",iBB,iBG,iInt)
 339                                 ,kNChannelBins, kChannelMin, kChannelMax,kNChargeBins, kChargeMin, kChargeMax);
 340                         int idx;
 341                         if(iInt==0){
 342                                 if(iBB==0){
 343                                         if(iBG==0) idx = kChargeMBBB0BG0Int0;
 344                                         else idx = kChargeMBBB0BG1Int0;
 345                                 } else {
 346                                         if(iBG==0) idx = kChargeMBBB1BG0Int0;
 347                                         else idx = kChargeMBBB1BG1Int0;
 348                                 }
 349                         } else {
 350                                 if(iBB==0){
 351                                         if(iBG==0) idx = kChargeMBBB0BG0Int1;
 352                                         else idx = kChargeMBBB0BG1Int1;
 353                                 } else {
 354                                         if(iBG==0) idx = kChargeMBBB1BG0Int1;
 355                                         else idx = kChargeMBBB1BG1Int1;
 356                                 }
 357                         }
 358                         Add2RawsList(h2i,idx, expert, !image, !saveCorr); iHisto++;
 359                 }
 360     }
 361
 362  }
 363
 364      // Creation of Time histograms
 365         h2i = new TH2I("H2I_Width", "HPTDC Width;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
 366         Add2RawsList(h2i,kWidth, expert, !image, !saveCorr); iHisto++;
 367
 368         h2i = new TH2I("H2I_Width_BB", "HPTDC Width w/ BB Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
 369         Add2RawsList(h2i,kWidthBB, expert, !image, !saveCorr); iHisto++;
 370
 371         h2i = new TH2I("H2I_Width_BG", "HPTDC Width w/ BG Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
 372         Add2RawsList(h2i,kWidthBG, expert, !image, !saveCorr); iHisto++;
 373
 374         h2i = new TH2I("H2I_HPTDCTime", "HPTDC Time;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
 375         Add2RawsList(h2i,kHPTDCTime, expert, image, !saveCorr); iHisto++;
 376
 377         h2i = new TH2I("H2I_HPTDCTime_BB", "HPTDC Time w/ BB Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
 378         Add2RawsList(h2i,kHPTDCTimeBB, !expert, image, !saveCorr); iHisto++;
 379
 380         h2i = new TH2I("H2I_HPTDCTime_BG", "HPTDC Time w/ BG Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
 381         Add2RawsList(h2i,kHPTDCTimeBG, !expert, image, !saveCorr); iHisto++;
 382
 383         h1d = new TH1D("H1D_V0A_Time", "V0A Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
 384         Add2RawsList(h1d,kV0ATime, expert, !image, saveCorr); iHisto++;
 385
 386         h1d = new TH1D("H1D_V0C_Time", "V0C Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
 387         Add2RawsList(h1d,kV0CTime, expert, !image, saveCorr); iHisto++;
 388
 389         h1d = new TH1D("H1D_Diff_Time","Diff V0A-V0C Time;Time [ns];Counts",2*kNTdcTimeBins, -50., 50.);
 390         Add2RawsList(h1d,kDiffTime, expert, !image, saveCorr); iHisto++;
 391
 392     h2d = new TH2D("H2D_TimeV0A_V0C", "Mean Time in V0C versus V0A;Time V0A [ns];Time V0C [ns]",
 393                 150, kTimeMin,kTimeMax,150,kTimeMin,kTimeMax) ;
 394     Add2RawsList(h2d,kTimeV0AV0C, expert, image, !saveCorr);   iHisto++;
 395
 396         // Creation of Flag versus LHC Clock histograms
 397
 398         h1d = new TH1D("H1D_BBFlagPerChannel", "BB-Flags Versus Channel;Channel;BB Flags Count",kNChannelBins, kChannelMin, kChannelMax );
 399         h1d->SetMinimum(0);
 400         Add2RawsList(h1d,kBBFlagsPerChannel, !expert, image, !saveCorr); iHisto++;
 401
 402         h2d = new TH2D("H2D_BBFlagVsClock", "BB-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
 403         Add2RawsList(h2d,kBBFlagVsClock, expert, !image, !saveCorr); iHisto++;
 404
 405         h2d = new TH2D("H2D_BGFlagVsClock", "BG-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
 406         Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++;
 407
 408
 409         AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto));
 410  }
 411
 412 //____________________________________________________________________________
 413 void AliVZEROQADataMakerRec::InitDigits()
 414 {
 415   // create Digits histograms in Digits subdir
 416   const Bool_t expert   = kTRUE ;
 417   const Bool_t image    = kTRUE ;
 418
 419   TH1I *fhDigTDC[64];
 420   TH1I *fhDigADC[64];
 421
 422   // create Digits histograms in Digits subdir
 423   TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO;# of Digits;Entries", 100, 0, 99) ;
 424   h0->Sumw2() ;
 425   Add2DigitsList(h0, 0, !expert, image) ;
 426
 427   for (Int_t i=0; i<64; i++)
 428     {
 429     fhDigTDC[i] = new TH1I(Form("hDigitTDC%d", i),Form("Digit TDC in cell %d; TDC value;Entries",i),300,0.,149.);
 430
 431     fhDigADC[i]= new TH1I(Form("hDigitADC%d",i),Form("Digit ADC in cell %d;ADC value;Entries",i),1024,0.,1023.);
 432
 433     Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
 434     Add2DigitsList(fhDigADC[i],i+1+64, !expert, image);
 435     }
 436 }
 437
 438 //____________________________________________________________________________
 439 void AliVZEROQADataMakerRec::MakeDigits()
 440 {
 441   // makes data from Digits
 442
 443   GetDigitsData(0)->Fill(fDigitsArray->GetEntriesFast()) ;
 444   TIter next(fDigitsArray) ;
 445   AliVZEROdigit *aVZERODigit ;
 446   while ( (aVZERODigit = dynamic_cast<AliVZEROdigit *>(next())) ) {
 447     Int_t   aPMNumber  = aVZERODigit->PMNumber();
 448     GetDigitsData(aPMNumber +1)->Fill( aVZERODigit->Time()) ;    // in 100 of picoseconds
 449     GetDigitsData(aPMNumber +1+64)->Fill( aVZERODigit->ADC()) ;
 450   }
 451 }
 452
 453
 454 //____________________________________________________________________________
 455 void AliVZEROQADataMakerRec::MakeDigits(TTree *digitTree)
 456 {
 457   // makes data from Digit Tree
 458
 459   if ( fDigitsArray )
 460     fDigitsArray->Clear() ;
 461   else
 462     fDigitsArray = new TClonesArray("AliVZEROdigit", 1000) ;
 463
 464   TBranch * branch = digitTree->GetBranch("VZERODigit") ;
 465   if ( ! branch ) {
 466     AliWarning("VZERO branch in Digit Tree not found") ;
 467   } else {
 468     branch->SetAddress(&fDigitsArray) ;
 469     branch->GetEntry(0) ;
 470     MakeDigits() ;
 471   }
 472 }
 473
 474
 475 //____________________________________________________________________________
 476 void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 477 {
 478   // Creates QA data from ESDs
 479
 480   UInt_t eventType = esd->GetEventType();
 481
 482   switch (eventType){
 483         case PHYSICS_EVENT:
 484         AliESDVZERO *esdVZERO=esd->GetVZEROData();
 485
 486         if (!esdVZERO) break;
 487
 488         GetESDsData(kCellMultiV0A)->Fill(esdVZERO->GetNbPMV0A());
 489         GetESDsData(kCellMultiV0C)->Fill(esdVZERO->GetNbPMV0C());
 490         GetESDsData(kMIPMultiV0A)->Fill(esdVZERO->GetMTotV0A());
 491         GetESDsData(kMIPMultiV0C)->Fill(esdVZERO->GetMTotV0C());
 492
 493         Float_t  timeV0A = 0., timeV0C = 0., diffTime;
 494         Int_t   iTimeV0A = 0, iTimeV0C = 0;
 495
 496         for(Int_t i=0;i<64;i++) {
 497                         GetESDsData(kMIPMultiChannel)->Fill((Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i));
 498                         GetESDsData(kChargeChannel)->Fill((Float_t) i,(Float_t) esdVZERO->GetAdc(i));
 499                         if(esdVZERO->GetBBFlag(i)) GetESDsData(kBBFlag)->Fill((Float_t) i);
 500                         if(esdVZERO->GetBGFlag(i)) GetESDsData(kBGFlag)->Fill((Float_t) i);
 501
 502                         Float_t time = (Float_t) esdVZERO->GetTime(i)/10.; //Convert in ns:  1 TDC channel = 100ps
 503                         GetESDsData(kTimeChannel)->Fill((Float_t) i,time);
 504
 505                         if(time>0.){
 506                                 if (i<32) {
 507                                         iTimeV0C++;
 508                                         timeV0C += time;
 509                                 }else{
 510                                         iTimeV0A++;
 511                                         timeV0A += time;
 512                                 }
 513                         }
 514         }
 515         if(iTimeV0A>0) timeV0A /= iTimeV0A;
 516         else timeV0A = -1.;
 517         if(iTimeV0C>0) timeV0C /= iTimeV0C;
 518         else timeV0C = -1.;
 519         if(timeV0A<0. || timeV0C<0.) diffTime = -10000.;
 520         else diffTime = timeV0A - timeV0C;
 521
 522         GetESDsData(kESDV0ATime)->Fill(timeV0A);
 523         GetESDsData(kESDV0CTime)->Fill(timeV0C);
 524         GetESDsData(kESDDiffTime)->Fill(diffTime);
 525
 526         break;
 527         }
 528
 529 }
 530
 531 //____________________________________________________________________________
 532  void AliVZEROQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 533  {
 534   // Fills histograms with Raws, computes average ADC values dynamically (pedestal subtracted)
 535
 536
 537    // Check id histograms already created for this Event Specie
 538    if ( ! GetRawsData(kPedestalInt0) )
 539      InitRaws() ;
 540
 541    rawReader->Reset() ;
 542   AliVZERORawStream* rawStream  = new AliVZERORawStream(rawReader);
 543  if(!(rawStream->Next())) return;
 544
 545   eventTypeType eventType = rawReader->GetType();
 546
 547   Int_t    mulV0A = 0 ;
 548   Int_t    mulV0C = 0 ;
 549   Double_t timeV0A =0., timeV0C = 0.;
 550   Double_t weightV0A =0., weightV0C = 0.;
 551   UInt_t   itimeV0A=0, itimeV0C=0;
 552   Double_t chargeV0A=0., chargeV0C=0.;
 553   Double_t mipV0A=0., mipV0C=0.;
 554
 555   Double_t diffTime=-100000.;
 556
 557
 558   switch (eventType){
 559        case PHYSICS_EVENT:
 560
 561                 fNTotEvents++;
 562
 563        Int_t  iFlag=0;
 564        Int_t  pedestal;
 565        Int_t  integrator;
 566        Bool_t flagBB[64];
 567        Bool_t flagBG[64];
 568        Int_t  mbCharge;
 569            Float_t charge;
 570        Int_t  offlineCh;
 571        Float_t adc[64], time[64], width[64], timeCorr[64];
 572
 573        for(Int_t iChannel=0; iChannel<64; iChannel++) { // BEGIN : Loop over channels
 574
 575            offlineCh = rawStream->GetOfflineChannel(iChannel);
 576
 577            // Fill Pedestal histograms
 578
 579            for(Int_t j=15; j<21; j++) {
 580                        if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++;
 581            }
 582
 583            if(iFlag == 0){ //No Flag found
 584                        for(Int_t j=15; j<21; j++){
 585                                pedestal= (Int_t) rawStream->GetPedestal(iChannel, j);
 586                                integrator = rawStream->GetIntegratorFlag(iChannel, j);
 587
 588                                GetRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1))->Fill(offlineCh,pedestal);
 589                        }
 590             }
 591
 592            // Fill Charge EoI histograms
 593
 594                adc[offlineCh]    = 0.0;
 595
 596                // Search for the maximum charge in the train of 21 LHC clocks
 597                // regardless of the integrator which has been operated:
 598                Float_t maxadc = 0;
 599                Int_t imax = -1;
 600                Float_t adcPedSub[21];
 601                for(Int_t iClock=0; iClock<21; iClock++){
 602                            Bool_t iIntegrator = rawStream->GetIntegratorFlag(iChannel,iClock);
 603                            Int_t k = offlineCh+64*iIntegrator;
 604
 605                            //printf(Form("clock = %d adc = %f ped %f\n",iClock,rawStream->GetPedestal(iChannel,iClock),fPedestal[k]));
 606
 607                                 adcPedSub[iClock] = rawStream->GetPedestal(iChannel,iClock) - fCalibData->GetPedestal(k);
 608 //                              if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) {
 609                                 if(adcPedSub[iClock] <= 2.*fCalibData->GetSigma(k)) {
 610                                         adcPedSub[iClock] = 0;
 611                                         continue;
 612                                 }
 613 //                              if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue;
 614                                 if(iClock < 8 || iClock > 12) continue;
 615                                 if(adcPedSub[iClock] > maxadc) {
 616                                         maxadc = adcPedSub[iClock];
 617                                         imax   = iClock;
 618                                 }
 619                }
 620                //printf(Form("Channel %d (online), %d (offline)\n",iChannel,j));
 621                if (imax != -1) {
 622 //                              Int_t start = imax - GetRecoParam()->GetNPreClocks();
 623                                 Int_t start = imax - 2;
 624                                 if (start < 0) start = 0;
 625 //                              Int_t end = imax + GetRecoParam()->GetNPostClocks();
 626                                 Int_t end = imax + 1;
 627                                 if (end > 20) end = 20;
 628                                 for(Int_t iClock = start; iClock <= end; iClock++) {
 629                                         adc[offlineCh] += adcPedSub[iClock];
 630                                 }
 631                         }
 632
 633
 634            Int_t iClock  = imax;
 635            charge = rawStream->GetPedestal(iChannel,iClock); // Charge at the maximum
 636
 637            integrator    = rawStream->GetIntegratorFlag(iChannel,iClock);
 638            flagBB[offlineCh]     = rawStream->GetBBFlag(iChannel, iClock);
 639            flagBG[offlineCh]     = rawStream->GetBGFlag(iChannel,iClock );
 640                Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh);
 641                time[offlineCh] = rawStream->GetTime(iChannel)*fCalibData->GetTimeResolution(board);
 642                width[offlineCh] = rawStream->GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
 643
 644                if (time[offlineCh] >= 1e-6) GetRawsData(kChargeEoI)->Fill(offlineCh,adc[offlineCh]);
 645
 646            GetRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1))->Fill(offlineCh,charge);
 647                    if(flagBB[offlineCh]) GetRawsData((integrator == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1))->Fill(offlineCh,charge);
 648            if(flagBG[offlineCh]) GetRawsData((integrator == 0 ? kChargeEoIBGInt0 : kChargeEoIBGInt1))->Fill(offlineCh,charge);
 649
 650                         Float_t sigma = fCalibData->GetSigma(offlineCh+64*integrator);
 651
 652
 653            // Calculation of the number of MIP
 654            Double_t mipEoI = adc[offlineCh] * fCalibData->GetMIPperADC(offlineCh);
 655
 656            if((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)){
 657                    ((TH2D*)GetRawsData(kRawMIPChannel))->Fill(offlineCh,mipEoI);
 658                    if(offlineCh<32) {
 659                                    mulV0C++;
 660                                    chargeV0C += adc[offlineCh];
 661                                    mipV0C += mipEoI;
 662                    } else {
 663                                    mulV0A++;
 664                                    chargeV0A += adc[offlineCh];
 665                                    mipV0A += mipEoI;
 666                    }
 667            }
 668
 669            // Fill Charge Minimum Bias Histograms
 670
 671            int idx;
 672            for(Int_t iBunch=0; iBunch<10; iBunch++){
 673                            integrator = rawStream->GetIntMBFlag(iChannel, iBunch);
 674                            bool bbFlag     = rawStream->GetBBMBFlag(iChannel, iBunch);
 675                            bool bgFlag     = rawStream->GetBGMBFlag(iChannel, iBunch);
 676                            mbCharge   = rawStream->GetChargeMB(iChannel, iBunch);
 677
 678                            if(integrator==0){
 679                                    if(bbFlag==0){
 680                                            if(bgFlag==0) idx = kChargeMBBB0BG0Int0;
 681                                            else idx = kChargeMBBB0BG1Int0;
 682                                    } else {
 683                                            if(bgFlag==0) idx = kChargeMBBB1BG0Int0;
 684                                            else idx = kChargeMBBB1BG1Int0;
 685                                    }
 686                            } else {
 687                                    if(bbFlag==0){
 688                                            if(bgFlag==0) idx = kChargeMBBB0BG0Int1;
 689                                            else idx = kChargeMBBB0BG1Int1;
 690                                    } else {
 691                                            if(bgFlag==0) idx = kChargeMBBB1BG0Int1;
 692                                            else idx = kChargeMBBB1BG1Int1;
 693                                    }
 694                            }
 695                            GetRawsData(idx)->Fill(offlineCh,mbCharge);
 696        }
 697
 698           // Fill HPTDC Time Histograms
 699            timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]);
 700
 701            const Float_t p1 = 2.50; // photostatistics term in the time resolution
 702            const Float_t p2 = 3.00; // slewing related term in the time resolution
 703            if(timeCorr[offlineCh]>-1024 + 1.e-6){
 704                         Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
 705                         Float_t timeErr = 0;
 706                         if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
 707                                       p1*p1/nphe+
 708                                       p2*p2*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*
 709                                       TMath::Power(adc[offlineCh]/fCalibData->GetDiscriThr(offlineCh),2.*(fTimeSlewing->GetParameter(1)-1.))/
 710                                       (fCalibData->GetDiscriThr(offlineCh)*fCalibData->GetDiscriThr(offlineCh)));
 711
 712                         if (timeErr>1.e-6) {
 713                           if (offlineCh<32) {
 714                             itimeV0C++;
 715                             timeV0C += timeCorr[offlineCh]/(timeErr*timeErr);
 716                             weightV0C += 1./(timeErr*timeErr);
 717                           }else{
 718                             itimeV0A++;
 719                             timeV0A += timeCorr[offlineCh]/(timeErr*timeErr);
 720                             weightV0A += 1./(timeErr*timeErr);
 721                           }
 722                         }
 723            }
 724                 GetRawsData(kHPTDCTime)->Fill(offlineCh,timeCorr[offlineCh]);
 725                 GetRawsData(kWidth)->Fill(offlineCh,width[offlineCh]);
 726         if(flagBB[offlineCh]) {
 727                         GetRawsData(kHPTDCTimeBB)->Fill(offlineCh,timeCorr[offlineCh]);
 728                         GetRawsData(kWidthBB)->Fill(offlineCh,width[offlineCh]);
 729                 }
 730                 if(flagBG[offlineCh]) {
 731                         GetRawsData(kHPTDCTimeBG)->Fill(offlineCh,timeCorr[offlineCh]);
 732                         GetRawsData(kWidthBG)->Fill(offlineCh,width[offlineCh]);
 733                 }
 734
 735            // Fill Flag and Charge Versus LHC-Clock histograms
 736
 737            for(Int_t iEvent=0; iEvent<21; iEvent++){
 738                charge = rawStream->GetPedestal(iChannel,iEvent);
 739                integrator = rawStream->GetIntegratorFlag(iChannel,iEvent);
 740                bool bbFlag        = rawStream->GetBBFlag(iChannel, iEvent);
 741                bool bgFlag        = rawStream->GetBGFlag(iChannel,iEvent );
 742
 743                ((TH2*) GetRawsData((integrator == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 )))->Fill(offlineCh,(float)iEvent-10,(float)charge);
 744                ((TH2*) GetRawsData(kBBFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)bbFlag);
 745                ((TH2*) GetRawsData(kBGFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)bgFlag);
 746                if(iEvent==10) ((TH1*) GetRawsData(kBBFlagsPerChannel))->Fill(offlineCh,(float)bbFlag);
 747            }
 748
 749        }// END of Loop over channels
 750
 751                 if(weightV0A>1.e-6) timeV0A /= weightV0A;
 752                 else timeV0A = -1024.;
 753                 if(weightV0C>1.e-6) timeV0C /= weightV0C;
 754                 else timeV0C = -1024.;
 755                 if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.;
 756                 else diffTime = timeV0A - timeV0C;
 757
 758                 Bool_t v0ABB = kFALSE;
 759                 Bool_t v0CBB = kFALSE;
 760                 Bool_t v0ABG = kFALSE;
 761                 Bool_t v0CBG = kFALSE;
 762
 763                 if(timeV0A>kMinBBA && timeV0A<kMaxBBA) {
 764                         v0ABB = kTRUE;
 765                 } else if(timeV0A>kMinBGA && timeV0A<kMaxBGA) {
 766                         v0ABG = kTRUE;
 767                 }
 768                 if(timeV0C>kMinBBC && timeV0C<kMaxBBC) {
 769                         v0CBB = kTRUE;
 770                 } else if(timeV0C>kMinBGC && timeV0C<kMaxBGC) {
 771                         v0CBG = kTRUE;
 772                 }
 773
 774 // Fill Trigger output histogram
 775                 if(v0ABB && v0CBB) GetRawsData(kTriggers)->Fill(0);
 776                 if((v0ABB || v0CBB) && !(v0ABG || v0CBG)) GetRawsData(kTriggers)->Fill(1);
 777                 if(v0ABG && v0CBB) GetRawsData(kTriggers)->Fill(2);
 778                 if(v0ABB && v0CBG) GetRawsData(kTriggers)->Fill(3);
 779
 780
 781                 GetRawsData(kV0ATime)->Fill(timeV0A);
 782                 GetRawsData(kV0CTime)->Fill(timeV0C);
 783                 GetRawsData(kDiffTime)->Fill(diffTime);
 784                 GetRawsData(kTimeV0AV0C)->Fill(timeV0A,timeV0C);
 785
 786                 GetRawsData(kMultiV0A)->Fill(mulV0A);
 787                 GetRawsData(kMultiV0C)->Fill(mulV0C);
 788
 789                 GetRawsData(kChargeV0A)->Fill(chargeV0A);
 790                 GetRawsData(kChargeV0C)->Fill(chargeV0C);
 791                 GetRawsData(kChargeV0)->Fill(chargeV0A + chargeV0C);
 792
 793                 GetRawsData(kRawMIPV0A)->Fill(mipV0A);
 794                 GetRawsData(kRawMIPV0C)->Fill(mipV0C);
 795                 GetRawsData(kRawMIPV0)->Fill(mipV0A + mipV0C);
 796                 break;
 797
 798         } // END of SWITCH : EVENT TYPE
 799
 800         fEvent++;
 801         TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ;
 802         if (p) p->SetVal((double)mulV0A) ;
 803
 804         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ;
 805         if (p) p->SetVal((double)mulV0C) ;
 806
 807         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ;
 808         if (p) p->SetVal((double)chargeV0A) ;
 809
 810         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ;
 811         if (p) p->SetVal((double)chargeV0C) ;
 812
 813         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ;
 814         if (p) p->SetVal((double)(chargeV0A + chargeV0C)) ;
 815
 816         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ;
 817         if (p) p->SetVal((double)mipV0A) ;
 818
 819         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ;
 820         if (p) p->SetVal((double)mipV0C) ;
 821
 822         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ;
 823         if (p) p->SetVal((double)(mipV0A + mipV0C)) ;
 824
 825         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ;
 826         if (p) p->SetVal((double)timeV0A) ;
 827
 828         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ;
 829         if (p) p->SetVal((double)timeV0C) ;
 830
 831         p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ;
 832         if (p) p->SetVal((double)diffTime) ;
 833
 834         delete rawStream; rawStream = 0x0;
 835
 836
 837  }
 838
 839 //____________________________________________________________________________
 840 void AliVZEROQADataMakerRec::StartOfDetectorCycle()
 841 {
 842   // Detector specific actions at start of cycle
 843
 844   // Reset of the histogram used - to have the trend versus time -
 845
 846   fCalibData = GetCalibData();
 847
 848   AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
 849   if (!entry) AliFatal("CTP timing parameters are not found in OCDB !");
 850   AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject();
 851   Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0;
 852
 853   AliCDBEntry *entry1 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
 854   if (!entry1) AliFatal("CTP time-alignment is not found in OCDB !");
 855   AliCTPTimeParams *ctpTimeAlign = (AliCTPTimeParams*)entry1->GetObject();
 856   l1Delay += ((Float_t)ctpTimeAlign->GetDelayL1L0()*25.0);
 857
 858   AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeDelays");
 859   if (!entry2) AliFatal("VZERO time delays are not found in OCDB !");
 860   TH1F *delays = (TH1F*)entry2->GetObject();
 861
 862   AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing");
 863   if (!entry3) AliFatal("VZERO time slewing function is not found in OCDB !");
 864   fTimeSlewing = (TF1*)entry3->GetObject();
 865
 866   for(Int_t i = 0 ; i < 64; ++i) {
 867     //Int_t board = AliVZEROCalibData::GetBoardNumber(i);
 868     fTimeOffset[i] = (
 869                 //      ((Float_t)fCalibData->GetTriggerCountOffset(board) -
 870                 //      (Float_t)fCalibData->GetRollOver(board))*25.0 +
 871                  //     fCalibData->GetTimeOffset(i) -
 872                   //     l1Delay+
 873                        delays->GetBinContent(i+1)//+
 874                  //      kV0Offset
 875                        );
 876 //                    AliInfo(Form(" fTimeOffset[%d] = %f  kV0offset %f",i,fTimeOffset[i],kV0Offset));
 877   }
 878
 879
 880
 881
 882
 883   TTimeStamp currentTime;
 884   fCycleStartTime = currentTime.GetSec();
 885
 886   fNTotEvents = 0;
 887 }
 888
 889
 890 //-------------------------------------------------------------------------------------------------
 891 Float_t AliVZEROQADataMakerRec::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
 892 {
 893   // Correct the leading time
 894   // for slewing effect and
 895   // misalignment of the channels
 896   if (time < 1e-6) return -1024;
 897
 898   // Channel alignment and general offset subtraction
 899 //  if (i < 32) time -= kV0CDelayCables;
 900 //  time -= fTimeOffset[i];
 901   //AliInfo(Form("time-offset %f", time));
 902
 903   // In case of pathological signals
 904   if (adc < 1e-6) return time;
 905
 906   // Slewing correction
 907   Float_t thr = fCalibData->GetDiscriThr(i);
 908   //AliInfo(Form("adc %f thr %f dtime %f ", adc,thr,fTimeSlewing->Eval(adc/thr)));
 909   time -= fTimeSlewing->Eval(adc/thr);
 910
 911   return time;
 912 }
 913