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