]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGHF/hfe/AliAnalysisTaskHFE.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'feature-movesplit'
[u/mrichter/AliRoot.git] / PWGHF / hfe / AliAnalysisTaskHFE.cxx
CommitLineData
01745870 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// The analysis task:
17// Filling an AliCFContainer with the quantities pt, eta and phi
18// for tracks which survivied the particle cuts (MC resp. ESD tracks)
19// Track selection is done using the AliHFE package
20//
21// Author:
22// Raphaelle Bailhache <R.Bailhache@gsi.de>
23// Markus Fasel <M.Fasel@gsi.de>
24// Matus Kalisky <matus.kalisky@cern.ch>
25// MinJung Kweon <minjung@physi.uni-heidelberg.de>
26//
27#include <TAxis.h>
28#include <TBits.h>
29#include <TCanvas.h>
30#include <TChain.h>
31#include <TDirectory.h>
32#include <TFile.h>
33#include <TH3D.h>
34#include <TIterator.h>
35#include <TList.h>
36#include <TLegend.h>
37#include <TMath.h>
38#include <TObjArray.h>
39#include <TObjString.h>
40#include <TParticle.h>
41#include <TProfile.h>
42#include <TString.h>
43#include <TF1.h>
44#include <TTree.h>
45
46#include "AliESDtrackCuts.h"
47#include "AliAnalysisManager.h"
48#include "AliAnalysisUtils.h"
49#include "AliAODInputHandler.h"
50#include "AliAODMCParticle.h"
51#include "AliAODTrack.h"
52#include "AliAODVertex.h"
53#include "AliCentrality.h"
54#include "AliCFContainer.h"
55#include "AliCFManager.h"
56#include "AliESDEvent.h"
57#include "AliESDInputHandler.h"
58#include "AliESDtrack.h"
59#include "AliLog.h"
60#include "AliMCEvent.h"
61#include "AliMCEventHandler.h"
62#include "AliMCParticle.h"
63#include "AliMultiplicity.h"
64#include "AliPID.h"
65#include "AliPIDResponse.h"
66#include "AliOADBContainer.h"
67#include "AliStack.h"
68#include "AliTriggerAnalysis.h"
4437a0d2 69#include "AliTRDTriggerAnalysis.h"
01745870 70#include "AliVVertex.h"
71
72#include "AliHFEcollection.h"
73#include "AliHFEcontainer.h"
74#include "AliHFEcuts.h"
75#include "AliHFEelecbackground.h"
76#include "AliHFENonPhotonicElectron.h"
77#include "AliHFEmcQA.h"
78#include "AliHFEpairs.h"
79#include "AliHFEpid.h"
80#include "AliHFEpidQAmanager.h"
81#include "AliHFEsecVtxs.h"
82#include "AliHFEsecVtx.h"
83#include "AliHFEsignalCuts.h"
84#include "AliHFEtaggedTrackAnalysis.h"
85#include "AliHFEtools.h"
7986e54e 86#include "AliHFEV0taginfo.h"
01745870 87#include "AliHFEvarManager.h"
88#include "AliAnalysisTaskHFE.h"
89#include "AliAODMCHeader.h"
90#include "TClonesArray.h"
91
92ClassImp(AliAnalysisTaskHFE)
93
94//____________________________________________________________
95AliAnalysisTaskHFE::AliAnalysisTaskHFE():
96AliAnalysisTaskSE("PID efficiency Analysis")
97 , fAODMCHeader(NULL)
98 , fAODArrayMCInfo(NULL)
99 , fQAlevel(0)
100 , fPlugins(0)
101 , fCollisionSystem(3)
102 , fFillSignalOnly(kTRUE)
2e4ed823 103 , fRejectMCFakeTracks(kFALSE)
01745870 104 , fFillNoCuts(kFALSE)
01745870 105 , fBackGroundFactorApply(kFALSE)
106 , fRemovePileUp(kFALSE)
107 , fIdentifiedAsPileUp(kFALSE)
108 , fIdentifiedAsOutInz(kFALSE)
109 , fPassTheEventCut(kFALSE)
465ff082 110 , fRejectKinkMother(kFALSE)
01745870 111 , fisppMultiBin(kFALSE)
112 , fPbPbUserCentralityBinning(kFALSE)
113 , fRemoveFirstEvent(kFALSE)
114 , fisNonHFEsystematics(kFALSE)
115 , fSpecialTrigger(NULL)
116 , fCentralityF(-1)
117 , fCentralityPercent(-1)
118 , fCentralityEstimator("V0M")
119 , fContributors(0.5)
120 , fWeightBackGround(0.)
121 , fVz(0.0)
122 , fContainer(NULL)
123 , fVarManager(NULL)
124 , fSignalCuts(NULL)
125 , fCFM(NULL)
126 , fTriggerAnalysis(NULL)
127 , fPID(NULL)
128 , fPIDqa(NULL)
ff8249bd 129 , fTRDTriggerAnalysismb(NULL)
130 , fTRDTriggerAnalysistrg(NULL)
01745870 131 , fPIDpreselect(NULL)
132 , fCuts(NULL)
133 , fTaggedTrackCuts(NULL)
134 , fCleanTaggedTrack(kFALSE)
135 , fVariablesTRDTaggedTrack(kFALSE)
136 , fAnalysisUtils(NULL)
137 , fCutspreselect(NULL)
138 , fSecVtx(NULL)
139 , fElecBackGround(NULL)
140 , fMCQA(NULL)
141 , fTaggedTrackAnalysis(NULL)
142 , fExtraCuts(NULL)
143 , fBackgroundSubtraction(NULL)
144 , fTRDTrigger(kFALSE)
145 , fWhichTRDTrigger(0)
7986e54e 146 , fV0Tagger(NULL)
01745870 147 , fQA(NULL)
148 , fOutput(NULL)
149 , fHistMCQA(NULL)
150 , fHistSECVTX(NULL)
151 , fHistELECBACKGROUND(NULL)
152 , fQACollection(NULL)
153{
154 //
155 // Dummy constructor
156 //
157 memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
158 memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
159 memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));
160 memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
161 memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
162
163 SetppAnalysis();
164}
165
166//____________________________________________________________
167AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name):
168 AliAnalysisTaskSE(name)
169 , fAODMCHeader(NULL)
170 , fAODArrayMCInfo(NULL)
171 , fQAlevel(0)
172 , fPlugins(0)
173 , fCollisionSystem(3)
174 , fFillSignalOnly(kTRUE)
2e4ed823 175 , fRejectMCFakeTracks(kFALSE)
01745870 176 , fFillNoCuts(kFALSE)
01745870 177 , fBackGroundFactorApply(kFALSE)
178 , fRemovePileUp(kFALSE)
179 , fIdentifiedAsPileUp(kFALSE)
180 , fIdentifiedAsOutInz(kFALSE)
181 , fPassTheEventCut(kFALSE)
465ff082 182 , fRejectKinkMother(kFALSE)
01745870 183 , fisppMultiBin(kFALSE)
184 , fPbPbUserCentralityBinning(kFALSE)
185 , fRemoveFirstEvent(kFALSE)
186 , fisNonHFEsystematics(kFALSE)
187 , fSpecialTrigger(NULL)
188 , fCentralityF(-1)
189 , fCentralityPercent(-1)
190 , fCentralityEstimator("V0M")
191 , fContributors(0.5)
192 , fWeightBackGround(0.)
193 , fVz(0.0)
194 , fContainer(NULL)
195 , fVarManager(NULL)
196 , fSignalCuts(NULL)
197 , fCFM(NULL)
198 , fTriggerAnalysis(NULL)
199 , fPID(NULL)
200 , fPIDqa(NULL)
ff8249bd 201 , fTRDTriggerAnalysismb(NULL)
202 , fTRDTriggerAnalysistrg(NULL)
01745870 203 , fPIDpreselect(NULL)
204 , fCuts(NULL)
205 , fTaggedTrackCuts(NULL)
206 , fCleanTaggedTrack(kFALSE)
207 , fVariablesTRDTaggedTrack(kFALSE)
208 , fAnalysisUtils(NULL)
209 , fCutspreselect(NULL)
210 , fSecVtx(NULL)
211 , fElecBackGround(NULL)
212 , fMCQA(NULL)
213 , fTaggedTrackAnalysis(NULL)
214 , fExtraCuts(NULL)
215 , fBackgroundSubtraction(NULL)
216 , fTRDTrigger(kFALSE)
217 , fWhichTRDTrigger(0)
7986e54e 218 , fV0Tagger(NULL)
01745870 219 , fQA(NULL)
220 , fOutput(NULL)
221 , fHistMCQA(NULL)
222 , fHistSECVTX(NULL)
223 , fHistELECBACKGROUND(NULL)
224 , fQACollection(0x0)
225{
226 //
227 // Default constructor
228 //
229 DefineOutput(1, TList::Class());
230 DefineOutput(2, TList::Class());
231
7986e54e 232 fV0Tagger = new AliHFEV0taginfo("Tagger");
01745870 233 fPID = new AliHFEpid("hfePid");
234 fPIDqa = new AliHFEpidQAmanager;
235 fVarManager = new AliHFEvarManager("hfeVarManager");
236 fAnalysisUtils = new AliAnalysisUtils;
ff8249bd 237 fTRDTriggerAnalysismb = new AliTRDTriggerAnalysis();
238 fTRDTriggerAnalysistrg = new AliTRDTriggerAnalysis();
239 fTRDTriggerAnalysistrg->SetRequireMatchElectron(kTRUE);
01745870 240
241 memset(fElecBackgroundFactor, 0, sizeof(Double_t) * kElecBgSpecies * kBgPtBins * kCentBins * kBgLevels);
242 memset(fkBackGroundFactorArray, 0, sizeof(TF1 *) * 12);
243 memset(fBinLimit, 0, sizeof(Double_t) * (kBgPtBins+1));
244 memset(&fisppMultiBin, kFALSE, sizeof(fisppMultiBin));
245 memset(fCentralityLimits, 0, sizeof(Float_t) * 12);
246
247 SetppAnalysis();
248}
249
250//____________________________________________________________
251AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref):
252 AliAnalysisTaskSE(ref)
253 , fAODMCHeader(NULL)
254 , fAODArrayMCInfo(NULL)
255 , fQAlevel(0)
256 , fPlugins(0)
257 , fCollisionSystem(ref.fCollisionSystem)
258 , fFillSignalOnly(ref.fFillSignalOnly)
2e4ed823 259 , fRejectMCFakeTracks(ref.fRejectMCFakeTracks)
01745870 260 , fFillNoCuts(ref.fFillNoCuts)
01745870 261 , fBackGroundFactorApply(ref.fBackGroundFactorApply)
262 , fRemovePileUp(ref.fRemovePileUp)
263 , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp)
264 , fIdentifiedAsOutInz(ref.fIdentifiedAsOutInz)
265 , fPassTheEventCut(ref.fPassTheEventCut)
266 , fRejectKinkMother(ref.fRejectKinkMother)
267 , fisppMultiBin(ref.fisppMultiBin)
268 , fPbPbUserCentralityBinning(ref.fPbPbUserCentralityBinning)
269 , fRemoveFirstEvent(ref.fRemoveFirstEvent)
270 , fisNonHFEsystematics(ref.fisNonHFEsystematics)
271 , fSpecialTrigger(ref.fSpecialTrigger)
272 , fCentralityF(ref.fCentralityF)
273 , fCentralityPercent(ref.fCentralityPercent)
274 , fCentralityEstimator(ref.fCentralityEstimator)
275 , fContributors(ref.fContributors)
276 , fWeightBackGround(ref.fWeightBackGround)
277 , fVz(ref.fVz)
278 , fContainer(NULL)
279 , fVarManager(NULL)
280 , fSignalCuts(NULL)
281 , fCFM(NULL)
282 , fTriggerAnalysis(NULL)
283 , fPID(NULL)
284 , fPIDqa(NULL)
ff8249bd 285 , fTRDTriggerAnalysismb(NULL)
286 , fTRDTriggerAnalysistrg(NULL)
01745870 287 , fPIDpreselect(NULL)
288 , fCuts(NULL)
289 , fTaggedTrackCuts(NULL)
290 , fCleanTaggedTrack(ref.fCleanTaggedTrack)
291 , fVariablesTRDTaggedTrack(ref.fVariablesTRDTaggedTrack)
292 , fAnalysisUtils(NULL)
293 , fCutspreselect(NULL)
294 , fSecVtx(NULL)
295 , fElecBackGround(NULL)
296 , fMCQA(NULL)
297 , fTaggedTrackAnalysis(NULL)
298 , fExtraCuts(NULL)
299 , fBackgroundSubtraction(NULL)
300 , fTRDTrigger(ref.fTRDTrigger)
301 , fWhichTRDTrigger(ref.fWhichTRDTrigger)
7986e54e 302 , fV0Tagger(NULL)
01745870 303 , fQA(NULL)
304 , fOutput(NULL)
305 , fHistMCQA(NULL)
306 , fHistSECVTX(NULL)
307 , fHistELECBACKGROUND(NULL)
308 , fQACollection(NULL)
309{
310 //
311 // Copy Constructor
312 //
313 ref.Copy(*this);
314}
315
316//____________________________________________________________
317AliAnalysisTaskHFE &AliAnalysisTaskHFE::operator=(const AliAnalysisTaskHFE &ref){
318 //
319 // Assignment operator
320 //
321 if(this == &ref)
322 ref.Copy(*this);
323 return *this;
324}
325
326//____________________________________________________________
327void AliAnalysisTaskHFE::Copy(TObject &o) const {
328 //
329 // Copy into object o
330 //
331 AliAnalysisTaskHFE &target = dynamic_cast<AliAnalysisTaskHFE &>(o);
332 target.fAODMCHeader = fAODMCHeader;
333 target.fAODArrayMCInfo = fAODArrayMCInfo;
334 target.fQAlevel = fQAlevel;
335 target.fPlugins = fPlugins;
336 target.fCollisionSystem = fCollisionSystem;
337 target.fFillSignalOnly = fFillSignalOnly;
2e4ed823 338 target.fRejectMCFakeTracks = fRejectMCFakeTracks;
01745870 339 target.fFillNoCuts = fFillNoCuts;
01745870 340 target.fBackGroundFactorApply = fBackGroundFactorApply;
341 target.fRemovePileUp = fRemovePileUp;
342 target.fIdentifiedAsPileUp = fIdentifiedAsPileUp;
343 target.fIdentifiedAsOutInz = fIdentifiedAsOutInz;
344 target.fPassTheEventCut = fPassTheEventCut;
345 target.fRejectKinkMother = fRejectKinkMother;
346 target.fisppMultiBin = fisppMultiBin;
347 target.fPbPbUserCentralityBinning = fPbPbUserCentralityBinning;
348 target.fRemoveFirstEvent = fRemoveFirstEvent;
349 target.fisNonHFEsystematics = fisNonHFEsystematics;
350 target.fSpecialTrigger = fSpecialTrigger;
351 target.fCentralityF = fCentralityF;
352 target.fCentralityPercent = fCentralityPercent;
353 target.fCentralityEstimator = fCentralityEstimator;
354 target.fContributors = fContributors;
355 target.fWeightBackGround = fWeightBackGround;
356 target.fVz = fVz;
357 target.fContainer = fContainer;
358 target.fVarManager = fVarManager;
359 target.fSignalCuts = fSignalCuts;
360 target.fCFM = fCFM;
361 target.fTriggerAnalysis = fTriggerAnalysis;
362 target.fPID = fPID;
363 target.fPIDqa = fPIDqa;
ff8249bd 364 target.fTRDTriggerAnalysismb = fTRDTriggerAnalysismb;
365 target.fTRDTriggerAnalysistrg = fTRDTriggerAnalysistrg;
01745870 366 target.fPIDpreselect = fPIDpreselect;
367 target.fCuts = fCuts;
368 target.fTaggedTrackCuts = fTaggedTrackCuts;
369 target.fCleanTaggedTrack = fCleanTaggedTrack;
370 target.fVariablesTRDTaggedTrack = fVariablesTRDTaggedTrack;
371 target.fAnalysisUtils = fAnalysisUtils;
372 target.fCutspreselect = fCutspreselect;
373 target.fSecVtx = fSecVtx;
374 target.fElecBackGround = fElecBackGround;
375 target.fMCQA = fMCQA;
376 target.fTaggedTrackAnalysis = fTaggedTrackAnalysis;
377 target.fExtraCuts = fExtraCuts;
378 target.fBackgroundSubtraction = fBackgroundSubtraction;
379 target.fTRDTrigger = fTRDTrigger;
380 target.fWhichTRDTrigger = fWhichTRDTrigger;
7986e54e 381 target.fV0Tagger = fV0Tagger;
01745870 382 target.fQA = fQA;
383 target.fOutput = fOutput;
384 target.fHistMCQA = fHistMCQA;
385 target.fHistSECVTX = fHistSECVTX;
386 target.fHistELECBACKGROUND = fHistELECBACKGROUND;
387 target.fQACollection = fQACollection;
388}
389
390//____________________________________________________________
391AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){
392 //
393 // Destructor
394 //
395 if(fPID) delete fPID;
396 if(fPIDpreselect) delete fPIDpreselect;
397 if(fVarManager) delete fVarManager;
ff8249bd 398 if(fTRDTriggerAnalysismb) delete fTRDTriggerAnalysismb;
399 if(fTRDTriggerAnalysistrg) delete fTRDTriggerAnalysistrg;
01745870 400 if(fCFM) delete fCFM;
401 if(fTriggerAnalysis) delete fTriggerAnalysis;
402 if(fSignalCuts) delete fSignalCuts;
403 if(fSecVtx) delete fSecVtx;
404 if(fMCQA) delete fMCQA;
405 if(fElecBackGround) delete fElecBackGround;
406 if(fBackgroundSubtraction) delete fBackgroundSubtraction;
407 if(fSpecialTrigger) delete fSpecialTrigger;
408 if(fAnalysisUtils) delete fAnalysisUtils;
7986e54e 409 if(fV0Tagger) delete fV0Tagger;
01745870 410 // Delete output objects only if we are not running in PROOF mode because otherwise this produces a crash during merging
411 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
412 if(mgr && mgr->GetAnalysisType() != AliAnalysisManager::kProofAnalysis){
413 if(fPIDqa) delete fPIDqa;
414 if(fOutput) delete fOutput;
415 if(fQA) delete fQA;
416 }
417}
418
419//____________________________________________________________
420void AliAnalysisTaskHFE::UserCreateOutputObjects(){
421 //
422 // Creating output container and output objects
423 // Here we also Initialize the correction framework container and
424 // the objects for
425 // - PID
426 // - MC QA
427 // - SecVtx
428 // QA histograms are created if requested
429 // Called once per worker
430 //
431 AliDebug(3, "Creating Output Objects");
432
433 // Make lists for Output
434 if(!fQA) fQA = new TList;
435 fQA->SetOwner();
436 if(!fOutput) fOutput = new TList;
437 fOutput->SetOwner();
438
439 // Automatic determination of the analysis mode
440 AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
441 if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){
442 SetAODAnalysis();
443 } else {
444 SetESDAnalysis();
445 if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler())
446 SetHasMCData();
447 }
448 printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD");
449 printf("MC Data available %s\n", HasMCData() ? "Yes" : "No");
450
451 // Enable Trigger Analysis
452 fTriggerAnalysis = new AliTriggerAnalysis;
453 fTriggerAnalysis->EnableHistograms();
454 fTriggerAnalysis->SetAnalyzeMC(HasMCData());
455
456 // First Part: Make QA histograms
457 fQACollection = new AliHFEcollection("TaskQA", "QA histos from the Electron Task");
458 fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100);
459 fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100);
460 fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0);
461 fQACollection->CreateTH1F("nTriggerBit", "Histo Trigger Bit", 22, 0, 22);
ff8249bd 462 fQACollection->CreateTH2F("TriggerAnalysis","TRD Trigger Analysis",10,0.,10.,10,0.,10.);
e2861c1a 463 fQACollection->CreateTH1F("Filterbegin", "AOD filter of tracks after all cuts", 21, -1, 20);
47faab26 464 fQACollection->CreateTH1F("Filterend", "AOD filter of tracks after all cuts", 21, -1, 20);
2e4ed823 465 fQACollection->CreateTH2F("Kinkbefore", "Kink status before filter; p_{T} (GeV/c); kink status", 100, 0., 20., 3, -0.5, 2.5);
466 fQACollection->CreateTH2F("Kinkafter", "Kink status after filter; p_{T} (GeV/c); kink status", 100, 0., 20., 3, -0.5, 2.5);
467 fQACollection->CreateTH1F("HFPuzzle", "Source definition for electrons from HF", 11, -0.5, 10.5);
7bdde22f 468 InitHistoRadius();
01745870 469 InitHistoITScluster();
470 InitContaminationQA();
471 fQA->Add(fQACollection);
472
473 // Initialize PID
474 fPID->SetHasMCData(HasMCData());
475 if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0);
476 if(IsQAOn(kPIDqa)){
477 AliInfo("PID QA switched on");
478 fPIDqa->Initialize(fPID);
479 fQA->Add(fPIDqa->MakeList("HFEpidQA"));
480 }
481 fPID->SortDetectors();
482
483 // Background subtraction-------------------------------------------------------------------
ff8249bd 484 if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) {
01745870 485 if(!fBackgroundSubtraction) fBackgroundSubtraction = new AliHFENonPhotonicElectron();
486 if(IsAODanalysis()) fBackgroundSubtraction->SetAOD(kTRUE);
487 fBackgroundSubtraction->Init();
488 fOutput->Add(fBackgroundSubtraction->GetListOutput());
489 }
490 //------------------------------------------------------------------------------------------
491
492
493 // Initialize correction Framework and Cuts
494 const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack + AliHFEcuts::kNcutStepsSecvtxTrack;
495 fCFM = new AliCFManager;
496 fCFM->SetNStepParticle(kNcutSteps);
497 MakeParticleContainer();
498 MakeEventContainer();
499 // Temporary fix: Initialize particle cuts with NULL
500 for(Int_t istep = 0; istep < kNcutSteps; istep++)
501 fCFM->SetParticleCutsList(istep, NULL);
502 if(!fCuts){
503 AliWarning("Cuts not available. Default cuts will be used");
504 fCuts = new AliHFEcuts;
505 fCuts->CreateStandardCuts();
506 }
507 if(IsAODanalysis()) fCuts->SetAOD();
508 // Make clone for V0 tagging step
509 fCuts->Initialize(fCFM);
510 if(fCuts->IsQAOn()) fQA->Add(fCuts->GetQAhistograms());
511 fSignalCuts = new AliHFEsignalCuts("HFEsignalCuts", "HFE MC Signal definition");
512 fVarManager->SetSignalCuts(fSignalCuts);
513
514 // add output objects to the List
515 fOutput->AddAt(fContainer, 0);
516 fOutput->AddAt(fCFM->GetEventContainer(), 1);
517
518 // mcQA----------------------------------
519 if (HasMCData() && IsQAOn(kMCqa)) {
520 AliInfo("MC QA on");
521 if(!fMCQA) fMCQA = new AliHFEmcQA;
522 if(!fHistMCQA) fHistMCQA = new TList();
523 fHistMCQA->SetOwner();
524 if(IsPbPb()) fMCQA->SetPbPb();
525 if(fisppMultiBin) fMCQA->SetPPMultiBin();
526 if(TestBit(kTreeStream)){
527 fMCQA->EnableDebugStreamer();
528 }
7bdde22f 529 if(TestBit(kWeightHist)){
530 fMCQA->EnableGetWeightHist();
531 }
01745870 532 fMCQA->CreatDefaultHistograms(fHistMCQA);
533 fMCQA->SetBackgroundWeightFactor(fElecBackgroundFactor[0][0][0],fBinLimit);
534 fQA->Add(fHistMCQA);
535 }
536
537 // secvtx----------------------------------
538 if (GetPlugin(kSecVtx)) {
539 AliInfo("Secondary Vertex Analysis on");
540 if(!fSecVtx) fSecVtx = new AliHFEsecVtx;
541 fSecVtx->SetHasMCData(HasMCData());
542
543 if(!fHistSECVTX) fHistSECVTX = new TList();
544 fHistSECVTX->SetOwner();
545 fSecVtx->CreateHistograms(fHistSECVTX);
546 fOutput->Add(fHistSECVTX);
547 }
548
549 // background----------------------------------
550 if (GetPlugin(kIsElecBackGround)) {
551 AliInfo("Electron BackGround Analysis on");
552 if(!fElecBackGround){
553 AliWarning("ElecBackGround not available. Default elecbackground will be used");
554 fElecBackGround = new AliHFEelecbackground;
555 }
556 fElecBackGround->SetHasMCData(HasMCData());
557
558 if(!fHistELECBACKGROUND) fHistELECBACKGROUND = new TList();
559 fHistELECBACKGROUND->SetOwner();
560 fElecBackGround->CreateHistograms(fHistELECBACKGROUND);
561 fOutput->Add(fHistELECBACKGROUND);
562 }
563
564 // tagged tracks
565 if(GetPlugin(kTaggedTrackAnalysis)){
566 AliInfo("Analysis on V0-tagged tracks enabled");
567 fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis(Form("taggedTrackAnalysis%s", GetName()));
568 fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts);
569 fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack);
ff8249bd 570 if(IsAODanalysis()) fTaggedTrackAnalysis->SetAOD();
01745870 571 AliHFEvarManager *varManager = fTaggedTrackAnalysis->GetVarManager();
572 TObjArray *array = fVarManager->GetVariables();
573 Int_t nvars = array->GetEntriesFast();
574 TString namee;
575 for(Int_t v = 0; v < nvars; v++) {
576 AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);
577 if(!variable) continue;
578 TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());
579 if(!name.CompareTo("source")) namee = TString("species");
580 else namee = TString(name);
581 Int_t nbins = variable->GetNumberOfBins();
582 if(variable->HasUserDefinedBinning()){
583 varManager->AddVariable(namee, nbins, variable->GetBinning());
584 } else {
585 varManager->AddVariable(namee, nbins, variable->GetMinimum(), variable->GetMaximum());
586 }
587 //printf("For AliTaggedTrackAnalysis, had the variable %s and the one used %s\n",(const char*)variable->GetName(),(const char*) namee);
588 }
589 if(fPIDqa->HasHighResolutionHistos())
590 fTaggedTrackAnalysis->GetPIDqa()->SetHighResolutionHistos();
591 fTaggedTrackAnalysis->SetPID(fPID);
592 fTaggedTrackAnalysis->SetVariablesTRD(fVariablesTRDTaggedTrack);
593 fTaggedTrackAnalysis->InitContainer();
594 fOutput->Add(fTaggedTrackAnalysis->GetContainer());
595 fQA->Add(fTaggedTrackAnalysis->GetPIDQA());
596 fQA->Add(fTaggedTrackAnalysis->GetCutQA());
597 fQA->Add(fTaggedTrackAnalysis->GetQAcollection());
598 }
599
600 //fQA->Print();
601
602 PrintStatus();
603 // Done!!!
604 PostData(1, fOutput);
605 PostData(2, fQA);
606}
607
608//____________________________________________________________
609void AliAnalysisTaskHFE::UserExec(Option_t *){
610 //
611 // Run the analysis
612 //
613
614 //printf("test00\n");
615
616 AliDebug(3, "Starting Single Event Analysis");
617 if(!fInputEvent){
618 AliError("Reconstructed Event not available");
619 //printf("Reconstructed Event not available");
620 return;
621 }
622 if(HasMCData() && IsESDanalysis()){
623 AliDebug(4, Form("MC Event: %p", fMCEvent));
624 if(!fMCEvent){
625 AliError("No MC Event, but MC Data required");
626 //printf("No MC Event, but MC Data required");
627 return;
628 }
629 }
630 if(!fCuts){
631 AliError("HFE cuts not available");
632 //printf("HFE cuts not available");
633 return;
634 }
635 if(!fPID->IsInitialized()){
636 // Initialize PID with the given run number
637 fPID->InitializePID(fInputEvent->GetRunNumber());
638 }
639
640 if(fRemoveFirstEvent){
641 if(fAnalysisUtils->IsFirstEventInChunk(fInputEvent)) return;
642 }
643
644 AliESDEvent *ev = dynamic_cast<AliESDEvent *>(fInputEvent);
4437a0d2 645 if(ev && fTRDTrigger && (fWhichTRDTrigger<6))
01745870 646 {
4437a0d2 647 if(!CheckTRDTriggerESD(ev)) return;
648 }
649 if(fInputEvent && fTRDTrigger && (fWhichTRDTrigger>5))
650 {
651 if(!CheckTRDTrigger(fInputEvent)) return;
01745870 652 }
01745870 653
654 if(IsESDanalysis() && HasMCData()){
655 // Protect against missing MC trees
656 AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
657 if(!mcH){
658 AliError("No MC Event Handler available");
659 return;
660 }
661 if(!mcH->InitOk()) return;
662 if(!mcH->TreeK()) return;
663 if(!mcH->TreeTR()) return;
664
665 // Background subtraction-------------------------------------------------------------------
465ff082 666 if(GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->SetMCEvent(fMCEvent);
01745870 667 //------------------------------------------------------------------------------------------
668 }
669
670 if(IsAODanalysis() && HasMCData()){
671 // take MC info
672 AliAODEvent *aodE = dynamic_cast<AliAODEvent *>(fInputEvent);
673 if(!aodE){
674 AliError("No AOD Event");
675 return;
676 }
677 fAODMCHeader = dynamic_cast<AliAODMCHeader *>(fInputEvent->FindListObject(AliAODMCHeader::StdBranchName()));
678 if(!fAODMCHeader){
679 AliError("No AliAODMCHeader");
680 //printf("No AliAODMCHeader");
681 return;
682 }
683 fAODArrayMCInfo = dynamic_cast<TClonesArray *>(fInputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
684 if(!fAODArrayMCInfo){
685 AliError("No AOD MC particles");
686 //printf("No AOD MC particles");
687 return;
688 }
689 fSignalCuts->SetMCAODInfo(fAODArrayMCInfo);
690 // Background subtraction-------------------------------------------------------------------
ff8249bd 691 if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->SetAODArrayMCInfo(fAODArrayMCInfo);
01745870 692 //------------------------------------------------------------------------------------------
693 }
694
695 //printf("test2\n");
696
697 // need the centrality for everything (MC also)
698 fCentralityF = -1;
699 if(!ReadCentrality()) fCentralityF = -1;
700 //printf("pass centrality\n");
701 //printf("Reading fCentralityF %d\n",fCentralityF);
702
703 // See if pile up and z in the range
704 RejectionPileUpVertexRangeEventCut();
705
706 //printf("test3\n");
707
708 // Protect agains missing
709 if(HasMCData()){
710 //printf("Has MC data\n");
711 fSignalCuts->SetMCEvent(fMCEvent);
712 ProcessMC(); // Run the MC loop + MC QA in case MC Data are available
713 }
714
715 AliPIDResponse *pidResponse = fInputHandler->GetPIDResponse();
716 if(!pidResponse){
717 AliDebug(1, "Using default PID Response");
718 pidResponse = AliHFEtools::GetDefaultPID(HasMCData(), fInputEvent->IsA() == AliESDEvent::Class());
719 }
720 fPID->SetPIDResponse(pidResponse);
721 if(fPIDpreselect) fPIDpreselect->SetPIDResponse(pidResponse);
722
723 // Background subtraction-------------------------------------------------------------------
ff8249bd 724 if(GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->InitRun(fInputEvent,pidResponse);
01745870 725 //------------------------------------------------------------------------------------------
726
727 // Event loop
728 if(IsAODanalysis()){
729 //printf("test4\n");
730 ProcessAOD();
731 } else {
732 const char *specialTrigger = GetSpecialTrigger(fInputEvent->GetRunNumber());
733 // Check Trigger selection
734 if(specialTrigger){
735 AliDebug(2, Form("Special Trigger requested: %s", specialTrigger));
736 if(!(ev && ev->IsTriggerClassFired(specialTrigger))){
737 AliDebug(2, "Event not selected");
738 return;
739 } else AliDebug(2, "Event Selected");
740 } else AliDebug(2, "No Special Trigger requested");
741
742 ProcessESD();
743 }
744 // Done!!!
745 PostData(1, fOutput);
746 PostData(2, fQA);
747}
748
749//____________________________________________________________
750void AliAnalysisTaskHFE::Terminate(Option_t *){
751 //
752 // Terminate not implemented at the moment
753 //
754}
755
756//_______________________________________________________________
757Bool_t AliAnalysisTaskHFE::IsEventInBinZero() {
758 //
759 //
760 //
761
762 //printf("test in IsEventInBinZero\n");
763 if(!fInputEvent){
764 AliError("Reconstructed Event not available");
765 return kFALSE;
766 }
767
768 // check vertex
769 const AliVVertex *vertex = fInputEvent->GetPrimaryVertex();
770 if(!vertex) return kTRUE;
771 //if(vertex) return kTRUE;
772
773 // check tracks
774 if(fInputEvent->GetNumberOfTracks()<=0) return kTRUE;
775 //if(fInputEvent->GetNumberOfTracks()>0) return kTRUE;
776
777
778 return kFALSE;
779
780}
781//____________________________________________________________
782void AliAnalysisTaskHFE::ProcessMC(){
783 //
784 // Runs the MC Loop (filling the container for the MC Cut Steps with the observables pt, eta and phi)
785 // In case MC QA is on also MC QA loop is done
786 //
787 AliDebug(3, "Processing MC Information");
788 Double_t eventContainer [4] = {0., 0., 0., 0.};
789 if(IsESDanalysis()) eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ();
790 else eventContainer[0] = fAODMCHeader->GetVtxZ();
791 eventContainer[2] = fCentralityF;
792 eventContainer[3] = fContributors;
793 fVz = eventContainer[0];
794 //printf("z position is %f\n",eventContainer[0]);
795 //if(fCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent))
796 fCFM->GetEventContainer()->Fill(eventContainer,AliHFEcuts::kEventStepGenerated);
797 Int_t nElectrons = 0;
798 if(IsESDanalysis()){
799 if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine
800 if (HasMCData() && IsQAOn(kMCqa)) {
801 AliDebug(2, "Running MC QA");
802
803 if(fMCEvent->Stack()){
804 fMCQA->SetMCEvent(fMCEvent);
805 fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader());
806 fMCQA->SetCentrality(fCentralityF);
807 fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
808 if(IsPbPb()) { fMCQA->SetPbPb();}
809 else
810 {
811 if(fisppMultiBin) fMCQA->SetPPMultiBin();
812 else fMCQA->SetPP();
813 }
814 fMCQA->Init();
815
816 fMCQA->GetMesonKine();
817
818 // loop over all tracks for decayed electrons
819 for (Int_t igen = 0; igen < fMCEvent->GetNumberOfTracks(); igen++){
820 TParticle* mcpart = fMCEvent->Stack()->Particle(igen);
821 if(!mcpart) continue;
822 fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kCharm);
823 fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kBeauty);
824 fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kCharm);
825 fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kBeauty);
826 fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG); // no accept cut
827 fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut
828 fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut
829 }
830 //fMCQA->EndOfEventAna(AliHFEmcQA::kCharm);
831 //fMCQA->EndOfEventAna(AliHFEmcQA::kBeauty);
832 }
833
834 } // end of MC QA loop
835 }
836 // -----------------------------------------------------------------
837 fCFM->SetMCEventInfo(fMCEvent);
838 // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
839 } else {
2e4ed823 840 fMCQA->SetMCArray(fAODArrayMCInfo);
ff8249bd 841
842 if(!((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0))){ //kStepMCGeneratedZOutNoPileUpCentralityFine
843 if (HasMCData() && IsQAOn(kMCqa)) {
844 AliDebug(2, "Running MC QA");
845
846 fMCQA->SetCentrality(fCentralityF);
847 fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
848
849 if(IsPbPb()) { fMCQA->SetPbPb();}
850 else
851 {
852 if(fisppMultiBin) fMCQA->SetPPMultiBin();
853 else fMCQA->SetPP();
854 }
855 fMCQA->Init();
856
857 //fMCQA->GetMesonKine();
858
859 // loop over all tracks for decayed electrons
860 AliAODMCParticle * mcpart;
861 for (Int_t igen = 0; igen < fAODArrayMCInfo->GetEntriesFast(); igen++){
862 mcpart = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(igen));
863 if(!mcpart) continue;
864 fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG); // no accept cut
865 fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG); // no accept cut
866 fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG); // no accept cut
867 }
868
869 } // end of MC QA loop
870 }
871
01745870 872 fCFM->SetMCEventInfo(fInputEvent);
873 }
874 // Run MC loop
875 AliVParticle *mctrack = NULL;
876 Int_t numberofmctracks = 0;
877 if(IsESDanalysis()){
878 numberofmctracks = fMCEvent->GetNumberOfTracks();
879 }
880 else {
881 numberofmctracks = fAODArrayMCInfo->GetEntriesFast();
882 }
883 AliDebug(3, Form("Number of Tracks: %d",numberofmctracks));
884 //printf("Number of MC track %d\n",numberofmctracks);
885 for(Int_t imc = 0; imc <numberofmctracks; imc++){
886 if(IsESDanalysis()) {
887 if(!(mctrack = fMCEvent->GetTrack(imc))) continue;
888 }
889 else {
890 if(!(mctrack = (AliVParticle *) fAODArrayMCInfo->At(imc))) continue;
891 }
892 //printf("Test in ProcessMC\n");
893 AliDebug(4, "Next MC Track");
894 if(ProcessMCtrack(mctrack)) nElectrons++;
895 }
896
897 // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD);
898 fQACollection->Fill("nElectron", nElectrons);
899}
900
901//____________________________________________________________
902void AliAnalysisTaskHFE::ProcessESD(){
903 //
904 // Run Analysis of reconstructed event in ESD Mode
905 // Loop over Tracks, filter according cut steps defined in AliHFEcuts
906 //
907 AliDebug(1, Form("Task %s", GetName()));
908 AliDebug(3, "Processing ESD Event");
909 AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
910 if(!fESD){
911 AliError("ESD Event required for ESD Analysis");
912 return;
913 }
914
915 // Set magnetic field if V0 task on
916 if(fTaggedTrackAnalysis) {
2e4ed823 917 // Tag all v0s in current event
918 if(fV0Tagger){
919 fV0Tagger->Reset();
920 fV0Tagger->TagV0Tracks(fESD);
921 }
01745870 922 fTaggedTrackAnalysis->SetMagneticField(fESD->GetMagneticField());
923 fTaggedTrackAnalysis->SetCentrality(fCentralityF);
4437a0d2 924 if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
925 else {
2e4ed823 926 if(IspPb()) fTaggedTrackAnalysis->SetpPb();
927 else fTaggedTrackAnalysis->SetPP();
4437a0d2 928 }
01745870 929 }
930
931 // Do event Normalization
932 Double_t eventContainer[4];
933 eventContainer[0] = 0.;
934 if(HasMCData()) eventContainer[0] = fVz;
935 else {
936 const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
937 if(vtxESD) eventContainer[0] = vtxESD->GetZ();
938 }
939 eventContainer[1] = 0.;
940 eventContainer[2] = fCentralityF;
941 eventContainer[3] = fContributors;
942 if(fTriggerAnalysis->IsOfflineTriggerFired(fESD, AliTriggerAnalysis::kV0AND))
943 eventContainer[1] = 1.;
944
945 //
946 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);
947
948 //
949 if(fIdentifiedAsPileUp) return;
950 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);
951
952 //
953 if(TMath::Abs(fCentralityF) < 0) return;
954 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecCentralityOk);
955 //printf("In ProcessESD %f\n",fCentralityF);
956
957 //
958 if(fIdentifiedAsOutInz) return;
959 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);
960
961 //
962 if(!fPassTheEventCut) return;
963 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);
964
965
966 fContainer->NewEvent();
967
968 if (GetPlugin(kIsElecBackGround)) {
969 fElecBackGround->SetEvent(fESD);
970 }
971 if (GetPlugin(kSecVtx)) {
972 fSecVtx->SetEvent(fESD);
973 fSecVtx->GetPrimaryCondition();
974 }
975
976 if(HasMCData()){
977 if (GetPlugin(kSecVtx)) {
978 fSecVtx->SetMCEvent(fMCEvent);
979 fSecVtx->SetMCQA(fMCQA);
980 }
981 if (GetPlugin(kIsElecBackGround)) {
982 fElecBackGround->SetMCEvent(fMCEvent);
983 }
984 }
985
986 Double_t container[10];
987 memset(container, 0, sizeof(Double_t) * 10);
988 // container for the output THnSparse
989 Double_t dataDca[6]; // [source, pT, dca, centrality]
990 Int_t nElectronCandidates = 0;
991 AliESDtrack *track = NULL, *htrack = NULL;
992 AliMCParticle *mctrack = NULL;
993 AliMCParticle *mctrackmother = NULL;
994
995 Bool_t signal = kTRUE;
996
997 fCFM->SetRecEventInfo(fESD);
998
999 // Get Number of contributors to the primary vertex for multiplicity-dependent correction
1000 Int_t ncontribVtx = 0;
1001 const AliESDVertex *priVtx = fESD->GetPrimaryVertexTracks();
1002 if(priVtx){
1003 ncontribVtx = priVtx->GetNContributors();
1004 }
1005
1006 // minjung for IP QA(temporary ~ 2weeks)
1007 if(!fExtraCuts){
1008 fExtraCuts = new AliHFEextraCuts("hfetmpCuts","HFE tmp Cuts");
1009 }
1010 fExtraCuts->SetRecEventInfo(fESD);
1011
1012 // Electron background analysis
1013 if (GetPlugin(kIsElecBackGround)) {
1014
1015 AliDebug(2, "Running BackGround Analysis");
1016
1017 fElecBackGround->Reset();
1018
1019 } // end of electron background analysis
1020
1021
1022 // Background subtraction-------------------------------------------------------------------
465ff082 1023 if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
01745870 1024 //------------------------------------------------------------------------------------------
1025
1026 //
1027 // Loop ESD
1028 //
1029 AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks()));
2e4ed823 1030 Bool_t kinkmother(kFALSE), kinkdaughter(kFALSE); Double_t kinkstatus(0);
01745870 1031 for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){
1032 AliDebug(4, "New ESD track");
1033 track = fESD->GetTrack(itrack);
1034 track->SetESDEvent(fESD);
2e4ed823 1035 kinkmother = track->GetKinkIndex(0) < 0; kinkdaughter = track->GetKinkIndex(0) > 0;
1036 kinkstatus = 0.;
1037 if(kinkmother) kinkstatus = 1.;
1038 else if(kinkdaughter) kinkstatus = 2.;
4437a0d2 1039
01745870 1040 // fill counts of v0-identified particles
dab4f95d 1041 AliPID::EParticleType v0pid = fV0Tagger ? fV0Tagger->GetV0Info(track->GetID()) : AliPID::kUnknown;
01745870 1042 // here the tagged track analysis will run
7986e54e 1043 if(fTaggedTrackAnalysis && v0pid != AliPID::kUnknown){
01745870 1044 AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
1045 fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
1046 AliDebug(1, "V0 PID done");
1047 }
1048
1049
1050 //Fill non-HFE source containers at reconstructed events cut step
1051 AliDebug(3, Form("Doing track %d, %p", itrack, track));
1052
1053
1054 //////////////////////////////////////
1055 // preselect
1056 //////////////////////////////////////
1057 if(fPIDpreselect || fCutspreselect) {
1058 if(!PreSelectTrack(track)) continue;
1059 }
1060
1061 signal = kTRUE;
1062
1063 // Fill step without any cut
1064
1065 if(HasMCData()){
1066 // Check if it is electrons near the vertex
1067 if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue;
1068
1069 if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
2e4ed823 1070 if(fRejectMCFakeTracks && IsMCFakeTrack(track)) signal = kFALSE;
01745870 1071 else AliDebug(3, "Signal Electron");
1072
1073 // Fill K pt for Ke3 contributions
1074 if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==321)) fQACollection->Fill("Kptspectra",mctrack->Pt());
1075 else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode())==130)) fQACollection->Fill("K0Lptspectra",mctrack->Pt());
1076 }
1077 // Cache new Track information inside the var manager
1078 fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);
1079
1080 if(fFillNoCuts) {
1081 if(signal || !fFillSignalOnly){
1082 fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);
1083 fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
1084 }
1085 }
1086
1087 // RecKine: ITSTPC cuts
1088 if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
1089
2e4ed823 1090 fQACollection->Fill("Kinkbefore", track->Pt(), kinkstatus);
01745870 1091 // RecPrim
1092 if(fRejectKinkMother) {
1093 if(track->GetKinkIndex(0) != 0) continue; } // Quick and dirty fix to reject both kink mothers and daughters
1094 if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
2e4ed823 1095 fQACollection->Fill("Kinkafter", track->Pt(), kinkstatus);
01745870 1096
7bdde22f 1097 // production radius
5565ef0f 1098 Double_t pradius[3] = {(Double_t)fCentralityF,track->Pt(),-1.};
7bdde22f 1099 Bool_t fill = kFALSE;
1100 if(HasMCData()){
1101 Int_t labelr = track->GetLabel();
1102 if(labelr >=0) {
1103 AliMCParticle *mctrackk = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(labelr));
5565ef0f 1104 if(mctrackk && (TMath::Abs(mctrackk->Particle()->GetPdgCode()) == 11)) {
7bdde22f 1105 Int_t motherlabel = mctrackk->Particle()->GetFirstMother();
1106 if(motherlabel >= 0){
1107 AliMCParticle *mothertrack = NULL;
1108 if((mothertrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(motherlabel)))){
1109 TParticle * mother = mothertrack->Particle();
1110 Int_t pdgmother = mother->GetPdgCode();
1111 if(pdgmother == 22) {
1112 pradius[2] = mctrackk->Particle()->R();
1113 fill = kTRUE;
1114 }
1115 }
1116 }
1117 }
1118 }
1119 if(fill) fQACollection->Fill("RadiusBefore", pradius);
1120 }
1121
01745870 1122 // HFEcuts: ITS layers cuts
1123 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
1124
7bdde22f 1125 // production vertex
1126 if(fill) {
1127 fQACollection->Fill("RadiusAfter", pradius);
1128 FillProductionVertex(track);
1129 }
1130
01745870 1131 // HFE cuts: TOF PID and mismatch flag
1132 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;
1133
1134 // HFE cuts: TPC PID cleanup
1135 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;
1136
1137 // HFEcuts: Nb of tracklets TRD0
1138 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;
1139
1140 // Fill correlation maps before PID
1141 if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
1142 //printf("Fill correlation maps before PID\n");
1143 fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
1144 }
1145
1146 if(HasMCData()){
7bdde22f 1147 //FillProductionVertex(track);
01745870 1148
1149 if(fMCQA && signal){
1150 fMCQA->SetCentrality(fCentralityF);
1151 if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){
1152 Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
1153 Double_t hfeimpactRtmp=0., hfeimpactnsigmaRtmp=0.;
1154 fExtraCuts->GetHFEImpactParameters(track, hfeimpactRtmp, hfeimpactnsigmaRtmp);
1155 UChar_t itsPixel = track->GetITSClusterMap();
1156 Double_t ilyrhit=0, ilyrstat=0;
1157 for(Int_t ilyr=0; ilyr<6; ilyr++){
1158 if(TESTBIT(itsPixel, ilyr)) ilyrhit += TMath::Power(2,ilyr);
1159 if(fExtraCuts->CheckITSstatus(fExtraCuts->GetITSstatus(track,ilyr))) ilyrstat += TMath::Power(2,ilyr);
1160 }
1161 fMCQA->SetITSInfo(ilyrhit,ilyrstat);
1162 fMCQA->SetHFEImpactParameters(hfeimpactRtmp, hfeimpactnsigmaRtmp);
1163 fMCQA->SetTrkKine(track->Pt(),track->Eta(), track->Phi());
1164 fMCQA->SetContainerStep(3);
1165 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1166 weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
1167 if(!fisNonHFEsystematics || IsPbPb())break;
1168 }
1169
1170 if(fisNonHFEsystematics){
1171 //Fill additional containers for electron source distinction
1172 Int_t elecSource = 0;
7bdde22f 1173 elecSource = fMCQA->GetElecSource(mctrack->Particle(), kTRUE);
01745870 1174 const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
1175 const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
1176 Int_t iName = 0;
1177 for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){
1178 if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
1179 if(elecSource == iSource){
1180 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1181 if(weightElecBgV0[iLevel]>0){
1182 fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, weightElecBgV0[iLevel]);
1183 }
1184 else if(weightElecBgV0[iLevel]<0){
1185 fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 3, kFALSE, -1*weightElecBgV0[iLevel]);
1186 }
1187 if(IsPbPb())break;
1188 }
1189 break;
1190 }
1191 iName++;
1192 if(iName == kElecBgSpecies)iName = 0;
1193 }
1194 }
1195 //else{
1196 if(weightElecBgV0[0]>0) {
1197 fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);
1198 fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);
1199 }
1200 else if(weightElecBgV0[0]<0) {
1201 fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);
1202 fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);
1203 }
1204 //}
1205 }
1206 }
1207
1208 Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
1209 Int_t sourceDca =-1;
1210 if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 211)){
1211 if(track->Pt()>4.){
1212 fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
1213 dataDca[0]=0; //pion
1214 dataDca[1]=track->Pt();
1215 dataDca[2]=hfeimpactR4all;
1216 dataDca[3]=fCentralityF;
1217 dataDca[4] = v0pid;
1218 dataDca[5] = double(track->Charge());
1219 fQACollection->Fill("Dca", dataDca);
1220 }
1221 }
1222 else if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) == 11)){ // to increas statistics for Martin
1223 if(signal){
1224 fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
1225 if(fSignalCuts->IsCharmElectron(track)){
1226 sourceDca=1;
1227 }
1228 else if(fSignalCuts->IsBeautyElectron(track)){
1229 sourceDca=2;
1230 }
1231 else if(fSignalCuts->IsGammaElectron(track)){
1232 sourceDca=3;
1233 }
1234 else if(fSignalCuts->IsNonHFElectron(track)){
1235 sourceDca=4;
1236 }
1237 else if(fSignalCuts->IsJpsiElectron(track)){
1238 sourceDca=5;
1239 }
1240 else {
1241 sourceDca=6;
1242 }
1243 dataDca[0]=sourceDca;
1244 dataDca[1]=track->Pt();
1245 dataDca[2]=hfeimpactR4all;
1246 dataDca[3]=fCentralityF;
1247 dataDca[4] = v0pid;
1248 dataDca[5] = double(track->Charge());
1249 if(signal) fQACollection->Fill("Dca", dataDca);
1250 }
1251 }
1252 }
1253
1254 AliHFEpidObject hfetrack;
1255 hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
1256 hfetrack.SetRecTrack(track);
1257 if(HasMCData()) hfetrack.SetMCTrack(mctrack);
1258 hfetrack.SetCentrality(fCentralityF);
1259 hfetrack.SetMulitplicity(ncontribVtx);
4437a0d2 1260 if(IsPbPb()) hfetrack.SetPbPb();
1261 else {
1262 if(IspPb()) hfetrack.SetpPb();
1263 else hfetrack.SetPP();
1264 }
01745870 1265 fPID->SetVarManager(fVarManager);
1266 if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
1267 nElectronCandidates++;
1268
1269 // Background subtraction------------------------------------------------------------------------------------------
465ff082 1270 if (GetPlugin(kNonPhotonicElectron)&&!GetPlugin(kNonPhotonicElectronBeauty)) {
01745870 1271 Int_t indexmother = -1;
1272 Int_t mcsource = -1;
ff8249bd 1273 Int_t mcQAsource = -1;
1274 Double_t weightNonPhotonicFactor = 1.;
01745870 1275 if(HasMCData()){
1276 mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
ff8249bd 1277 if(fBackgroundSubtraction->GetLevelBack()>=0) {
1278 if(fMCQA) {
465ff082 1279 fMCQA->SetCentrality(fCentralityF);
1280 fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
7bdde22f 1281 mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
ff8249bd 1282 weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
1283 }
1284 }
01745870 1285 }
ff8249bd 1286 fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1, mcsource, indexmother,mcQAsource);
01745870 1287 }
1288 //-----------------------------------------------------------------------------------------------------------------
1289
1290 // Temporary histogram for chi2/ITS cluster
1291 if(IsPbPb()) {
1292 TBits shared = track->GetTPCSharedMap();
1293 Int_t sharebit=0;
1294 if(shared.CountBits() >= 2) sharebit=1;
1295
1296 Double_t itschi2percluster = 0.0;
1297 Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
1298 if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
1299
1300 Double_t itsChi2[7] = {track->Pt(),track->Eta(), track->Phi(),
1301 static_cast<Double_t>(fCentralityF),static_cast<Double_t>(track->GetTPCsignalN()), static_cast<Double_t>(sharebit),itschi2percluster};
1302 fQACollection->Fill("fChi2perITScluster", itsChi2);
1303 }
1304 else{
1305
1306 Double_t itschi2percluster = 0.0;
1307 Double_t itsnbcls = static_cast<Double_t>(track->GetNcls(0));
1308 if(itsnbcls > 0) itschi2percluster = track->GetITSchi2()/itsnbcls;
1309
1310 Double_t itsChi2[3] = {track->Pt(), static_cast<Double_t>(fCentralityF), itschi2percluster};
1311 fQACollection->Fill("fChi2perITScluster", itsChi2);
1312 }
1313
1314 // Fill Histogram for Hadronic Background
1315 if(HasMCData()){
1316 if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11))
1317 fVarManager->FillContainer(fContainer, "hadronicBackground", UInt_t(0), kFALSE);
1318 else if(mctrack){
1319 // Fill Ke3 contributions
1320 Int_t glabel=TMath::Abs(mctrack->GetMother());
1321 if((mctrackmother = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(glabel)))){
1322 if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==321)
1323 fQACollection->Fill("Ke3Kecorr",mctrack->Pt(),mctrackmother->Pt());
1324 else if(TMath::Abs(mctrackmother->Particle()->GetPdgCode())==130)
1325 fQACollection->Fill("Ke3K0Lecorr",mctrack->Pt(),mctrackmother->Pt());
1326 }
1327 }
1328 }
1329
1330 // Fill Containers
1331 if(signal) {
1332 // Apply weight for background contamination
1333 if(fBackGroundFactorApply) {
4437a0d2 1334 if(IsPbPb() && fCentralityF >= 0) fWeightBackGround = fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
1335 else fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // for pp and pPb
01745870 1336
1337 if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
1338 else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
1339 // weightBackGround as special weight
1340 fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
1341 }
1342 fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));
1343 }
1344
1345 Bool_t bTagged=kFALSE;
1346 if(GetPlugin(kSecVtx)) {
1347 AliDebug(2, "Running Secondary Vertex Analysis");
1348 if(fSecVtx->Process(track) && signal) {
1349 fVarManager->FillContainer(fContainer, "recTrackContSecvtxReco", AliHFEcuts::kStepHFEcutsSecvtx, kFALSE);
1350 fVarManager->FillContainer(fContainer, "recTrackContSecvtxMC", AliHFEcuts::kStepHFEcutsSecvtx, kTRUE);
1351 bTagged=kTRUE;
1352 }
1353 }
1354
1355 // Electron background analysis
1356 if (GetPlugin(kIsElecBackGround)) {
1357
1358 AliDebug(2, "Running BackGround Analysis");
1359
1360 for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){
1361 htrack = fESD->GetTrack(jtrack);
1362 if ( itrack == jtrack ) continue;
1363 fElecBackGround->PairAnalysis(track, htrack);
1364 }
1365 } // end of electron background analysis
1366
1367 if (GetPlugin(kDEstep)) {
1368 Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.,};
1369 Int_t elecSource = 0;
1370 Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;
1371 fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);
1372 if(HasMCData())
1373 {
1374 if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
1375 fQACollection->Fill("hadronsBeforeIPcut",track->Pt());
1376 }
1377 if(fMCQA && signal) {
1378
1379 fMCQA->SetContainerStep(0);
1380 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1381 weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
1382 if(!fisNonHFEsystematics || IsPbPb())break;
1383 }
1384
1385 if(fisNonHFEsystematics){
1386 //Fill additional containers for electron source distinction
7bdde22f 1387 elecSource = fMCQA->GetElecSource(mctrack->Particle(), kTRUE);
01745870 1388 const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
1389 const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
1390 Int_t iName = 0;
1391 for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){
1392 if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
1393 if(elecSource == iSource){
1394 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1395 if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, weightElecBgV0[iLevel]);
1396 else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 0, kFALSE, -1*weightElecBgV0[iLevel]);
1397 if(IsPbPb())break;
1398 }
1399 break;
1400 }
1401 iName++;
1402 if(iName == kElecBgSpecies)iName = 0;
1403 }
1404 }
1405 //else{
1406 if(weightElecBgV0[0]>0) {
1407 fVarManager->FillContainer(fContainer, "conversionElecs", 0, kFALSE, weightElecBgV0[0]);
1408 fVarManager->FillContainer(fContainer, "conversionElecs", 5, kTRUE, weightElecBgV0[0]);
1409 }
1410 else if(weightElecBgV0[0]<0) {
1411 fVarManager->FillContainer(fContainer, "mesonElecs", 0, kFALSE, -1*weightElecBgV0[0]);
1412 fVarManager->FillContainer(fContainer, "mesonElecs", 5, kTRUE, -1*weightElecBgV0[0]);
1413 }
1414 //}
1415 if(bTagged){ // bg estimation for the secondary vertex tagged signals
1416 if(weightElecBgV0[0]>0) fVarManager->FillContainer(fContainer, "conversionElecs", 2, kFALSE, weightElecBgV0[0]);
1417 else if(weightElecBgV0[0]<0) fVarManager->FillContainer(fContainer, "mesonElecs", 2, kFALSE, -1*weightElecBgV0[0]);
1418 }
1419 }
1420 } // end of MC
1421
1422 dataDca[0]=-1; //for data, don't know the origin
1423 dataDca[1]=track->Pt();
1424 dataDca[2]=hfeimpactR;
1425 dataDca[3]=fCentralityF;
1426 dataDca[4] = v0pid;
1427 dataDca[5] = double(track->Charge());
1428 if (!HasMCData()) fQACollection->Fill("Dca", dataDca);
1429
1430 // Fill Containers for impact parameter analysis
1431 if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
1432 if(signal) {
1433 // Apply weight for background contamination after ip cut
1434 if(fBackGroundFactorApply) {
1435 fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
1436 if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
1437 else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
1438 // weightBackGround as special weight
1439 fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
1440 }
1441 }
1442
1443 if(HasMCData()){
1444 if(fMCQA && signal) {
1445 fMCQA->SetContainerStep(1);
1446 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1447 weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
1448 if(!fisNonHFEsystematics || IsPbPb())break;
1449 }
1450 if(fisNonHFEsystematics){
1451 //Fill additional containers for electron source distinction
7bdde22f 1452 elecSource = fMCQA->GetElecSource(mctrack->Particle(), kTRUE);
01745870 1453 const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
1454 const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
1455 Int_t iName = 0;
1456 for(Int_t iSource = AliHFEmcQA::kPi0; iSource <= AliHFEmcQA::kGammaRho0; iSource++){
1457 if((iSource == AliHFEmcQA::kElse)||(iSource == AliHFEmcQA::kMisID)) continue;
1458 if(elecSource == iSource){
1459 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1460 if(weightElecBgV0[iLevel]>0) fVarManager->FillContainer(fContainer, Form("conversionElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, weightElecBgV0[iLevel]);
1461 else if(weightElecBgV0[iLevel]<0) fVarManager->FillContainer(fContainer, Form("mesonElecs%s%s",sourceName[iName], levelName[iLevel]), 1, kFALSE, -1*weightElecBgV0[iLevel]);
1462 if(IsPbPb())break;
1463 }
1464 break;
1465 }
1466 iName++;
1467 if(iName == kElecBgSpecies)iName = 0;
1468 }
1469 }
1470 // else{
1471 if(weightElecBgV0[0]>0) {
1472 fVarManager->FillContainer(fContainer, "conversionElecs", 1, kFALSE, weightElecBgV0[0]);
1473 fVarManager->FillContainer(fContainer, "conversionElecs", 6, kTRUE, weightElecBgV0[0]);
1474 }
1475 else if(weightElecBgV0[0]<0) {
1476 fVarManager->FillContainer(fContainer, "mesonElecs", 1, kFALSE, -1*weightElecBgV0[0]);
1477 fVarManager->FillContainer(fContainer, "mesonElecs", 6, kTRUE, -1*weightElecBgV0[0]);
1478 }
1479 //}
1480 }
1481 }
1482 if(signal) {
1483 fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);
1484 fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);
1485 fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
1486 }
1487 if(HasMCData()){
1488 if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){
1489 fQACollection->Fill("hadronsAfterIPcut",track->Pt());
1490 }
1491 }
1492 }
1493
465ff082 1494 // Background subtraction------------------------------------------------------------------------------------------
1495 if (!GetPlugin(kNonPhotonicElectron)&&GetPlugin(kNonPhotonicElectronBeauty)) {
1496 Int_t indexmother = -1;
1497 Int_t mcsource = -1;
1498 Int_t mcQAsource = -1;
1499 Double_t weightNonPhotonicFactor = 1.;
1500 if(HasMCData()){
1501 mcsource = fBackgroundSubtraction->FindMother(mctrack->GetLabel(),indexmother);
1502 if(fBackgroundSubtraction->GetLevelBack()>=0) {
1503 if(fMCQA) {
1504 fMCQA->SetCentrality(fCentralityF);
1505 fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
1506 mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
1507 weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
1508 }
1509 }
1510 }
1511 fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1, mcsource, indexmother,mcQAsource);
1512 }
1513 //-----------------------------------------------------------------------------------------------------------------
01745870 1514 }
1515
1516 // Background subtraction-------------------------------------------------------------------
465ff082 1517 if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
01745870 1518 //------------------------------------------------------------------------------------------
1519
1520 fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
1521}
1522
1523//____________________________________________________________
1524void AliAnalysisTaskHFE::ProcessAOD(){
1525 //
1526 // Run Analysis in AOD Mode
1527 // Function is still in development
1528 //
1529 //printf("Process AOD\n");
1530 AliDebug(3, "Processing AOD Event");
1531 Double_t eventContainer[4];
1532 eventContainer[0] = 0.0;
1533 if(HasMCData()) eventContainer[0] = fVz;
1534 else {
1535 if(fInputEvent->GetPrimaryVertex()) eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ();
1536 }
1537 eventContainer[1] = 1.; // No Information available in AOD analysis, assume all events have V0AND
1538 eventContainer[2] = fCentralityF;
1539 eventContainer[3] = fContributors;
1540
1541 //printf("value event container %f, %f, %f, %f\n",eventContainer[0],eventContainer[1],eventContainer[2],eventContainer[3]);
1542
1543 AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
1544 if(!fAOD){
1545 AliError("AOD Event required for AOD Analysis");
1546 return;
1547 }
e2861c1a 1548
e2861c1a 1549 // Set magnetic field if V0 task on
1550 if(fTaggedTrackAnalysis) {
2e4ed823 1551 // Tag all v0s in current event
1552 if(fV0Tagger){
1553 fV0Tagger->Reset();
1554 fV0Tagger->TagV0Tracks(fAOD);
1555 }
e2861c1a 1556 fTaggedTrackAnalysis->SetMagneticField(fAOD->GetMagneticField());
1557 fTaggedTrackAnalysis->SetCentrality(fCentralityF);
1558 if(IsPbPb()) fTaggedTrackAnalysis->SetPbPb();
1559 else {
dab4f95d 1560 if(IspPb()) fTaggedTrackAnalysis->SetpPb();
1561 else fTaggedTrackAnalysis->SetPP();
e2861c1a 1562 }
1563 }
01745870 1564
1565 //printf("Will fill\n");
1566 //
1567 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut);
1568 //printf("Fill\n");
1569 //
1570 if(fIdentifiedAsPileUp) return;
1571 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp);
1572
1573 //
1574 if(fIdentifiedAsOutInz) return;
1575 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange);
1576
1577 //
1578 if(!fPassTheEventCut) return;
1579 fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed);
1580 //printf("pass\n");
1581
1582 fContainer->NewEvent();
1583
1584 fCFM->SetRecEventInfo(fAOD);
1585
1586 if(!fExtraCuts){
1587 fExtraCuts = new AliHFEextraCuts("hfeExtraCuts","HFE Extra Cuts");
1588 }
1589 fExtraCuts->SetRecEventInfo(fAOD);
1590
1591 // Get Number of contributors to the primary vertex for multiplicity-dependent correction
1592 Int_t ncontribVtx = 0;
1593 AliAODVertex *priVtx = fAOD->GetPrimaryVertex();
1594 if(priVtx){
1595 ncontribVtx = priVtx->GetNContributors();
1596 }
1597
1598 // Look for kink mother
1599 Int_t numberofvertices = fAOD->GetNumberOfVertices();
1600 Double_t listofmotherkink[numberofvertices];
1601 Int_t numberofmotherkink = 0;
1602 for(Int_t ivertex=0; ivertex < numberofvertices; ivertex++) {
1603 AliAODVertex *aodvertex = fAOD->GetVertex(ivertex);
1604 if(!aodvertex) continue;
1605 if(aodvertex->GetType()==AliAODVertex::kKink) {
1606 AliAODTrack *mother = (AliAODTrack *) aodvertex->GetParent();
1607 if(!mother) continue;
1608 Int_t idmother = mother->GetID();
1609 listofmotherkink[numberofmotherkink] = idmother;
1610 //printf("ID %d\n",idmother);
1611 numberofmotherkink++;
1612 }
1613 }
1614 //printf("Number of kink mother in the events %d\n",numberofmotherkink);
1615
1616 // Background subtraction-------------------------------------------------------------------
ff8249bd 1617 if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->FillPoolAssociatedTracks(fInputEvent, fCentralityF);
01745870 1618 //------------------------------------------------------------------------------------------
1619
1620 // Loop over tracks
1621 AliAODTrack *track = NULL;
1622 AliAODMCParticle *mctrack = NULL;
1623 Double_t dataDca[6]; // [source, pT, dca, centrality]
1624 Int_t nElectronCandidates = 0;
1625 Bool_t signal;
1626
1627 //printf("Number of track %d\n",(Int_t) fAOD->GetNumberOfTracks());
2e4ed823 1628 Bool_t kinkmother(kFALSE), kinkdaughter(kFALSE); Double_t kinkstatus(0);
01745870 1629 for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){
2e4ed823 1630 kinkmother=kFALSE;
1631 kinkdaughter=kFALSE;
1632 kinkstatus = 0.;
465ff082 1633 track = (AliAODTrack *) fAOD->GetTrack(itrack); mctrack = NULL;
01745870 1634 if(!track) continue;
e2861c1a 1635
2e4ed823 1636 for(int ivx = 0; ivx < numberofmotherkink; ivx++){
1637 if(track->GetID() == listofmotherkink[ivx]){
1638 kinkmother = kTRUE;
1639 break;
1640 }
1641 }
1642 AliAODVertex *pvx = track->GetProdVertex();
1643 if(pvx && (pvx->GetType() == AliAODVertex::kKink)) kinkdaughter = kTRUE;
1644 kinkstatus = 0.;
1645 if(kinkmother) kinkstatus = 1.;
1646 else if(kinkdaughter) kinkstatus = 2.;
1647
e2861c1a 1648 // fill counts of v0-identified particles
dab4f95d 1649 AliPID::EParticleType v0pid = fV0Tagger ? fV0Tagger->GetV0Info(track->GetID()) : AliPID::kUnknown;
e2861c1a 1650 // here the tagged track analysis will run
1651 if(fTaggedTrackAnalysis && v0pid != AliPID::kUnknown){
1652 AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid)));
1653 fTaggedTrackAnalysis->ProcessTrack(track, v0pid);
1654 AliDebug(1, "V0 PID done");
1655 }
01745870 1656
1657 signal = kTRUE;
1658 if(HasMCData()){
01745870 1659 Int_t label = TMath::Abs(track->GetLabel());
1660 if(label && label < fAODArrayMCInfo->GetEntriesFast())
1661 mctrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(label));
1662 if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE;
2e4ed823 1663 if(fRejectMCFakeTracks && IsMCFakeTrack(track)) signal = kFALSE;
01745870 1664 }
1665
1666 fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal);
1667
1668 if(fFillNoCuts) {
1669 if(signal || !fFillSignalOnly){
1670 fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE);
1671 fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE);
1672 }
1673 }
1674
e2861c1a 1675 // begin AOD QA
1676 fQACollection->Fill("Filterbegin", -1);
1677 for(Int_t k=0; k<20; k++) {
1678 Int_t u = 1<<k;
1679 if((track->TestFilterBit(u))) {
2e4ed823 1680 fQACollection->Fill("Filterbegin", k);
e2861c1a 1681 }
1682 }
1683
2e4ed823 1684 // RecKine: ITSTPC cuts
1685 if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue;
1686
1687 fQACollection->Fill("Kinkbefore", track->Pt(), kinkstatus);
1688 // Reject kink mother
1689 if(fRejectKinkMother) {
1690 Bool_t kinkmotherpass = kTRUE;
1691 for(Int_t ikinkmother = 0; ikinkmother < numberofmotherkink; ikinkmother++) {
1692 if(track->GetID() == listofmotherkink[ikinkmother]) {
1693 kinkmotherpass = kFALSE;
1694 continue;
1695 }
01745870 1696 }
2e4ed823 1697 if(!kinkmotherpass) continue;
1698 }
1699
1700 // RecPrim
1701 if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue;
1702 fQACollection->Fill("Kinkafter", track->Pt(), kinkstatus);
1703
7bdde22f 1704 // production radius
5565ef0f 1705 Double_t pradius[3] = {(Double_t)fCentralityF,track->Pt(),-1.};
7bdde22f 1706 Bool_t fill = kFALSE;
1707 if(HasMCData()){
1708 Int_t labelr = track->GetLabel();
1709 if(labelr>=0) {
1710 AliAODMCParticle *mctrackk = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(labelr));
1711 if(mctrackk && (TMath::Abs(mctrackk->GetPdgCode()) == 11)) {
1712 Int_t motherlabel = mctrackk->GetMother();
1713 if((motherlabel>=0) && (motherlabel < fAODArrayMCInfo->GetEntriesFast())) {
1714 AliAODMCParticle *mcmothertrack = dynamic_cast<AliAODMCParticle *>(fAODArrayMCInfo->At(motherlabel));
1715 if(mcmothertrack && (TMath::Abs(mcmothertrack->GetPdgCode()) == 22)) {
1716 pradius[2] = TMath::Sqrt(mctrackk->Xv()*mctrackk->Xv()+mctrackk->Yv()*mctrackk->Yv());
1717 fill = kTRUE;
1718 }
1719 }
1720 }
1721 }
1722 if(fill) fQACollection->Fill("RadiusBefore", pradius);
1723 }
1724
2e4ed823 1725 // HFEcuts: ITS layers cuts
1726 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue;
7bdde22f 1727
1728 // production radius
1729 if(fill) fQACollection->Fill("RadiusAfter", pradius);
01745870 1730
2e4ed823 1731 // HFE cuts: TOF PID and mismatch flag
1732 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTOF, track)) continue;
01745870 1733
2e4ed823 1734 // HFE cuts: TPC PID cleanup
1735 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTPC, track)) continue;
1736
1737 // HFEcuts: Nb of tracklets TRD0
1738 if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue;
01745870 1739
1740 // Fill correlation maps before PID
1741 if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) {
1742 //printf("Fill correlation maps before PID\n");
1743 fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID"));
1744 }
1745
1746 if(HasMCData()){
ff8249bd 1747
1748 if(fMCQA && signal){
1749 fMCQA->SetCentrality(fCentralityF);
1750 if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){
1751 Double_t weightElecBgV0[kBgLevels] = {0.,0.,0.};
1752 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
1753 weightElecBgV0[iLevel] = fMCQA->GetWeightFactor(mctrack, iLevel); // positive:conversion e, negative: nonHFE
1754 }
1755 if(weightElecBgV0[0]>0) {
1756 fVarManager->FillContainer(fContainer, "conversionElecs", 3, kFALSE, weightElecBgV0[0]);
1757 fVarManager->FillContainer(fContainer, "conversionElecs", 4, kTRUE, weightElecBgV0[0]);
1758 }
1759 else if(weightElecBgV0[0]<0) {
1760 fVarManager->FillContainer(fContainer, "mesonElecs", 3, kFALSE, -1*weightElecBgV0[0]);
1761 fVarManager->FillContainer(fContainer, "mesonElecs", 4, kTRUE, -1*weightElecBgV0[0]);
1762 }
1763 }
1764 }
1765
01745870 1766 Double_t hfeimpactR4all=0., hfeimpactnsigmaR4all=0.;
1767 Int_t sourceDca =-1;
1768 if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 211)){
1769 if(track->Pt()>4.){
1770 fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
1771 dataDca[0]=0; //pion
1772 dataDca[1]=track->Pt();
1773 dataDca[2]=hfeimpactR4all;
1774 dataDca[3]=fCentralityF;
1775 dataDca[4] = -1; // not store V0 for the moment
1776 dataDca[5] = double(track->Charge());
1777 fQACollection->Fill("Dca", dataDca);
1778 }
1779 }
1780 else if(mctrack && (TMath::Abs(mctrack->GetPdgCode()) == 11)){ // to increas statistics for Martin
1781 if(signal){
1782 fExtraCuts->GetHFEImpactParameters(track, hfeimpactR4all, hfeimpactnsigmaR4all);
1783 if(fSignalCuts->IsCharmElectron(track)){
1784 sourceDca=1;
1785 }
1786 else if(fSignalCuts->IsBeautyElectron(track)){
1787 sourceDca=2;
1788 }
1789 else if(fSignalCuts->IsGammaElectron(track)){
1790 sourceDca=3;
1791 }
1792 else if(fSignalCuts->IsNonHFElectron(track)){
1793 sourceDca=4;
1794 }
1795 else if(fSignalCuts->IsJpsiElectron(track)){
1796 sourceDca=5;
1797 }
1798 else {
1799 sourceDca=6;
1800 }
1801 dataDca[0]=sourceDca;
1802 dataDca[1]=track->Pt();
1803 dataDca[2]=hfeimpactR4all;
1804 dataDca[3]=fCentralityF;
1805 dataDca[4] = -1; // not store V0 for the moment
1806 dataDca[5] = double(track->Charge());
1807 if(signal) fQACollection->Fill("Dca", dataDca);
1808 }
1809 }
1810 }
1811
1812 //printf("Will process to PID\n");
1813
1814 // track accepted, do PID
1815 AliHFEpidObject hfetrack;
1816 hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis);
1817 hfetrack.SetRecTrack(track);
1818 if(HasMCData()) hfetrack.SetMCTrack(mctrack);
1819 hfetrack.SetCentrality(fCentralityF);
1820 hfetrack.SetMulitplicity(ncontribVtx); // for correction
4437a0d2 1821 if(IsPbPb()) hfetrack.SetPbPb();
1822 else{
1823 if(IspPb()) hfetrack.SetpPb();
1824 else hfetrack.SetPP();
1825 }
01745870 1826 fPID->SetVarManager(fVarManager);
1827 if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue;
1828 // we will do PID here as soon as possible
1829
1830 // Background subtraction----------------------------------------------------------------------------------------------
ff8249bd 1831 if (GetPlugin(kNonPhotonicElectron)&&!GetPlugin(kNonPhotonicElectronBeauty)) {
01745870 1832 Int_t indexmother = -1;
ff8249bd 1833 Int_t mcsource = -1;
1834 Int_t mcQAsource = -1;
1835 Double_t weightNonPhotonicFactor = 1.;
1836 //printf("weight %f \n",weightNonPhotonicFactor);
2e4ed823 1837 if(HasMCData() && mctrack){
1838 mcsource = fBackgroundSubtraction->FindMother(TMath::Abs(track->GetLabel()),indexmother);
ff8249bd 1839 if(fBackgroundSubtraction->GetLevelBack()>=0) {
1840 if(fMCQA) {
465ff082 1841 fMCQA->SetCentrality(fCentralityF);
1842 fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
7bdde22f 1843 mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
ff8249bd 1844 weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
7bdde22f 1845 //weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactorForPrimaries(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
ff8249bd 1846 }
1847 }
2e4ed823 1848 }
ff8249bd 1849 fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1,mcsource, indexmother,mcQAsource);
01745870 1850 }
1851 //---------------------------------------------------------------------------------------------------------------------
1852
1853 // end AOD QA
1854 fQACollection->Fill("Filterend", -1);
1855 for(Int_t k=0; k<20; k++) {
1856 Int_t u = 1<<k;
1857 if((track->TestFilterBit(u))) {
1858 fQACollection->Fill("Filterend", k);
1859 }
1860 }
1861
1862 // Apply weight for background contamination
1863 //Double_t weightBackGround = 1.0;
1864 if(signal) {
1865 // Apply weight for background contamination
1866 if(fBackGroundFactorApply) {
4437a0d2 1867 if(IsPbPb() && fCentralityF >= 0) fWeightBackGround = fkBackGroundFactorArray[fCentralityF >= 0 ? fCentralityF : 0]->Eval(TMath::Abs(track->P()));
01745870 1868 else fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
1869
1870 if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
1871 else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
1872 // weightBackGround as special weight
1873 fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, fWeightBackGround);
1874 }
1875 fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID"));
1876 }
1877
1878 nElectronCandidates++;
1879
1880 if (GetPlugin(kDEstep)) {
1881 if (!HasMCData()){
1882 Double_t hfeimpactR=0., hfeimpactnsigmaR=0.;
1883 fExtraCuts->GetHFEImpactParameters(track, hfeimpactR, hfeimpactnsigmaR);
1884 dataDca[0]=-1; //for data, don't know the origin
1885 dataDca[1]=track->Pt();
1886 dataDca[2]=hfeimpactR;
1887 dataDca[3]=fCentralityF;
1888 dataDca[4] = -1; // not store V0 for the moment
1889 dataDca[5] = double(track->Charge());
1890 fQACollection->Fill("Dca", dataDca);
1891 }
1892
1893 // Fill Containers for impact parameter analysis
1894 if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue;
1895 if(signal) {
1896 // Apply weight for background contamination after ip cut
1897 if(fBackGroundFactorApply) {
1898 fWeightBackGround = fkBackGroundFactorArray[0]->Eval(TMath::Abs(track->P())); // pp case
1899 if(fWeightBackGround < 0.0) fWeightBackGround = 0.0;
1900 else if(fWeightBackGround > 1.0) fWeightBackGround = 1.0;
1901 // weightBackGround as special weight
1902 fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE, fWeightBackGround);
1903 }
ff8249bd 1904
1905 fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE);
1906 fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE);
1907 fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE"));
1908 }
1909 }
1910
1911 // Background subtraction----------------------------------------------------------------------------------------------
1912 if (!GetPlugin(kNonPhotonicElectron)&&GetPlugin(kNonPhotonicElectronBeauty)) {
1913 Int_t indexmother = -1;
1914 Int_t mcsource = -1;
1915 Int_t mcQAsource = -1;
1916 Double_t weightNonPhotonicFactor = 1.;
1917 //printf("weight %f \n",weightNonPhotonicFactor);
1918 if(HasMCData() && mctrack){
1919 mcsource = fBackgroundSubtraction->FindMother(TMath::Abs(track->GetLabel()),indexmother);
1920 if(fBackgroundSubtraction->GetLevelBack()>=0) {
1921 if(fMCQA) {
465ff082 1922 fMCQA->SetCentrality(fCentralityF);
1923 fMCQA->SetPercentrality(static_cast<Int_t>(fCentralityPercent));
7bdde22f 1924 mcQAsource = fMCQA->GetElecSource(mctrack, kTRUE);
ff8249bd 1925 weightNonPhotonicFactor = TMath::Abs(fMCQA->GetWeightFactor(mctrack, fBackgroundSubtraction->GetLevelBack())); // positive:conversion e, negative: nonHFE
1926 }
1927 }
01745870 1928 }
ff8249bd 1929 fBackgroundSubtraction->LookAtNonHFE(itrack, track, fInputEvent, weightNonPhotonicFactor, fCentralityF, -1,mcsource, indexmother,mcQAsource);
01745870 1930 }
ff8249bd 1931 //---------------------------------------------------------------------------------------------------------------------
1932
01745870 1933 }
1934
1935 // Background subtraction-------------------------------------------------------------------
ff8249bd 1936 if (GetPlugin(kNonPhotonicElectron)||GetPlugin(kNonPhotonicElectronBeauty)) fBackgroundSubtraction->CountPoolAssociated(fInputEvent, fCentralityF);
01745870 1937 //------------------------------------------------------------------------------------------
1938
1939 fQACollection->Fill("nElectronTracksEvent", nElectronCandidates);
1940}
1941
1942//____________________________________________________________
1943Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){
1944 //
1945 // Filter the Monte Carlo Track
1946 // Additionally Fill a THnSparse for Signal To Background Studies
1947 // Works for AOD and MC analysis Type
1948 //
1949 fVarManager->NewTrack(track, NULL, fCentralityF, -1, kTRUE);
465ff082 1950 //printf("Is primary %d\n",((Int_t)track->IsPrimary()));
01745870 1951
1952
1953 Double_t vertex[3] = {0.,0.,0.}; // Production vertex cut to mask gammas which are NOT supposed to have hits in the first ITS layer(s)
1954 if(IsESDanalysis()){
1955 AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(track);
1956 if(mctrack){
1957 vertex[0] = mctrack->Particle()->Vx();
1958 vertex[1] = mctrack->Particle()->Vy();
1959 }
1960 } else {
1961 AliAODMCParticle *aodmctrack = dynamic_cast<AliAODMCParticle *>(track);
1962 if(aodmctrack) aodmctrack->XvYvZv(vertex);
1963 }
1964
1965 //printf("MC Generated\n");
1966 if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE;
1967 //printf("MC Generated pass\n");
1968 fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE);
1969
1970 // Step GeneratedZOutNoPileUp
1971 if((fIdentifiedAsPileUp) || (TMath::Abs(fVz) > fCuts->GetVertexRange()) || (fCentralityF < 0)) return kFALSE;
1972 fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedZOutNoPileUpCentralityFine, kFALSE);
1973 //printf("In ProcessMCtrack %f\n",fCentralityF);
1974
1975 // Step Generated Event Cut
1976 if(!fPassTheEventCut) return kFALSE;
1977 fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedEventCut, kFALSE);
1978
e2861c1a 1979 if(IsESDanalysis()){
1980 if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE;
1981 fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE);
1982 }
01745870 1983 return kTRUE;
1984}
1985
1986//____________________________________________________________
1987Bool_t AliAnalysisTaskHFE::PreSelectTrack(AliESDtrack *track) const {
1988 //
1989 // Preselect tracks
1990 //
1991
1992
1993 Bool_t survived = kTRUE;
1994
1995 if(fCutspreselect) {
1996 //printf("test preselect\n");
1997 if(!fCutspreselect->IsSelected(track)) survived=kFALSE;
1998 }
1999 //printf("survived %d\n",(Int_t)survived);
2000
2001 if(survived && fPIDpreselect){
2002 // Apply PID
2003 AliHFEpidObject hfetrack;
2004 hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis);
2005 hfetrack.SetRecTrack(track);
2006 if(!fPIDpreselect->IsSelected(&hfetrack)) {
2007 //printf("Did not pass AliHFEcuts::kPID\n");
2008 survived = kFALSE;
2009 }
2010 //else printf("Pass AliHFEcuts::kPID\n");
2011 }
2012
2013 return survived;
2014
2015}
2016//____________________________________________________________
2017void AliAnalysisTaskHFE::MakeEventContainer(){
2018 //
2019 // Create the event container for the correction framework and link it
2020 // 1st bin: Vertex z-position
2021 // 2nd bin: V0AND decision (normalization to sigma_inel)
2022 // 3rd bin: Centrality class (for pp defined as number of contributors in vertex.)
2023 // 4th bin: Number of contributors > 0
2024 //
2025
2026 const Int_t kNvar = 4; // number of variables on the grid:
2027 Int_t nBins[kNvar] = {120, 2, 11, 2};
2028 Double_t binMin[kNvar] = {-30. , 0., 0.0, 0.};
2029 Double_t binMax[kNvar] = {30., 2., 11.0, 2.};
2030
2031 AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins);
2032
2033 Double_t *vertexBins = AliHFEtools::MakeLinearBinning(nBins[0], binMin[0], binMax[0]);
2034 Double_t *v0andBins = AliHFEtools::MakeLinearBinning(nBins[1], binMin[1], binMax[1]);
2035 Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBins[2], binMin[2], binMax[2]);
2036 Double_t *contributorsBins = AliHFEtools::MakeLinearBinning(nBins[3], binMin[3], binMax[3]);
2037 evCont->SetBinLimits(0, vertexBins);
2038 evCont->SetBinLimits(1, v0andBins);
2039 evCont->SetBinLimits(2, centralityBins);
2040 evCont->SetBinLimits(3, contributorsBins);
2041 delete[] vertexBins; delete[] v0andBins; delete[] centralityBins; delete[] contributorsBins;
2042
2043 fCFM->SetEventContainer(evCont);
2044}
2045
2046//____________________________________________________________
2047void AliAnalysisTaskHFE::MakeParticleContainer(){
2048 //
2049 // Create the particle container for the correction framework manager and
2050 // link it
2051 //
2052 if(!fContainer) fContainer = new AliHFEcontainer("trackContainer");
2053 fVarManager->DefineVariables(fContainer);
2054
2055 // Create Correction Framework containers
2056 fContainer->CreateContainer("MCTrackCont", "Track Container filled with MC information", AliHFEcuts::kNcutStepsMCTrack);
2057 fContainer->CreateContainer("recTrackContReco", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());
2058 fContainer->CreateContainer("recTrackContMC", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors());
2059
2060 fContainer->CreateContainer("hadronicBackground", "Container for Hadronic Background", 3);
2061 fContainer->CreateContainer("recTrackContDEReco", "Container for displaced electron analysis with Reco information", 1);
2062 fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1);
2063 fContainer->CreateContainer("recTrackContSecvtxReco", "Container for secondary vertexing analysis with Reco information", 1);
2064 fContainer->CreateContainer("recTrackContSecvtxMC", "Container for secondary vertexing analysis with MC information", 1);
2065
2066 if(HasMCData()){
2067 fContainer->CreateContainer("conversionElecs", "Container for weighted conversion electrons",7);
2068 fContainer->CreateContainer("mesonElecs", "Container for weighted electrons from meson decays",7);
2069 fContainer->Sumw2("conversionElecs");
2070 fContainer->Sumw2("mesonElecs");
2071
2072 if(fisNonHFEsystematics){
2073 const Char_t *sourceName[kElecBgSpecies]={"Pion","Eta","Omega","Phi","EtaPrime","Rho"};
2074 const Char_t *levelName[kBgLevels]={"Best","Lower","Upper"};
2075 for(Int_t iSource = 0; iSource < kElecBgSpecies; iSource++){
2076 for(Int_t iLevel = 0; iLevel < kBgLevels; iLevel++){
2077 fContainer->CreateContainer(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted conversion electrons from %s grandm., %s level",sourceName[iSource],levelName[iLevel]),5);
2078 fContainer->CreateContainer(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]), Form("Container for weighted electrons from %s decays, %s level",sourceName[iSource],levelName[iLevel]),5);
2079 fContainer->Sumw2(Form("conversionElecs%s%s",sourceName[iSource],levelName[iLevel]));
2080 fContainer->Sumw2(Form("mesonElecs%s%s",sourceName[iSource],levelName[iLevel]));
2081 if(IsPbPb())break;
2082 }
2083 }
2084 }
2085 //fContainer->CreateContainer("charmElecs", "Container for weighted charm electrons",2);
2086 }
2087
2088 fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations");
2089 fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations");
2090 if(!fVarManager->IsVariableDefined("centrality")) {
2091 //printf("Create the two other correlation maps\n");
2092 fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations");
2093 fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations");
2094 }
2095
2096 // Define the step names
2097 for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){
2098 fContainer->SetStepTitle("MCTrackCont", AliHFEcuts::MCCutName(istep), istep);
2099 }
2100 for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsRecTrack; istep++){
2101 fContainer->SetStepTitle("recTrackContReco", AliHFEcuts::RecoCutName(istep), istep);
2102 fContainer->SetStepTitle("recTrackContMC", AliHFEcuts::RecoCutName(istep), istep);
2103 }
2104 for(UInt_t ipid = 0; ipid < fPID->GetNumberOfPIDdetectors(); ipid++){
2105 fContainer->SetStepTitle("recTrackContReco", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
2106 fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid);
2107 }
2108}
2109//____________________________________________________________
2110void AliAnalysisTaskHFE::InitContaminationQA(){
2111 //
2112 // Add QA for Impact Parameter cut
2113 //
2114
2115 TObjArray *array = fVarManager->GetVariables();
2116 Int_t nvars = array->GetEntriesFast();
2117 for(Int_t v = 0; v < nvars; v++) {
2118 AliHFEvarManager::AliHFEvariable *variable = (AliHFEvarManager::AliHFEvariable *) array->At(v);
2119 if(!variable) continue;
2120 TString name(((AliHFEvarManager::AliHFEvariable *)variable)->GetName());
2121 if(!name.CompareTo("pt")) {
2122 const Int_t nBinPt = variable->GetNumberOfBins();
2123 const Double_t *kPtRange = variable->GetBinning();
2124
2125 fQACollection->CreateTH1Farray("hadronsBeforeIPcut", "Hadrons before IP cut", nBinPt, kPtRange);
2126 fQACollection->CreateTH1Farray("hadronsAfterIPcut", "Hadrons after IP cut", nBinPt, kPtRange);
2127
2128 fQACollection->CreateTH2Farray("Ke3Kecorr", "Ke3 decay e and K correlation; Ke3K p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);
2129 fQACollection->CreateTH2Farray("Ke3K0Lecorr", "Ke3 decay e and K0L correlation; Ke3K0L p_{t}; Ke3e p_{t}; ", nBinPt, kPtRange, 20,0.,20.);
2130 fQACollection->CreateTH1Farray("Kptspectra", "Charged Kaons: MC p_{t} ", nBinPt, kPtRange);
2131 fQACollection->CreateTH1Farray("K0Lptspectra", "K0L: MC p_{t} ", nBinPt, kPtRange);
2132
2133 const Double_t kDCAbound[2] = {-0.2, 0.2};
2134
2135 const Int_t nDimDca=6;
2136 const Int_t nBinDca[nDimDca] = { 8, nBinPt, 800, 12, 6, 2};
2137 Double_t minimaDca[nDimDca] = { -1., 0., kDCAbound[0], -1., -1, -1.1};
2138 Double_t maximaDca[nDimDca] = { 7., 20., kDCAbound[1], 11., 5, 1.1};
2139
2140 Double_t *sourceBins = AliHFEtools::MakeLinearBinning(nBinDca[0], minimaDca[0], maximaDca[0]);
2141 Double_t *dcaBins = AliHFEtools::MakeLinearBinning(nBinDca[2], minimaDca[2], maximaDca[2]);
2142 Double_t *centralityBins = AliHFEtools::MakeLinearBinning(nBinDca[3], minimaDca[3], maximaDca[3]);
2143 Double_t *v0PIDBins = AliHFEtools::MakeLinearBinning(nBinDca[4], minimaDca[4], maximaDca[4]);
2144 Double_t *chargeBins = AliHFEtools::MakeLinearBinning(nBinDca[5], minimaDca[5], maximaDca[5]);
2145
2146 fQACollection->CreateTHnSparseNoLimits("Dca", "Dca; source (0-all, 1-charm,etc); pT [GeV/c]; dca; centrality bin; v0pid; charge", nDimDca, nBinDca);
2147 ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(0, sourceBins);
2148 ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(1, kPtRange);
2149 ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(2, dcaBins);
2150 ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(3, centralityBins);
2151 ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(4, v0PIDBins);
2152 ((THnSparse*)(fQACollection->Get("Dca")))->SetBinEdges(5, chargeBins);
2153
2154 break;
2155 }
2156 }
2157
7bdde22f 2158}
2159//____________________________________________________________
2160void AliAnalysisTaskHFE::InitHistoRadius(){
2161 //
2162
2163 // Before
2164 const Int_t kNDim = 3;
465ff082 2165 const Int_t kNBins[kNDim] = {11, 35, 25};
7bdde22f 2166 const Double_t kMin[kNDim] = {0,0.1,0.01};
465ff082 2167 const Double_t kMax[kNDim] = {11,20.,25.};
7bdde22f 2168 fQACollection->CreateTHnSparse("RadiusBefore", "RadiusBefore; centrality; p_{T} (GeV/c);radius [cm]", kNDim, kNBins, kMin, kMax);
2169 fQACollection->BinLogAxis("RadiusBefore", 1);
2170 fQACollection->BinLogAxis("RadiusBefore", 2);
2171
2172 // After
2173 fQACollection->CreateTHnSparse("RadiusAfter", "RadiusAfter; centrality; p_{T} (GeV/c);radius [cm]", kNDim, kNBins, kMin, kMax);
2174 fQACollection->BinLogAxis("RadiusAfter", 1);
2175 fQACollection->BinLogAxis("RadiusAfter", 2);
2176
2177
01745870 2178}
2179
2180//____________________________________________________________
2181void AliAnalysisTaskHFE::InitHistoITScluster(){
2182 //
2183 // Initialize a temporary histogram to monitor the chi2/ITS cluster
2184 if(IsPbPb()) {
2185 const Int_t kNDim = 7;
2186 const Int_t kNBins[kNDim] = {88, 20,90,11, 160, 2, 1000};
2187 const Double_t kMin[kNDim] = {0.1, -1,0, 0.,0., 0, 0.};
2188 const Double_t kMax[kNDim] = {20., 1, 2.*TMath::Pi(), 11.,160, 2, 100.};
2189 fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c);eta;phi; centrality class;nclus;sharebit; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);
2190 fQACollection->BinLogAxis("fChi2perITScluster", 0);
2191 }
2192 else
2193 {
2194 const Int_t kNDim = 3;
2195 const Int_t kNBins[kNDim] = {44, 11, 1000};
2196 const Double_t kMin[kNDim] = {0.1, 0., 0.};
2197 const Double_t kMax[kNDim] = {20., 11., 100.};
2198 fQACollection->CreateTHnSparse("fChi2perITScluster", "chi2/ITS cluster; p_{T} (GeV/c); centrality class; #chi^{2}/ITS cluster", kNDim, kNBins, kMin, kMax);
2199 fQACollection->BinLogAxis("fChi2perITScluster", 0);
2200 }
2201}
2202
2203//____________________________________________________________
2204void AliAnalysisTaskHFE::SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin, Int_t runMax){
2205 //
2206 // Select only events triggered by a special trigeer cluster
2207 //
2208 if(!fSpecialTrigger) fSpecialTrigger = new AliOADBContainer("SpecialTrigger");
2209 fSpecialTrigger->AppendObject(new TObjString(trgclust), runMin, runMax);
2210}
2211
2212//____________________________________________________________
2213const Char_t * AliAnalysisTaskHFE::GetSpecialTrigger(Int_t run){
2214 //
2215 // Derive selected trigger string for given run
2216 //
2217 if(!fSpecialTrigger) return NULL;
2218 TObjString *trg = dynamic_cast<TObjString *>(fSpecialTrigger->GetObject(run));
2219 if(!trg) return NULL;
2220 return trg->String().Data();
2221}
2222
2223//____________________________________________________________
2224void AliAnalysisTaskHFE::PrintStatus() const {
2225 //
2226 // Print Analysis status
2227 //
2228 printf("\n\tAnalysis Settings\n\t========================================\n\n");
2229 printf("\tSecondary Vertex finding: %s\n", GetPlugin(kSecVtx) ? "YES" : "NO");
2230 printf("\tPrimary Vertex resolution: %s\n", GetPlugin(kPriVtx) ? "YES" : "NO");
2231 printf("\tDisplaced electron analysis step: %s\n", GetPlugin(kDEstep) ? "YES" : "NO");
2232 printf("\tTagged Track Analysis: %s\n", GetPlugin(kTaggedTrackAnalysis) ? "YES" : "NO");
2233 printf("\n");
2234 printf("\tParticle Identification Detectors:\n");
2235 fPID->PrintStatus();
2236 printf("\n");
2237 printf("\tQA: \n");
2238 printf("\t\tPID: %s\n", IsQAOn(kPIDqa) ? "YES" : "NO");
2239 printf("\t\tCUTS: %s\n", (fCuts != NULL && fCuts->IsQAOn()) ? "YES" : "NO");
2240 printf("\t\tMC: %s\n", IsQAOn(kMCqa) ? "YES" : "NO");
2241 printf("\n");
2242}
2243
2244//____________________________________________________________
2245Bool_t AliAnalysisTaskHFE::FillProductionVertex(const AliVParticle * const track) const{
2246 //
2247 // Find the production vertex of the associated MC track
2248 //
2249 if(!fMCEvent) return kFALSE;
2250 const AliVParticle *mctrack = NULL;
2251 TString objectType = track->IsA()->GetName();
2252 if(objectType.CompareTo("AliESDtrack") == 0 || objectType.CompareTo("AliAODTrack") == 0){
2253 // Reconstructed track
2254 mctrack = fMCEvent->GetTrack(TMath::Abs(track->GetLabel()));
2255 } else {
2256 // MCParticle
2257 mctrack = track;
2258 }
2259
2260 if(!mctrack) return kFALSE;
2261
2262 Double_t xv = 0.0;
2263 Double_t yv = 0.0;
2264
2265 if(TString(mctrack->IsA()->GetName()).CompareTo("AliMCParticle") == 0){
2266 // case MCParticle
2267 const AliMCParticle *mcpart = dynamic_cast<const AliMCParticle *>(mctrack);
2268 if(mcpart){
2269 xv = mcpart->Xv();
2270 yv = mcpart->Yv();
2271 }
2272 } else {
2273 // case AODMCParticle
2274 const AliAODMCParticle *mcpart = dynamic_cast<const AliAODMCParticle *>(mctrack);
2275 if(mcpart){
2276 xv = mcpart->Xv();
2277 yv = mcpart->Yv();
2278 }
2279 }
2280
2281 //printf("xv %f, yv %f\n",xv,yv);
2282 fQACollection->Fill("radius", TMath::Abs(xv),TMath::Abs(yv));
2283
2284 return kTRUE;
2285
2286}
2287//__________________________________________
2288void AliAnalysisTaskHFE::SwitchOnPlugin(Int_t plug){
2289 //
2290 // Switch on Plugin
2291 // Available:
2292 // - Primary vertex studies
2293 // - Secondary vertex Studies
2294 // - Post Processing
2295 //
2296 switch(plug){
2297 case kPriVtx: SETBIT(fPlugins, plug); break;
2298 case kSecVtx: SETBIT(fPlugins, plug); break;
2299 case kIsElecBackGround: SETBIT(fPlugins, plug); break;
2300 case kPostProcess: SETBIT(fPlugins, plug); break;
2301 case kDEstep: SETBIT(fPlugins, plug); break;
2302 case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break;
2303 case kNonPhotonicElectron: SETBIT(fPlugins, plug); break;
ff8249bd 2304 case kNonPhotonicElectronBeauty: SETBIT(fPlugins, plug); break;
01745870 2305 default: AliError("Unknown Plugin");
2306 };
2307}
2308//__________________________________________
2309Bool_t AliAnalysisTaskHFE::ProcessCutStep(Int_t cutStep, AliVParticle *track){
2310 //
2311 // Check single track cuts for a given cut step
2312 // Fill the particle container
2313 //
2314 const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack;
2315 if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE;
2316 if(fVarManager->IsSignalTrack()) {
2317 fVarManager->FillContainer(fContainer, "recTrackContReco", cutStep, kFALSE);
2318 fVarManager->FillContainer(fContainer, "recTrackContMC", cutStep, kTRUE);
2319 }
2320 return kTRUE;
2321}
2322//___________________________________________________
2323Bool_t AliAnalysisTaskHFE::ReadCentrality() {
2324 //
2325 // Recover the centrality of the event from ESD or AOD
2326 //
2327
2328 Float_t fCentralityLimitstemp[12];
2e4ed823 2329 Float_t fCentralityLimitsdefault[12]= {0.,5.,10., 20., 30., 40., 50., 60.,70.,80., 90., 100.00001};
01745870 2330 if(!fPbPbUserCentralityBinning) memcpy(fCentralityLimitstemp,fCentralityLimitsdefault,sizeof(fCentralityLimitsdefault));
2331 else memcpy(fCentralityLimitstemp,fCentralityLimits,sizeof(fCentralityLimitsdefault));
2332
2333
2334 Int_t bin = -1;
4437a0d2 2335 if(IsPbPb()||IspPb()) {
01745870 2336 // Centrality
2337 AliCentrality *centrality = fInputEvent->GetCentrality();
2338 fCentralityPercent = centrality->GetCentralityPercentile(fCentralityEstimator.Data());
2339 //printf("centrality %f\n",fCentralityPercent);
2340
2341 for(Int_t ibin = 0; ibin < 11; ibin++){
2342 if(fCentralityPercent >= fCentralityLimitstemp[ibin] && fCentralityPercent < fCentralityLimitstemp[ibin+1]){
2343 bin = ibin;
2344 //printf("test bin %f, low %f, high %f, %d\n",fCentralityPercent,fCentralityLimitstemp[ibin],fCentralityLimitstemp[ibin+1],ibin);
2345 break;
2346 }
2347 }
2348
2349 if(bin == -1) bin = 11; // Overflow
2350 } else {
2351 // PP: Tracklet multiplicity, use common definition
2352 Int_t itsMultiplicity = GetITSMultiplicity(fInputEvent);
2353 Int_t multiplicityLimits[8] = {0, 1, 9, 17, 25, 36, 60, 500};
2354 for(Int_t ibin = 0; ibin < 7; ibin++){
2355 if(itsMultiplicity >= multiplicityLimits[ibin] && itsMultiplicity < multiplicityLimits[ibin + 1]){
2356 bin = ibin;
2357 break;
2358 }
2359 }
2360 if(bin == -1) bin = 7; // Overflow
2361 }
2362 fCentralityF = bin;
2363 AliDebug(2, Form("Centrality class %d\n", fCentralityF));
2364
2365
2366 // contributors, to be outsourced
2367 const AliVVertex *vtx;
2368 if(IsAODanalysis()){
2369 AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
2370 if(!fAOD){
2371 AliError("AOD Event required for AOD Analysis");
2372 return kFALSE;
2373 }
2374 vtx = fAOD->GetPrimaryVertex();
2375 } else {
2376 AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
2377 if(!fESD){
2378 AliError("ESD Event required for ESD Analysis");
2379 return kFALSE;
2380 }
2381 vtx = fESD->GetPrimaryVertex() ;
2382 }
2383 if(!vtx){
2384 fContributors = 0.5;
2385 return kFALSE;
2386 }
2387 else {
2388 Int_t contributorstemp = vtx->GetNContributors();
2389 if( contributorstemp <= 0) {
2390 fContributors = 0.5;
2391 //printf("Number of contributors %d and vz %f\n",contributorstemp,vtx->GetZ());
2392 }
2393 else fContributors = 1.5;
2394 //printf("Number of contributors %d\n",contributorstemp);
2395 }
2396 return kTRUE;
2397}
2398
2399//___________________________________________________
2400Int_t AliAnalysisTaskHFE::GetITSMultiplicity(AliVEvent *ev){
2401 //
2402 // Definition of the Multiplicity according to the JPSI group (F. Kramer)
2403 //
2404 Int_t nTracklets = 0;
2405 Int_t nAcc = 0;
2406 Double_t etaRange = 1.6;
2407
2408 if (ev->IsA() == AliAODEvent::Class()) {
2409 AliAODTracklets *tracklets = ((AliAODEvent*)ev)->GetTracklets();
2410 nTracklets = tracklets->GetNumberOfTracklets();
2411 for (Int_t nn = 0; nn < nTracklets; nn++) {
2412 Double_t theta = tracklets->GetTheta(nn);
2413 Double_t eta = -TMath::Log(TMath::Tan(theta/2.0));
2414 if (TMath::Abs(eta) < etaRange) nAcc++;
2415 }
2416 } else if (ev->IsA() == AliESDEvent::Class()) {
2417 nTracklets = ((AliESDEvent*)ev)->GetMultiplicity()->GetNumberOfTracklets();
2418 for (Int_t nn = 0; nn < nTracklets; nn++) {
2419 Double_t eta = ((AliESDEvent*)ev)->GetMultiplicity()->GetEta(nn);
2420 if (TMath::Abs(eta) < etaRange) nAcc++;
2421 }
2422 } else return -1;
2423
2424 return nAcc;
2425}
2426
2427//___________________________________________________
2428void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() {
2429 //
2430 // Recover the centrality of the event from ESD or AOD
2431 //
2432 if(IsAODanalysis()){
2433
2434 AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent);
2435 if(!fAOD){
2436 AliError("AOD Event required for AOD Analysis");
2437 return;
2438 }
2439 // PileUp
2440 fIdentifiedAsPileUp = kFALSE;
2441 if(fRemovePileUp && fAOD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE;
2442 // Z vertex
2443 fIdentifiedAsOutInz = kFALSE;
2444 //printf("Z vertex %f and out %f\n",fAOD->GetPrimaryVertex()->GetZ(),fCuts->GetVertexRange());
2445 if(TMath::Abs(fAOD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
2446 // Event Cut
2447 fPassTheEventCut = kTRUE;
2448 if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) fPassTheEventCut = kFALSE;
2449
2450
2451 } else {
2452
2453 AliDebug(3, "Processing ESD Centrality");
2454 AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent);
2455 if(!fESD){
2456 AliError("ESD Event required for ESD Analysis");
2457 return;
2458 }
2459 // PileUp
2460 fIdentifiedAsPileUp = kFALSE;
2461 if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE;
2462
2463
2464
2465 // Z vertex
2466 fIdentifiedAsOutInz = kFALSE;
2467 Bool_t findvertex = kTRUE;
2468 const AliESDVertex* vtxESD = fESD->GetPrimaryVertex();
2469 if((!vtxESD) || (vtxESD->GetNContributors() <= 0)) findvertex = kFALSE;
2470 if(findvertex) {
2471 if(TMath::Abs(vtxESD->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE;
2472 }
2473
2474 //Event Cut
2475 fPassTheEventCut = kTRUE;
2476 if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE;
2477
2478 }
2479
2480}
8c07fb0d 2481
2482//___________________________________________________
4437a0d2 2483Bool_t AliAnalysisTaskHFE::CheckTRDTriggerESD(AliESDEvent *ev) {
8c07fb0d 2484//
2485// Check TRD trigger; pPb settings
2486//
2487 Bool_t cint8=kFALSE;
2488 Bool_t cint7=kFALSE;
2489 Bool_t cint5=kFALSE;
2e4ed823 2490 Bool_t cint8s=kFALSE;
2491 Bool_t cint7s=kFALSE;
2492 Bool_t cint7ppb=kFALSE;
8c07fb0d 2493 Bool_t trdtrgevent=kFALSE;
2494
2e4ed823 2495 // printf("TRIGGERS %s \n",ev->GetFiredTriggerClasses().Data());
4437a0d2 2496
7bdde22f 2497 if(fWhichTRDTrigger==4) fTRDTriggerAnalysistrg->CalcTriggers(ev);
2498 else fTRDTriggerAnalysismb->CalcTriggers(ev);
2499
ff8249bd 2500
4437a0d2 2501 // mb selection of WU events
8c07fb0d 2502 if(fWhichTRDTrigger==1)
2503 {
ff8249bd 2504// if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
2505 if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
8c07fb0d 2506 {
2507 DrawTRDTrigger(ev);
ff8249bd 2508 DrawTRDTriggerAnalysis(ev);
8c07fb0d 2509 return kTRUE;
2510 }
4437a0d2 2511 else return kFALSE;
8c07fb0d 2512 }
618038b6 2513
4437a0d2 2514
2515 // HSE no cleanup
8c07fb0d 2516 if(fWhichTRDTrigger==2)
2517 {
4437a0d2 2518 cint8= ev->IsTriggerClassFired("CINT8WUHSE-B-NOPF-CENT");
2e4ed823 2519 cint7= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT"); // pPb rare
2520 cint7ppb= ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-ALL"); // pPb mb
2521 cint8s= ev->IsTriggerClassFired("CINT7WUHSE-S-NOPF-CENT");
2522 cint7s= ev->IsTriggerClassFired("CINT8WUHSE-S-NOPF-CENT");
4437a0d2 2523 cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
2524 (ev->GetHeader()->GetL1TriggerInputs() & (1 << 10));
2e4ed823 2525// printf("hse trigger %i %i %i %i %i \n",cint7,cint7ppb,cint8,cint7s,cint8s);
2526 if((cint7==kFALSE)&&(cint7ppb==kFALSE)&&(cint8==kFALSE)&&(cint7s==kFALSE)&&(cint8s==kFALSE)&&(cint5==kFALSE)) return kFALSE;
8c07fb0d 2527 else
2528 {
2529 DrawTRDTrigger(ev);
ff8249bd 2530 DrawTRDTriggerAnalysis(ev);
8c07fb0d 2531 return kTRUE;
2532 }
2533 }
2534
4437a0d2 2535
2536
618038b6 2537 //HQU no cleanup
8c07fb0d 2538 if(fWhichTRDTrigger==3)
2539 {
8c07fb0d 2540 cint8= ev->IsTriggerClassFired("CINT8WUHQU-B-NOPF-CENT");
2e4ed823 2541 cint7= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT"); // pPb rare
2542 cint7ppb= ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-ALL"); // pPb mb
2543 cint8s= ev->IsTriggerClassFired("CINT7WUHQU-S-NOPF-CENT");
2544 cint7s= ev->IsTriggerClassFired("CINT8WUHQU-S-NOPF-CENT");
8c07fb0d 2545 cint5= (ev->IsTriggerClassFired("CINT5WU-B-NOPF-ALL")) &&
2546 (ev->GetHeader()->GetL1TriggerInputs() & (1 << 12));
2e4ed823 2547 // printf("hqu trigger %i %i %i %i %i \n",cint7,cint7ppb,cint8,cint7s,cint8s);
2548 if((cint7==kFALSE)&&(cint7ppb==kFALSE)&&(cint8==kFALSE)&&(cint7s==kFALSE)&&(cint8s==kFALSE)&&(cint5==kFALSE)) return kFALSE;
8c07fb0d 2549 else
2550 {
2551 DrawTRDTrigger(ev);
ff8249bd 2552 DrawTRDTriggerAnalysis(ev);
8c07fb0d 2553 return kTRUE;
2554 }
8c07fb0d 2555 }
618038b6 2556
2e4ed823 2557 if(fWhichTRDTrigger==4)
2558 {
2559// printf("trigger %i %i \n", ev->GetHeader()->IsTriggerInputFired("1HSE"),(ev->GetHeader()->GetL1TriggerInputs() & (1 << 10))); // bug in IsTriggerInputFired; reported in savannah
2560
ff8249bd 2561// if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
2562// {
2563// Int_t trginput=0;
2564// trginput=ev->GetHeader()->GetL1TriggerInputs() & (1 << 10); // HSE
2565 // if(trginput==1024)
2566// if(fTRDTriggerAnalysismb->CheckCondition(AliTRDTriggerAnalysis::kHSE))
7bdde22f 2567 // if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHSE))
2568
2569// if(fTRDTriggerAnalysismb->HasFired(AliTRDTriggerAnalysis::kHSE)) // for mb analysis
2570 if(fTRDTriggerAnalysistrg->HasFired(AliTRDTriggerAnalysis::kHSE)) // just to check clean-up effect
2571 {
2572 // check if pre-trigger fired
2573 if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
2e4ed823 2574 {
2575 DrawTRDTrigger(ev);
ff8249bd 2576 DrawTRDTriggerAnalysis(ev);
2e4ed823 2577 return kTRUE;
2578 } else return kFALSE;
7bdde22f 2579 }
ff8249bd 2580 }// else return kFALSE;
2581// }
2e4ed823 2582 if(fWhichTRDTrigger==5)
2583 {
2584// printf("trigger %i %i \n", ev->GetHeader()->IsTriggerInputFired("1HQU"),(ev->GetHeader()->GetL1TriggerInputs() & (1 << 12))); // bug in IsTriggerInputFired; reported in savannah
ff8249bd 2585// if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
2586// {
2e4ed823 2587
ff8249bd 2588// Int_t trginput=0;
2589// trginput=ev->GetHeader()->GetL1TriggerInputs() & (1 << 12); //HQU
2e4ed823 2590 // printf("triggerinput %i \n",trginput);
ff8249bd 2591 // if(trginput==4096)
2592// if(fTRDTriggerAnalysismb->CheckCondition(AliTRDTriggerAnalysis::kHQU))
7bdde22f 2593// if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHQU))
2594 if(fTRDTriggerAnalysismb->HasFired(AliTRDTriggerAnalysis::kHQU)) // for mb analysis
2e4ed823 2595 {
7bdde22f 2596 // check if pre-trigger fired
2597 if((ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT7WU-S-NOPF-ALL"))||(ev->IsTriggerClassFired("CINT8WU-S-NOPF-ALL")))
2598 {
2599 DrawTRDTrigger(ev);
2600 DrawTRDTriggerAnalysis(ev);
2601 return kTRUE;
2602 } else return kFALSE;
2603 }
ff8249bd 2604 } //else return kFALSE;
2605// }
7bdde22f 2606
2607
2608
2609
2610
4437a0d2 2611
2612 return trdtrgevent;
2613
2614}
2615
2616
2617//___________________________________________________
2618Bool_t AliAnalysisTaskHFE::CheckTRDTrigger(AliVEvent *ev) {
2619//
2620// Check TRD trigger; pPb settings
2621//
2622
7bdde22f 2623 if(fWhichTRDTrigger<10) fTRDTriggerAnalysistrg->CalcTriggers(ev);
2624 else fTRDTriggerAnalysismb->CalcTriggers(ev);
4437a0d2 2625
2626 // HSE cleanup
2627 if(fWhichTRDTrigger==6)
2628 {
7bdde22f 2629 if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHSE)) // for rare period physics analysis
4437a0d2 2630 {
ff8249bd 2631 // DrawTRDTrigger(ev);
2632 DrawTRDTriggerAnalysis(ev);
4437a0d2 2633 return kTRUE;
7bdde22f 2634 } else return kFALSE;
4437a0d2 2635 }
2636
2637
2638
618038b6 2639 // HQU cleanup
4437a0d2 2640 if(fWhichTRDTrigger==7)
8c07fb0d 2641 {
618038b6 2642
7bdde22f 2643 if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHQU)) // for rare period physics analysis
8c07fb0d 2644 {
ff8249bd 2645 // DrawTRDTrigger(ev);
2646 DrawTRDTriggerAnalysis(ev);
8c07fb0d 2647 return kTRUE;
7bdde22f 2648 } else return kFALSE;
8c07fb0d 2649 }
4437a0d2 2650
2651 // HSE or HQU cleanup
2652 if(fWhichTRDTrigger==8)
2653 {
ff8249bd 2654 if((fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHSE))||(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHQU)))
4437a0d2 2655 {
ff8249bd 2656 // DrawTRDTrigger(ev);
2657 DrawTRDTriggerAnalysis(ev);
4437a0d2 2658 return kTRUE;
2659 }
2660 else
2661 {
2662 return kFALSE;
2663 }
2664 }
2665
7bdde22f 2666 // HEE cleanup
2667 if(fWhichTRDTrigger==9)
2668 {
2669
2670 if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed(AliTRDTriggerAnalysis::kHEE)) // for rare period physics analysis
2671 {
2672 // DrawTRDTrigger(ev);
2673 DrawTRDTriggerAnalysis(ev);
2674 return kTRUE;
2675 } else return kFALSE;
2676 }
2677
2678
2679 if(fWhichTRDTrigger==11)
2680 {
2681 if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHSE))
2682 {
2683 // DrawTRDTrigger(ev);
2684 DrawTRDTriggerAnalysis(ev);
2685 return kTRUE;
2686 } else return kFALSE;
2687 }
2688 if(fWhichTRDTrigger==12)
2689 {
2690 if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHQU))
2691 {
2692 // DrawTRDTrigger(ev);
2693 DrawTRDTriggerAnalysis(ev);
2694 return kTRUE;
2695 } else return kFALSE;
2696 }
2697 if(fWhichTRDTrigger==13)
2698 {
2699 if(fTRDTriggerAnalysismb->HasTriggered(AliTRDTriggerAnalysis::kHEE))
2700 {
2701 // DrawTRDTrigger(ev);
2702 DrawTRDTriggerAnalysis(ev);
2703 return kTRUE;
2704 } else return kFALSE;
2705 }
2706
4437a0d2 2707 return kFALSE;
8c07fb0d 2708
2709}
2710
2e4ed823 2711//___________________________________________________
8c07fb0d 2712void AliAnalysisTaskHFE::DrawTRDTrigger(AliESDEvent *ev) {
2713
2714 Int_t ntriggerbit=0;
2715 fQACollection->Fill("nTriggerBit",ntriggerbit);
2716 if(ev->IsTriggerClassFired("CINT7-B-NOPF-ALLNOTRD"))
2717 {
2718 ntriggerbit=2;
2719 fQACollection->Fill("nTriggerBit",ntriggerbit);
2720 }
2721 if(ev->IsTriggerClassFired("CINT7WU-B-NOPF-ALL"))
2722 {
2723 ntriggerbit=3;
2724 fQACollection->Fill("nTriggerBit",ntriggerbit);
2725 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
2726 ntriggerbit=18;
2727 fQACollection->Fill("nTriggerBit",ntriggerbit);
2728 }
2729 if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
2730 ntriggerbit=19;
2731 fQACollection->Fill("nTriggerBit",ntriggerbit);
2732 }
2733 }
2734 if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT"))
2735 {
2736 ntriggerbit=4;
2737 fQACollection->Fill("nTriggerBit",ntriggerbit);
2738
2739 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
2740 ntriggerbit=13;
2741 fQACollection->Fill("nTriggerBit",ntriggerbit);
2742 }
2743 if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
2744 ntriggerbit=14;
2745 fQACollection->Fill("nTriggerBit",ntriggerbit);
2746 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
2747 ntriggerbit=17;
2748 fQACollection->Fill("nTriggerBit",ntriggerbit);
2749 }
2750 }
2751 }
2752 if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT"))
2753 {
2754 ntriggerbit=5;
2755 fQACollection->Fill("nTriggerBit",ntriggerbit);
2756 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
2757 ntriggerbit=11;
2758 fQACollection->Fill("nTriggerBit",ntriggerbit);
2759 }
2760 if((!(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
2761 ntriggerbit=21;
2762 fQACollection->Fill("nTriggerBit",ntriggerbit);
2763
2764 /*
2765 Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
2766 for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
2767 AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
2768 printf("GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
2769 }*/
2770
2771
2772 }
2773
2774 }
2775 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT"))
2776 {
2777 ntriggerbit=6;
2778 fQACollection->Fill("nTriggerBit",ntriggerbit);
2779 if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")) {
2780 ntriggerbit=12;
2781 fQACollection->Fill("nTriggerBit",ntriggerbit);
2782 }
2783 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
2784 ntriggerbit=15;
2785 fQACollection->Fill("nTriggerBit",ntriggerbit);
2786
2787 if((!(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-CENT")))&&(!(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-CENT")))) {
2788 ntriggerbit=20;
2789 fQACollection->Fill("nTriggerBit",ntriggerbit);
2790 /*
2791 Int_t nTrdTracks = ev->GetNumberOfTrdTracks();
2792 for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
2793 AliESDTrdTrack* trdTrack = ev->GetTrdTrack(iTrack);
2794 printf("HSE GTU track %3i: pt = %5.1f, PID = %3i\n", iTrack, trdTrack->Pt(), trdTrack->GetPID());
2795 } */
2796
2797 }
2798
2799 }
2800
2801 }
2802 if(ev->IsTriggerClassFired("CEMC7WUHEE-B-NOPF-CENT")) {
2803 ntriggerbit=7;
2804 fQACollection->Fill("nTriggerBit",ntriggerbit);
2805 }
2806 if(ev->IsTriggerClassFired("CINT7WUHJT-B-NOPF-FAST")){
2807 ntriggerbit=8;
2808 fQACollection->Fill("nTriggerBit",ntriggerbit);
2809 }
2810 if(ev->IsTriggerClassFired("CINT7WUHQU-B-NOPF-FAST")){
2811 ntriggerbit=9;
2812 fQACollection->Fill("nTriggerBit",ntriggerbit);
2813 }
2814 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-FAST")){
2815 ntriggerbit=10;
2816 fQACollection->Fill("nTriggerBit",ntriggerbit);
2817 if(ev->IsTriggerClassFired("CINT7WUHSE-B-NOPF-CENT")) {
2818 ntriggerbit=16;
2819 fQACollection->Fill("nTriggerBit",ntriggerbit);
2820 }
2821 }
2822 if(ntriggerbit==0) fQACollection->Fill("nTriggerBit",1);
2823
01745870 2824}
2e4ed823 2825
ff8249bd 2826
2827//___________________________________________________
2828void AliAnalysisTaskHFE::DrawTRDTriggerAnalysis(AliVEvent *ev) {
2829
2830 fTRDTriggerAnalysistrg->CalcTriggers(ev);
2831 for(Int_t itrg=0;itrg<AliTRDTriggerAnalysis::kHlast;itrg++)
2832 {
2833 Int_t trdtrgstatus=0;
2834 if(fTRDTriggerAnalysistrg->CheckCondition((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=1;
2835 if(fTRDTriggerAnalysistrg->HasFired((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=2;
2836 if(fTRDTriggerAnalysistrg->HasTriggered((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=3;
2837 if(fTRDTriggerAnalysistrg->HasTriggeredConfirmed((AliTRDTriggerAnalysis::TRDTrigger_t) itrg))trdtrgstatus=4;
2838 fQACollection->Fill("TriggerAnalysis",(Float_t)itrg,(Float_t)trdtrgstatus);
2839 }
2840}
2841
2e4ed823 2842//___________________________________________________
2843Bool_t AliAnalysisTaskHFE::IsMCFakeTrack(const AliVTrack *const trk) const {
2844 //
2845 // Check whether track is MC Fake track using the sign of the track label
2846 //
2847 return trk->GetLabel() < 0;
2848}