]>
Commit | Line | Data |
---|---|---|
809a4336 | 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 | **************************************************************************/ | |
50685501 | 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 | // | |
809a4336 | 27 | #include <TAxis.h> |
28 | #include <TCanvas.h> | |
29 | #include <TChain.h> | |
259c3296 | 30 | #include <TDirectory.h> |
6ad05e72 | 31 | #include <TFile.h> |
faee3b18 | 32 | #include <TH3D.h> |
809a4336 | 33 | #include <TIterator.h> |
34 | #include <TList.h> | |
35 | #include <TLegend.h> | |
36 | #include <TMath.h> | |
37 | #include <TObjArray.h> | |
38 | #include <TParticle.h> | |
39 | #include <TProfile.h> | |
75d81601 | 40 | #include <TString.h> |
faee3b18 | 41 | #include <TF1.h> |
809a4336 | 42 | #include <TTree.h> |
43 | ||
9bcfd1ab | 44 | #include "AliAODInputHandler.h" |
45 | #include "AliAODMCParticle.h" | |
46 | #include "AliAODTrack.h" | |
809a4336 | 47 | #include "AliCFContainer.h" |
48 | #include "AliCFManager.h" | |
49 | #include "AliESDEvent.h" | |
50 | #include "AliESDInputHandler.h" | |
faee3b18 | 51 | #include "AliESDpid.h" |
809a4336 | 52 | #include "AliESDtrack.h" |
3a72645a | 53 | #include "AliESDCentrality.h" |
809a4336 | 54 | #include "AliLog.h" |
55 | #include "AliAnalysisManager.h" | |
56 | #include "AliMCEvent.h" | |
57 | #include "AliMCEventHandler.h" | |
58 | #include "AliMCParticle.h" | |
59 | #include "AliPID.h" | |
259c3296 | 60 | #include "AliStack.h" |
69ac0e6f | 61 | #include "AliTriggerAnalysis.h" |
70da6c5a | 62 | #include "AliVVertex.h" |
809a4336 | 63 | |
9bcfd1ab | 64 | #include "AliHFEcollection.h" |
3a72645a | 65 | #include "AliHFEcontainer.h" |
809a4336 | 66 | #include "AliHFEcuts.h" |
3a72645a | 67 | #include "AliHFEelecbackground.h" |
259c3296 | 68 | #include "AliHFEmcQA.h" |
9bcfd1ab | 69 | #include "AliHFEpairs.h" |
3a72645a | 70 | #include "AliHFEpid.h" |
71 | #include "AliHFEpidQAmanager.h" | |
d2af20c5 | 72 | #include "AliHFEpostAnalysis.h" |
9bcfd1ab | 73 | #include "AliHFEsecVtxs.h" |
259c3296 | 74 | #include "AliHFEsecVtx.h" |
3a72645a | 75 | #include "AliHFEsignalCuts.h" |
76 | #include "AliHFEtaggedTrackAnalysis.h" | |
70da6c5a | 77 | #include "AliHFEtools.h" |
3a72645a | 78 | #include "AliHFEvarManager.h" |
809a4336 | 79 | #include "AliAnalysisTaskHFE.h" |
80 | ||
faee3b18 | 81 | ClassImp(AliAnalysisTaskHFE) |
82 | ||
809a4336 | 83 | //____________________________________________________________ |
84 | AliAnalysisTaskHFE::AliAnalysisTaskHFE(): | |
d2af20c5 | 85 | AliAnalysisTaskSE("PID efficiency Analysis") |
75d81601 | 86 | , fQAlevel(0) |
9bcfd1ab | 87 | , fPlugins(0) |
3a72645a | 88 | , fFillSignalOnly(kTRUE) |
89 | , fRemovePileUp(kFALSE) | |
90 | , fIdentifiedAsPileUp(kFALSE) | |
91 | , fIdentifiedAsOutInz(kFALSE) | |
92 | , fPassTheEventCut(kFALSE) | |
93 | , fCentralityF(99.0) | |
e3fc062d | 94 | , fBackGroundFactorsFunction(NULL) |
3a72645a | 95 | , fContainer(NULL) |
96 | , fVarManager(NULL) | |
97 | , fSignalCuts(NULL) | |
9bcfd1ab | 98 | , fCFM(NULL) |
69ac0e6f | 99 | , fTriggerAnalysis(NULL) |
9bcfd1ab | 100 | , fPID(NULL) |
3a72645a | 101 | , fPIDqa(NULL) |
e3fc062d | 102 | , fPIDpreselect(NULL) |
9bcfd1ab | 103 | , fCuts(NULL) |
3a72645a | 104 | , fTaggedTrackCuts(NULL) |
6555e2ad | 105 | , fCleanTaggedTrack(kFALSE) |
e3fc062d | 106 | , fCutspreselect(NULL) |
9bcfd1ab | 107 | , fSecVtx(NULL) |
108 | , fElecBackGround(NULL) | |
109 | , fMCQA(NULL) | |
3a72645a | 110 | , fTaggedTrackAnalysis(NULL) |
9bcfd1ab | 111 | , fQA(NULL) |
112 | , fOutput(NULL) | |
113 | , fHistMCQA(NULL) | |
114 | , fHistSECVTX(NULL) | |
115 | , fHistELECBACKGROUND(NULL) | |
69ac0e6f | 116 | , fQACollection(NULL) |
0792aa82 | 117 | { |
118 | // | |
50685501 | 119 | // Dummy constructor |
0792aa82 | 120 | // |
0792aa82 | 121 | } |
122 | ||
123 | //____________________________________________________________ | |
124 | AliAnalysisTaskHFE::AliAnalysisTaskHFE(const char * name): | |
d2af20c5 | 125 | AliAnalysisTaskSE(name) |
0792aa82 | 126 | , fQAlevel(0) |
9bcfd1ab | 127 | , fPlugins(0) |
3a72645a | 128 | , fFillSignalOnly(kTRUE) |
129 | , fRemovePileUp(kFALSE) | |
130 | , fIdentifiedAsPileUp(kFALSE) | |
131 | , fIdentifiedAsOutInz(kFALSE) | |
132 | , fPassTheEventCut(kFALSE) | |
133 | , fCentralityF(99.0) | |
e3fc062d | 134 | , fBackGroundFactorsFunction(NULL) |
3a72645a | 135 | , fContainer(NULL) |
136 | , fVarManager(NULL) | |
137 | , fSignalCuts(NULL) | |
9bcfd1ab | 138 | , fCFM(NULL) |
69ac0e6f | 139 | , fTriggerAnalysis(NULL) |
9bcfd1ab | 140 | , fPID(NULL) |
3a72645a | 141 | , fPIDqa(NULL) |
e3fc062d | 142 | , fPIDpreselect(NULL) |
9bcfd1ab | 143 | , fCuts(NULL) |
3a72645a | 144 | , fTaggedTrackCuts(NULL) |
6555e2ad | 145 | , fCleanTaggedTrack(kFALSE) |
e3fc062d | 146 | , fCutspreselect(NULL) |
9bcfd1ab | 147 | , fSecVtx(NULL) |
148 | , fElecBackGround(NULL) | |
149 | , fMCQA(NULL) | |
3a72645a | 150 | , fTaggedTrackAnalysis(NULL) |
9bcfd1ab | 151 | , fQA(NULL) |
152 | , fOutput(NULL) | |
153 | , fHistMCQA(NULL) | |
154 | , fHistSECVTX(NULL) | |
155 | , fHistELECBACKGROUND(NULL) | |
69ac0e6f | 156 | , fQACollection(0x0) |
809a4336 | 157 | { |
dbe3abbe | 158 | // |
159 | // Default constructor | |
9bcfd1ab | 160 | // |
3a72645a | 161 | DefineOutput(1, TList::Class()); |
259c3296 | 162 | DefineOutput(2, TList::Class()); |
809a4336 | 163 | |
3a72645a | 164 | fPID = new AliHFEpid("hfePid"); |
165 | fVarManager = new AliHFEvarManager("hfeVarManager"); | |
809a4336 | 166 | } |
167 | ||
dbe3abbe | 168 | //____________________________________________________________ |
169 | AliAnalysisTaskHFE::AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref): | |
d2af20c5 | 170 | AliAnalysisTaskSE(ref) |
faee3b18 | 171 | , fQAlevel(0) |
faee3b18 | 172 | , fPlugins(0) |
3a72645a | 173 | , fFillSignalOnly(ref.fFillSignalOnly) |
174 | , fRemovePileUp(ref.fRemovePileUp) | |
175 | , fIdentifiedAsPileUp(ref.fIdentifiedAsPileUp) | |
176 | , fIdentifiedAsOutInz(ref.fIdentifiedAsOutInz) | |
177 | , fPassTheEventCut(ref.fPassTheEventCut) | |
178 | , fCentralityF(ref.fCentralityF) | |
e3fc062d | 179 | , fBackGroundFactorsFunction(NULL) |
3a72645a | 180 | , fContainer(NULL) |
181 | , fVarManager(NULL) | |
182 | , fSignalCuts(NULL) | |
faee3b18 | 183 | , fCFM(NULL) |
69ac0e6f | 184 | , fTriggerAnalysis(NULL) |
faee3b18 | 185 | , fPID(NULL) |
3a72645a | 186 | , fPIDqa(NULL) |
e3fc062d | 187 | , fPIDpreselect(NULL) |
faee3b18 | 188 | , fCuts(NULL) |
3a72645a | 189 | , fTaggedTrackCuts(NULL) |
6555e2ad | 190 | , fCleanTaggedTrack(ref.fCleanTaggedTrack) |
e3fc062d | 191 | , fCutspreselect(NULL) |
faee3b18 | 192 | , fSecVtx(NULL) |
193 | , fElecBackGround(NULL) | |
194 | , fMCQA(NULL) | |
3a72645a | 195 | , fTaggedTrackAnalysis(NULL) |
faee3b18 | 196 | , fQA(NULL) |
197 | , fOutput(NULL) | |
198 | , fHistMCQA(NULL) | |
199 | , fHistSECVTX(NULL) | |
200 | , fHistELECBACKGROUND(NULL) | |
69ac0e6f | 201 | , fQACollection(NULL) |
dbe3abbe | 202 | { |
203 | // | |
204 | // Copy Constructor | |
205 | // | |
faee3b18 | 206 | ref.Copy(*this); |
dbe3abbe | 207 | } |
208 | ||
209 | //____________________________________________________________ | |
210 | AliAnalysisTaskHFE &AliAnalysisTaskHFE::operator=(const AliAnalysisTaskHFE &ref){ | |
211 | // | |
212 | // Assignment operator | |
213 | // | |
faee3b18 | 214 | if(this == &ref) |
215 | ref.Copy(*this); | |
dbe3abbe | 216 | return *this; |
217 | } | |
218 | ||
faee3b18 | 219 | //____________________________________________________________ |
220 | void AliAnalysisTaskHFE::Copy(TObject &o) const { | |
221 | // | |
222 | // Copy into object o | |
223 | // | |
224 | AliAnalysisTaskHFE &target = dynamic_cast<AliAnalysisTaskHFE &>(o); | |
225 | target.fQAlevel = fQAlevel; | |
faee3b18 | 226 | target.fPlugins = fPlugins; |
3a72645a | 227 | target.fFillSignalOnly = fFillSignalOnly; |
228 | target.fRemovePileUp = fRemovePileUp; | |
229 | target.fIdentifiedAsPileUp = fIdentifiedAsPileUp; | |
230 | target.fIdentifiedAsOutInz = fIdentifiedAsOutInz; | |
231 | target.fPassTheEventCut = fPassTheEventCut; | |
232 | target.fCentralityF = fCentralityF; | |
e3fc062d | 233 | target.fBackGroundFactorsFunction = fBackGroundFactorsFunction; |
3a72645a | 234 | target.fContainer = fContainer; |
235 | target.fVarManager = fVarManager; | |
236 | target.fSignalCuts = fSignalCuts; | |
faee3b18 | 237 | target.fCFM = fCFM; |
69ac0e6f | 238 | target.fTriggerAnalysis = fTriggerAnalysis; |
faee3b18 | 239 | target.fPID = fPID; |
3a72645a | 240 | target.fPIDqa = fPIDqa; |
e3fc062d | 241 | target.fPIDpreselect = fPIDpreselect; |
faee3b18 | 242 | target.fCuts = fCuts; |
3a72645a | 243 | target.fTaggedTrackCuts = fTaggedTrackCuts; |
6555e2ad | 244 | target.fCleanTaggedTrack = fCleanTaggedTrack; |
e3fc062d | 245 | target.fCutspreselect = fCutspreselect; |
faee3b18 | 246 | target.fSecVtx = fSecVtx; |
247 | target.fElecBackGround = fElecBackGround; | |
248 | target.fMCQA = fMCQA; | |
3a72645a | 249 | target.fTaggedTrackAnalysis = fTaggedTrackAnalysis; |
faee3b18 | 250 | target.fQA = fQA; |
251 | target.fOutput = fOutput; | |
252 | target.fHistMCQA = fHistMCQA; | |
253 | target.fHistSECVTX = fHistSECVTX; | |
254 | target.fHistELECBACKGROUND = fHistELECBACKGROUND; | |
69ac0e6f | 255 | target.fQACollection = fQACollection; |
faee3b18 | 256 | } |
257 | ||
809a4336 | 258 | //____________________________________________________________ |
259 | AliAnalysisTaskHFE::~AliAnalysisTaskHFE(){ | |
dbe3abbe | 260 | // |
261 | // Destructor | |
262 | // | |
dbe3abbe | 263 | if(fPID) delete fPID; |
3a72645a | 264 | if(fVarManager) delete fVarManager; |
265 | if(fPIDqa) delete fPIDqa; | |
266 | if(fSignalCuts) delete fSignalCuts; | |
267 | if(fCFM) delete fCFM; | |
259c3296 | 268 | if(fSecVtx) delete fSecVtx; |
dbe3abbe | 269 | if(fMCQA) delete fMCQA; |
3a72645a | 270 | if(fElecBackGround) delete fElecBackGround; |
271 | if(fTriggerAnalysis) delete fTriggerAnalysis; | |
272 | if(fPIDpreselect) delete fPIDpreselect; | |
273 | if(fQA) delete fQA; | |
274 | if(fOutput) delete fOutput; | |
809a4336 | 275 | } |
276 | ||
277 | //____________________________________________________________ | |
d2af20c5 | 278 | void AliAnalysisTaskHFE::UserCreateOutputObjects(){ |
50685501 | 279 | // |
280 | // Creating output container and output objects | |
281 | // Here we also Initialize the correction framework container and | |
282 | // the objects for | |
283 | // - PID | |
284 | // - MC QA | |
285 | // - SecVtx | |
286 | // QA histograms are created if requested | |
287 | // Called once per worker | |
288 | // | |
9bcfd1ab | 289 | AliDebug(3, "Creating Output Objects"); |
70da6c5a | 290 | // Automatic determination of the analysis mode |
faee3b18 | 291 | AliVEventHandler *inputHandler = dynamic_cast<AliVEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); |
70da6c5a | 292 | if(!TString(inputHandler->IsA()->GetName()).CompareTo("AliAODInputHandler")){ |
293 | SetAODAnalysis(); | |
294 | } else { | |
295 | SetESDAnalysis(); | |
296 | if(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()) | |
297 | SetHasMCData(); | |
298 | } | |
9bcfd1ab | 299 | printf("Analysis Mode: %s Analysis\n", IsAODanalysis() ? "AOD" : "ESD"); |
300 | printf("MC Data available %s\n", HasMCData() ? "Yes" : "No"); | |
301 | ||
69ac0e6f | 302 | // Enable Trigger Analysis |
303 | fTriggerAnalysis = new AliTriggerAnalysis; | |
304 | fTriggerAnalysis->EnableHistograms(); | |
305 | fTriggerAnalysis->SetAnalyzeMC(HasMCData()); | |
306 | ||
3a72645a | 307 | |
308 | // Make lists for Output | |
dbe3abbe | 309 | if(!fQA) fQA = new TList; |
3a72645a | 310 | fQA->SetOwner(); |
311 | if(!fOutput) fOutput = new TList; | |
312 | fOutput->SetOwner(); | |
69ac0e6f | 313 | |
3a72645a | 314 | // First Part: Make QA histograms |
69ac0e6f | 315 | fQACollection = new AliHFEcollection("TaskQA", "QA histos from the Electron Task"); |
3a72645a | 316 | fQACollection->CreateTH1F("nElectronTracksEvent", "Number of Electron Candidates", 100, 0, 100); |
69ac0e6f | 317 | fQACollection->CreateProfile("conr", "Electron PID contamination", 20, 0, 20); |
318 | fQACollection->CreateTH1F("alpha_rec", "Alpha from reconstructed tracks with TRD hits", 36, -TMath::Pi(), TMath::Pi()); | |
319 | fQACollection->CreateTH1F("alpha_sim", "Alpha from simulated electron tracks", 36, -TMath::Pi(), TMath::Pi()); | |
320 | fQACollection->CreateTH1F("nElectron", "Number of electrons", 100, 0, 100); | |
321 | fQACollection->CreateProfile("pidquality", "TRD PID quality as function of momentum", 20, 0, 20); | |
322 | fQACollection->CreateProfile("ntrdclusters", "Number of TRD clusters as function of momentum", 20, 0, 20); | |
323 | fQACollection->CreateTH1F("chi2TRD","#chi2 per TRD cluster", 20, 0, 20); | |
324 | fQACollection->CreateTH1F("mccharge", "MC Charge", 200, -100, 100); | |
325 | fQACollection->CreateTH2F("radius", "Production Vertex", 100, 0.0, 5.0, 100, 0.0, 5.0); | |
3a72645a | 326 | InitPIDperformanceQA(); |
6555e2ad | 327 | InitContaminationQA(); |
69ac0e6f | 328 | fQA->Add(fQACollection->GetList()); |
809a4336 | 329 | |
3a72645a | 330 | // Initialize PID |
331 | fPID->SetHasMCData(HasMCData()); | |
332 | if(!fPID->GetNumberOfPIDdetectors()) fPID->AddDetector("TPC", 0); | |
333 | fPID->InitializePID(); | |
334 | if(IsQAOn(kPIDqa)){ | |
335 | AliInfo("PID QA switched on"); | |
336 | fPIDqa = new AliHFEpidQAmanager; | |
337 | fPIDqa->Initialize(fPID); | |
338 | fQA->Add(fPIDqa->MakeList("HFEpidQA")); | |
339 | } | |
340 | ||
809a4336 | 341 | // Initialize correction Framework and Cuts |
3a72645a | 342 | const Int_t kNcutSteps = AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack + AliHFEcuts::kNcutStepsDETrack; |
809a4336 | 343 | fCFM = new AliCFManager; |
3a72645a | 344 | fCFM->SetNStepParticle(kNcutSteps); |
809a4336 | 345 | MakeParticleContainer(); |
70da6c5a | 346 | MakeEventContainer(); |
9bcfd1ab | 347 | // Temporary fix: Initialize particle cuts with NULL |
3a72645a | 348 | for(Int_t istep = 0; istep < kNcutSteps; istep++) |
9bcfd1ab | 349 | fCFM->SetParticleCutsList(istep, NULL); |
0792aa82 | 350 | if(!fCuts){ |
351 | AliWarning("Cuts not available. Default cuts will be used"); | |
352 | fCuts = new AliHFEcuts; | |
353 | fCuts->CreateStandardCuts(); | |
809a4336 | 354 | } |
9bcfd1ab | 355 | if(IsAODanalysis()) fCuts->SetAOD(); |
e3fc062d | 356 | // Make clone for V0 tagging step |
0792aa82 | 357 | fCuts->Initialize(fCFM); |
e3fc062d | 358 | if(fCuts->IsQAOn()) fQA->Add(fCuts->GetQAhistograms()); |
3a72645a | 359 | fSignalCuts = new AliHFEsignalCuts("HFEsignalCuts", "HFE MC Signal definition"); |
360 | fVarManager->SetSignalCuts(fSignalCuts); | |
0792aa82 | 361 | |
259c3296 | 362 | // add output objects to the List |
3a72645a | 363 | fOutput->AddAt(fContainer, 0); |
70da6c5a | 364 | fOutput->AddAt(fCFM->GetEventContainer(), 1); |
3a72645a | 365 | |
dbe3abbe | 366 | // mcQA---------------------------------- |
9bcfd1ab | 367 | if (HasMCData() && IsQAOn(kMCqa)) { |
dbe3abbe | 368 | AliInfo("MC QA on"); |
369 | if(!fMCQA) fMCQA = new AliHFEmcQA; | |
259c3296 | 370 | if(!fHistMCQA) fHistMCQA = new TList(); |
3a72645a | 371 | fHistMCQA->SetOwner(); |
e3fc062d | 372 | fMCQA->CreatDefaultHistograms(fHistMCQA); |
259c3296 | 373 | fQA->Add(fHistMCQA); |
dbe3abbe | 374 | } |
259c3296 | 375 | |
dbe3abbe | 376 | // secvtx---------------------------------- |
9bcfd1ab | 377 | if (GetPlugin(kSecVtx)) { |
dbe3abbe | 378 | AliInfo("Secondary Vertex Analysis on"); |
e3fc062d | 379 | if(!fSecVtx) fSecVtx = new AliHFEsecVtx; |
9bcfd1ab | 380 | fSecVtx->SetHasMCData(HasMCData()); |
dbe3abbe | 381 | |
259c3296 | 382 | if(!fHistSECVTX) fHistSECVTX = new TList(); |
3a72645a | 383 | fHistSECVTX->SetOwner(); |
9bcfd1ab | 384 | fSecVtx->CreateHistograms(fHistSECVTX); |
75d81601 | 385 | fOutput->Add(fHistSECVTX); |
9bcfd1ab | 386 | } |
387 | ||
388 | // background---------------------------------- | |
389 | if (GetPlugin(kIsElecBackGround)) { | |
390 | AliInfo("Electron BackGround Analysis on"); | |
70da6c5a | 391 | if(!fElecBackGround){ |
392 | AliWarning("ElecBackGround not available. Default elecbackground will be used"); | |
393 | fElecBackGround = new AliHFEelecbackground; | |
394 | } | |
9bcfd1ab | 395 | fElecBackGround->SetHasMCData(HasMCData()); |
396 | ||
397 | if(!fHistELECBACKGROUND) fHistELECBACKGROUND = new TList(); | |
3a72645a | 398 | fHistELECBACKGROUND->SetOwner(); |
9bcfd1ab | 399 | fElecBackGround->CreateHistograms(fHistELECBACKGROUND); |
400 | fOutput->Add(fHistELECBACKGROUND); | |
401 | } | |
3a72645a | 402 | |
403 | // tagged tracks | |
404 | if(GetPlugin(kTaggedTrackAnalysis)){ | |
405 | AliInfo("Analysis on V0-tagged tracks enabled"); | |
406 | fTaggedTrackAnalysis = new AliHFEtaggedTrackAnalysis; | |
407 | fTaggedTrackAnalysis->SetCuts(fTaggedTrackCuts); | |
6555e2ad | 408 | fTaggedTrackAnalysis->SetClean(fCleanTaggedTrack); |
3a72645a | 409 | fTaggedTrackAnalysis->SetPID(fPID); |
410 | fTaggedTrackAnalysis->InitContainer(); | |
411 | fOutput->Add(fTaggedTrackAnalysis->GetContainer()); | |
412 | fQA->Add(fTaggedTrackAnalysis->GetPIDQA()); | |
413 | fQA->Add(fTaggedTrackAnalysis->GetCutQA()); | |
414 | } | |
415 | PrintStatus(); | |
809a4336 | 416 | } |
417 | ||
418 | //____________________________________________________________ | |
d2af20c5 | 419 | void AliAnalysisTaskHFE::UserExec(Option_t *){ |
dbe3abbe | 420 | // |
421 | // Run the analysis | |
422 | // | |
9bcfd1ab | 423 | AliDebug(3, "Starting Single Event Analysis"); |
d2af20c5 | 424 | if(!fInputEvent){ |
9bcfd1ab | 425 | AliError("Reconstructed Event not available"); |
dbe3abbe | 426 | return; |
427 | } | |
9bcfd1ab | 428 | if(HasMCData()){ |
d2af20c5 | 429 | AliDebug(4, Form("MC Event: %p", fMCEvent)); |
430 | if(!fMCEvent){ | |
9bcfd1ab | 431 | AliError("No MC Event, but MC Data required"); |
432 | return; | |
433 | } | |
dbe3abbe | 434 | } |
722347d8 | 435 | if(!fCuts){ |
436 | AliError("HFE cuts not available"); | |
437 | return; | |
438 | } | |
809a4336 | 439 | |
faee3b18 | 440 | if(IsESDanalysis() && HasMCData()){ |
441 | // Protect against missing MC trees | |
442 | AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler *>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); | |
69ac0e6f | 443 | if(!mcH){ |
444 | AliError("No MC Event Handler available"); | |
445 | return; | |
446 | } | |
faee3b18 | 447 | if(!mcH->InitOk()) return; |
448 | if(!mcH->TreeK()) return; | |
449 | if(!mcH->TreeTR()) return; | |
450 | } | |
451 | ||
3a72645a | 452 | // need the centrality for everything (MC also) |
453 | fCentralityF = 99.0; | |
454 | ReadCentrality(); | |
455 | ||
456 | // See if pile up and z in the range | |
457 | RejectionPileUpVertexRangeEventCut(); | |
458 | ||
faee3b18 | 459 | // Protect agains missing |
3a72645a | 460 | if(HasMCData()){ |
461 | fSignalCuts->SetMCEvent(fMCEvent); | |
462 | ProcessMC(); // Run the MC loop + MC QA in case MC Data are available | |
463 | } | |
809a4336 | 464 | |
3a72645a | 465 | if(IsAODanalysis()){ |
466 | AliAODpidUtil *aodworkingpid = AliHFEtools::GetDefaultAODPID(HasMCData()); | |
467 | fPID->SetAODpid(aodworkingpid); | |
3a72645a | 468 | ProcessAOD(); |
469 | } else { | |
faee3b18 | 470 | AliESDInputHandler *inH = dynamic_cast<AliESDInputHandler *>(fInputHandler); |
69ac0e6f | 471 | if(!inH){ |
472 | AliError("No ESD Input handler available"); | |
473 | return; | |
474 | } | |
faee3b18 | 475 | AliESDpid *workingPID = inH->GetESDpid(); |
3a72645a | 476 | if(!workingPID){ |
faee3b18 | 477 | AliDebug(1, "Using default ESD PID"); |
3a72645a | 478 | workingPID = AliHFEtools::GetDefaultPID(HasMCData()); |
479 | } else { | |
480 | AliDebug(1, "Using ESD PID from the input handler"); | |
faee3b18 | 481 | } |
3a72645a | 482 | fPID->SetESDpid(workingPID); |
3a72645a | 483 | if(fPIDpreselect) fPIDpreselect->SetESDpid(workingPID); |
484 | ||
faee3b18 | 485 | ProcessESD(); |
486 | } | |
9bcfd1ab | 487 | // Done!!! |
3a72645a | 488 | PostData(1, fOutput); |
489 | PostData(2, fQA); | |
9bcfd1ab | 490 | } |
259c3296 | 491 | |
9bcfd1ab | 492 | //____________________________________________________________ |
493 | void AliAnalysisTaskHFE::Terminate(Option_t *){ | |
494 | // | |
495 | // Terminate not implemented at the moment | |
496 | // | |
497 | if(GetPlugin(kPostProcess)){ | |
3a72645a | 498 | fOutput = dynamic_cast<TList *>(GetOutputData(1)); |
499 | fQA = dynamic_cast<TList *>(GetOutputData(2)); | |
9bcfd1ab | 500 | if(!fOutput){ |
501 | AliError("Results not available"); | |
502 | return; | |
259c3296 | 503 | } |
3a72645a | 504 | if(!fQA){ |
505 | AliError("QA output not available"); | |
506 | return; | |
507 | } | |
508 | fContainer = dynamic_cast<AliHFEcontainer *>(fOutput->FindObject("trackContainer")); | |
509 | if(!fContainer){ | |
510 | AliError("Track container not found"); | |
511 | return; | |
512 | } | |
d2af20c5 | 513 | AliHFEpostAnalysis postanalysis; |
3a72645a | 514 | postanalysis.SetTaskResults(fContainer); |
515 | TList *qalist = dynamic_cast<TList *>(fQA->FindObject("list_TaskQA")); | |
516 | if(!qalist){ | |
517 | AliError("QA List not found"); | |
518 | return; | |
519 | } | |
520 | postanalysis.SetTaskQA(qalist); | |
521 | printf("Running post analysis\n"); | |
522 | //if(HasMCData()) | |
523 | postanalysis.DrawMCSignal2Background(); | |
d2af20c5 | 524 | postanalysis.DrawEfficiency(); |
525 | postanalysis.DrawPIDperformance(); | |
70da6c5a | 526 | postanalysis.DrawCutEfficiency(); |
527 | ||
528 | if (GetPlugin(kIsElecBackGround)) { | |
529 | AliHFEelecbackground elecBackGround; | |
530 | TList *oe = 0x0; | |
531 | if(!(oe = (TList*)dynamic_cast<TList *>(fOutput->FindObject("HFEelecbackground")))){ | |
532 | return; | |
533 | } | |
534 | elecBackGround.Load(oe); | |
535 | elecBackGround.Plot(); | |
536 | elecBackGround.PostProcess(); | |
537 | } | |
9bcfd1ab | 538 | } |
9bcfd1ab | 539 | } |
faee3b18 | 540 | //_______________________________________________________________ |
541 | Bool_t AliAnalysisTaskHFE::IsEventInBinZero() { | |
542 | // | |
543 | // | |
544 | // | |
545 | ||
546 | //printf("test in IsEventInBinZero\n"); | |
547 | if(!fInputEvent){ | |
548 | AliError("Reconstructed Event not available"); | |
549 | return kFALSE; | |
550 | } | |
dbe3abbe | 551 | |
faee3b18 | 552 | // check vertex |
553 | const AliVVertex *vertex = fInputEvent->GetPrimaryVertex(); | |
554 | if(!vertex) return kTRUE; | |
555 | //if(vertex) return kTRUE; | |
556 | ||
557 | // check tracks | |
558 | if(fInputEvent->GetNumberOfTracks()<=0) return kTRUE; | |
559 | //if(fInputEvent->GetNumberOfTracks()>0) return kTRUE; | |
560 | ||
561 | ||
562 | return kFALSE; | |
563 | ||
564 | } | |
9bcfd1ab | 565 | //____________________________________________________________ |
566 | void AliAnalysisTaskHFE::ProcessMC(){ | |
567 | // | |
568 | // Runs the MC Loop (filling the container for the MC Cut Steps with the observables pt, eta and phi) | |
569 | // In case MC QA is on also MC QA loop is done | |
570 | // | |
571 | AliDebug(3, "Processing MC Information"); | |
3a72645a | 572 | Double_t eventContainer [3]; |
69ac0e6f | 573 | eventContainer[0] = fMCEvent->GetPrimaryVertex()->GetZ(); |
3a72645a | 574 | eventContainer[2] = fCentralityF; |
69ac0e6f | 575 | if(fCFM->CheckEventCuts(AliHFEcuts::kEventStepGenerated, fMCEvent)) |
576 | fCFM->GetEventContainer()->Fill(eventContainer,AliHFEcuts::kEventStepGenerated); | |
9bcfd1ab | 577 | Int_t nElectrons = 0; |
578 | if(IsESDanalysis()){ | |
579 | if (HasMCData() && IsQAOn(kMCqa)) { | |
580 | AliDebug(2, "Running MC QA"); | |
581 | ||
70da6c5a | 582 | if(fMCEvent->Stack()){ |
e3fc062d | 583 | fMCQA->SetMCEvent(fMCEvent); |
70da6c5a | 584 | fMCQA->SetGenEventHeader(fMCEvent->GenEventHeader()); |
585 | fMCQA->Init(); | |
586 | ||
587 | Int_t nMCTracks = fMCEvent->Stack()->GetNtrack(); | |
588 | ||
589 | // loop over all tracks for decayed electrons | |
590 | for (Int_t igen = 0; igen < nMCTracks; igen++){ | |
591 | TParticle* mcpart = fMCEvent->Stack()->Particle(igen); | |
592 | fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kCharm); | |
593 | fMCQA->GetQuarkKine(mcpart, igen, AliHFEmcQA::kBeauty); | |
594 | fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kCharm); | |
595 | fMCQA->GetHadronKine(mcpart, AliHFEmcQA::kBeauty); | |
596 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG, 0); // no accept cut | |
597 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG, 0); // no accept cut | |
faee3b18 | 598 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG, 0); // no accept cut |
70da6c5a | 599 | if (TMath::Abs(mcpart->Eta()) < 0.9) { |
600 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG, 1); // accept |eta|<0.9 | |
601 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG, 1); // accept |eta|<0.9 | |
faee3b18 | 602 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG, 1); // accept |eta|<0.9 |
70da6c5a | 603 | } |
604 | if (TMath::Abs(AliHFEtools::GetRapidity(mcpart)) < 0.5) { | |
605 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG, 2); // accept |y|<0.5 | |
606 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG, 2); // accept |y|<0.5 | |
faee3b18 | 607 | fMCQA->GetDecayedKine(mcpart, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG, 2); // accept |y|<0.5 |
9bcfd1ab | 608 | } |
9bcfd1ab | 609 | } |
70da6c5a | 610 | fMCQA->EndOfEventAna(AliHFEmcQA::kCharm); |
611 | fMCQA->EndOfEventAna(AliHFEmcQA::kBeauty); | |
9bcfd1ab | 612 | } |
809a4336 | 613 | |
9bcfd1ab | 614 | } // end of MC QA loop |
615 | // ----------------------------------------------------------------- | |
d2af20c5 | 616 | fCFM->SetMCEventInfo(fMCEvent); |
9bcfd1ab | 617 | // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD); |
618 | } else { | |
d2af20c5 | 619 | fCFM->SetMCEventInfo(fInputEvent); |
9bcfd1ab | 620 | } |
621 | // Run MC loop | |
70da6c5a | 622 | AliVParticle *mctrack = NULL; |
faee3b18 | 623 | AliDebug(3, Form("Number of Tracks: %d", fMCEvent->GetNumberOfTracks())); |
70da6c5a | 624 | for(Int_t imc = 0; imc <fMCEvent->GetNumberOfTracks(); imc++){ |
625 | if(!(mctrack = fMCEvent->GetTrack(imc))) continue; | |
3a72645a | 626 | AliDebug(4, "Next MC Track"); |
70da6c5a | 627 | if(ProcessMCtrack(mctrack)) nElectrons++; |
dbe3abbe | 628 | } |
dbe3abbe | 629 | |
630 | // fCFM->CheckEventCuts(AliCFManager::kEvtRecCuts, fESD); | |
69ac0e6f | 631 | fQACollection->Fill("nElectron", nElectrons); |
9bcfd1ab | 632 | } |
dbe3abbe | 633 | |
9bcfd1ab | 634 | //____________________________________________________________ |
635 | void AliAnalysisTaskHFE::ProcessESD(){ | |
dbe3abbe | 636 | // |
9bcfd1ab | 637 | // Run Analysis of reconstructed event in ESD Mode |
638 | // Loop over Tracks, filter according cut steps defined in AliHFEcuts | |
dbe3abbe | 639 | // |
9bcfd1ab | 640 | AliDebug(3, "Processing ESD Event"); |
d2af20c5 | 641 | AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent); |
9bcfd1ab | 642 | if(!fESD){ |
643 | AliError("ESD Event required for ESD Analysis") | |
644 | return; | |
645 | } | |
69ac0e6f | 646 | |
647 | // Do event Normalization | |
3a72645a | 648 | Double_t eventContainer[3]; |
69ac0e6f | 649 | eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ(); |
650 | eventContainer[1] = 0.; | |
3a72645a | 651 | eventContainer[2] = fCentralityF; |
69ac0e6f | 652 | if(fTriggerAnalysis->IsOfflineTriggerFired(fESD, AliTriggerAnalysis::kV0AND)) |
653 | eventContainer[1] = 1.; | |
3a72645a | 654 | |
655 | // | |
69ac0e6f | 656 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut); |
3a72645a | 657 | |
658 | // | |
659 | if(fIdentifiedAsPileUp) return; | |
660 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp); | |
661 | ||
662 | // | |
663 | if(fIdentifiedAsOutInz) return; | |
664 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange); | |
665 | ||
666 | // | |
667 | if(!fPassTheEventCut) return; | |
69ac0e6f | 668 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed); |
669 | ||
3a72645a | 670 | |
671 | ||
672 | fContainer->NewEvent(); | |
673 | ||
9bcfd1ab | 674 | if (GetPlugin(kIsElecBackGround)) { |
675 | fElecBackGround->SetEvent(fESD); | |
676 | } | |
677 | if (GetPlugin(kSecVtx)) { | |
678 | fSecVtx->SetEvent(fESD); | |
679 | fSecVtx->GetPrimaryCondition(); | |
680 | } | |
681 | ||
682 | if(HasMCData()){ | |
683 | if (GetPlugin(kSecVtx)) { | |
faee3b18 | 684 | fSecVtx->SetMCEvent(fMCEvent); |
3a72645a | 685 | fSecVtx->SetMCQA(fMCQA); |
9bcfd1ab | 686 | } |
687 | if (GetPlugin(kIsElecBackGround)) { | |
d2af20c5 | 688 | fElecBackGround->SetMCEvent(fMCEvent); |
9bcfd1ab | 689 | } |
690 | } | |
691 | ||
faee3b18 | 692 | Double_t container[10]; |
693 | memset(container, 0, sizeof(Double_t) * 10); | |
9bcfd1ab | 694 | // container for the output THnSparse |
67fe7bd0 | 695 | Double_t dataE[6]; // [pT, eta, Phi, type, 'C' or 'B'] |
75d81601 | 696 | Int_t nElectronCandidates = 0; |
9bcfd1ab | 697 | AliESDtrack *track = NULL, *htrack = NULL; |
698 | AliMCParticle *mctrack = NULL; | |
699 | TParticle* mctrack4QA = NULL; | |
259c3296 | 700 | Int_t pid = 0; |
dbe3abbe | 701 | |
78ea5ef4 | 702 | Bool_t signal = kTRUE; |
703 | ||
554e120d | 704 | fCFM->SetRecEventInfo(fESD); |
d2af20c5 | 705 | // Electron background analysis |
706 | if (GetPlugin(kIsElecBackGround)) { | |
707 | ||
708 | AliDebug(2, "Running BackGround Analysis"); | |
709 | ||
710 | fElecBackGround->Reset(); | |
711 | ||
712 | } // end of electron background analysis | |
9bcfd1ab | 713 | // |
714 | // Loop ESD | |
715 | // | |
faee3b18 | 716 | AliDebug(3, Form("Number of Tracks: %d", fESD->GetNumberOfTracks())); |
dbe3abbe | 717 | for(Int_t itrack = 0; itrack < fESD->GetNumberOfTracks(); itrack++){ |
3a72645a | 718 | AliDebug(4, "New ESD track"); |
dbe3abbe | 719 | track = fESD->GetTrack(itrack); |
faee3b18 | 720 | |
e3fc062d | 721 | // fill counts of v0-identified particles |
722 | Int_t v0pid = -1; | |
723 | if(track->TestBit(BIT(14))) v0pid = AliPID::kElectron; | |
724 | else if(track->TestBit(BIT(15))) v0pid = AliPID::kPion; | |
725 | else if(track->TestBit(BIT(16))) v0pid = AliPID::kProton; | |
3a72645a | 726 | // here the tagged track analysis will run |
727 | if(fTaggedTrackAnalysis && v0pid > -1){ | |
728 | AliDebug(1, Form("Track identified as %s", AliPID::ParticleName(v0pid))); | |
729 | fTaggedTrackAnalysis->ProcessTrack(track, v0pid); | |
730 | } | |
e3fc062d | 731 | |
faee3b18 | 732 | AliDebug(3, Form("Doing track %d, %p", itrack, track)); |
e3fc062d | 733 | |
734 | ////////////////////////////////////// | |
735 | // preselect | |
736 | ///////////////////////////////////// | |
737 | if(fPIDpreselect && fCutspreselect) { | |
738 | if(!PreSelectTrack(track)) continue; | |
739 | } | |
78ea5ef4 | 740 | |
741 | signal = kTRUE; | |
faee3b18 | 742 | |
70da6c5a | 743 | // Fill step without any cut |
dbe3abbe | 744 | |
9bcfd1ab | 745 | if(HasMCData()){ |
746 | // Check if it is electrons near the vertex | |
d2af20c5 | 747 | if(!(mctrack = dynamic_cast<AliMCParticle *>(fMCEvent->GetTrack(TMath::Abs(track->GetLabel()))))) continue; |
faee3b18 | 748 | mctrack4QA = mctrack->Particle(); |
749 | ||
3a72645a | 750 | if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE; |
faee3b18 | 751 | else AliDebug(3, "Signal Electron"); |
e3fc062d | 752 | } |
3a72645a | 753 | // Cache new Track information inside the var manager |
754 | fVarManager->NewTrack(track, mctrack, fCentralityF, -1, signal); | |
755 | ||
dbe3abbe | 756 | if(signal) { |
3a72645a | 757 | fVarManager->FillContainer(fContainer, "recTrackContReco", AliHFEcuts::kStepRecNoCut, kFALSE); |
758 | fVarManager->FillContainer(fContainer, "recTrackContMC", AliHFEcuts::kStepRecNoCut, kTRUE); | |
dbe3abbe | 759 | } |
760 | ||
70da6c5a | 761 | // RecKine: ITSTPC cuts |
3a72645a | 762 | if(!ProcessCutStep(AliHFEcuts::kStepRecKineITSTPC, track)) continue; |
70da6c5a | 763 | |
dbe3abbe | 764 | // Check TRD criterions (outside the correction framework) |
765 | if(track->GetTRDncls()){ | |
69ac0e6f | 766 | fQACollection->Fill("chi2TRD", track->GetTRDchi2()/track->GetTRDncls()); |
767 | fQACollection->Fill("alpha_rec", track->GetAlpha()); | |
768 | fQACollection->Fill("pidquality", container[0], track->GetTRDpidQuality()); | |
769 | fQACollection->Fill("ntrdclusters", container[0], track->GetTRDncls()); | |
dbe3abbe | 770 | } |
771 | ||
772 | ||
773 | // RecPrim | |
3a72645a | 774 | if(!ProcessCutStep(AliHFEcuts::kStepRecPrim, track)) continue; |
dbe3abbe | 775 | |
776 | // HFEcuts: ITS layers cuts | |
3a72645a | 777 | if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsITS, track)) continue; |
dbe3abbe | 778 | |
9bcfd1ab | 779 | if(HasMCData() && IsQAOn(kMCqa)) { |
780 | // mc qa for after the reconstruction cuts | |
781 | AliDebug(2, "Running MC QA"); | |
782 | fMCQA->GetDecayedKine(mctrack4QA, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG, 3); // charm | |
783 | fMCQA->GetDecayedKine(mctrack4QA, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG, 3); // beauty | |
faee3b18 | 784 | fMCQA->GetDecayedKine(mctrack4QA, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG, 3); // beauty |
3a72645a | 785 | } |
786 | ||
787 | // HFEcuts: Nb of tracklets TRD0 | |
788 | if(!ProcessCutStep(AliHFEcuts::kStepHFEcutsTRD, track)) continue; | |
789 | ||
6555e2ad | 790 | // Fill correlation maps before PID |
791 | if(signal && fContainer->GetCorrelationMatrix("correlationstepbeforePID")) { | |
792 | //printf("Fill correlation maps before PID\n"); | |
793 | fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepbeforePID")); | |
794 | } | |
795 | ||
3a72645a | 796 | if (HasMCData() && IsQAOn(kMCqa)) { |
797 | // mc qa for after the reconstruction and pid cuts | |
798 | AliDebug(2, "Running MC QA"); | |
799 | fMCQA->GetDecayedKine(mctrack4QA, AliHFEmcQA::kCharm, AliHFEmcQA::kElectronPDG, 4); // charm | |
800 | fMCQA->GetDecayedKine(mctrack4QA, AliHFEmcQA::kBeauty, AliHFEmcQA::kElectronPDG, 4); // beauty | |
801 | fMCQA->GetDecayedKine(mctrack4QA, AliHFEmcQA::kOthers, AliHFEmcQA::kElectronPDG, 4); // beauty | |
802 | } | |
dbe3abbe | 803 | |
faee3b18 | 804 | if(HasMCData()){ |
805 | FillProductionVertex(track); | |
806 | } | |
807 | ||
809a4336 | 808 | // track accepted, do PID |
722347d8 | 809 | AliHFEpidObject hfetrack; |
3a72645a | 810 | hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis); |
811 | hfetrack.SetRecTrack(track); | |
812 | if(HasMCData()) hfetrack.SetMCTrack(mctrack); | |
813 | hfetrack.SetCentrality(fCentralityF); | |
814 | fPID->SetVarManager(fVarManager); | |
815 | if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue; | |
75d81601 | 816 | nElectronCandidates++; |
dbe3abbe | 817 | |
faee3b18 | 818 | // Fill Histogram for Hadronic Background |
819 | if(HasMCData()){ | |
820 | if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)) | |
3a72645a | 821 | fVarManager->FillContainer(fContainer, "hadronicBackground", UInt_t(0), kFALSE); |
faee3b18 | 822 | } |
823 | ||
dbe3abbe | 824 | // Fill Containers |
dbe3abbe | 825 | if(signal) { |
e3fc062d | 826 | // Apply weight for background contamination |
e3fc062d | 827 | if(fBackGroundFactorsFunction) { |
3a72645a | 828 | Double_t weightBackGround = fBackGroundFactorsFunction->Eval(TMath::Abs(track->P())); |
829 | if(weightBackGround < 0.0) weightBackGround = 0.0; | |
830 | else if(weightBackGround > 1.0) weightBackGround = 1.0; | |
831 | // weightBackGround as special weight | |
832 | fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE, weightBackGround); | |
dbe3abbe | 833 | } |
3a72645a | 834 | fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterPID")); |
dbe3abbe | 835 | } |
836 | ||
faee3b18 | 837 | if(GetPlugin(kSecVtx)) { |
9bcfd1ab | 838 | AliDebug(2, "Running Secondary Vertex Analysis"); |
3a72645a | 839 | fSecVtx->Process(track); |
78ea5ef4 | 840 | } |
9bcfd1ab | 841 | |
842 | if(HasMCData()){ | |
3a72645a | 843 | dataE[0] = track->Pt(); |
844 | dataE[1] = track->Eta(); | |
845 | dataE[2] = track->Phi(); | |
846 | dataE[3] = track->Charge(); | |
847 | dataE[4] = -1.; | |
848 | dataE[5] = -1.; | |
849 | ||
9bcfd1ab | 850 | // Track selected: distinguish between true and fake |
851 | AliDebug(1, Form("Candidate Selected, filling THnSparse, PID: %d\n", mctrack->Particle()->GetPdgCode())); | |
852 | if((pid = TMath::Abs(mctrack->Particle()->GetPdgCode())) == 11){ | |
3a72645a | 853 | Int_t type = 0; |
854 | if(fSignalCuts->IsCharmElectron(track)) | |
855 | type = 1; | |
856 | else if(fSignalCuts->IsBeautyElectron(track)) | |
857 | type = 2; | |
9bcfd1ab | 858 | AliDebug(1, Form("Type: %d\n", type)); |
859 | if(type){ | |
70da6c5a | 860 | dataE[5] = type; // beauty[1] or charm[2] |
861 | dataE[4] = 2; // signal electron | |
9bcfd1ab | 862 | } |
863 | else{ | |
70da6c5a | 864 | dataE[4] = 1; // not a signal electron |
865 | dataE[5] = 0; | |
9bcfd1ab | 866 | } |
867 | } | |
868 | else { | |
869 | // Fill THnSparse with the information for Fake Electrons | |
9bcfd1ab | 870 | dataE[4] = 0; |
70da6c5a | 871 | dataE[5] = 0; |
9bcfd1ab | 872 | } |
873 | // fill the performance THnSparse, if the mc origin could be defined | |
70da6c5a | 874 | if(dataE[4] > -1){ |
875 | AliDebug(1, Form("Entries: [%.3f|%.3f|%.3f|%f|%f|%f]\n", dataE[0],dataE[1],dataE[2],dataE[3],dataE[4],dataE[5])); | |
3a72645a | 876 | fQACollection->Fill("PIDperformance", dataE); |
9bcfd1ab | 877 | } |
259c3296 | 878 | } |
9bcfd1ab | 879 | // Electron background analysis |
880 | if (GetPlugin(kIsElecBackGround)) { | |
881 | ||
882 | AliDebug(2, "Running BackGround Analysis"); | |
883 | ||
884 | for(Int_t jtrack = 0; jtrack < fESD->GetNumberOfTracks(); jtrack++){ | |
885 | htrack = fESD->GetTrack(jtrack); | |
886 | if ( itrack == jtrack ) continue; | |
887 | fElecBackGround->PairAnalysis(track, htrack); | |
888 | } | |
889 | } // end of electron background analysis | |
890 | ||
3a72645a | 891 | if (GetPlugin(kDEstep)) { |
6555e2ad | 892 | if(HasMCData()){ |
893 | if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){ | |
894 | fQACollection->Fill("hadronsBeforeIPcut",track->Pt()); | |
895 | fQACollection->Fill("hadronsBeforeIPcutMC",mctrack->Pt()); | |
896 | } | |
897 | } | |
3a72645a | 898 | // Fill Containers for impact parameter analysis |
899 | if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepHFEcutsDca + AliHFEcuts::kNcutStepsMCTrack + AliHFEcuts::kNcutStepsRecTrack,track)) continue; | |
900 | if(signal) { | |
901 | fVarManager->FillContainer(fContainer, "recTrackContDEReco", AliHFEcuts::kStepHFEcutsDca, kFALSE); | |
902 | fVarManager->FillContainer(fContainer, "recTrackContDEMC", AliHFEcuts::kStepHFEcutsDca, kTRUE); | |
903 | fVarManager->FillCorrelationMatrix(fContainer->GetCorrelationMatrix("correlationstepafterDE")); | |
904 | } | |
905 | if(HasMCData()){ | |
6555e2ad | 906 | if(mctrack && (TMath::Abs(mctrack->Particle()->GetPdgCode()) != 11)){ |
3a72645a | 907 | fVarManager->FillContainer(fContainer, "hadronicBackground", 2, kFALSE); |
6555e2ad | 908 | fQACollection->Fill("hadronsAfterIPcut",track->Pt()); |
909 | fQACollection->Fill("hadronsAfterIPcutMC",mctrack->Pt()); | |
910 | } | |
3a72645a | 911 | } |
912 | } | |
913 | ||
dbe3abbe | 914 | } |
3a72645a | 915 | fQACollection->Fill("nElectronTracksEvent", nElectronCandidates); |
809a4336 | 916 | } |
917 | ||
918 | //____________________________________________________________ | |
9bcfd1ab | 919 | void AliAnalysisTaskHFE::ProcessAOD(){ |
dbe3abbe | 920 | // |
9bcfd1ab | 921 | // Run Analysis in AOD Mode |
922 | // Function is still in development | |
dbe3abbe | 923 | // |
9bcfd1ab | 924 | AliDebug(3, "Processing AOD Event"); |
69ac0e6f | 925 | Double_t eventContainer[2]; |
926 | eventContainer[0] = fInputEvent->GetPrimaryVertex()->GetZ(); | |
927 | eventContainer[1] = 1.; // No Information available in AOD analysis, assume all events have V0AND | |
3a72645a | 928 | |
d2af20c5 | 929 | AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent); |
9bcfd1ab | 930 | if(!fAOD){ |
931 | AliError("AOD Event required for AOD Analysis") | |
3a72645a | 932 | return; |
9bcfd1ab | 933 | } |
3a72645a | 934 | |
935 | // | |
936 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoCut); | |
937 | ||
938 | // | |
939 | if(fIdentifiedAsPileUp) return; | |
940 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepRecNoPileUp); | |
941 | ||
942 | // | |
943 | if(fIdentifiedAsOutInz) return; | |
944 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepZRange); | |
945 | ||
946 | // | |
947 | if(!fPassTheEventCut) return; | |
948 | fCFM->GetEventContainer()->Fill(eventContainer, AliHFEcuts::kEventStepReconstructed); | |
949 | ||
950 | fContainer->NewEvent(); | |
9bcfd1ab | 951 | |
952 | AliAODTrack *track = NULL; | |
953 | AliAODMCParticle *mctrack = NULL; | |
70da6c5a | 954 | Double_t dataE[6]; // [pT, eta, Phi, Charge, type, 'C' or 'B'] |
9bcfd1ab | 955 | Int_t nElectronCandidates = 0; |
956 | Int_t pid; | |
3a72645a | 957 | Bool_t signal; |
9bcfd1ab | 958 | for(Int_t itrack = 0; itrack < fAOD->GetNumberOfTracks(); itrack++){ |
959 | track = fAOD->GetTrack(itrack); | |
960 | if(!track) continue; | |
961 | if(track->GetFlags() != 1<<4) continue; // Only process AOD tracks where the HFE is set | |
962 | ||
3a72645a | 963 | signal = kTRUE; |
9bcfd1ab | 964 | if(HasMCData()){ |
faee3b18 | 965 | |
9bcfd1ab | 966 | Int_t label = TMath::Abs(track->GetLabel()); |
3a72645a | 967 | if(label) |
d2af20c5 | 968 | mctrack = dynamic_cast<AliAODMCParticle *>(fMCEvent->GetTrack(label)); |
3a72645a | 969 | if(fFillSignalOnly && !fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, mctrack)) signal = kFALSE; |
9bcfd1ab | 970 | } |
3a72645a | 971 | fVarManager->NewTrack(track, mctrack, fCentralityF, -1, kTRUE); |
9bcfd1ab | 972 | // track accepted, do PID |
973 | AliHFEpidObject hfetrack; | |
3a72645a | 974 | hfetrack.SetAnalysisType(AliHFEpidObject::kAODanalysis); |
975 | hfetrack.SetRecTrack(track); | |
976 | if(HasMCData()) hfetrack.SetMCTrack(mctrack); | |
977 | hfetrack.SetCentrality(fCentralityF); | |
978 | fPID->SetVarManager(fVarManager); | |
979 | if(!fPID->IsSelected(&hfetrack, fContainer, "recTrackCont", fPIDqa)) continue; // we will do PID here as soon as possible | |
e3fc062d | 980 | // Apply weight for background contamination |
981 | Double_t weightBackGround = 1.0; | |
982 | if(fBackGroundFactorsFunction) { | |
3a72645a | 983 | weightBackGround = fBackGroundFactorsFunction->Eval(TMath::Abs(track->P())); |
984 | if(weightBackGround < 0.0) weightBackGround = 0.0; | |
e3fc062d | 985 | } |
3a72645a | 986 | fVarManager->FillContainer(fContainer, "hadronicBackground", 1, kFALSE); |
9bcfd1ab | 987 | nElectronCandidates++; |
988 | if(HasMCData()){ | |
3a72645a | 989 | dataE[0] = track->Pt(); |
990 | dataE[1] = track->Eta(); | |
991 | dataE[2] = track->Phi(); | |
992 | dataE[3] = track->Charge(); | |
993 | dataE[4] = -1; | |
994 | dataE[5] = -1; | |
995 | // Track selected: distinguish between true and fake | |
9bcfd1ab | 996 | AliDebug(1, Form("Candidate Selected, filling THnSparse, PID: %d\n", mctrack->GetPdgCode())); |
997 | if((pid = TMath::Abs(mctrack->GetPdgCode())) == 11){ | |
3a72645a | 998 | |
999 | Int_t type = 0; | |
1000 | if(fSignalCuts->IsCharmElectron(track)) | |
1001 | type = 1; | |
1002 | else if(fSignalCuts->IsBeautyElectron(track)) | |
1003 | type = 2; | |
9bcfd1ab | 1004 | AliDebug(1, Form("Type: %d\n", type)); |
1005 | if(type){ | |
70da6c5a | 1006 | dataE[5] = type; // beauty[1] or charm[2] |
1007 | dataE[4] = 2; // signal electron | |
9bcfd1ab | 1008 | } |
1009 | else{ | |
70da6c5a | 1010 | dataE[4] = 1; // not a signal electron |
1011 | dataE[5] = 0; | |
9bcfd1ab | 1012 | } |
1013 | } | |
1014 | else { | |
1015 | // Fill THnSparse with the information for Fake Electrons | |
9bcfd1ab | 1016 | dataE[4] = 0; |
70da6c5a | 1017 | dataE[5] = 0; |
9bcfd1ab | 1018 | } |
1019 | // fill the performance THnSparse, if the mc origin could be defined | |
70da6c5a | 1020 | if(dataE[4] > -1){ |
1021 | AliDebug(1, Form("Entries: [%.3f|%.3f|%.3f|%f|%f|%f]\n", dataE[0],dataE[1],dataE[2],dataE[3],dataE[4],dataE[5])); | |
3a72645a | 1022 | fQACollection->Fill("PIDperformance", dataE); |
9bcfd1ab | 1023 | } |
6ad05e72 | 1024 | } |
6ad05e72 | 1025 | } |
3a72645a | 1026 | fQACollection->Fill("nElectronTracksEvent", nElectronCandidates); |
6ad05e72 | 1027 | } |
1028 | ||
1029 | //____________________________________________________________ | |
9bcfd1ab | 1030 | Bool_t AliAnalysisTaskHFE::ProcessMCtrack(AliVParticle *track){ |
6ad05e72 | 1031 | // |
9bcfd1ab | 1032 | // Filter the Monte Carlo Track |
1033 | // Additionally Fill a THnSparse for Signal To Background Studies | |
1034 | // Works for AOD and MC analysis Type | |
6ad05e72 | 1035 | // |
3a72645a | 1036 | fVarManager->NewTrack(track, NULL, -1, kTRUE); |
1037 | Double_t signalContainer[6]; | |
9bcfd1ab | 1038 | |
3a72645a | 1039 | signalContainer[0] = track->Pt(); |
1040 | signalContainer[1] = track->Eta(); | |
1041 | signalContainer[2] = track->Phi(); | |
1042 | signalContainer[3] = track->Charge()/3; | |
9bcfd1ab | 1043 | |
3a72645a | 1044 | Double_t vertex[3]; // Production vertex cut to mask gammas which are NOT supposed to have hits in the first ITS layer(s) |
1045 | if(IsESDanalysis()){ | |
1046 | AliMCParticle *mctrack = dynamic_cast<AliMCParticle *>(track); | |
9bcfd1ab | 1047 | vertex[0] = mctrack->Particle()->Vx(); |
1048 | vertex[1] = mctrack->Particle()->Vy(); | |
1049 | } else { | |
1050 | AliAODMCParticle *aodmctrack = dynamic_cast<AliAODMCParticle *>(track); | |
9bcfd1ab | 1051 | aodmctrack->XvYvZv(vertex); |
6ad05e72 | 1052 | } |
3a72645a | 1053 | |
1054 | if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCGenerated, track)) return kFALSE; | |
1055 | fQACollection->Fill("mccharge", signalContainer[3]); | |
1056 | fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGenerated, kFALSE); | |
1057 | signalContainer[4] = 0; | |
1058 | if(fSignalCuts->IsSelected(track)){ | |
1059 | //fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCsignal, kFALSE); | |
1060 | // Filling of the Signal/Background histogram using the | |
1061 | // definition of the codes for charm and beauty as below in | |
1062 | // th crearion of the histogram | |
1063 | if(fSignalCuts->IsCharmElectron(track)) | |
1064 | signalContainer[4] = 1; | |
1065 | else | |
1066 | signalContainer[4] = 2; | |
1067 | } else { | |
1068 | signalContainer[4] = 0; // (and other background) | |
1069 | } | |
70da6c5a | 1070 | signalContainer[5] = 0; |
9bcfd1ab | 1071 | // apply cut on the sqrt of the production vertex |
1072 | Double_t radVertex = TMath::Sqrt(vertex[0]*vertex[0] + vertex[1] * vertex[1]); | |
1073 | if(radVertex < 3.5){ | |
1074 | // Within first ITS layer(2) -> Background we cannot reject by ITS cut, let it pass | |
70da6c5a | 1075 | signalContainer[5] = 1; |
9bcfd1ab | 1076 | } else if (radVertex < 7.5){ |
70da6c5a | 1077 | signalContainer[5] = 2; |
9bcfd1ab | 1078 | } |
3a72645a | 1079 | fQACollection->Fill("SignalToBackgroundMC", signalContainer); |
1080 | fQACollection->Fill("alpha_sim", track->Phi() - TMath::Pi()); | |
1081 | ||
1082 | // Step GeneratedZOutNoPileUp | |
1083 | if((fIdentifiedAsPileUp) || (fIdentifiedAsOutInz)) return kFALSE; | |
1084 | fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedZOutNoPileUp, kFALSE); | |
1085 | ||
1086 | // Step Generated Event Cut | |
1087 | if(!fPassTheEventCut) return kFALSE; | |
1088 | fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCGeneratedEventCut, kFALSE); | |
1089 | ||
1090 | if(!fCFM->CheckParticleCuts(AliHFEcuts::kStepMCInAcceptance, track)) return kFALSE; | |
1091 | fVarManager->FillContainer(fContainer, "MCTrackCont", AliHFEcuts::kStepMCInAcceptance, kFALSE); | |
9bcfd1ab | 1092 | return kTRUE; |
6ad05e72 | 1093 | } |
1094 | ||
e3fc062d | 1095 | //____________________________________________________________ |
1096 | Bool_t AliAnalysisTaskHFE::PreSelectTrack(AliESDtrack *track) const { | |
1097 | // | |
1098 | // Preselect tracks | |
1099 | // | |
1100 | ||
1101 | ||
1102 | Bool_t survived = kTRUE; | |
1103 | ||
1104 | if(!fCutspreselect->CheckParticleCuts(AliHFEcuts::kStepRecKineITSTPC, track)) { | |
1105 | survived = kFALSE; | |
1106 | //printf("Did not pass AliHFEcuts::kStepRecKineITSTPC\n"); | |
1107 | } | |
1108 | //else printf("Pass AliHFEcuts::kStepRecKineITSTPC\n"); | |
1109 | if(!fCutspreselect->CheckParticleCuts(AliHFEcuts::kStepRecPrim, track)) { | |
1110 | survived = kFALSE; | |
1111 | //printf("Did not pass AliHFEcuts::kStepRecPrim\n"); | |
1112 | } | |
1113 | //else printf("Pass AliHFEcuts::kStepRecPrim\n"); | |
1114 | if(!fCutspreselect->CheckParticleCuts(AliHFEcuts::kStepHFEcutsITS, track)) { | |
1115 | survived = kFALSE; | |
1116 | //printf("Did not pass AliHFEcuts::kStepHFEcutsITS\n"); | |
1117 | } | |
1118 | //else printf("Pass AliHFEcuts::kStepHFEcutsITS\n"); | |
1119 | if(!fCutspreselect->CheckParticleCuts(AliHFEcuts::kStepHFEcutsTRD, track)) { | |
1120 | survived = kFALSE; | |
1121 | //printf("Did not pass AliHFEcuts::kStepHFEcutsTRD\n"); | |
1122 | } | |
1123 | //else printf("Pass AliHFEcuts::kStepHFEcutsTRD\n"); | |
1124 | ||
1125 | if(survived){ | |
1126 | // Apply PID | |
1127 | AliHFEpidObject hfetrack; | |
3a72645a | 1128 | hfetrack.SetAnalysisType(AliHFEpidObject::kESDanalysis); |
1129 | hfetrack.SetRecTrack(track); | |
e3fc062d | 1130 | if(!fPIDpreselect->IsSelected(&hfetrack)) { |
1131 | //printf("Did not pass AliHFEcuts::kPID\n"); | |
1132 | survived = kFALSE; | |
1133 | } | |
1134 | //else printf("Pass AliHFEcuts::kPID\n"); | |
1135 | } | |
1136 | ||
1137 | return survived; | |
1138 | ||
1139 | } | |
70da6c5a | 1140 | //____________________________________________________________ |
1141 | void AliAnalysisTaskHFE::MakeEventContainer(){ | |
1142 | // | |
1143 | // Create the event container for the correction framework and link it | |
3a72645a | 1144 | // 1st bin: Vertex z-position |
1145 | // 2nd bin: V0AND decision (normalization to sigma_inel) | |
1146 | // 3rd bin: Centrality class (for pp defined as 99.) | |
70da6c5a | 1147 | // |
3a72645a | 1148 | const Int_t kNvar = 3; // number of variables on the grid: |
6555e2ad | 1149 | Int_t nBins[kNvar] = {120, 2, 11}; |
1150 | Double_t binMin[kNvar] = {-30. , 0., 0.0}; | |
1151 | Double_t binMax[kNvar] = {30., 2., 11.0}; | |
70da6c5a | 1152 | |
69ac0e6f | 1153 | AliCFContainer *evCont = new AliCFContainer("eventContainer", "Container for events", AliHFEcuts::kNcutStepsEvent, kNvar, nBins); |
70da6c5a | 1154 | |
69ac0e6f | 1155 | Double_t *vertexBins = AliHFEtools::MakeLinearBinning(nBins[0], binMin[0], binMax[0]); |
1156 | Double_t *v0andBins = AliHFEtools::MakeLinearBinning(nBins[1], binMin[1], binMax[1]); | |
1157 | evCont->SetBinLimits(0, vertexBins); | |
1158 | evCont->SetBinLimits(1, v0andBins); | |
1159 | delete[] vertexBins; delete[] v0andBins; | |
70da6c5a | 1160 | |
1161 | fCFM->SetEventContainer(evCont); | |
1162 | } | |
1163 | ||
809a4336 | 1164 | //____________________________________________________________ |
1165 | void AliAnalysisTaskHFE::MakeParticleContainer(){ | |
1166 | // | |
1167 | // Create the particle container for the correction framework manager and | |
1168 | // link it | |
1169 | // | |
3a72645a | 1170 | |
1171 | if(!fContainer) fContainer = new AliHFEcontainer("trackContainer"); | |
1172 | fVarManager->DefineVariables(fContainer); | |
1173 | ||
1174 | // Create Correction Framework containers | |
1175 | fContainer->CreateContainer("MCTrackCont", "Track Container filled with MC information", AliHFEcuts::kNcutStepsMCTrack); | |
1176 | fContainer->CreateContainer("recTrackContReco", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors()); | |
1177 | fContainer->CreateContainer("recTrackContMC", "Track Container filled with MC information", AliHFEcuts::kNcutStepsRecTrack + fPID->GetNumberOfPIDdetectors()); | |
1178 | ||
1179 | fContainer->CreateContainer("hadronicBackground", "Container for Hadronic Background", 3); | |
1180 | fContainer->CreateContainer("recTrackContDEReco", "Container for displaced electron analysis with Reco information", 1); | |
1181 | fContainer->CreateContainer("recTrackContDEMC", "Container for displaced electron analysis with MC information", 1); | |
1182 | fContainer->CreateCorrelationMatrix("correlationstepafterPID","THnSparse with correlations"); | |
1183 | fContainer->CreateCorrelationMatrix("correlationstepafterDE","THnSparse with correlations"); | |
6555e2ad | 1184 | if(!fVarManager->IsVariableDefined("centrality")) { |
1185 | //printf("Create the two other correlation maps\n"); | |
1186 | fContainer->CreateCorrelationMatrix("correlationstepbeforePID","THnSparse with correlations"); | |
1187 | fContainer->CreateCorrelationMatrix("correlationstepafterTOF","THnSparse with correlations"); | |
1188 | } | |
3a72645a | 1189 | |
1190 | // Define the step names | |
1191 | for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsMCTrack; istep++){ | |
1192 | fContainer->SetStepTitle("MCTrackCont", AliHFEcuts::MCCutName(istep), istep); | |
faee3b18 | 1193 | } |
3a72645a | 1194 | for(UInt_t istep = 0; istep < AliHFEcuts::kNcutStepsRecTrack; istep++){ |
1195 | fContainer->SetStepTitle("recTrackContReco", AliHFEcuts::RecoCutName(istep), istep); | |
1196 | fContainer->SetStepTitle("recTrackContMC", AliHFEcuts::RecoCutName(istep), istep); | |
259c3296 | 1197 | } |
3a72645a | 1198 | for(UInt_t ipid = 0; ipid < fPID->GetNumberOfPIDdetectors(); ipid++){ |
1199 | fContainer->SetStepTitle("recTrackContReco", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid); | |
1200 | fContainer->SetStepTitle("recTrackContMC", fPID->SortedDetectorName(ipid), AliHFEcuts::kNcutStepsRecTrack + ipid); | |
259c3296 | 1201 | } |
3a72645a | 1202 | } |
1203 | ||
1204 | //____________________________________________________________ | |
1205 | void AliAnalysisTaskHFE::InitPIDperformanceQA(){ | |
259c3296 | 1206 | // Add a histogram for Fake electrons |
70da6c5a | 1207 | const Int_t nDim=6; |
1208 | Int_t nBin[nDim] = {40, 8, 18, 2, 3, 3}; | |
3a72645a | 1209 | //number of variables on the grid:pt,eta,phi,charge, |
1210 | const Double_t kPtbound[2] = {0.1, 20.}; | |
1211 | const Double_t kEtabound[2] = {-0.8, 0.8}; | |
1212 | const Double_t kPhibound[2] = {0., 2. * TMath::Pi()}; | |
1213 | const Double_t kChargebound[2] = {-1.1, 1.1}; | |
1214 | const Double_t kAddInf1bound[2] = {0., 3.}; | |
1215 | const Double_t kAddInf2bound[2] = {0., 3.}; | |
1216 | Double_t minima[nDim] = {kPtbound[0], kEtabound[0], kPhibound[0], kChargebound[0], kAddInf1bound[0], kAddInf2bound[0]}; | |
1217 | Double_t maxima[nDim] = {kPtbound[1], kEtabound[1], kPhibound[1], kChargebound[1], kAddInf1bound[1], kAddInf2bound[1]}; | |
1218 | ||
1219 | fQACollection->CreateTHnSparse("PIDperformance", "PID performance; pT [GeV/c]; theta [rad]; phi [rad]; charge; type (0 - not el, 1 - other el, 2 - HF el; flavor (0 - no, 1 - charm, 2 - bottom)", nDim, nBin, minima, maxima); | |
1220 | fQACollection->CreateTHnSparse("SignalToBackgroundMC", "PID performance; pT [GeV/c]; theta [rad]; phi [rad]; charge; flavor (0 - no, 1 - charm, 2 - bottom); ITS Cluster (0 - no, 1 - first (and maybe second), 2 - second)", nDim, nBin, minima, maxima); | |
dbe3abbe | 1221 | |
3a72645a | 1222 | fQACollection->BinLogAxis("PIDperformance", 0); |
1223 | fQACollection->BinLogAxis("SignalToBackgroundMC", 0); | |
1224 | fQACollection->Sumw2("PIDperformance"); | |
1225 | fQACollection->Sumw2("SignalToBackgroundMC"); | |
75d81601 | 1226 | } |
1227 | ||
6555e2ad | 1228 | //____________________________________________________________ |
1229 | void AliAnalysisTaskHFE::InitContaminationQA(){ | |
1230 | const Double_t kPtbound[2] = {0.1, 20.}; | |
1231 | Int_t iBin[1]; | |
1232 | iBin[0] = 44; // bins in pt | |
1233 | fQACollection->CreateTH1F("hadronsBeforeIPcut", "Hadrons before IP cut", iBin[0], kPtbound[0], kPtbound[1], 1); | |
1234 | fQACollection->CreateTH1F("hadronsAfterIPcut", "Hadrons after IP cut", iBin[0], kPtbound[0], kPtbound[1], 1); | |
1235 | fQACollection->CreateTH1F("hadronsBeforeIPcutMC", "Hadrons before IP cut: MC p_{t}", iBin[0], kPtbound[0], kPtbound[1], 1); | |
1236 | fQACollection->CreateTH1F("hadronsAfterIPcutMC", "Hadrons after IP cut: MC p_{t} ", iBin[0],kPtbound[0], kPtbound[1], 1); | |
1237 | } | |
1238 | ||
75d81601 | 1239 | //____________________________________________________________ |
50685501 | 1240 | void AliAnalysisTaskHFE::PrintStatus() const { |
78ea5ef4 | 1241 | // |
1242 | // Print Analysis status | |
1243 | // | |
75d81601 | 1244 | printf("\n\tAnalysis Settings\n\t========================================\n\n"); |
9bcfd1ab | 1245 | printf("\tSecondary Vertex finding: %s\n", GetPlugin(kSecVtx) ? "YES" : "NO"); |
1246 | printf("\tPrimary Vertex resolution: %s\n", GetPlugin(kPriVtx) ? "YES" : "NO"); | |
3a72645a | 1247 | printf("\tDisplaced electron analysis step: %s\n", GetPlugin(kDEstep) ? "YES" : "NO"); |
1248 | printf("\tTagged Track Analysis: %s\n", GetPlugin(kTaggedTrackAnalysis) ? "YES" : "NO"); | |
75d81601 | 1249 | printf("\n"); |
1250 | printf("\tParticle Identification Detectors:\n"); | |
3a72645a | 1251 | fPID->PrintStatus(); |
75d81601 | 1252 | printf("\n"); |
1253 | printf("\tQA: \n"); | |
1254 | printf("\t\tPID: %s\n", IsQAOn(kPIDqa) ? "YES" : "NO"); | |
e3fc062d | 1255 | printf("\t\tCUTS: %s\n", (fCuts != NULL && fCuts->IsQAOn()) ? "YES" : "NO"); |
75d81601 | 1256 | printf("\t\tMC: %s\n", IsQAOn(kMCqa) ? "YES" : "NO"); |
1257 | printf("\n"); | |
1258 | } | |
78ea5ef4 | 1259 | |
faee3b18 | 1260 | //____________________________________________________________ |
1261 | Bool_t AliAnalysisTaskHFE::FillProductionVertex(const AliVParticle * const track) const{ | |
1262 | // | |
1263 | // Find the production vertex of the associated MC track | |
1264 | // | |
1265 | if(!fMCEvent) return kFALSE; | |
1266 | const AliVParticle *mctrack = NULL; | |
1267 | TString objectType = track->IsA()->GetName(); | |
1268 | if(objectType.CompareTo("AliESDtrack") == 0 || objectType.CompareTo("AliAODTrack") == 0){ | |
1269 | // Reconstructed track | |
1270 | mctrack = fMCEvent->GetTrack(TMath::Abs(track->GetLabel())); | |
1271 | } else { | |
1272 | // MCParticle | |
1273 | mctrack = track; | |
1274 | } | |
1275 | ||
1276 | if(!mctrack) return kFALSE; | |
1277 | ||
1278 | Double_t xv = 0.0; | |
1279 | Double_t yv = 0.0; | |
1280 | ||
1281 | if(TString(mctrack->IsA()->GetName()).CompareTo("AliMCParticle") == 0){ | |
1282 | // case MCParticle | |
1283 | xv = (dynamic_cast<const AliMCParticle *>(mctrack)->Xv()); | |
1284 | yv = (dynamic_cast<const AliMCParticle *>(mctrack)->Yv()); | |
1285 | ||
1286 | } else { | |
1287 | // case AODMCParticle | |
1288 | xv = (dynamic_cast<const AliAODMCParticle *>(mctrack)->Xv()); | |
1289 | yv = (dynamic_cast<const AliAODMCParticle *>(mctrack)->Yv()); | |
1290 | } | |
1291 | ||
1292 | //printf("xv %f, yv %f\n",xv,yv); | |
69ac0e6f | 1293 | fQACollection->Fill("radius", TMath::Abs(xv),TMath::Abs(yv)); |
faee3b18 | 1294 | |
1295 | return kTRUE; | |
1296 | ||
1297 | } | |
9bcfd1ab | 1298 | //__________________________________________ |
1299 | void AliAnalysisTaskHFE::SwitchOnPlugin(Int_t plug){ | |
1300 | // | |
1301 | // Switch on Plugin | |
1302 | // Available: | |
1303 | // - Primary vertex studies | |
1304 | // - Secondary vertex Studies | |
1305 | // - Post Processing | |
1306 | // | |
1307 | switch(plug){ | |
1308 | case kPriVtx: SETBIT(fPlugins, plug); break; | |
1309 | case kSecVtx: SETBIT(fPlugins, plug); break; | |
1310 | case kIsElecBackGround: SETBIT(fPlugins, plug); break; | |
1311 | case kPostProcess: SETBIT(fPlugins, plug); break; | |
3a72645a | 1312 | case kDEstep: SETBIT(fPlugins, plug); break; |
1313 | case kTaggedTrackAnalysis: SETBIT(fPlugins, plug); break; | |
9bcfd1ab | 1314 | default: AliError("Unknown Plugin"); |
1315 | }; | |
1316 | } | |
9bcfd1ab | 1317 | //__________________________________________ |
3a72645a | 1318 | Bool_t AliAnalysisTaskHFE::ProcessCutStep(Int_t cutStep, AliVParticle *track){ |
9bcfd1ab | 1319 | // |
1320 | // Check single track cuts for a given cut step | |
1321 | // Fill the particle container | |
1322 | // | |
3a72645a | 1323 | const Int_t kMCOffset = AliHFEcuts::kNcutStepsMCTrack; |
1324 | if(!fCFM->CheckParticleCuts(cutStep + kMCOffset, track)) return kFALSE; | |
1325 | if(fVarManager->IsSignalTrack()) { | |
1326 | fVarManager->FillContainer(fContainer, "recTrackContReco", cutStep, kFALSE); | |
1327 | fVarManager->FillContainer(fContainer, "recTrackContMC", cutStep, kTRUE); | |
9bcfd1ab | 1328 | } |
1329 | return kTRUE; | |
1330 | } | |
3a72645a | 1331 | //___________________________________________________ |
1332 | void AliAnalysisTaskHFE::ReadCentrality() { | |
1333 | // | |
1334 | // Recover the centrality of the event from ESD or AOD | |
1335 | // | |
1336 | if(IsAODanalysis()){ | |
1337 | ||
1338 | AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent); | |
1339 | if(!fAOD){ | |
1340 | AliError("AOD Event required for AOD Analysis") | |
1341 | return; | |
1342 | } | |
1343 | // Centrality | |
1344 | //AliAODCentrality *aodCentrality = fAOD->GetCentrality(); | |
1345 | //Double_t fCentralityF = aodCentrality->GetCentralityPercentile("V0M"); | |
1346 | fCentralityF = 99.0; // Fake for the moment | |
1347 | ||
1348 | ||
1349 | } else { | |
1350 | ||
1351 | AliDebug(3, "Processing ESD Centrality"); | |
1352 | AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent); | |
1353 | if(!fESD){ | |
1354 | AliError("ESD Event required for ESD Analysis") | |
1355 | return; | |
1356 | } | |
1357 | // Centrality | |
6555e2ad | 1358 | AliESDCentrality *esdCentrality = fESD->GetCentrality(); |
1359 | Float_t fCentralityF_temp = esdCentrality->GetCentralityPercentile("V0M"); | |
1360 | ||
1361 | if( fCentralityF_temp >= 0. && fCentralityF_temp < 5.) fCentralityF = 0; | |
1362 | else if ( fCentralityF_temp >= 5. && fCentralityF_temp < 10.) fCentralityF = 1; | |
1363 | else if ( fCentralityF_temp >= 10. && fCentralityF_temp < 20.) fCentralityF = 2; | |
1364 | else if ( fCentralityF_temp >= 20. && fCentralityF_temp < 30.) fCentralityF = 3; | |
1365 | else if ( fCentralityF_temp >= 30. && fCentralityF_temp < 40.) fCentralityF = 4; | |
1366 | else if ( fCentralityF_temp >= 40. && fCentralityF_temp < 50.) fCentralityF = 5; | |
1367 | else if ( fCentralityF_temp >= 50. && fCentralityF_temp < 60.) fCentralityF = 6; | |
1368 | else if ( fCentralityF_temp >= 60. && fCentralityF_temp < 70.) fCentralityF = 7; | |
1369 | else if ( fCentralityF_temp >= 70. && fCentralityF_temp < 80.) fCentralityF = 8; | |
1370 | else if ( fCentralityF_temp >= 80. && fCentralityF_temp < 90.) fCentralityF = 9; | |
1371 | else if ( fCentralityF_temp >= 90. && fCentralityF_temp <=100.) fCentralityF = 10; | |
3a72645a | 1372 | |
1373 | //printf("centrality %f\n",fCentralityF); | |
1374 | ||
1375 | } | |
1376 | ||
1377 | } | |
1378 | //___________________________________________________ | |
1379 | void AliAnalysisTaskHFE::RejectionPileUpVertexRangeEventCut() { | |
1380 | // | |
1381 | // Recover the centrality of the event from ESD or AOD | |
1382 | // | |
1383 | if(IsAODanalysis()){ | |
1384 | ||
1385 | AliAODEvent *fAOD = dynamic_cast<AliAODEvent *>(fInputEvent); | |
1386 | if(!fAOD){ | |
1387 | AliError("AOD Event required for AOD Analysis") | |
1388 | return; | |
1389 | } | |
1390 | // PileUp | |
1391 | if(fRemovePileUp && fAOD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; | |
1392 | // Z vertex | |
1393 | if(TMath::Abs(fAOD->GetPrimaryVertex()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE; | |
1394 | // Event Cut | |
1395 | fPassTheEventCut = kTRUE; | |
1396 | if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fAOD)) fPassTheEventCut = kFALSE; | |
1397 | ||
1398 | ||
1399 | } else { | |
1400 | ||
1401 | AliDebug(3, "Processing ESD Centrality"); | |
1402 | AliESDEvent *fESD = dynamic_cast<AliESDEvent *>(fInputEvent); | |
1403 | if(!fESD){ | |
1404 | AliError("ESD Event required for ESD Analysis") | |
1405 | return; | |
1406 | } | |
1407 | // PileUp | |
1408 | fIdentifiedAsPileUp = kFALSE; | |
1409 | if(fRemovePileUp && fESD->IsPileupFromSPD()) fIdentifiedAsPileUp = kTRUE; | |
1410 | // Z vertex | |
1411 | fIdentifiedAsOutInz = kFALSE; | |
1412 | if(fESD->GetPrimaryVertexTracks()){ | |
1413 | if(TMath::Abs(fESD->GetPrimaryVertexTracks()->GetZ()) > fCuts->GetVertexRange()) fIdentifiedAsOutInz = kTRUE; | |
1414 | } | |
1415 | //Event Cut | |
1416 | fPassTheEventCut = kTRUE; | |
1417 | if(!fCFM->CheckEventCuts(AliHFEcuts::kEventStepReconstructed, fESD)) fPassTheEventCut = kFALSE; | |
1418 | ||
1419 | ||
1420 | } | |
1421 | ||
1422 | } | |
70da6c5a | 1423 |