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