]>
Commit | Line | Data |
---|---|---|
a148e064 | 1 | #include "TChain.h" |
2 | #include "TTree.h" | |
3 | #include "TH1F.h" | |
4 | #include "TH2F.h" | |
5 | ||
6 | #include "AliAnalysisTask.h" | |
7 | #include "AliAnalysisManager.h" | |
8 | ||
9 | #include "AliESDEvent.h" | |
10 | #include "AliESDInputHandler.h" | |
11 | #include "AliAnaVZEROPbPb.h" | |
12 | #include "AliMultiplicity.h" | |
a148e064 | 13 | #include "AliESDUtils.h" |
14 | #include "AliCentrality.h" | |
15 | ||
16 | // VZERO includes | |
17 | #include "AliESDVZERO.h" | |
a148e064 | 18 | |
19 | ClassImp(AliAnaVZEROPbPb) | |
20 | ||
a148e064 | 21 | AliAnaVZEROPbPb::AliAnaVZEROPbPb() |
1c8bbd7f | 22 | : AliAnalysisTaskSE(), fESD(0), fEsdV0(0), fOutputList(0), fNClasses(0), fClassesNames(0), |
a148e064 | 23 | fNFlags(0), |
24 | fhAdcPMTNoTime(0), | |
25 | fhAdcPMTWithTime(0), | |
26 | fhTimePMT(0), | |
27 | fhWidthPMT(0), | |
28 | fhTimeCorr(0), | |
29 | fhPmtMult(0), | |
30 | fhV0ampl(0), | |
31 | fhEvents(0), | |
32 | fhVtxXYBB(0), | |
33 | fhVtxZBB(0), | |
34 | fhVtxXYBGA(0), | |
35 | fhVtxZBGA(0), | |
36 | fhVtxXYBGC(0), | |
37 | fhVtxZBGC(0), | |
38 | fhL2Triggers(0), | |
39 | fhOnlineCharge(0), | |
40 | fhRecoMult(0), | |
1c8bbd7f | 41 | fhRecoMultPMT(0), |
a148e064 | 42 | fhV0vsSPDCentrality(0), |
43 | fhTriggerBits(0), | |
44 | fhTotRecoMult(0), | |
7b0ae030 | 45 | fhCentrality(0), |
46 | fhEqualizedMult(0), | |
47 | fhEqualizedMultSum(0), | |
aea8bf4d | 48 | fNBinTotMult(100), |
49 | fTotMultMax(30000), | |
50 | fNBinMult(100), | |
51 | fV0AMultMax(20000), | |
52 | fV0CMultMax(30000), | |
53 | fNBinOnlineCharge(100), | |
54 | fV0AOnlineChargeMax(20000), | |
55 | fV0COnlineChargeMax(30000), | |
a6d6c8ca | 56 | fNBinEquaMult(400), |
57 | fEquaMultMax(1000), | |
aea8bf4d | 58 | fNBinSumsEqMult(100), |
a6d6c8ca | 59 | fV0AEqMultMax(4000.), |
60 | fV0CEqMultMax(4000.), | |
61 | fZvtxCut(10.) | |
aea8bf4d | 62 | |
a148e064 | 63 | { |
64 | // Constructor | |
6a9e696e | 65 | // Init arrays |
a148e064 | 66 | for(Int_t i = 0; i < 2; ++i) { |
67 | fhAdcNoTime[i] = fhAdcWithTime[i] = fhWidth[i] = fhTime[i] = NULL; | |
68 | fhAdcTime[i] = fhAdcWidth[i] = NULL; | |
69 | } | |
70 | ||
a148e064 | 71 | } |
72 | ||
73 | //________________________________________________________________________ | |
74 | AliAnaVZEROPbPb::AliAnaVZEROPbPb(const char *name) | |
75 | : AliAnalysisTaskSE(name), fESD(0), fEsdV0(0), fOutputList(0),fNClasses(0),fClassesNames(0), | |
76 | fNFlags(0), | |
77 | fhAdcPMTNoTime(0), | |
78 | fhAdcPMTWithTime(0), | |
79 | fhTimePMT(0), | |
80 | fhWidthPMT(0), | |
81 | fhTimeCorr(0), | |
82 | fhPmtMult(0), | |
83 | fhV0ampl(0), | |
84 | fhEvents(0), | |
85 | fhVtxXYBB(0), | |
86 | fhVtxZBB(0), | |
87 | fhVtxXYBGA(0), | |
88 | fhVtxZBGA(0), | |
89 | fhVtxXYBGC(0), | |
90 | fhVtxZBGC(0), | |
91 | fhL2Triggers(0), | |
92 | fhOnlineCharge(0), | |
93 | fhRecoMult(0), | |
1c8bbd7f | 94 | fhRecoMultPMT(0), |
a148e064 | 95 | fhV0vsSPDCentrality(0), |
96 | fhTriggerBits(0), | |
97 | fhTotRecoMult(0), | |
7b0ae030 | 98 | fhCentrality(0), |
99 | fhEqualizedMult(0), | |
100 | fhEqualizedMultSum(0), | |
aea8bf4d | 101 | fNBinTotMult(100), |
102 | fTotMultMax(30000), | |
103 | fNBinMult(100), | |
104 | fV0AMultMax(20000), | |
105 | fV0CMultMax(30000), | |
106 | fNBinOnlineCharge(100), | |
107 | fV0AOnlineChargeMax(20000), | |
108 | fV0COnlineChargeMax(30000), | |
c5c72a22 | 109 | fNBinEquaMult(400), |
110 | fEquaMultMax(1000), | |
aea8bf4d | 111 | fNBinSumsEqMult(100), |
c5c72a22 | 112 | fV0AEqMultMax(4000.), |
a6d6c8ca | 113 | fV0CEqMultMax(4000.), |
114 | fZvtxCut(10.) | |
a148e064 | 115 | { |
116 | // Constructor | |
6a9e696e | 117 | // Init arrays |
a148e064 | 118 | for(Int_t i = 0; i < 2; ++i) { |
119 | fhAdcNoTime[i] = fhAdcWithTime[i] = fhWidth[i] = fhTime[i] = NULL; | |
120 | fhAdcTime[i] = fhAdcWidth[i] = NULL; | |
121 | } | |
122 | // Define input and output slots here | |
123 | // Input slot #0 works with a TChain | |
124 | DefineInput(0, TChain::Class()); | |
125 | // Output slot #0 id reserved by the base class for AOD | |
126 | // Output slot #1 writes into a TH1 container | |
127 | DefineOutput(1, TList::Class()); | |
128 | } | |
129 | //________________________________________________________________________ | |
130 | void AliAnaVZEROPbPb::SetClassesNames(const Char_t * nameList){ | |
6a9e696e | 131 | // Initialize the class names |
132 | // which are used in the trigger split | |
a148e064 | 133 | TString names("AllClasses,"); |
134 | names += nameList; | |
135 | fClassesNames = names.Tokenize(","); | |
136 | fNClasses = fClassesNames->GetEntriesFast(); | |
137 | } | |
138 | //________________________________________________________________________ | |
139 | TH1F * AliAnaVZEROPbPb::CreateHisto1D(const char* name, const char* title,Int_t nBins, | |
140 | Double_t xMin, Double_t xMax, | |
141 | const char* xLabel, const char* yLabel) | |
142 | { | |
143 | // create a histogram | |
6a9e696e | 144 | // and set the axis labels and the style |
a148e064 | 145 | TH1F* result = new TH1F(name, title, nBins, xMin, xMax); |
146 | result->SetOption("hist"); | |
147 | if (xLabel) result->GetXaxis()->SetTitle(xLabel); | |
148 | if (yLabel) result->GetYaxis()->SetTitle(yLabel); | |
149 | result->SetMarkerStyle(kFullCircle); | |
150 | return result; | |
151 | } | |
152 | ||
153 | //________________________________________________________________________ | |
154 | TH2F * AliAnaVZEROPbPb::CreateHisto2D(const char* name, const char* title,Int_t nBinsX, | |
155 | Double_t xMin, Double_t xMax, | |
156 | Int_t nBinsY, | |
157 | Double_t yMin, Double_t yMax, | |
158 | const char* xLabel, const char* yLabel) | |
159 | { | |
160 | // create a histogram | |
6a9e696e | 161 | // and set the axis labels and the style |
a148e064 | 162 | TH2F* result = new TH2F(name, title, nBinsX, xMin, xMax, nBinsY, yMin, yMax); |
163 | if (xLabel) result->GetXaxis()->SetTitle(xLabel); | |
164 | if (yLabel) result->GetYaxis()->SetTitle(yLabel); | |
165 | return result; | |
166 | } | |
167 | ||
168 | ||
169 | //________________________________________________________________________ | |
170 | void AliAnaVZEROPbPb::UserCreateOutputObjects() | |
171 | { | |
172 | // Create histograms | |
173 | // Called once | |
174 | if(fNClasses==0) { | |
175 | AliFatal("No Classes Defined"); | |
176 | return; | |
177 | } | |
178 | ||
179 | fOutputList = new TList(); | |
180 | fOutputList->SetOwner(kTRUE); | |
181 | ||
182 | ||
7b0ae030 | 183 | CreateHistosPerL2Trigger(); |
a148e064 | 184 | CreateQAHistos(); |
a148e064 | 185 | |
186 | PostData(1, fOutputList); | |
187 | } | |
188 | //________________________________________________________________________ | |
189 | void AliAnaVZEROPbPb::Init() | |
190 | { | |
f55faedc | 191 | // Nothing here |
6a9e696e | 192 | // ... |
a148e064 | 193 | } |
194 | ||
195 | //________________________________________________________________________ | |
196 | void AliAnaVZEROPbPb::UserExec(Option_t *) | |
197 | { | |
198 | // Main loop | |
199 | // Called for each event | |
200 | ||
201 | fESD = dynamic_cast<AliESDEvent*>(InputEvent()); | |
202 | if (!fESD) { | |
203 | printf("ERROR: fESD not available\n"); | |
204 | return; | |
205 | } | |
206 | ||
207 | fEsdV0 = fESD->GetVZEROData(); | |
208 | if (!fEsdV0) { | |
209 | Printf("ERROR: esd V0 not available"); | |
210 | return; | |
211 | } | |
212 | ||
213 | FillQAHistos(); | |
214 | ||
a6d6c8ca | 215 | Bool_t isSelected = kFALSE; |
216 | ||
217 | const AliESDVertex *vtx = fESD->GetPrimaryVertexSPD(); | |
218 | ||
219 | if ((vtx != NULL) && (vtx->GetStatus()) && (TMath::Abs(vtx->GetZv())<fZvtxCut) && (fEsdV0->GetV0ADecision()==1) && (fEsdV0->GetV0CDecision()==1)){ | |
220 | isSelected = kTRUE; | |
221 | } | |
222 | ||
44ca78a6 | 223 | if (isSelected) FillPerL2TriggerHistos(); |
a148e064 | 224 | |
225 | ||
226 | ||
227 | PostData(1, fOutputList); | |
228 | } | |
229 | //________________________________________________________________________ | |
230 | void AliAnaVZEROPbPb::CreateHistosPerL2Trigger(){ | |
6a9e696e | 231 | // Create the histograms |
232 | // for all the required L2 trigger classes | |
a148e064 | 233 | fhOnlineCharge= new TH2F*[fNClasses]; |
234 | fhCentrality= new TH1F*[fNClasses]; | |
235 | fhV0vsSPDCentrality= new TH2F*[fNClasses]; | |
236 | fhRecoMult= new TH2F*[fNClasses]; | |
1c8bbd7f | 237 | fhRecoMultPMT= new TH2F*[fNClasses]; |
a148e064 | 238 | fhTotRecoMult= new TH1F*[fNClasses]; |
239 | fhTriggerBits= new TH1F*[fNClasses]; | |
7b0ae030 | 240 | fhEqualizedMult= new TH2F*[fNClasses]; |
241 | fhEqualizedMultSum = new TH2F*[fNClasses]; | |
242 | ||
a148e064 | 243 | fhL2Triggers = CreateHisto1D("hL2Triggers","L2 Triggers",fNClasses,0,fNClasses); |
244 | fOutputList->Add(fhL2Triggers); | |
7b0ae030 | 245 | |
a148e064 | 246 | TIter iter(fClassesNames); |
247 | TObjString* name; | |
248 | Int_t iClass =0; | |
249 | while((name = (TObjString*) iter.Next())){ | |
250 | fhL2Triggers->GetXaxis()->SetBinLabel(iClass+1,name->String().Data()); | |
251 | ||
aea8bf4d | 252 | fhOnlineCharge[iClass] = CreateHisto2D(Form("hOnlineCharge_%s",name->String().Data()),Form("Online Charge for %s",name->String().Data()),fNBinOnlineCharge,0.,fV0AOnlineChargeMax,fNBinOnlineCharge,0.,fV0COnlineChargeMax,"V0A","V0C"); |
a148e064 | 253 | fOutputList->Add(fhOnlineCharge[iClass]); |
254 | ||
255 | fhCentrality[iClass] = CreateHisto1D(Form("hV0Centrality_%s",name->String().Data()),Form("V0 centrality for %s",name->String().Data()),100,0.,100.); | |
256 | fOutputList->Add(fhCentrality[iClass]); | |
257 | ||
258 | fhV0vsSPDCentrality[iClass] = CreateHisto2D(Form("hV0vsSPDCentrality_%s",name->String().Data()),Form("Centrality for %s",name->String().Data()),100,0.,100.,100,0.,100,"SPD Centrality (CL1)","V0 Centrality (V0M)"); | |
259 | fOutputList->Add(fhV0vsSPDCentrality[iClass]); | |
260 | ||
aea8bf4d | 261 | fhRecoMult[iClass] = CreateHisto2D(Form("hRecoMult_%s",name->String().Data()),Form("Reco Multiplicity for %s",name->String().Data()),fNBinMult,0.,fV0AMultMax,fNBinMult,0.,fV0CMultMax,"V0A Offline Mult","V0C Offline Mult"); |
a148e064 | 262 | fOutputList->Add(fhRecoMult[iClass]); |
263 | ||
1c8bbd7f | 264 | fhRecoMultPMT[iClass] = CreateHisto2D(Form("hRecoMultPMT_%s",name->String().Data()),Form("Reco Multiplicity per PMT for %s",name->String().Data()),64,-0.5,63.5,200,0.,2000.,"PMT channel","Offline Mult"); |
265 | fOutputList->Add(fhRecoMultPMT[iClass]); | |
266 | ||
aea8bf4d | 267 | fhTotRecoMult[iClass] = CreateHisto1D(Form("hTotRecoMult_%s",name->String().Data()),Form("Total Reco Multiplicity for %s",name->String().Data()),fNBinTotMult,0.,fTotMultMax,"V0A + V0C Offline Mult"); |
a148e064 | 268 | fOutputList->Add(fhTotRecoMult[iClass]); |
269 | ||
270 | fhTriggerBits[iClass] = CreateHisto1D(Form("hTriggerBits_%s",name->String().Data()),Form("Trigger Bits for %s",name->String().Data()),16,-0.5,15.5); | |
271 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(1,"BBA_AND_BBC"); | |
272 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(2,"BBA_OR_BBC"); | |
273 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(3,"BGA_AND_BBC"); | |
274 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(4,"BGA"); | |
275 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(5,"BBA_AND_BGC"); | |
276 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(6,"BGC"); | |
277 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(7,"CTA1_AND_CTC1"); | |
278 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(8,"CTA1_OR_CTC1"); | |
279 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(9,"CTA2_AND_CTC2"); | |
f55faedc | 280 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(10,"CTA2_OR_CTC2"); |
a148e064 | 281 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(11,"MTA_AND_MTC"); |
282 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(12,"MTA_OR_MTC"); | |
283 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(13,"BBA"); | |
284 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(14,"BBC"); | |
285 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(15,"BGA_OR_BGC"); | |
286 | fhTriggerBits[iClass]->GetXaxis()->SetBinLabel(16,"All True BG"); | |
7b0ae030 | 287 | fOutputList->Add(fhTriggerBits[iClass]); |
288 | ||
aea8bf4d | 289 | fhEqualizedMult[iClass] = CreateHisto2D(Form("hEqualizedMult_%s",name->String().Data()),Form("Equalized Multiplicity for %s",name->String().Data()),64,-0.5,63.5,fNBinEquaMult,0.,fEquaMultMax,"PMT channel","Equalized Multiplicity"); |
7b0ae030 | 290 | fOutputList->Add(fhEqualizedMult[iClass]); |
291 | ||
aea8bf4d | 292 | fhEqualizedMultSum[iClass] = CreateHisto2D(Form("hEqualizedMultSum_%s",name->String().Data()),Form("Summed Equalized Multiplicity for %s",name->String().Data()),fNBinSumsEqMult,0.,fV0AEqMultMax,fNBinSumsEqMult,0.,fV0CEqMultMax,"V0A","V0C"); |
7b0ae030 | 293 | fOutputList->Add(fhEqualizedMultSum[iClass]); |
a148e064 | 294 | |
7b0ae030 | 295 | |
a148e064 | 296 | iClass++; |
297 | } | |
298 | ||
299 | } | |
300 | //________________________________________________________________________ | |
301 | void AliAnaVZEROPbPb::CreateQAHistos(){ | |
6a9e696e | 302 | // Create the main |
303 | // QA histos | |
a148e064 | 304 | fNFlags = CreateHisto2D("hNFlags","BB Flags",33,-0.5,32.5,33,-0.5,32.5,"V0A","V0C"); |
305 | fOutputList->Add(fNFlags); | |
306 | ||
307 | for(int iSide = 0; iSide < 2; ++iSide){ | |
308 | TString side; | |
309 | if(iSide) side = "V0A"; | |
310 | else side = "V0C"; | |
311 | ||
312 | fhAdcNoTime[iSide] = CreateHisto1D(Form("hAdcNoTime%s",side.Data()),Form("ADC (no Leading Time) %s",side.Data()),200,0,200,"ADC charge","Entries"); | |
313 | fOutputList->Add(fhAdcNoTime[iSide]); | |
314 | fhAdcWithTime[iSide] = CreateHisto1D(Form("hAdcWithTime%s",side.Data()),Form("ADC (with Leading Time) %s",side.Data()),200,0,200,"ADC charge","Entries"); | |
315 | fOutputList->Add(fhAdcWithTime[iSide]); | |
1c8bbd7f | 316 | fhTime[iSide] = CreateHisto1D(Form("htimepmt%s",side.Data()),Form("Time measured by TDC %s",side.Data()),1000,-100,100,"Leading time (ns)","Entries"); |
a148e064 | 317 | fOutputList->Add(fhTime[iSide]); |
f55faedc | 318 | fhWidth[iSide] = CreateHisto1D(Form("hwidth%s",side.Data()),Form("Signal width measured by TDC %s",side.Data()),128,0,800,"Signal width (ns)","Entries"); |
a148e064 | 319 | fOutputList->Add(fhWidth[iSide]); |
f55faedc | 320 | fhAdcWidth[iSide] = CreateHisto2D(Form("hadcwidth%s",side.Data()),Form("Time width vs ADC %s",side.Data()),200,0,1200,128,0,800,"ADC charge","Width (ns)"); |
a148e064 | 321 | fOutputList->Add(fhAdcWidth[iSide]); |
1c8bbd7f | 322 | fhAdcTime[iSide] = CreateHisto2D(Form("hAdcTime%s",side.Data()),Form("ADC vs Time %s",side.Data()),200,-100,100,200,0,200,"Time (ns)","ADC charge"); |
a148e064 | 323 | fOutputList->Add(fhAdcTime[iSide]); |
324 | } | |
325 | ||
326 | fhAdcPMTNoTime = CreateHisto2D("hadcpmtnotime","ADC vs PMT index (no leading time)",64,-0.5,63.5,200,0,200,"PMT index","ADC charge"); | |
1c8bbd7f | 327 | fhAdcPMTWithTime = CreateHisto2D("hadcpmtwithtime","ADC vs PMT index (with leading time)",64,-0.5,63.5,200,0,2000,"PMT index","ADC charge"); |
a148e064 | 328 | |
1c8bbd7f | 329 | fhTimePMT = CreateHisto2D("htimepmt","Time measured by TDC vs PMT index",64,-0.5,63.5,200,-50,50,"PMT Index","Leading time (ns)"); |
f55faedc | 330 | fhWidthPMT = CreateHisto2D("hwidthpmt","Time width vs PMT index",64,-0.5,63.5,128,0,800,"PMT Index","Signal width (ns)"); |
a148e064 | 331 | |
1c8bbd7f | 332 | fhTimeCorr = CreateHisto2D("htimecorr","Average time C side vs. A side",200,-50,50,200,-50,50,"Time V0A (ns)","Time V0C (ns"); |
a148e064 | 333 | |
334 | fhV0ampl = CreateHisto1D("hV0ampl","V0 multiplicity in single channel (all V0 channels)",500,-0.5,499.5); | |
335 | ||
336 | fhEvents = CreateHisto2D("hTriggerDecision","Trigger Decision",3,-0.5,2.5,3,-0.5,2.5,"V0A Decision","V0C Decision"); | |
337 | fhEvents->GetXaxis()->SetBinLabel(1,"Fake"); | |
338 | fhEvents->GetXaxis()->SetBinLabel(2,"BB"); | |
339 | fhEvents->GetXaxis()->SetBinLabel(3,"BG"); | |
340 | fhEvents->GetYaxis()->SetBinLabel(1,"Fake"); | |
341 | fhEvents->GetYaxis()->SetBinLabel(2,"BB"); | |
342 | fhEvents->GetYaxis()->SetBinLabel(3,"BG"); | |
343 | ||
344 | fhVtxXYBB = CreateHisto2D("fhVtxXYBB","XY SPD vertex (bb)",200,-2,2,200,-2,2); | |
345 | fhVtxZBB = CreateHisto1D("fhVtxZBB","Z SPD vertex (bb)",400,-50,50); | |
346 | fhVtxXYBGA = CreateHisto2D("fhVtxXYBGA","XY SPD vertex (bga)",200,-2,2,200,-2,2); | |
347 | fhVtxZBGA = CreateHisto1D("fhVtxZBGA","Z SPD vertex (bga)",400,-50,50); | |
348 | fhVtxXYBGC = CreateHisto2D("fhVtxXYBGC","XY SPD vertex (bgc)",200,-2,2,200,-2,2); | |
349 | fhVtxZBGC = CreateHisto1D("fhVtxZBGC","Z SPD vertex (bgc)",400,-50,50); | |
350 | ||
351 | fhPmtMult = CreateHisto2D("hV0CellMult","Number of fired PMTs (V0C vs V0A)",33,-0.5,32.5,33,-0.5,32.5,"# Cell (V0A)","# Cell (V0C)"); | |
352 | fOutputList->Add(fhPmtMult); | |
353 | ||
354 | ||
355 | fOutputList->Add(fhAdcPMTNoTime); | |
356 | fOutputList->Add(fhAdcPMTWithTime); | |
357 | ||
358 | fOutputList->Add(fhTimePMT); | |
359 | fOutputList->Add(fhWidthPMT); | |
360 | ||
361 | fOutputList->Add(fhTimeCorr); | |
362 | fOutputList->Add(fhV0ampl); | |
363 | ||
364 | fOutputList->Add(fhEvents); | |
365 | ||
366 | fOutputList->Add(fhVtxXYBB); | |
367 | fOutputList->Add(fhVtxZBB); | |
368 | fOutputList->Add(fhVtxXYBGA); | |
369 | fOutputList->Add(fhVtxZBGA); | |
370 | fOutputList->Add(fhVtxXYBGC); | |
371 | fOutputList->Add(fhVtxZBGC); | |
372 | ||
373 | } | |
374 | //________________________________________________________________________ | |
a148e064 | 375 | void AliAnaVZEROPbPb::FillPerL2TriggerHistos(){ |
6a9e696e | 376 | // Fill the histos which are split |
377 | // by L2 trigger class | |
a148e064 | 378 | TString trigStr(fESD->GetFiredTriggerClasses()); |
379 | ||
a148e064 | 380 | TIter iter(fClassesNames); |
381 | TObjString* name; | |
382 | Int_t iClass =0; | |
7b0ae030 | 383 | |
aea8bf4d | 384 | |
385 | TObjArray * tokens = trigStr.Tokenize(" "); | |
386 | Int_t ntokens = tokens->GetEntriesFast(); | |
387 | ||
a148e064 | 388 | while((name = (TObjString*) iter.Next())){ |
389 | ||
aea8bf4d | 390 | Bool_t goodTrig = kFALSE; |
391 | if(iClass>0){ | |
392 | for (Int_t itoken = 0; itoken < ntokens; ++itoken) { | |
393 | if (!((((TObjString*)tokens->At(itoken))->String()).Contains("-B-"))) continue; | |
394 | if ((((TObjString*)tokens->At(itoken))->String()).BeginsWith(name->String().Data())) { | |
395 | goodTrig = kTRUE; | |
396 | break; | |
397 | } | |
398 | } | |
399 | } else goodTrig = kTRUE; | |
400 | ||
401 | if (!goodTrig) { | |
402 | iClass++; | |
403 | continue; | |
404 | } | |
405 | // if (!trigStr.Contains(name->String().Data())) continue; | |
a148e064 | 406 | |
407 | fhOnlineCharge[iClass]->Fill(fEsdV0->GetTriggerChargeA(),fEsdV0->GetTriggerChargeC()); | |
408 | ||
409 | fhL2Triggers->Fill(iClass); | |
410 | ||
411 | fhRecoMult[iClass]->Fill(fEsdV0->GetMTotV0A(),fEsdV0->GetMTotV0C()); | |
412 | fhTotRecoMult[iClass]->Fill(fEsdV0->GetMTotV0A()+fEsdV0->GetMTotV0C()); | |
413 | ||
414 | for(int iTrig = 0; iTrig < 16; ++iTrig){ | |
415 | if(fEsdV0->GetTriggerBits() & (1<<iTrig)) fhTriggerBits[iClass]->Fill(iTrig); | |
416 | } | |
417 | ||
418 | AliCentrality *centrality = fESD->GetCentrality(); | |
419 | Float_t percentile = centrality->GetCentralityPercentile("V0M"); | |
420 | Float_t spdPercentile = centrality->GetCentralityPercentile("CL1"); | |
1916bd64 | 421 | // if (spdPercentile < 0) spdPercentile = 0; |
422 | // if (percentile < 0) percentile = 0; | |
a148e064 | 423 | fhCentrality[iClass]->Fill(percentile); |
424 | fhV0vsSPDCentrality[iClass]->Fill(spdPercentile,percentile); | |
7b0ae030 | 425 | |
426 | Float_t sumEqMult[2] = {0.,0.}; | |
427 | for(int iCh = 0; iCh < 64; ++iCh){ | |
aea8bf4d | 428 | if(fEsdV0->GetTime(iCh) < -1024.+ 1e-6) continue; |
1c8bbd7f | 429 | fhRecoMultPMT[iClass]->Fill(iCh,fEsdV0->GetMultiplicity(iCh)); |
7b0ae030 | 430 | Int_t side = iCh / 32 ; |
431 | sumEqMult[side] += fESD->GetVZEROEqMultiplicity(iCh); | |
432 | fhEqualizedMult[iClass]->Fill(iCh,fESD->GetVZEROEqMultiplicity(iCh)); | |
433 | } | |
434 | fhEqualizedMultSum[iClass]->Fill(sumEqMult[1],sumEqMult[0]); | |
435 | ||
a148e064 | 436 | iClass++; |
437 | } | |
aea8bf4d | 438 | delete tokens; |
439 | ||
a148e064 | 440 | } |
441 | //________________________________________________________________________ | |
442 | void AliAnaVZEROPbPb::FillQAHistos(){ | |
6a9e696e | 443 | // Fill the main QA histos |
a148e064 | 444 | // Count V0 flags |
445 | Int_t nV0A = 0, nV0C = 0; | |
446 | for(Int_t i = 0; i < 32; ++i) { | |
447 | if (fEsdV0->GetBBFlag(i)) nV0C++; | |
448 | if (fEsdV0->GetBBFlag(i+32)) nV0A++; | |
449 | } | |
450 | fNFlags->Fill((Float_t)nV0A,(Float_t)nV0C); | |
451 | ||
452 | for (Int_t i=0; i<64; ++i) { | |
453 | Int_t side = i/32; | |
454 | if (fEsdV0->GetTime(i) < 1e-6) { | |
455 | fhAdcNoTime[side]->Fill(fEsdV0->GetAdc(i)); | |
456 | fhAdcPMTNoTime->Fill(i,fEsdV0->GetAdc(i)); | |
457 | } else { | |
458 | fhAdcWithTime[side]->Fill(fEsdV0->GetAdc(i)); | |
459 | fhAdcPMTWithTime->Fill(i,fEsdV0->GetAdc(i)); | |
460 | } | |
461 | ||
462 | fhTime[side]->Fill(fEsdV0->GetTime(i)); | |
463 | fhWidth[side]->Fill(fEsdV0->GetWidth(i)); | |
464 | fhAdcWidth[side]->Fill(fEsdV0->GetAdc(i),fEsdV0->GetWidth(i)); | |
465 | fhAdcTime[side]->Fill(fEsdV0->GetTime(i),fEsdV0->GetAdc(i)); | |
466 | ||
467 | fhTimePMT->Fill(i,fEsdV0->GetTime(i)); | |
468 | fhWidthPMT->Fill(i,fEsdV0->GetWidth(i)); | |
469 | ||
470 | } | |
471 | ||
472 | fhTimeCorr->Fill(fEsdV0->GetV0ATime(),fEsdV0->GetV0CTime()); | |
473 | ||
474 | AliESDVZERO::Decision flaga = fEsdV0->GetV0ADecision(); | |
475 | AliESDVZERO::Decision flagc = fEsdV0->GetV0CDecision(); | |
476 | ||
477 | fhEvents->Fill(flaga,flagc); | |
478 | ||
479 | const AliESDVertex *vtx = fESD->GetPrimaryVertexSPD(); | |
480 | ||
481 | if (flaga <= 1 && flagc <=1) { | |
482 | fhVtxXYBB->Fill(vtx->GetXv(),vtx->GetYv()); | |
483 | fhVtxZBB->Fill(vtx->GetZv()); | |
484 | } | |
485 | else { | |
486 | if (flaga == 2) { | |
487 | fhVtxXYBGA->Fill(vtx->GetXv(),vtx->GetYv()); | |
488 | fhVtxZBGA->Fill(vtx->GetZv()); | |
489 | } | |
490 | if (flagc == 2) { | |
491 | fhVtxXYBGC->Fill(vtx->GetXv(),vtx->GetYv()); | |
492 | fhVtxZBGC->Fill(vtx->GetZv()); | |
493 | } | |
494 | } | |
495 | ||
496 | fhPmtMult->Fill(fEsdV0->GetNbPMV0A(),fEsdV0->GetNbPMV0C()); | |
497 | for(Int_t i = 0; i < 64; i++) { | |
498 | fhV0ampl->Fill(fEsdV0->GetMultiplicity(i)); | |
499 | } | |
500 | ||
501 | } | |
502 | //________________________________________________________________________ | |
503 | void AliAnaVZEROPbPb::Terminate(Option_t *) | |
504 | { | |
6a9e696e | 505 | // Check if the output list is there |
a148e064 | 506 | // Called once at the end of the query |
507 | ||
508 | fOutputList = dynamic_cast<TList*> (GetOutputData(1)); | |
509 | if (!fOutputList) { | |
510 | printf("ERROR: Output list not available\n"); | |
511 | return; | |
512 | } | |
7b0ae030 | 513 | |
a148e064 | 514 | } |
aea8bf4d | 515 | //________________________________________________________________________ |
aea8bf4d | 516 | void AliAnaVZEROPbPb::SetOnlineChargeRange(Int_t nbins, Float_t maxA, Float_t maxC){ |
6a9e696e | 517 | // Set Trigger charge |
518 | // range used for histogramming | |
aea8bf4d | 519 | fNBinOnlineCharge = nbins; |
520 | fV0AOnlineChargeMax = maxA; | |
521 | fV0COnlineChargeMax = maxC; | |
522 | } | |
523 | //________________________________________________________________________ | |
524 | void AliAnaVZEROPbPb::SetTotalMultiplicityRange(Int_t nbins, Float_t max){ | |
6a9e696e | 525 | // Set Multiplicity |
526 | // range used for histogramming | |
aea8bf4d | 527 | fNBinTotMult = nbins; |
528 | fTotMultMax = max; | |
529 | } | |
530 | //________________________________________________________________________ | |
531 | void AliAnaVZEROPbPb::SetMultiplicityRange(Int_t nbins, Float_t maxA, Float_t maxC){ | |
6a9e696e | 532 | // Set Multiplicity |
533 | // range used for histogramming | |
aea8bf4d | 534 | fNBinMult = nbins; |
535 | fV0AMultMax = maxA; | |
536 | fV0CMultMax = maxC; | |
537 | } | |
538 | //________________________________________________________________________ | |
539 | void AliAnaVZEROPbPb::SetEquaMultRange(Int_t nbins, Float_t max){ | |
6a9e696e | 540 | // Set Equalized multiplicity |
541 | // range used for histogramming | |
aea8bf4d | 542 | fNBinEquaMult = nbins; |
543 | fEquaMultMax = max; | |
544 | } | |
545 | //________________________________________________________________________ | |
546 | void AliAnaVZEROPbPb::SetSumEquaMultRange(Int_t nbins, Float_t maxA, Float_t maxC){ | |
6a9e696e | 547 | // Set Equalized multiplicity |
548 | // range used for histogramming | |
aea8bf4d | 549 | fNBinSumsEqMult = nbins; |
550 | fV0AEqMultMax = maxA; | |
551 | fV0CEqMultMax = maxC; | |
552 | } | |
553 |