]>
Commit | Line | Data |
---|---|---|
2da09763 | 1 | // |
2 | // Emcal base analysis task. | |
3 | // | |
9239b066 | 4 | // Author: S.Aiola, M. Verweij |
219799d0 | 5 | |
2da09763 | 6 | #include "AliAnalysisTaskEmcal.h" |
7 | ||
2da09763 | 8 | #include <TClonesArray.h> |
9 | #include <TList.h> | |
09ca054b | 10 | #include <TObject.h> |
159802e2 | 11 | #include <TH1F.h> |
ed0243d8 | 12 | #include <TProfile.h> |
13 | #include <TSystem.h> | |
14 | #include <TFile.h> | |
15 | #include <TChain.h> | |
16 | #include <TKey.h> | |
2da09763 | 17 | |
d29ed625 | 18 | #include "AliAODEvent.h" |
2da09763 | 19 | #include "AliAnalysisManager.h" |
20 | #include "AliCentrality.h" | |
09ca054b | 21 | #include "AliEMCALGeometry.h" |
22 | #include "AliESDEvent.h" | |
09ca054b | 23 | #include "AliEmcalParticle.h" |
d29ed625 | 24 | #include "AliEventplane.h" |
25 | #include "AliInputEventHandler.h" | |
2da09763 | 26 | #include "AliLog.h" |
09ca054b | 27 | #include "AliMCParticle.h" |
28 | #include "AliVCluster.h" | |
29 | #include "AliVEventHandler.h" | |
30 | #include "AliVParticle.h" | |
00c77045 | 31 | #include "AliVCaloTrigger.h" |
ed0243d8 | 32 | #include "AliGenPythiaEventHeader.h" |
33 | #include "AliAODMCHeader.h" | |
34 | #include "AliMCEvent.h" | |
9239b066 | 35 | #include "AliAnalysisUtils.h" |
37a63fdf | 36 | #include "AliEmcalTriggerPatchInfo.h" |
9239b066 | 37 | |
38 | #include "AliParticleContainer.h" | |
39 | #include "AliClusterContainer.h" | |
2da09763 | 40 | |
41 | ClassImp(AliAnalysisTaskEmcal) | |
42 | ||
43 | //________________________________________________________________________ | |
44 | AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() : | |
45 | AliAnalysisTaskSE("AliAnalysisTaskEmcal"), | |
159802e2 | 46 | fForceBeamType(kNA), |
47 | fGeneralHistograms(kFALSE), | |
2da09763 | 48 | fInitialized(kFALSE), |
49 | fCreateHisto(kTRUE), | |
53948904 | 50 | fMainTriggerPatchSet(kFALSE), |
f660c2d6 | 51 | fCaloCellsName(), |
00c77045 | 52 | fCaloTriggersName(), |
37a63fdf | 53 | fCaloTriggerPatchInfoName(), |
2ac8ca4f | 54 | fMinCent(-999), |
55 | fMaxCent(-999), | |
56 | fMinVz(-999), | |
57 | fMaxVz(-999), | |
9239b066 | 58 | fTrackPtCut(0), |
59 | fMinNTrack(0), | |
60 | fUseAliAnaUtils(kFALSE), | |
667f8d76 | 61 | fRejectPileup(kFALSE), |
d6ea3a48 | 62 | fTklVsClusSPDCut(kFALSE), |
9239b066 | 63 | fAliAnalysisUtils(0x0), |
2ac8ca4f | 64 | fOffTrigger(AliVEvent::kAny), |
b4339010 | 65 | fTrigClass(), |
8e49a788 | 66 | fTriggerTypeSel(kND), |
2da09763 | 67 | fNbins(500), |
68 | fMinBinPt(0), | |
69 | fMaxBinPt(250), | |
6c41fc8c | 70 | fMinPtTrackInEmcal(0), |
6f6dc2ba | 71 | fEventPlaneVsEmcal(-1), |
254370e1 | 72 | fMinEventPlane(-1e6), |
73 | fMaxEventPlane(1e6), | |
a52de945 | 74 | fCentEst("V0M"), |
8c0d179d | 75 | fIsEmbedded(kFALSE), |
ed0243d8 | 76 | fIsPythia(kFALSE), |
77 | fSelectPtHardBin(-999), | |
78 | fMinMCLabel(0), | |
79 | fMCLabelShift(0), | |
2130abba | 80 | fNcentBins(4), |
78a69392 | 81 | fNeedEmcalGeom(kTRUE), |
1876c758 | 82 | fIsEsd(kFALSE), |
159802e2 | 83 | fGeom(0), |
2da09763 | 84 | fTracks(0), |
85 | fCaloClusters(0), | |
f660c2d6 | 86 | fCaloCells(0), |
00c77045 | 87 | fCaloTriggers(0), |
37a63fdf | 88 | fTriggerPatchInfo(0), |
2da09763 | 89 | fCent(0), |
90 | fCentBin(-1), | |
3c124212 | 91 | fEPV0(-1.0), |
92 | fEPV0A(-1.0), | |
93 | fEPV0C(-1.0), | |
b4339010 | 94 | fNVertCont(0), |
1f6fff78 | 95 | fBeamType(kNA), |
ed0243d8 | 96 | fPythiaHeader(0), |
97 | fPtHard(0), | |
98 | fPtHardBin(0), | |
99 | fNTrials(0), | |
8c34a1cc | 100 | fXsection(0), |
9239b066 | 101 | fParticleCollArray(), |
102 | fClusterCollArray(), | |
f9a1843e | 103 | fTriggers(0), |
a4e91fed | 104 | fOutput(0), |
219799d0 | 105 | fHistEventCount(0), |
ed0243d8 | 106 | fHistTrialsAfterSel(0), |
107 | fHistEventsAfterSel(0), | |
6da81bde | 108 | fHistXsectionAfterSel(0), |
ed0243d8 | 109 | fHistTrials(0), |
ed0243d8 | 110 | fHistEvents(0), |
6da81bde | 111 | fHistXsection(0), |
ed0243d8 | 112 | fHistPtHard(0), |
a4e91fed | 113 | fHistCentrality(0), |
6f6dc2ba | 114 | fHistZVertex(0), |
8e49a788 | 115 | fHistEventPlane(0), |
116 | fHistEventRejection(0) | |
2da09763 | 117 | { |
118 | // Default constructor. | |
119 | ||
120 | fVertex[0] = 0; | |
121 | fVertex[1] = 0; | |
122 | fVertex[2] = 0; | |
9239b066 | 123 | |
124 | fParticleCollArray.SetOwner(kTRUE); | |
125 | fClusterCollArray.SetOwner(kTRUE); | |
53948904 | 126 | memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * kNType); |
2da09763 | 127 | } |
128 | ||
129 | //________________________________________________________________________ | |
130 | AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) : | |
131 | AliAnalysisTaskSE(name), | |
159802e2 | 132 | fForceBeamType(kNA), |
133 | fGeneralHistograms(kFALSE), | |
2da09763 | 134 | fInitialized(kFALSE), |
135 | fCreateHisto(histo), | |
53948904 | 136 | fMainTriggerPatchSet(kFALSE), |
f660c2d6 | 137 | fCaloCellsName(), |
00c77045 | 138 | fCaloTriggersName(), |
37a63fdf | 139 | fCaloTriggerPatchInfoName(), |
2ac8ca4f | 140 | fMinCent(-999), |
141 | fMaxCent(-999), | |
142 | fMinVz(-999), | |
143 | fMaxVz(-999), | |
9239b066 | 144 | fTrackPtCut(0), |
145 | fMinNTrack(0), | |
146 | fUseAliAnaUtils(kFALSE), | |
667f8d76 | 147 | fRejectPileup(kFALSE), |
d6ea3a48 | 148 | fTklVsClusSPDCut(kFALSE), |
9239b066 | 149 | fAliAnalysisUtils(0x0), |
2ac8ca4f | 150 | fOffTrigger(AliVEvent::kAny), |
b4339010 | 151 | fTrigClass(), |
8e49a788 | 152 | fTriggerTypeSel(kND), |
2da09763 | 153 | fNbins(500), |
154 | fMinBinPt(0), | |
155 | fMaxBinPt(250), | |
6c41fc8c | 156 | fMinPtTrackInEmcal(0), |
6f6dc2ba | 157 | fEventPlaneVsEmcal(-1), |
254370e1 | 158 | fMinEventPlane(-1e6), |
159 | fMaxEventPlane(1e6), | |
a52de945 | 160 | fCentEst("V0M"), |
8c0d179d | 161 | fIsEmbedded(kFALSE), |
ed0243d8 | 162 | fIsPythia(kFALSE), |
163 | fSelectPtHardBin(-999), | |
164 | fMinMCLabel(0), | |
165 | fMCLabelShift(0), | |
2130abba | 166 | fNcentBins(4), |
78a69392 | 167 | fNeedEmcalGeom(kTRUE), |
1876c758 | 168 | fIsEsd(kFALSE), |
159802e2 | 169 | fGeom(0), |
2da09763 | 170 | fTracks(0), |
171 | fCaloClusters(0), | |
f660c2d6 | 172 | fCaloCells(0), |
00c77045 | 173 | fCaloTriggers(0), |
37a63fdf | 174 | fTriggerPatchInfo(0), |
2da09763 | 175 | fCent(0), |
176 | fCentBin(-1), | |
3c124212 | 177 | fEPV0(-1.0), |
178 | fEPV0A(-1.0), | |
179 | fEPV0C(-1.0), | |
b4339010 | 180 | fNVertCont(0), |
1f6fff78 | 181 | fBeamType(kNA), |
ed0243d8 | 182 | fPythiaHeader(0), |
183 | fPtHard(0), | |
184 | fPtHardBin(0), | |
185 | fNTrials(0), | |
8c34a1cc | 186 | fXsection(0), |
9239b066 | 187 | fParticleCollArray(), |
188 | fClusterCollArray(), | |
f9a1843e | 189 | fTriggers(0), |
a4e91fed | 190 | fOutput(0), |
219799d0 | 191 | fHistEventCount(0), |
ed0243d8 | 192 | fHistTrialsAfterSel(0), |
193 | fHistEventsAfterSel(0), | |
6da81bde | 194 | fHistXsectionAfterSel(0), |
ed0243d8 | 195 | fHistTrials(0), |
ed0243d8 | 196 | fHistEvents(0), |
6da81bde | 197 | fHistXsection(0), |
ed0243d8 | 198 | fHistPtHard(0), |
a4e91fed | 199 | fHistCentrality(0), |
6f6dc2ba | 200 | fHistZVertex(0), |
8e49a788 | 201 | fHistEventPlane(0), |
202 | fHistEventRejection(0) | |
2da09763 | 203 | { |
204 | // Standard constructor. | |
205 | ||
206 | fVertex[0] = 0; | |
207 | fVertex[1] = 0; | |
208 | fVertex[2] = 0; | |
209 | ||
9239b066 | 210 | fParticleCollArray.SetOwner(kTRUE); |
211 | fClusterCollArray.SetOwner(kTRUE); | |
53948904 | 212 | memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * kNType); |
9239b066 | 213 | |
2da09763 | 214 | if (fCreateHisto) { |
2da09763 | 215 | DefineOutput(1, TList::Class()); |
216 | } | |
217 | } | |
218 | ||
219 | //________________________________________________________________________ | |
220 | AliAnalysisTaskEmcal::~AliAnalysisTaskEmcal() | |
221 | { | |
222 | // Destructor | |
223 | } | |
224 | ||
9239b066 | 225 | //________________________________________________________________________ |
226 | void AliAnalysisTaskEmcal::SetClusPtCut(Double_t cut, Int_t c) | |
227 | { | |
228 | AliClusterContainer *cont = GetClusterContainer(c); | |
229 | if (cont) cont->SetClusPtCut(cut); | |
230 | else AliError(Form("%s in SetClusPtCut(...): container %d not found",GetName(),c)); | |
231 | } | |
232 | ||
233 | //________________________________________________________________________ | |
234 | void AliAnalysisTaskEmcal::SetClusTimeCut(Double_t min, Double_t max, Int_t c) | |
235 | { | |
236 | AliClusterContainer *cont = GetClusterContainer(c); | |
237 | if (cont) cont->SetClusTimeCut(min,max); | |
238 | else AliError(Form("%s in SetClusTimeCut(...): container %d not found",GetName(),c)); | |
239 | } | |
240 | ||
241 | //________________________________________________________________________ | |
242 | void AliAnalysisTaskEmcal::SetTrackPtCut(Double_t cut, Int_t c) | |
243 | { | |
244 | AliParticleContainer *cont = GetParticleContainer(c); | |
245 | if (cont) cont->SetParticlePtCut(cut); | |
246 | else AliError(Form("%s in SetTrackPtCut(...): container %d not found",GetName(),c)); | |
247 | ||
248 | fTrackPtCut = cut; | |
249 | } | |
250 | ||
251 | //________________________________________________________________________ | |
252 | void AliAnalysisTaskEmcal::SetTrackEtaLimits(Double_t min, Double_t max, Int_t c) | |
253 | { | |
254 | AliParticleContainer *cont = GetParticleContainer(c); | |
255 | if (cont) cont->SetParticleEtaLimits(min,max); | |
256 | else AliError(Form("%s in SetTrackPtCut(...): container %d not found",GetName(),c)); | |
257 | } | |
258 | ||
259 | //________________________________________________________________________ | |
260 | void AliAnalysisTaskEmcal::SetTrackPhiLimits(Double_t min, Double_t max, Int_t c) | |
261 | { | |
262 | AliParticleContainer *cont = GetParticleContainer(c); | |
263 | if (cont) cont->SetParticlePhiLimits(min,max); | |
264 | else AliError(Form("%s in SetTrackPhiLimits(...): container %d not found",GetName(),c)); | |
265 | } | |
266 | ||
159802e2 | 267 | //________________________________________________________________________ |
268 | void AliAnalysisTaskEmcal::UserCreateOutputObjects() | |
269 | { | |
270 | // Create user output. | |
1876c758 | 271 | |
272 | AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); | |
273 | if (mgr) { | |
274 | AliVEventHandler *evhand = mgr->GetInputEventHandler(); | |
275 | if (evhand) { | |
276 | if (evhand->InheritsFrom("AliESDInputHandler")) { | |
277 | fIsEsd = kTRUE; | |
278 | } | |
279 | else { | |
280 | fIsEsd = kFALSE; | |
281 | } | |
282 | } | |
283 | else { | |
284 | AliError("Event handler not found!"); | |
285 | } | |
286 | } | |
287 | else { | |
288 | AliError("Analysis manager not found!"); | |
289 | } | |
290 | ||
159802e2 | 291 | if (!fCreateHisto) |
292 | return; | |
293 | ||
294 | OpenFile(1); | |
295 | fOutput = new TList(); | |
296 | fOutput->SetOwner(); | |
297 | ||
2130abba | 298 | if (fForceBeamType == kpp) |
299 | fNcentBins = 1; | |
300 | ||
159802e2 | 301 | if (!fGeneralHistograms) |
302 | return; | |
303 | ||
ed0243d8 | 304 | if (fIsPythia) { |
305 | fHistTrialsAfterSel = new TH1F("fHistTrialsAfterSel", "fHistTrialsAfterSel", 11, 0, 11); | |
306 | fHistTrialsAfterSel->GetXaxis()->SetTitle("p_{T} hard bin"); | |
307 | fHistTrialsAfterSel->GetYaxis()->SetTitle("trials"); | |
308 | fOutput->Add(fHistTrialsAfterSel); | |
309 | ||
310 | fHistEventsAfterSel = new TH1F("fHistEventsAfterSel", "fHistEventsAfterSel", 11, 0, 11); | |
311 | fHistEventsAfterSel->GetXaxis()->SetTitle("p_{T} hard bin"); | |
312 | fHistEventsAfterSel->GetYaxis()->SetTitle("total events"); | |
313 | fOutput->Add(fHistEventsAfterSel); | |
6da81bde | 314 | |
315 | fHistXsectionAfterSel = new TProfile("fHistXsectionAfterSel", "fHistXsectionAfterSel", 11, 0, 11); | |
316 | fHistXsectionAfterSel->GetXaxis()->SetTitle("p_{T} hard bin"); | |
317 | fHistXsectionAfterSel->GetYaxis()->SetTitle("xsection"); | |
318 | fOutput->Add(fHistXsectionAfterSel); | |
ed0243d8 | 319 | |
320 | fHistTrials = new TH1F("fHistTrials", "fHistTrials", 11, 0, 11); | |
321 | fHistTrials->GetXaxis()->SetTitle("p_{T} hard bin"); | |
322 | fHistTrials->GetYaxis()->SetTitle("trials"); | |
323 | fOutput->Add(fHistTrials); | |
324 | ||
ed0243d8 | 325 | fHistEvents = new TH1F("fHistEvents", "fHistEvents", 11, 0, 11); |
326 | fHistEvents->GetXaxis()->SetTitle("p_{T} hard bin"); | |
327 | fHistEvents->GetYaxis()->SetTitle("total events"); | |
328 | fOutput->Add(fHistEvents); | |
329 | ||
6da81bde | 330 | fHistXsection = new TProfile("fHistXsection", "fHistXsection", 11, 0, 11); |
331 | fHistXsection->GetXaxis()->SetTitle("p_{T} hard bin"); | |
332 | fHistXsection->GetYaxis()->SetTitle("xsection"); | |
333 | fOutput->Add(fHistXsection); | |
334 | ||
ed0243d8 | 335 | const Int_t ptHardLo[11] = { 0, 5,11,21,36,57, 84,117,152,191,234}; |
336 | const Int_t ptHardHi[11] = { 5,11,21,36,57,84,117,152,191,234,1000000}; | |
337 | ||
338 | for (Int_t i = 1; i < 12; i++) { | |
339 | fHistTrialsAfterSel->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1])); | |
340 | fHistEventsAfterSel->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1])); | |
341 | ||
342 | fHistTrials->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1])); | |
343 | fHistXsection->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1])); | |
344 | fHistEvents->GetXaxis()->SetBinLabel(i, Form("%d-%d",ptHardLo[i-1],ptHardHi[i-1])); | |
345 | } | |
346 | ||
347 | fHistPtHard = new TH1F("fHistPtHard", "fHistPtHard", fNbins*2, fMinBinPt, fMaxBinPt*4); | |
348 | fHistPtHard->GetXaxis()->SetTitle("p_{T,hard} (GeV/c)"); | |
349 | fHistPtHard->GetYaxis()->SetTitle("counts"); | |
350 | fOutput->Add(fHistPtHard); | |
351 | } | |
352 | ||
159802e2 | 353 | fHistCentrality = new TH1F("fHistCentrality","Event centrality distribution", 200, 0, 100); |
354 | fHistCentrality->GetXaxis()->SetTitle("Centrality (%)"); | |
355 | fHistCentrality->GetYaxis()->SetTitle("counts"); | |
356 | fOutput->Add(fHistCentrality); | |
357 | ||
358 | fHistZVertex = new TH1F("fHistZVertex","Z vertex position", 60, -30, 30); | |
359 | fHistZVertex->GetXaxis()->SetTitle("z"); | |
360 | fHistZVertex->GetYaxis()->SetTitle("counts"); | |
361 | fOutput->Add(fHistZVertex); | |
362 | ||
6f6dc2ba | 363 | fHistEventPlane = new TH1F("fHistEventPlane","Event plane", 120, -TMath::Pi(), TMath::Pi()); |
364 | fHistEventPlane->GetXaxis()->SetTitle("event plane"); | |
365 | fHistEventPlane->GetYaxis()->SetTitle("counts"); | |
366 | fOutput->Add(fHistEventPlane); | |
367 | ||
219799d0 | 368 | fHistEventRejection = new TH1F("fHistEventRejection","Reasons to reject event",20,0,20); |
369 | fHistEventRejection->GetXaxis()->SetBinLabel(1,"PhysSel"); | |
370 | fHistEventRejection->GetXaxis()->SetBinLabel(2,"trigger"); | |
371 | fHistEventRejection->GetXaxis()->SetBinLabel(3,"trigTypeSel"); | |
372 | fHistEventRejection->GetXaxis()->SetBinLabel(4,"Cent"); | |
373 | fHistEventRejection->GetXaxis()->SetBinLabel(5,"vertex contr."); | |
374 | fHistEventRejection->GetXaxis()->SetBinLabel(6,"Vz"); | |
375 | fHistEventRejection->GetXaxis()->SetBinLabel(7,"trackInEmcal"); | |
376 | fHistEventRejection->GetXaxis()->SetBinLabel(8,"minNTrack"); | |
377 | fHistEventRejection->GetXaxis()->SetBinLabel(9,"VtxSel2013pA"); | |
378 | fHistEventRejection->GetXaxis()->SetBinLabel(10,"PileUp"); | |
379 | fHistEventRejection->GetXaxis()->SetBinLabel(11,"EvtPlane"); | |
380 | fHistEventRejection->GetXaxis()->SetBinLabel(12,"SelPtHardBin"); | |
d6ea3a48 | 381 | fHistEventRejection->GetXaxis()->SetBinLabel(13,"Bkg evt"); |
8e49a788 | 382 | fHistEventRejection->GetYaxis()->SetTitle("counts"); |
383 | fOutput->Add(fHistEventRejection); | |
384 | ||
219799d0 | 385 | fHistEventCount = new TH1F("fHistEventCount","fHistEventCount",2,0,2); |
386 | fHistEventCount->GetXaxis()->SetBinLabel(1,"Accepted"); | |
387 | fHistEventCount->GetXaxis()->SetBinLabel(2,"Rejected"); | |
388 | fHistEventCount->GetYaxis()->SetTitle("counts"); | |
389 | fOutput->Add(fHistEventCount); | |
390 | ||
159802e2 | 391 | PostData(1, fOutput); |
392 | } | |
393 | ||
394 | //________________________________________________________________________ | |
395 | Bool_t AliAnalysisTaskEmcal::FillGeneralHistograms() | |
396 | { | |
ed0243d8 | 397 | if (fIsPythia) { |
6da81bde | 398 | fHistEventsAfterSel->Fill(fPtHardBin, 1); |
399 | fHistTrialsAfterSel->Fill(fPtHardBin, fNTrials); | |
400 | fHistXsectionAfterSel->Fill(fPtHardBin, fXsection); | |
ed0243d8 | 401 | fHistPtHard->Fill(fPtHard); |
402 | } | |
403 | ||
159802e2 | 404 | fHistCentrality->Fill(fCent); |
405 | fHistZVertex->Fill(fVertex[2]); | |
6f6dc2ba | 406 | fHistEventPlane->Fill(fEPV0); |
159802e2 | 407 | |
408 | return kTRUE; | |
409 | } | |
410 | ||
2da09763 | 411 | //________________________________________________________________________ |
629c7ac0 | 412 | void AliAnalysisTaskEmcal::UserExec(Option_t *) |
413 | { | |
414 | // Main loop, called for each event. | |
415 | ||
53948904 | 416 | memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * kNType); |
6c3aa659 | 417 | |
e44e8726 | 418 | if (!fInitialized) |
b3376347 | 419 | ExecOnce(); |
629c7ac0 | 420 | |
e44e8726 | 421 | if (!fInitialized) |
422 | return; | |
423 | ||
629c7ac0 | 424 | if (!RetrieveEventObjects()) |
425 | return; | |
426 | ||
219799d0 | 427 | if (IsEventSelected()) { |
428 | if (fGeneralHistograms) fHistEventCount->Fill("Accepted",1); | |
429 | } | |
430 | else { | |
431 | if (fGeneralHistograms) fHistEventCount->Fill("Rejected",1); | |
2ac8ca4f | 432 | return; |
219799d0 | 433 | } |
2ac8ca4f | 434 | |
159802e2 | 435 | if (fGeneralHistograms && fCreateHisto) { |
436 | if (!FillGeneralHistograms()) | |
437 | return; | |
438 | } | |
439 | ||
629c7ac0 | 440 | if (!Run()) |
441 | return; | |
442 | ||
159802e2 | 443 | if (fCreateHisto) { |
444 | if (!FillHistograms()) | |
445 | return; | |
446 | } | |
629c7ac0 | 447 | |
2ac8ca4f | 448 | if (fCreateHisto && fOutput) { |
629c7ac0 | 449 | // information for this iteration of the UserExec in the container |
450 | PostData(1, fOutput); | |
451 | } | |
452 | } | |
453 | ||
454 | //________________________________________________________________________ | |
a56383df | 455 | Bool_t AliAnalysisTaskEmcal::AcceptCluster(AliVCluster *clus, Int_t c) const |
2da09763 | 456 | { |
629c7ac0 | 457 | // Return true if cluster is accepted. |
458 | ||
459 | if (!clus) | |
460 | return kFALSE; | |
461 | ||
9239b066 | 462 | AliClusterContainer *cont = GetClusterContainer(c); |
157b926a | 463 | if (!cont) { |
9239b066 | 464 | AliError(Form("%s:Container %d not found",GetName(),c)); |
465 | return 0; | |
507f74bc | 466 | } |
629c7ac0 | 467 | |
9239b066 | 468 | return cont->AcceptCluster(clus); |
629c7ac0 | 469 | } |
470 | ||
471 | //________________________________________________________________________ | |
9239b066 | 472 | Bool_t AliAnalysisTaskEmcal::AcceptTrack(AliVParticle *track, Int_t c) const |
629c7ac0 | 473 | { |
159802e2 | 474 | // Return true if track is accepted. |
629c7ac0 | 475 | |
159802e2 | 476 | if (!track) |
629c7ac0 | 477 | return kFALSE; |
478 | ||
9239b066 | 479 | AliParticleContainer *cont = GetParticleContainer(c); |
157b926a | 480 | if (!cont) { |
9239b066 | 481 | AliError(Form("%s:Container %d not found",GetName(),c)); |
482 | return 0; | |
159802e2 | 483 | } |
484 | ||
9239b066 | 485 | return cont->AcceptParticle(track); |
2da09763 | 486 | } |
487 | ||
ed0243d8 | 488 | //________________________________________________________________________ |
489 | Bool_t AliAnalysisTaskEmcal::PythiaInfoFromFile(const char* currFile, Float_t &fXsec, Float_t &fTrials, Int_t &pthard) | |
490 | { | |
491 | // | |
492 | // Get the cross section and the trails either from pyxsec.root or from pysec_hists.root | |
493 | // Get the pt hard bin from the file path | |
494 | // This is to called in Notify and should provide the path to the AOD/ESD file | |
495 | // (Partially copied from AliAnalysisHelperJetTasks) | |
496 | ||
497 | TString file(currFile); | |
498 | fXsec = 0; | |
499 | fTrials = 1; | |
500 | ||
157b926a | 501 | if (file.Contains(".zip#")) { |
ed0243d8 | 502 | Ssiz_t pos1 = file.Index("root_archive",12,0,TString::kExact); |
503 | Ssiz_t pos = file.Index("#",1,pos1,TString::kExact); | |
504 | Ssiz_t pos2 = file.Index(".root",5,TString::kExact); | |
505 | file.Replace(pos+1,pos2-pos1,""); | |
dbd1583b | 506 | } else { |
ed0243d8 | 507 | // not an archive take the basename.... |
508 | file.ReplaceAll(gSystem->BaseName(file.Data()),""); | |
509 | } | |
9239b066 | 510 | AliDebug(1,Form("File name: %s",file.Data())); |
ed0243d8 | 511 | |
512 | // Get the pt hard bin | |
513 | TString strPthard(file); | |
514 | ||
515 | strPthard.Remove(strPthard.Last('/')); | |
516 | strPthard.Remove(strPthard.Last('/')); | |
517 | if (strPthard.Contains("AOD")) strPthard.Remove(strPthard.Last('/')); | |
518 | strPthard.Remove(0,strPthard.Last('/')+1); | |
519 | if (strPthard.IsDec()) | |
520 | pthard = strPthard.Atoi(); | |
521 | else | |
522 | AliWarning(Form("Could not extract file number from path %s", strPthard.Data())); | |
523 | ||
9239b066 | 524 | // problem that we cannot really test the existance of a file in a archive so we have to live with open error message from root |
525 | TFile *fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec.root")); | |
526 | ||
157b926a | 527 | if (!fxsec) { |
ed0243d8 | 528 | // next trial fetch the histgram file |
529 | fxsec = TFile::Open(Form("%s%s",file.Data(),"pyxsec_hists.root")); | |
157b926a | 530 | if (!fxsec) { |
ed0243d8 | 531 | // not a severe condition but inciate that we have no information |
532 | return kFALSE; | |
dbd1583b | 533 | } else { |
ed0243d8 | 534 | // find the tlist we want to be independtent of the name so use the Tkey |
535 | TKey* key = (TKey*)fxsec->GetListOfKeys()->At(0); | |
157b926a | 536 | if (!key) { |
ed0243d8 | 537 | fxsec->Close(); |
538 | return kFALSE; | |
539 | } | |
540 | TList *list = dynamic_cast<TList*>(key->ReadObj()); | |
157b926a | 541 | if (!list) { |
ed0243d8 | 542 | fxsec->Close(); |
543 | return kFALSE; | |
544 | } | |
545 | fXsec = ((TProfile*)list->FindObject("h1Xsec"))->GetBinContent(1); | |
546 | fTrials = ((TH1F*)list->FindObject("h1Trials"))->GetBinContent(1); | |
547 | fxsec->Close(); | |
548 | } | |
dbd1583b | 549 | } else { // no tree pyxsec.root |
ed0243d8 | 550 | TTree *xtree = (TTree*)fxsec->Get("Xsection"); |
157b926a | 551 | if (!xtree) { |
ed0243d8 | 552 | fxsec->Close(); |
553 | return kFALSE; | |
554 | } | |
555 | UInt_t ntrials = 0; | |
556 | Double_t xsection = 0; | |
557 | xtree->SetBranchAddress("xsection",&xsection); | |
558 | xtree->SetBranchAddress("ntrials",&ntrials); | |
559 | xtree->GetEntry(0); | |
560 | fTrials = ntrials; | |
561 | fXsec = xsection; | |
562 | fxsec->Close(); | |
563 | } | |
564 | return kTRUE; | |
565 | } | |
566 | ||
567 | //________________________________________________________________________ | |
568 | Bool_t AliAnalysisTaskEmcal::UserNotify() | |
569 | { | |
b8aeed95 | 570 | // Called when file changes. |
571 | ||
ed0243d8 | 572 | if (!fIsPythia || !fGeneralHistograms || !fCreateHisto) |
573 | return kTRUE; | |
574 | ||
575 | TTree *tree = AliAnalysisManager::GetAnalysisManager()->GetTree(); | |
576 | if (!tree) { | |
577 | AliError(Form("%s - UserNotify: No current tree!",GetName())); | |
578 | return kFALSE; | |
579 | } | |
580 | ||
6da81bde | 581 | Float_t xsection = 0; |
582 | Float_t trials = 0; | |
583 | Int_t pthardbin = 0; | |
ed0243d8 | 584 | |
585 | TFile *curfile = tree->GetCurrentFile(); | |
586 | if (!curfile) { | |
587 | AliError(Form("%s - UserNotify: No current file!",GetName())); | |
588 | return kFALSE; | |
589 | } | |
590 | ||
591 | TChain *chain = dynamic_cast<TChain*>(tree); | |
6da81bde | 592 | if (chain) tree = chain->GetTree(); |
ed0243d8 | 593 | |
594 | Int_t nevents = tree->GetEntriesFast(); | |
595 | ||
6da81bde | 596 | PythiaInfoFromFile(curfile->GetName(), xsection, trials, pthardbin); |
ed0243d8 | 597 | |
413c4f06 | 598 | // TODO: Workaround |
6da81bde | 599 | if ((pthardbin < 0) || (pthardbin > 10)) pthardbin = 0; |
600 | ||
601 | fHistTrials->Fill(pthardbin, trials); | |
602 | fHistXsection->Fill(pthardbin, xsection); | |
603 | fHistEvents->Fill(pthardbin, nevents); | |
ed0243d8 | 604 | |
605 | return kTRUE; | |
606 | } | |
607 | ||
629c7ac0 | 608 | //________________________________________________________________________ |
b3376347 | 609 | void AliAnalysisTaskEmcal::ExecOnce() |
8a28ded1 | 610 | { |
611 | // Init the analysis. | |
2ac8ca4f | 612 | |
b3376347 | 613 | if (!InputEvent()) { |
614 | AliError(Form("%s: Could not retrieve event! Returning!", GetName())); | |
615 | return; | |
616 | } | |
617 | ||
78a69392 | 618 | if (fNeedEmcalGeom) { |
619 | fGeom = AliEMCALGeometry::GetInstance(); | |
620 | if (!fGeom) { | |
621 | AliError(Form("%s: Can not create geometry", GetName())); | |
622 | return; | |
623 | } | |
bb98e333 | 624 | } |
159802e2 | 625 | |
78a69392 | 626 | |
6f6dc2ba | 627 | if (fEventPlaneVsEmcal >= 0) { |
78a69392 | 628 | if (fGeom) { |
629 | Double_t ep = (fGeom->GetArm1PhiMax() + fGeom->GetArm1PhiMin()) / 2 * TMath::DegToRad() + fEventPlaneVsEmcal - TMath::Pi(); | |
630 | fMinEventPlane = ep - TMath::Pi() / 4; | |
631 | fMaxEventPlane = ep + TMath::Pi() / 4; | |
632 | } | |
633 | else { | |
634 | AliWarning("Could not set event plane limits because EMCal geometry was not loaded!"); | |
635 | } | |
6f6dc2ba | 636 | } |
637 | ||
9239b066 | 638 | //Load all requested track branches - each container knows name already |
157b926a | 639 | for (Int_t i =0; i<fParticleCollArray.GetEntriesFast(); i++) { |
9239b066 | 640 | AliParticleContainer *cont = static_cast<AliParticleContainer*>(fParticleCollArray.At(i)); |
641 | cont->SetArray(InputEvent()); | |
642 | } | |
643 | ||
644 | if (fParticleCollArray.GetEntriesFast()>0) { | |
645 | fTracks = GetParticleArray(0); | |
157b926a | 646 | if (!fTracks) { |
9239b066 | 647 | AliError(Form("%s: Could not retrieve first track branch!", GetName())); |
b3376347 | 648 | return; |
b3376347 | 649 | } |
650 | } | |
651 | ||
9239b066 | 652 | //Load all requested cluster branches - each container knows name already |
157b926a | 653 | for (Int_t i =0; i<fClusterCollArray.GetEntriesFast(); i++) { |
9239b066 | 654 | AliClusterContainer *cont = static_cast<AliClusterContainer*>(fClusterCollArray.At(i)); |
655 | cont->SetArray(InputEvent()); | |
656 | } | |
657 | ||
157b926a | 658 | if (fClusterCollArray.GetEntriesFast()>0) { |
9239b066 | 659 | fCaloClusters = GetClusterArray(0); |
157b926a | 660 | if (!fCaloClusters) { |
9239b066 | 661 | AliError(Form("%s: Could not retrieve first cluster branch!", GetName())); |
b3376347 | 662 | return; |
b3376347 | 663 | } |
664 | } | |
159802e2 | 665 | |
f660c2d6 | 666 | if (!fCaloCellsName.IsNull() && !fCaloCells) { |
667 | fCaloCells = dynamic_cast<AliVCaloCells*>(InputEvent()->FindListObject(fCaloCellsName)); | |
668 | if (!fCaloCells) { | |
507f74bc | 669 | AliError(Form("%s: Could not retrieve cells %s!", GetName(), fCaloCellsName.Data())); |
f660c2d6 | 670 | return; |
671 | } | |
672 | } | |
673 | ||
00c77045 | 674 | if (!fCaloTriggersName.IsNull() && !fCaloTriggers) { |
675 | fCaloTriggers = dynamic_cast<AliVCaloTrigger*>(InputEvent()->FindListObject(fCaloTriggersName)); | |
676 | if (!fCaloTriggers) { | |
677 | AliError(Form("%s: Could not retrieve calo triggers %s!", GetName(), fCaloTriggersName.Data())); | |
678 | return; | |
679 | } | |
680 | } | |
681 | ||
37a63fdf | 682 | if (!fCaloTriggerPatchInfoName.IsNull() && !fTriggerPatchInfo) { |
37a63fdf | 683 | fTriggerPatchInfo = GetArrayFromEvent(fCaloTriggerPatchInfoName.Data(),"AliEmcalTriggerPatchInfo"); |
8e49a788 | 684 | if (!fTriggerPatchInfo) { |
685 | AliError(Form("%s: Could not retrieve calo trigger patch info %s!", GetName(), fCaloTriggerPatchInfoName.Data())); | |
686 | return; | |
687 | } | |
37a63fdf | 688 | |
689 | } | |
690 | ||
159802e2 | 691 | fInitialized = kTRUE; |
8a28ded1 | 692 | } |
693 | ||
2ac8ca4f | 694 | //_____________________________________________________ |
695 | AliAnalysisTaskEmcal::BeamType AliAnalysisTaskEmcal::GetBeamType() | |
696 | { | |
697 | // Get beam type : pp-AA-pA | |
698 | // ESDs have it directly, AODs get it from hardcoded run number ranges | |
699 | ||
159802e2 | 700 | if (fForceBeamType != kNA) |
701 | return fForceBeamType; | |
702 | ||
2ac8ca4f | 703 | AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent()); |
704 | if (esd) { | |
705 | const AliESDRun *run = esd->GetESDRun(); | |
706 | TString beamType = run->GetBeamType(); | |
707 | if (beamType == "p-p") | |
708 | return kpp; | |
709 | else if (beamType == "A-A") | |
710 | return kAA; | |
711 | else if (beamType == "p-A") | |
712 | return kpA; | |
713 | else | |
714 | return kNA; | |
715 | } else { | |
716 | Int_t runNumber = InputEvent()->GetRunNumber(); | |
717 | if ((runNumber >= 136851 && runNumber <= 139517) || // LHC10h | |
dbd1583b | 718 | (runNumber >= 166529 && runNumber <= 170593)) { // LHC11h |
2ac8ca4f | 719 | return kAA; |
dbd1583b | 720 | } else if ((runNumber>=188365 && runNumber <= 188366) || // LHC12g |
721 | (runNumber >= 195344 && runNumber <= 196608)) { // LHC13b-f | |
493d6e49 | 722 | return kpA; |
2ac8ca4f | 723 | } else { |
724 | return kpp; | |
725 | } | |
726 | } | |
727 | } | |
728 | ||
f9a1843e | 729 | //________________________________________________________________________ |
219799d0 | 730 | ULong_t AliAnalysisTaskEmcal::GetTriggerList() |
731 | { | |
732 | if (!fTriggerPatchInfo) | |
733 | return 0; | |
734 | ||
735 | //number of patches in event | |
736 | Int_t nPatch = fTriggerPatchInfo->GetEntries(); | |
737 | ||
738 | //loop over patches to define trigger type of event | |
739 | Int_t nG1 = 0; | |
740 | Int_t nG2 = 0; | |
741 | Int_t nJ1 = 0; | |
742 | Int_t nJ2 = 0; | |
743 | AliEmcalTriggerPatchInfo *patch; | |
744 | for (Int_t iPatch = 0; iPatch < nPatch; iPatch++) { | |
745 | patch = (AliEmcalTriggerPatchInfo*)fTriggerPatchInfo->At( iPatch ); | |
746 | if (patch->IsGammaHigh()) nG1++; | |
747 | if (patch->IsGammaLow()) nG2++; | |
748 | if (patch->IsJetHigh()) nJ1++; | |
749 | if (patch->IsJetLow()) nJ2++; | |
750 | } | |
751 | ||
752 | AliDebug(2, "Patch summary: "); | |
753 | AliDebug(2, Form("Number of patches: %d", nPatch)); | |
754 | AliDebug(2, Form("Jet: low[%d], high[%d]" ,nJ2, nJ1)); | |
755 | AliDebug(2, Form("Gamma: low[%d], high[%d]" ,nG2, nG1)); | |
756 | ||
757 | ULong_t triggers(0); | |
758 | if (nG1>0) | |
53948904 | 759 | triggers |= kG1; |
219799d0 | 760 | if (nG2>0) |
53948904 | 761 | triggers |= kG2; |
219799d0 | 762 | if (nJ1>0) |
53948904 | 763 | triggers |= kJ1; |
219799d0 | 764 | if (nJ2>0) |
53948904 | 765 | triggers |= kJ2; |
219799d0 | 766 | return triggers; |
f9a1843e | 767 | } |
8e49a788 | 768 | |
f9a1843e | 769 | //________________________________________________________________________ |
53948904 | 770 | Bool_t AliAnalysisTaskEmcal::HasTriggerType(Int_t trigger) |
219799d0 | 771 | { |
772 | // Check if event has a given trigger type | |
53948904 | 773 | if(trigger & kND){ |
219799d0 | 774 | return fTriggers == 0; |
775 | } | |
53948904 | 776 | return (fTriggers & trigger); |
8e49a788 | 777 | } |
778 | ||
2ac8ca4f | 779 | //________________________________________________________________________ |
d29ed625 | 780 | Bool_t AliAnalysisTaskEmcal::IsEventSelected() |
2ac8ca4f | 781 | { |
782 | // Check if event is selected | |
783 | ||
784 | if (fOffTrigger != AliVEvent::kAny) { | |
d29ed625 | 785 | UInt_t res = 0; |
786 | const AliESDEvent *eev = dynamic_cast<const AliESDEvent*>(InputEvent()); | |
787 | if (eev) { | |
788 | res = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected(); | |
789 | } else { | |
790 | const AliAODEvent *aev = dynamic_cast<const AliAODEvent*>(InputEvent()); | |
791 | if (aev) { | |
0a918d8d | 792 | res = ((AliVAODHeader*)aev->GetHeader())->GetOfflineTrigger(); |
d29ed625 | 793 | } |
794 | } | |
8e49a788 | 795 | if ((res & fOffTrigger) == 0) { |
219799d0 | 796 | if (fGeneralHistograms) fHistEventRejection->Fill("PhysSel",1); |
b4339010 | 797 | return kFALSE; |
8e49a788 | 798 | } |
b4339010 | 799 | } |
800 | ||
801 | if (!fTrigClass.IsNull()) { | |
802 | TString fired; | |
803 | const AliESDEvent *eev = dynamic_cast<const AliESDEvent*>(InputEvent()); | |
804 | if (eev) { | |
805 | fired = eev->GetFiredTriggerClasses(); | |
806 | } else { | |
807 | const AliAODEvent *aev = dynamic_cast<const AliAODEvent*>(InputEvent()); | |
808 | if (aev) { | |
809 | fired = aev->GetFiredTriggerClasses(); | |
810 | } | |
811 | } | |
8e49a788 | 812 | if (!fired.Contains("-B-")) { |
219799d0 | 813 | if (fGeneralHistograms) fHistEventRejection->Fill("trigger",1); |
b4339010 | 814 | return kFALSE; |
8e49a788 | 815 | } |
b4339010 | 816 | TObjArray *arr = fTrigClass.Tokenize("|"); |
8e49a788 | 817 | if (!arr) { |
219799d0 | 818 | if (fGeneralHistograms) fHistEventRejection->Fill("trigger",1); |
b4339010 | 819 | return kFALSE; |
8e49a788 | 820 | } |
b4339010 | 821 | Bool_t match = 0; |
822 | for (Int_t i=0;i<arr->GetEntriesFast();++i) { | |
823 | TObject *obj = arr->At(i); | |
824 | if (!obj) | |
825 | continue; | |
826 | if (fired.Contains(obj->GetName())) { | |
827 | match = 1; | |
828 | break; | |
829 | } | |
830 | } | |
831 | delete arr; | |
8e49a788 | 832 | if (!match) { |
219799d0 | 833 | if (fGeneralHistograms) fHistEventRejection->Fill("trigger",1); |
2ac8ca4f | 834 | return kFALSE; |
8e49a788 | 835 | } |
2ac8ca4f | 836 | } |
837 | ||
53948904 | 838 | if (!(fTriggerTypeSel & kND)) { |
f9a1843e | 839 | if (!HasTriggerType(fTriggerTypeSel)) { |
219799d0 | 840 | if (fGeneralHistograms) fHistEventRejection->Fill("trigTypeSel",1); |
2ac8ca4f | 841 | return kFALSE; |
8e49a788 | 842 | } |
843 | } | |
8e49a788 | 844 | |
845 | if ((fMinCent != -999) && (fMaxCent != -999)) { | |
846 | if (fCent<fMinCent || fCent>fMaxCent) { | |
219799d0 | 847 | if (fGeneralHistograms) fHistEventRejection->Fill("Cent",1); |
2ac8ca4f | 848 | return kFALSE; |
8e49a788 | 849 | } |
2ac8ca4f | 850 | } |
851 | ||
6cc60022 | 852 | if (fUseAliAnaUtils) { |
853 | if (!fAliAnalysisUtils) | |
854 | fAliAnalysisUtils = new AliAnalysisUtils(); | |
855 | fAliAnalysisUtils->SetMinVtxContr(2); | |
9b299cdd | 856 | fAliAnalysisUtils->SetMaxVtxZ(999); |
6cc60022 | 857 | if(fMinVz<-10.) fMinVz = -10.; |
858 | if(fMinVz>10.) fMaxVz = 10.; | |
859 | ||
860 | if (!fAliAnalysisUtils->IsVertexSelected2013pA(InputEvent())) { | |
219799d0 | 861 | if (fGeneralHistograms) fHistEventRejection->Fill("VtxSel2013pA",1); |
6cc60022 | 862 | return kFALSE; |
863 | } | |
864 | ||
95df3984 | 865 | if (fRejectPileup && fAliAnalysisUtils->IsPileUpEvent(InputEvent())) { |
219799d0 | 866 | if (fGeneralHistograms) fHistEventRejection->Fill("PileUp",1); |
6cc60022 | 867 | return kFALSE; |
868 | } | |
d6ea3a48 | 869 | |
870 | if(fTklVsClusSPDCut && fAliAnalysisUtils->IsSPDClusterVsTrackletBG(InputEvent())) { | |
871 | if (fGeneralHistograms) fHistEventRejection->Fill("Bkg evt",1); | |
872 | return kFALSE; | |
873 | } | |
6cc60022 | 874 | } |
875 | ||
2ac8ca4f | 876 | if ((fMinVz != -999) && (fMaxVz != -999)) { |
8e49a788 | 877 | if (fNVertCont == 0 ) { |
219799d0 | 878 | if (fGeneralHistograms) fHistEventRejection->Fill("vertex contr.",1); |
b4339010 | 879 | return kFALSE; |
8e49a788 | 880 | } |
2ac8ca4f | 881 | Double_t vz = fVertex[2]; |
8e49a788 | 882 | if (vz<fMinVz || vz>fMaxVz) { |
219799d0 | 883 | if (fGeneralHistograms) fHistEventRejection->Fill("Vz",1); |
254370e1 | 884 | return kFALSE; |
885 | } | |
2ac8ca4f | 886 | } |
887 | ||
8e49a788 | 888 | if (fMinPtTrackInEmcal > 0 && fGeom) { |
6c41fc8c | 889 | Bool_t trackInEmcalOk = kFALSE; |
9239b066 | 890 | Int_t ntracks = GetNParticles(0); |
6c41fc8c | 891 | for (Int_t i = 0; i < ntracks; i++) { |
9239b066 | 892 | AliVParticle *track = GetAcceptParticleFromArray(i,0); |
157b926a | 893 | if (!track) |
6c41fc8c | 894 | continue; |
9239b066 | 895 | |
896 | Double_t phiMin = fGeom->GetArm1PhiMin() * TMath::DegToRad(); | |
897 | Double_t phiMax = fGeom->GetArm1PhiMax() * TMath::DegToRad(); | |
898 | Int_t runNumber = InputEvent()->GetRunNumber(); | |
157b926a | 899 | if (runNumber>=177295 && runNumber<=197470) { //small SM masked in 2012 and 2013 |
9239b066 | 900 | phiMin = 1.4; |
901 | phiMax = TMath::Pi(); | |
902 | } | |
903 | ||
904 | if (track->Eta() < fGeom->GetArm1EtaMin() || track->Eta() > fGeom->GetArm1EtaMax() || track->Phi() < phiMin || track->Phi() > phiMax) | |
6c41fc8c | 905 | continue; |
906 | if (track->Pt() > fMinPtTrackInEmcal) { | |
907 | trackInEmcalOk = kTRUE; | |
908 | break; | |
909 | } | |
910 | } | |
8e49a788 | 911 | if (!trackInEmcalOk) { |
219799d0 | 912 | if (fGeneralHistograms) fHistEventRejection->Fill("trackInEmcal",1); |
6c41fc8c | 913 | return kFALSE; |
8e49a788 | 914 | } |
6c41fc8c | 915 | } |
916 | ||
8e49a788 | 917 | if (fMinNTrack > 0) { |
9239b066 | 918 | Int_t nTracksAcc = 0; |
919 | Int_t ntracks = GetNParticles(0); | |
920 | for (Int_t i = 0; i < ntracks; i++) { | |
921 | AliVParticle *track = GetAcceptParticleFromArray(i,0); | |
157b926a | 922 | if (!track) |
9239b066 | 923 | continue; |
924 | if (track->Pt() > fTrackPtCut) { | |
925 | nTracksAcc++; | |
157b926a | 926 | if (nTracksAcc>=fMinNTrack) |
9239b066 | 927 | break; |
928 | } | |
929 | } | |
8e49a788 | 930 | if (nTracksAcc<fMinNTrack) { |
219799d0 | 931 | if (fGeneralHistograms) fHistEventRejection->Fill("minNTrack",1); |
9239b066 | 932 | return kFALSE; |
8e49a788 | 933 | } |
9239b066 | 934 | } |
935 | ||
6f6dc2ba | 936 | if (!(fEPV0 > fMinEventPlane && fEPV0 <= fMaxEventPlane) && |
937 | !(fEPV0 + TMath::Pi() > fMinEventPlane && fEPV0 + TMath::Pi() <= fMaxEventPlane) && | |
938 | !(fEPV0 - TMath::Pi() > fMinEventPlane && fEPV0 - TMath::Pi() <= fMaxEventPlane)) | |
8e49a788 | 939 | { |
219799d0 | 940 | if (fGeneralHistograms) fHistEventRejection->Fill("EvtPlane",1); |
8e49a788 | 941 | return kFALSE; |
942 | } | |
6f6dc2ba | 943 | |
8e49a788 | 944 | if (fSelectPtHardBin != -999 && fSelectPtHardBin != fPtHardBin) { |
219799d0 | 945 | if (fGeneralHistograms) fHistEventRejection->Fill("SelPtHardBin",1); |
8e49a788 | 946 | return kFALSE; |
947 | } | |
219799d0 | 948 | |
2ac8ca4f | 949 | return kTRUE; |
950 | } | |
951 | ||
c596bd28 | 952 | //________________________________________________________________________ |
953 | TClonesArray *AliAnalysisTaskEmcal::GetArrayFromEvent(const char *name, const char *clname) | |
954 | { | |
955 | // Get array from event. | |
956 | ||
957 | TClonesArray *arr = 0; | |
958 | TString sname(name); | |
959 | if (!sname.IsNull()) { | |
960 | arr = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(sname)); | |
961 | if (!arr) { | |
962 | AliWarning(Form("%s: Could not retrieve array with name %s!", GetName(), name)); | |
963 | return 0; | |
964 | } | |
af0280a9 | 965 | } else { |
966 | return 0; | |
c596bd28 | 967 | } |
af0280a9 | 968 | |
c596bd28 | 969 | if (!clname) |
970 | return arr; | |
971 | ||
972 | TString objname(arr->GetClass()->GetName()); | |
973 | TClass cls(objname); | |
974 | if (!cls.InheritsFrom(clname)) { | |
975 | AliWarning(Form("%s: Objects of type %s in %s are not inherited from %s!", | |
976 | GetName(), cls.GetName(), name, clname)); | |
977 | return 0; | |
978 | } | |
979 | return arr; | |
980 | } | |
981 | ||
2da09763 | 982 | //________________________________________________________________________ |
983 | Bool_t AliAnalysisTaskEmcal::RetrieveEventObjects() | |
984 | { | |
985 | // Retrieve objects from event. | |
986 | ||
2da09763 | 987 | fVertex[0] = 0; |
988 | fVertex[1] = 0; | |
989 | fVertex[2] = 0; | |
b4339010 | 990 | fNVertCont = 0; |
991 | ||
992 | const AliVVertex *vert = InputEvent()->GetPrimaryVertex(); | |
993 | if (vert) { | |
994 | vert->GetXYZ(fVertex); | |
995 | fNVertCont = vert->GetNContributors(); | |
996 | } | |
2da09763 | 997 | |
1f6fff78 | 998 | fBeamType = GetBeamType(); |
999 | ||
a52de945 | 1000 | if (fBeamType == kAA || fBeamType == kpA ) { |
2da09763 | 1001 | AliCentrality *aliCent = InputEvent()->GetCentrality(); |
1002 | if (aliCent) { | |
9239b066 | 1003 | fCent = aliCent->GetCentralityPercentile(fCentEst.Data()); |
157b926a | 1004 | if (fNcentBins==4) { |
e304c410 | 1005 | if (fCent >= 0 && fCent < 10) fCentBin = 0; |
1006 | else if (fCent >= 10 && fCent < 30) fCentBin = 1; | |
1007 | else if (fCent >= 30 && fCent < 50) fCentBin = 2; | |
1008 | else if (fCent >= 50 && fCent <= 100) fCentBin = 3; | |
1009 | else { | |
1010 | AliWarning(Form("%s: Negative centrality: %f. Assuming 99", GetName(), fCent)); | |
53e07ba4 | 1011 | fCentBin = fNcentBins-1; |
e304c410 | 1012 | } |
dbd1583b | 1013 | } else { |
e304c410 | 1014 | Double_t centWidth = (fMaxCent-fMinCent)/(Double_t)fNcentBins; |
1781a0e2 | 1015 | if(centWidth>0.) |
1016 | fCentBin = TMath::FloorNint(fCent/centWidth); | |
1017 | else | |
1018 | fCentBin = 0; | |
157b926a | 1019 | if (fCentBin>=fNcentBins) { |
53e07ba4 | 1020 | AliWarning(Form("%s: fCentBin too large: cent = %f fCentBin = %d. Assuming 99", GetName(),fCent,fCentBin)); |
1021 | fCentBin = fNcentBins-1; | |
1022 | } | |
2da09763 | 1023 | } |
901cc837 | 1024 | } else { |
1025 | AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName())); | |
4c4a0fc7 | 1026 | fCentBin = fNcentBins-1; |
2da09763 | 1027 | } |
3c124212 | 1028 | AliEventplane *aliEP = InputEvent()->GetEventplane(); |
1029 | if (aliEP) { | |
1030 | fEPV0 = aliEP->GetEventplane("V0" ,InputEvent()); | |
1031 | fEPV0A = aliEP->GetEventplane("V0A",InputEvent()); | |
1032 | fEPV0C = aliEP->GetEventplane("V0C",InputEvent()); | |
1033 | } else { | |
1034 | AliWarning(Form("%s: Could not retrieve event plane information!", GetName())); | |
1035 | } | |
901cc837 | 1036 | } else { |
2da09763 | 1037 | fCent = 99; |
1038 | fCentBin = 0; | |
1039 | } | |
1040 | ||
ed0243d8 | 1041 | if (fIsPythia) { |
1042 | ||
1043 | if (MCEvent()) { | |
1044 | fPythiaHeader = dynamic_cast<AliGenPythiaEventHeader*>(MCEvent()->GenEventHeader()); | |
1045 | if (!fPythiaHeader) { | |
1046 | // Check if AOD | |
1047 | AliAODMCHeader* aodMCH = dynamic_cast<AliAODMCHeader*>(InputEvent()->FindListObject(AliAODMCHeader::StdBranchName())); | |
1048 | ||
1049 | if (aodMCH) { | |
157b926a | 1050 | for (UInt_t i = 0;i<aodMCH->GetNCocktailHeaders();i++) { |
ed0243d8 | 1051 | fPythiaHeader = dynamic_cast<AliGenPythiaEventHeader*>(aodMCH->GetCocktailHeader(i)); |
1052 | if (fPythiaHeader) break; | |
1053 | } | |
1054 | } | |
1055 | } | |
1056 | } | |
1057 | ||
1058 | if (fPythiaHeader) { | |
1059 | fPtHard = fPythiaHeader->GetPtHard(); | |
6a322f03 | 1060 | |
ed0243d8 | 1061 | const Int_t ptHardLo[11] = { 0, 5,11,21,36,57, 84,117,152,191,234}; |
1062 | const Int_t ptHardHi[11] = { 5,11,21,36,57,84,117,152,191,234,1000000}; | |
1063 | for (fPtHardBin = 0; fPtHardBin < 11; fPtHardBin++) { | |
1064 | if (fPtHard >= ptHardLo[fPtHardBin] && fPtHard < ptHardHi[fPtHardBin]) | |
1065 | break; | |
1066 | } | |
6da81bde | 1067 | |
1068 | fXsection = fPythiaHeader->GetXsection(); | |
ed0243d8 | 1069 | fNTrials = fPythiaHeader->Trials(); |
1070 | } | |
1071 | } | |
1072 | ||
f9a1843e | 1073 | fTriggers = GetTriggerList(); |
53948904 | 1074 | fMainTriggerPatchSet = kFALSE; |
1075 | memset(fMainTriggerPatch, 0, sizeof(AliEmcalTriggerPatchInfo *) * (kNType - 1)); | |
8e49a788 | 1076 | |
2da09763 | 1077 | return kTRUE; |
1078 | } | |
9239b066 | 1079 | |
1080 | //________________________________________________________________________ | |
b8aeed95 | 1081 | AliParticleContainer* AliAnalysisTaskEmcal::AddParticleContainer(const char *n) |
1082 | { | |
9239b066 | 1083 | // Add particle container |
1084 | // will be called in AddTask macro | |
1085 | ||
1086 | TString tmp = TString(n); | |
157b926a | 1087 | if (tmp.IsNull()) return 0; |
9239b066 | 1088 | |
1089 | AliParticleContainer *cont = 0x0; | |
1090 | cont = new AliParticleContainer(); | |
1091 | cont->SetArrayName(n); | |
1092 | TString contName = cont->GetArrayName(); | |
1093 | ||
1094 | fParticleCollArray.Add(cont); | |
1095 | ||
1096 | return cont; | |
1097 | } | |
1098 | ||
1099 | //________________________________________________________________________ | |
b8aeed95 | 1100 | AliClusterContainer* AliAnalysisTaskEmcal::AddClusterContainer(const char *n) |
1101 | { | |
9239b066 | 1102 | // Add cluster container |
1103 | // will be called in AddTask macro | |
1104 | ||
1105 | TString tmp = TString(n); | |
157b926a | 1106 | if (tmp.IsNull()) return 0; |
9239b066 | 1107 | |
1108 | AliClusterContainer *cont = 0x0; | |
1109 | cont = new AliClusterContainer(); | |
1110 | cont->SetArrayName(n); | |
1111 | ||
1112 | fClusterCollArray.Add(cont); | |
1113 | ||
1114 | return cont; | |
1115 | } | |
1116 | ||
1117 | //________________________________________________________________________ | |
b8aeed95 | 1118 | AliParticleContainer* AliAnalysisTaskEmcal::GetParticleContainer(Int_t i) const |
1119 | { | |
9239b066 | 1120 | // Get i^th particle container |
1121 | ||
157b926a | 1122 | if (i<0 || i>fParticleCollArray.GetEntriesFast()) return 0; |
9239b066 | 1123 | AliParticleContainer *cont = static_cast<AliParticleContainer*>(fParticleCollArray.At(i)); |
1124 | return cont; | |
1125 | } | |
1126 | ||
1127 | //________________________________________________________________________ | |
b8aeed95 | 1128 | AliClusterContainer* AliAnalysisTaskEmcal::GetClusterContainer(Int_t i) const |
1129 | { | |
9239b066 | 1130 | // Get i^th cluster container |
1131 | ||
157b926a | 1132 | if (i<0 || i>fClusterCollArray.GetEntriesFast()) return 0; |
9239b066 | 1133 | AliClusterContainer *cont = static_cast<AliClusterContainer*>(fClusterCollArray.At(i)); |
1134 | return cont; | |
1135 | } | |
1136 | ||
1137 | //________________________________________________________________________ | |
b8aeed95 | 1138 | AliParticleContainer* AliAnalysisTaskEmcal::GetParticleContainer(const char *name) const |
1139 | { | |
9239b066 | 1140 | // Get particle container with name |
1141 | ||
1142 | AliParticleContainer *cont = static_cast<AliParticleContainer*>(fParticleCollArray.FindObject(name)); | |
1143 | return cont; | |
1144 | } | |
1145 | ||
1146 | //________________________________________________________________________ | |
b8aeed95 | 1147 | AliClusterContainer* AliAnalysisTaskEmcal::GetClusterContainer(const char *name) const |
1148 | { | |
9239b066 | 1149 | // Get cluster container with name |
1150 | ||
1151 | AliClusterContainer *cont = static_cast<AliClusterContainer*>(fClusterCollArray.FindObject(name)); | |
1152 | return cont; | |
1153 | } | |
1154 | ||
1155 | //________________________________________________________________________ | |
b8aeed95 | 1156 | TClonesArray* AliAnalysisTaskEmcal::GetParticleArray(Int_t i) const |
1157 | { | |
9239b066 | 1158 | // Get i^th TClonesArray with AliVParticle |
1159 | ||
1160 | AliParticleContainer *cont = GetParticleContainer(i); | |
157b926a | 1161 | if (!cont) { |
9239b066 | 1162 | AliError(Form("%s: Particle container %d not found",GetName(),i)); |
1163 | return 0; | |
1164 | } | |
1165 | TString contName = cont->GetArrayName(); | |
1166 | return cont->GetArray(); | |
1167 | } | |
1168 | ||
1169 | //________________________________________________________________________ | |
b8aeed95 | 1170 | TClonesArray* AliAnalysisTaskEmcal::GetClusterArray(Int_t i) const |
1171 | { | |
9239b066 | 1172 | // Get i^th TClonesArray with AliVCluster |
1173 | ||
1174 | AliClusterContainer *cont = GetClusterContainer(i); | |
157b926a | 1175 | if (!cont) { |
9239b066 | 1176 | AliError(Form("%s:Cluster container %d not found",GetName(),i)); |
1177 | return 0; | |
1178 | } | |
1179 | return cont->GetArray(); | |
1180 | } | |
1181 | ||
1182 | //________________________________________________________________________ | |
b8aeed95 | 1183 | AliVParticle* AliAnalysisTaskEmcal::GetAcceptParticleFromArray(Int_t p, Int_t c) const |
1184 | { | |
9239b066 | 1185 | // Get particle p if accepted from container c |
1186 | // If particle not accepted return 0 | |
1187 | ||
1188 | AliParticleContainer *cont = GetParticleContainer(c); | |
157b926a | 1189 | if (!cont) { |
9239b066 | 1190 | AliError(Form("%s: Particle container %d not found",GetName(),c)); |
1191 | return 0; | |
1192 | } | |
1193 | AliVParticle *vp = cont->GetAcceptParticle(p); | |
1194 | ||
1195 | return vp; | |
1196 | } | |
1197 | ||
1198 | //________________________________________________________________________ | |
b8aeed95 | 1199 | AliVCluster* AliAnalysisTaskEmcal::GetAcceptClusterFromArray(Int_t cl, Int_t c) const |
1200 | { | |
9239b066 | 1201 | // Get particle p if accepted from container c |
1202 | // If particle not accepted return 0 | |
1203 | ||
1204 | AliClusterContainer *cont = GetClusterContainer(c); | |
157b926a | 1205 | if (!cont) { |
9239b066 | 1206 | AliError(Form("%s: Cluster container %d not found",GetName(),c)); |
1207 | return 0; | |
1208 | } | |
1209 | AliVCluster *vc = cont->GetAcceptCluster(cl); | |
1210 | ||
1211 | return vc; | |
1212 | } | |
1213 | ||
1214 | //________________________________________________________________________ | |
b8aeed95 | 1215 | Int_t AliAnalysisTaskEmcal::GetNParticles(Int_t i) const |
1216 | { | |
9239b066 | 1217 | // Get number of entries in particle array i |
1218 | ||
1219 | AliParticleContainer *cont = GetParticleContainer(i); | |
157b926a | 1220 | if (!cont) { |
9239b066 | 1221 | AliError(Form("%s: Particle container %d not found",GetName(),i)); |
1222 | return 0; | |
1223 | } | |
1224 | return cont->GetNEntries(); | |
1225 | } | |
1226 | ||
1227 | //________________________________________________________________________ | |
b8aeed95 | 1228 | Int_t AliAnalysisTaskEmcal::GetNClusters(Int_t i) const |
1229 | { | |
9239b066 | 1230 | // Get number of entries in cluster array i |
1231 | ||
1232 | AliClusterContainer *cont = GetClusterContainer(i); | |
157b926a | 1233 | if (!cont) { |
9239b066 | 1234 | AliError(Form("%s: Cluster container %d not found",GetName(),i)); |
1235 | return 0; | |
1236 | } | |
1237 | return cont->GetNEntries(); | |
1238 | } | |
1239 | ||
37a63fdf | 1240 | //________________________________________________________________________ |
53948904 | 1241 | AliEmcalTriggerPatchInfo* AliAnalysisTaskEmcal::GetMainTriggerPatch(Int_t types) |
b8aeed95 | 1242 | { |
37a63fdf | 1243 | //get main trigger match; if not known yet, look for it and cache |
53948904 | 1244 | // |
1245 | // In order to be able to select more than one class at the same time (i.e. low and | |
1246 | // high threshold trigger), the argument must be a bit string, however using the enum | |
1247 | // of trigger classes in order to define the selection | |
37a63fdf | 1248 | |
53948904 | 1249 | // Get from cache (if already set) |
1250 | if(fMainTriggerPatchSet){ | |
1251 | return ApplyMainTriggerSelection(types); | |
1252 | } | |
37a63fdf | 1253 | |
157b926a | 1254 | if (!fTriggerPatchInfo) { |
37a63fdf | 1255 | AliError(Form("%s: fTriggerPatchInfo not available",GetName())); |
1256 | return 0; | |
1257 | } | |
1258 | ||
1259 | //number of patches in event | |
1260 | Int_t nPatch = fTriggerPatchInfo->GetEntries(); | |
1261 | ||
53948904 | 1262 | //extract main trigger patch(es) |
37a63fdf | 1263 | AliEmcalTriggerPatchInfo *patch; |
157b926a | 1264 | for (Int_t iPatch = 0; iPatch < nPatch; iPatch++) { |
53948904 | 1265 | |
37a63fdf | 1266 | patch = (AliEmcalTriggerPatchInfo*)fTriggerPatchInfo->At( iPatch ); |
157b926a | 1267 | if (patch->IsMainTrigger()) { |
53948904 | 1268 | if(patch->IsJetHigh()) fMainTriggerPatch[kPosJ1] = patch; |
1269 | if(patch->IsJetLow()) fMainTriggerPatch[kPosJ2] = patch; | |
1270 | if(patch->IsGammaHigh()) fMainTriggerPatch[kPosG1] = patch; | |
1271 | if(patch->IsGammaLow()) fMainTriggerPatch[kPosG2] = patch; | |
1272 | if(patch->IsLevel0()) fMainTriggerPatch[kPosL0] = patch; | |
1273 | } | |
1274 | } | |
1275 | fMainTriggerPatchSet = kTRUE; | |
1276 | ||
1277 | return ApplyMainTriggerSelection(types); | |
1278 | } | |
1279 | ||
1280 | AliEmcalTriggerPatchInfo *AliAnalysisTaskEmcal::ApplyMainTriggerSelection(Int_t selectionBitmap) const { | |
1281 | // | |
1282 | // Select main trigger patch for a given combination of trigger classes | |
1283 | // If the bitmap contains only one class, the selection is trivial | |
1284 | // If the bitmap contains many classes, the selection takes the highest of the patchess according to the | |
1285 | // ADC Amplitude | |
1286 | // | |
1287 | AliEmcalTriggerPatchInfo *highest(NULL); | |
1288 | if(selectionBitmap & kJ1){ | |
1289 | highest = fMainTriggerPatch[kPosJ1]; | |
1290 | } | |
1291 | if(selectionBitmap & kJ2){ | |
1292 | if(!highest) highest = fMainTriggerPatch[kPosJ2]; | |
1293 | else{ | |
1294 | if(fMainTriggerPatch[kPosJ2] && fMainTriggerPatch[kPosJ2]->GetADCAmp() > highest->GetADCAmp()) | |
1295 | highest = fMainTriggerPatch[kPosJ2]; | |
1296 | } | |
1297 | } | |
1298 | ||
1299 | if(selectionBitmap & kG1){ | |
1300 | if(!highest) highest = fMainTriggerPatch[kPosG1]; | |
1301 | else{ | |
1302 | if(fMainTriggerPatch[kPosG1] && fMainTriggerPatch[kPosG1]->GetADCAmp() > highest->GetADCAmp()) | |
1303 | highest = fMainTriggerPatch[kPosG1]; | |
1304 | } | |
1305 | } | |
1306 | ||
1307 | if(selectionBitmap & kG2){ | |
1308 | if(!highest) highest = fMainTriggerPatch[kPosG2]; | |
1309 | else{ | |
1310 | if(fMainTriggerPatch[kPosG2] && fMainTriggerPatch[kPosG2]->GetADCAmp() > highest->GetADCAmp()) | |
1311 | highest = fMainTriggerPatch[kPosG2]; | |
1312 | } | |
1313 | } | |
1314 | if(selectionBitmap & kL0){ | |
1315 | if(!highest) highest = fMainTriggerPatch[kPosL0]; | |
1316 | else{ | |
1317 | if(fMainTriggerPatch[kPosL0] && fMainTriggerPatch[kPosL0]->GetADCAmp() > highest->GetADCAmp()) | |
1318 | highest = fMainTriggerPatch[kPosL0]; | |
37a63fdf | 1319 | } |
1320 | } | |
1321 | ||
53948904 | 1322 | return highest; |
37a63fdf | 1323 | } |
b8aeed95 | 1324 | |
1325 | //________________________________________________________________________ | |
1326 | void AliAnalysisTaskEmcal::AddObjectToEvent(TObject *obj) | |
1327 | { | |
1328 | // Add object to event | |
1329 | ||
1330 | if (!(InputEvent()->FindListObject(obj->GetName()))) { | |
1331 | InputEvent()->AddObject(obj); | |
1332 | } else { | |
1333 | AliFatal(Form("%s: Container with name %s already present. Aborting", GetName(), obj->GetName())); | |
1334 | } | |
1335 | } | |
9dc6ae4b | 1336 | |
1337 | //________________________________________________________________________ | |
1338 | void AliAnalysisTaskEmcal::GenerateFixedBinArray(Int_t n, Double_t min, Double_t max, Double_t* array) const | |
1339 | { | |
1340 | Double_t binWidth = (max-min)/n; | |
1341 | array[0] = min; | |
1342 | for (Int_t i = 1; i <= n; i++) { | |
1343 | array[i] = array[i-1]+binWidth; | |
1344 | } | |
1345 | } | |
1346 | ||
1347 | //________________________________________________________________________ | |
1348 | Double_t* AliAnalysisTaskEmcal::GenerateFixedBinArray(Int_t n, Double_t min, Double_t max) const | |
1349 | { | |
1350 | Double_t *array = new Double_t[n+1]; | |
1351 | ||
1352 | GenerateFixedBinArray(n, min, max, array); | |
1353 | ||
1354 | return array; | |
1355 | } | |
68e03fc3 | 1356 | |
1357 | //________________________________________________________________________ | |
1358 | void AliAnalysisTaskEmcal::SetRejectionReasonLabels(TAxis* axis) | |
1359 | { | |
1360 | axis->SetBinLabel(1, "NullObject"); | |
1361 | axis->SetBinLabel(2, "Pt"); | |
1362 | axis->SetBinLabel(3, "Acceptance"); | |
1363 | axis->SetBinLabel(4, "BitMap"); | |
1364 | axis->SetBinLabel(5, "Bit4"); | |
1365 | axis->SetBinLabel(6, "Bit5"); | |
1366 | axis->SetBinLabel(7, "Bit6"); | |
1367 | axis->SetBinLabel(8, "Bit7"); | |
1368 | axis->SetBinLabel(9, "MCFlag"); | |
1369 | axis->SetBinLabel(10, "MCGenerator"); | |
1370 | axis->SetBinLabel(11, "ChargeCut"); | |
1371 | axis->SetBinLabel(12, "Bit11"); | |
1372 | axis->SetBinLabel(13, "Bit12"); | |
1373 | axis->SetBinLabel(14, "IsEMCal"); | |
1374 | axis->SetBinLabel(15, "Time"); | |
1375 | axis->SetBinLabel(16, "Energy"); | |
1376 | axis->SetBinLabel(17, "Bit16"); | |
1377 | axis->SetBinLabel(18, "Bit17"); | |
1378 | axis->SetBinLabel(19, "Area"); | |
1379 | axis->SetBinLabel(20, "AreaEmc"); | |
1380 | axis->SetBinLabel(21, "ZLeadingCh"); | |
1381 | axis->SetBinLabel(22, "ZLeadingEmc"); | |
1382 | axis->SetBinLabel(23, "NEF"); | |
1383 | axis->SetBinLabel(24, "MinLeadPt"); | |
1384 | axis->SetBinLabel(25, "MaxTrackPt"); | |
1385 | axis->SetBinLabel(26, "MaxClusterPt"); | |
1386 | axis->SetBinLabel(27, "Flavour"); | |
1387 | axis->SetBinLabel(28, "TagStatus"); | |
1388 | axis->SetBinLabel(29, "Bit28"); | |
1389 | axis->SetBinLabel(30, "Bit29"); | |
1390 | axis->SetBinLabel(31, "Bit30"); | |
1391 | axis->SetBinLabel(32, "Bit31"); | |
1392 | } |