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