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