]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ANALYSIS/AliAnalysisTaskESDfilter.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
From Francesco: Update the Bayesian PID with dEdx for MC events
[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisTaskESDfilter.cxx
CommitLineData
f7ed7e88 1/**************************************************************************\r
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
3 * *\r
4 * Author: The ALICE Off-line Project. *\r
5 * Contributors are mentioned in the code where appropriate. *\r
6 * *\r
7 * Permission to use, copy, modify and distribute this software and its *\r
8 * documentation strictly for non-commercial purposes is hereby granted *\r
9 * without fee, provided that the above copyright notice appears in all *\r
10 * copies and that both the copyright notice and this permission notice *\r
11 * appear in the supporting documentation. The authors make no claims *\r
12 * about the suitability of this software for any purpose. It is *\r
13 * provided "as is" without express or implied warranty. *\r
14 **************************************************************************/\r
15\r
c7ef1c47 16/* $Id$ */\r
f7ed7e88 17 \r
18#include <TChain.h>\r
19#include <TTree.h>\r
20#include <TList.h>\r
21#include <TArrayI.h>\r
720f7306 22#include <TParameter.h>\r
f7ed7e88 23#include <TRandom.h>\r
24#include <TParticle.h>\r
a5f7aba4 25#include <TFile.h>\r
f7ed7e88 26\r
27#include "AliAnalysisTaskESDfilter.h"\r
28#include "AliAnalysisManager.h"\r
29#include "AliESDEvent.h"\r
f2f21b24 30#include "AliESDRun.h"\r
f7ed7e88 31#include "AliStack.h"\r
32#include "AliAODEvent.h"\r
33#include "AliMCEvent.h"\r
34#include "AliMCEventHandler.h"\r
35#include "AliESDInputHandler.h"\r
36#include "AliAODHandler.h"\r
37#include "AliAODMCParticle.h"\r
38#include "AliAnalysisFilter.h"\r
39#include "AliESDMuonTrack.h"\r
40#include "AliESDVertex.h"\r
fba4b2e2 41#include "AliCentrality.h"\r
ce7adfe9 42#include "AliEventplane.h"\r
f7ed7e88 43#include "AliESDv0.h"\r
44#include "AliESDkink.h"\r
45#include "AliESDcascade.h"\r
46#include "AliESDPmdTrack.h"\r
47#include "AliESDCaloCluster.h"\r
48#include "AliESDCaloCells.h"\r
49#include "AliMultiplicity.h"\r
50#include "AliLog.h"\r
c7ef1c47 51#include "AliCodeTimer.h"\r
a7b1466d 52#include "AliESDtrackCuts.h"\r
c7ef1c47 53#include "AliESDpid.h"\r
b8d29a28 54#include "AliV0vertexer.h"\r
55#include "AliCascadeVertexer.h"\r
c7ef1c47 56#include "Riostream.h"\r
57\r
f7ed7e88 58ClassImp(AliAnalysisTaskESDfilter)\r
59\r
60////////////////////////////////////////////////////////////////////////\r
61\r
62AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():\r
63 AliAnalysisTaskSE(),\r
64 fTrackFilter(0x0),\r
65 fKinkFilter(0x0),\r
66 fV0Filter(0x0),\r
67 fCascadeFilter(0x0),\r
68 fHighPthreshold(0),\r
12588061 69 fPtshape(0x0),\r
26917b0b 70 fEnableFillAOD(kTRUE),\r
8c87d22c 71 fUsedTrack(0x0),\r
72 fUsedKink(0x0),\r
73 fUsedV0(0x0),\r
74 fAODTrackRefs(0x0),\r
75 fAODV0VtxRefs(0x0),\r
76 fAODV0Refs(0x0),\r
77 fMChandler(0x0),\r
78 fNumberOfTracks(0),\r
79 fNumberOfPositiveTracks(0),\r
80 fNumberOfV0s(0),\r
81 fNumberOfVertices(0),\r
82 fNumberOfCascades(0),\r
83 fNumberOfKinks(0),\r
84 fOldESDformat(kFALSE),\r
85 fPrimaryVertex(0x0),\r
67abcce9 86 fTPCConstrainedFilterMask(0),\r
87 fHybridFilterMaskTPCCG(0),\r
88 fWriteHybridTPCCOnly(kFALSE),\r
89 fGlobalConstrainedFilterMask(0),\r
90 fHybridFilterMaskGCG(0),\r
91 fWriteHybridGCOnly(kFALSE),\r
8c87d22c 92 fIsVZEROEnabled(kTRUE),\r
a1f96974 93 fIsTZEROEnabled(kTRUE),\r
8c87d22c 94 fIsZDCEnabled(kTRUE),\r
b8d29a28 95 fIsV0CascadeRecoEnabled(kFALSE),\r
8c87d22c 96 fAreCascadesEnabled(kTRUE),\r
97 fAreV0sEnabled(kTRUE),\r
98 fAreKinksEnabled(kTRUE),\r
99 fAreTracksEnabled(kTRUE),\r
100 fArePmdClustersEnabled(kTRUE),\r
101 fAreCaloClustersEnabled(kTRUE),\r
102 fAreEMCALCellsEnabled(kTRUE),\r
103 fArePHOSCellsEnabled(kTRUE),\r
720f7306 104 fAreEMCALTriggerEnabled(kTRUE),\r
fa7d44a6 105 fArePHOSTriggerEnabled(kTRUE),\r
720f7306 106 fAreTrackletsEnabled(kTRUE),\r
8c87d22c 107 fESDpid(0x0),\r
108 fIsPidOwner(kFALSE),\r
109 fTimeZeroType(AliESDpid::kTOF_T0),\r
110 fTPCaloneTrackCuts(0)\r
f7ed7e88 111{\r
112 // Default constructor\r
30ea307c 113 fV0Cuts[0] = 33. ; // max allowed chi2\r
114 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter\r
115 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter\r
116 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks\r
117 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle\r
118 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume\r
119 fV0Cuts[6] = 100. ; // max radius of the fiducial volume\r
120\r
121 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)\r
122 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter\r
123 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass\r
124 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter\r
125 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor\r
126 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle\r
127 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume\r
128 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume\r
f7ed7e88 129}\r
130\r
c7ef1c47 131//______________________________________________________________________________\r
f7ed7e88 132AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):\r
133 AliAnalysisTaskSE(name),\r
134 fTrackFilter(0x0),\r
135 fKinkFilter(0x0),\r
136 fV0Filter(0x0),\r
137 fCascadeFilter(0x0),\r
138 fHighPthreshold(0),\r
12588061 139 fPtshape(0x0),\r
26917b0b 140 fEnableFillAOD(kTRUE),\r
8c87d22c 141 fUsedTrack(0x0),\r
142 fUsedKink(0x0),\r
143 fUsedV0(0x0),\r
144 fAODTrackRefs(0x0),\r
145 fAODV0VtxRefs(0x0),\r
146 fAODV0Refs(0x0),\r
147 fMChandler(0x0),\r
148 fNumberOfTracks(0),\r
149 fNumberOfPositiveTracks(0),\r
150 fNumberOfV0s(0),\r
151 fNumberOfVertices(0),\r
152 fNumberOfCascades(0),\r
153 fNumberOfKinks(0),\r
154 fOldESDformat(kFALSE),\r
155 fPrimaryVertex(0x0),\r
67abcce9 156 fTPCConstrainedFilterMask(0),\r
157 fHybridFilterMaskTPCCG(0),\r
158 fWriteHybridTPCCOnly(kFALSE),\r
159 fGlobalConstrainedFilterMask(0),\r
160 fHybridFilterMaskGCG(0),\r
161 fWriteHybridGCOnly(kFALSE),\r
8c87d22c 162 fIsVZEROEnabled(kTRUE),\r
a1f96974 163 fIsTZEROEnabled(kTRUE),\r
8c87d22c 164 fIsZDCEnabled(kTRUE),\r
b8d29a28 165 fIsV0CascadeRecoEnabled(kFALSE),\r
8c87d22c 166 fAreCascadesEnabled(kTRUE),\r
167 fAreV0sEnabled(kTRUE),\r
168 fAreKinksEnabled(kTRUE),\r
169 fAreTracksEnabled(kTRUE),\r
170 fArePmdClustersEnabled(kTRUE),\r
171 fAreCaloClustersEnabled(kTRUE),\r
172 fAreEMCALCellsEnabled(kTRUE),\r
173 fArePHOSCellsEnabled(kTRUE),\r
720f7306 174 fAreEMCALTriggerEnabled(kTRUE),\r
fa7d44a6 175 fArePHOSTriggerEnabled(kTRUE),\r
720f7306 176 fAreTrackletsEnabled(kTRUE),\r
8c87d22c 177 fESDpid(0x0),\r
178 fIsPidOwner(kFALSE),\r
179 fTimeZeroType(AliESDpid::kTOF_T0),\r
180 fTPCaloneTrackCuts(0)\r
f7ed7e88 181{\r
182 // Constructor\r
b8d29a28 183\r
184 fV0Cuts[0] = 33. ; // max allowed chi2\r
185 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter\r
186 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter\r
187 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks\r
188 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle\r
189 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume\r
190 fV0Cuts[6] = 100. ; // max radius of the fiducial volume\r
191\r
192 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)\r
193 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter\r
194 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass\r
195 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter\r
196 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor\r
197 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle\r
198 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume\r
199 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume\r
200\r
201\r
202\r
f7ed7e88 203}\r
75a996ab 204AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){\r
8c87d22c 205 if(fIsPidOwner) delete fESDpid;\r
75a996ab 206}\r
c7ef1c47 207//______________________________________________________________________________\r
f7ed7e88 208void AliAnalysisTaskESDfilter::UserCreateOutputObjects()\r
209{\r
cd5eefa7 210 //\r
211 // Create Output Objects conenct filter to outputtree\r
212 // \r
c7ef1c47 213 if(OutputTree())\r
214 {\r
f7ed7e88 215 OutputTree()->GetUserInfo()->Add(fTrackFilter);\r
d3815ca9 216 }\r
c7ef1c47 217 else\r
218 {\r
d3815ca9 219 AliError("No OutputTree() for adding the track filter");\r
220 }\r
2f5ee3b7 221 fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();\r
f7ed7e88 222}\r
223\r
c7ef1c47 224//______________________________________________________________________________\r
f7ed7e88 225void AliAnalysisTaskESDfilter::Init()\r
226{\r
c7ef1c47 227 // Initialization\r
228 if (fDebug > 1) AliInfo("Init() \n");\r
229 // Call configuration file\r
f7ed7e88 230}\r
231\r
c7ef1c47 232//______________________________________________________________________________\r
233void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const\r
234{\r
5204c278 235// Print selection task information\r
c7ef1c47 236 AliInfo("");\r
237 \r
238 AliAnalysisTaskSE::PrintTask(option,indent);\r
239 \r
240 TString spaces(' ',indent+3);\r
241 \r
720f7306 242 cout << spaces.Data() << Form("Cascades are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;\r
243 cout << spaces.Data() << Form("V0s are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;\r
244 cout << spaces.Data() << Form("Kinks are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;\r
245 cout << spaces.Data() << Form("Tracks are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;\r
246 cout << spaces.Data() << Form("PmdClusters are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
247 cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;\r
248 cout << spaces.Data() << Form("EMCAL cells are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;\r
249 cout << spaces.Data() << Form("EMCAL triggers are %s",fAreEMCALTriggerEnabled ? "ENABLED":"DISABLED") << endl;\r
250 cout << spaces.Data() << Form("PHOS triggers are %s",fArePHOSTriggerEnabled ? "ENABLED":"DISABLED") << endl;\r
251 cout << spaces.Data() << Form("Tracklets are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl; \r
c7ef1c47 252}\r
f7ed7e88 253\r
c7ef1c47 254//______________________________________________________________________________\r
f7ed7e88 255void AliAnalysisTaskESDfilter::UserExec(Option_t */*option*/)\r
256{\r
257// Execute analysis for current event\r
258//\r
259 \r
260 Long64_t ientry = Entry();\r
f2f21b24 261 \r
e26c0b71 262 if (fDebug > 0) {\r
f2f21b24 263 printf("Filter: Analysing event # %5d\n", (Int_t) ientry);\r
264 if (fHighPthreshold == 0) AliInfo("detector PID signals are stored in each track");\r
265 if (!fPtshape) AliInfo("detector PID signals are not stored below the pt threshold");\r
e26c0b71 266 }\r
5b173801 267 // Filters must explicitely enable AOD filling in their UserExec (AG)\r
268 if (!AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()) AliFatal("Cannot run ESD filter without an output event handler");\r
307b6330 269 if(fEnableFillAOD) {\r
270 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);\r
271 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);\r
272 } \r
f7ed7e88 273 ConvertESDtoAOD();\r
274}\r
275\r
c7ef1c47 276//______________________________________________________________________________\r
277TClonesArray& AliAnalysisTaskESDfilter::Cascades()\r
278{\r
279 return *(AODEvent()->GetCascades());\r
280}\r
f7ed7e88 281\r
c7ef1c47 282//______________________________________________________________________________\r
283TClonesArray& AliAnalysisTaskESDfilter::Tracks()\r
284{\r
285 return *(AODEvent()->GetTracks());\r
286}\r
f7ed7e88 287\r
c7ef1c47 288//______________________________________________________________________________\r
289TClonesArray& AliAnalysisTaskESDfilter::V0s()\r
290{\r
291 return *(AODEvent()->GetV0s());\r
292}\r
f7ed7e88 293\r
c7ef1c47 294//______________________________________________________________________________\r
295TClonesArray& AliAnalysisTaskESDfilter::Vertices()\r
296{\r
297 return *(AODEvent()->GetVertices());\r
298}\r
f7ed7e88 299\r
c7ef1c47 300//______________________________________________________________________________\r
301AliAODHeader* AliAnalysisTaskESDfilter::ConvertHeader(const AliESDEvent& esd)\r
302{\r
5204c278 303// Convert header information\r
304\r
c7ef1c47 305 AliCodeTimerAuto("",0);\r
306 \r
307 AliAODHeader* header = AODEvent()->GetHeader();\r
308 \r
309 header->SetRunNumber(esd.GetRunNumber());\r
310 header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection\r
f7ed7e88 311\r
c7ef1c47 312 TTree* tree = fInputHandler->GetTree();\r
313 if (tree) {\r
314 TFile* file = tree->GetCurrentFile();\r
315 if (file) header->SetESDFileName(file->GetName());\r
316 }\r
317 \r
318 if (fOldESDformat) {\r
319 header->SetBunchCrossNumber(0);\r
320 header->SetOrbitNumber(0);\r
321 header->SetPeriodNumber(0);\r
322 header->SetEventType(0);\r
323 header->SetMuonMagFieldScale(-999.);\r
324 header->SetCentrality(0); \r
ce7adfe9 325 header->SetEventplane(0);\r
c7ef1c47 326 } else {\r
327 header->SetBunchCrossNumber(esd.GetBunchCrossNumber());\r
328 header->SetOrbitNumber(esd.GetOrbitNumber());\r
329 header->SetPeriodNumber(esd.GetPeriodNumber());\r
330 header->SetEventType(esd.GetEventType());\r
f7ed7e88 331 \r
c7ef1c47 332 header->SetEventNumberESDFile(esd.GetHeader()->GetEventNumberInFile());\r
333 if(const_cast<AliESDEvent&>(esd).GetCentrality()){\r
75a996ab 334 header->SetCentrality(const_cast<AliESDEvent&>(esd).GetCentrality());\r
a98c78e5 335 }\r
c7ef1c47 336 else{\r
337 header->SetCentrality(0);\r
a98c78e5 338 }\r
ce7adfe9 339 if(const_cast<AliESDEvent&>(esd).GetEventplane()){\r
340 header->SetEventplane(const_cast<AliESDEvent&>(esd).GetEventplane());\r
341 }\r
342 else{\r
343 header->SetEventplane(0);\r
344 }\r
c7ef1c47 345 }\r
346 \r
347 // Trigger\r
348 header->SetFiredTriggerClasses(esd.GetFiredTriggerClasses());\r
349 header->SetTriggerMask(esd.GetTriggerMask()); \r
350 header->SetTriggerCluster(esd.GetTriggerCluster());\r
351 header->SetL0TriggerInputs(esd.GetHeader()->GetL0TriggerInputs()); \r
352 header->SetL1TriggerInputs(esd.GetHeader()->GetL1TriggerInputs()); \r
353 header->SetL2TriggerInputs(esd.GetHeader()->GetL2TriggerInputs()); \r
354 \r
355 header->SetMagneticField(esd.GetMagneticField());\r
356 header->SetMuonMagFieldScale(esd.GetCurrentDip()/6000.);\r
357 header->SetZDCN1Energy(esd.GetZDCN1Energy());\r
358 header->SetZDCP1Energy(esd.GetZDCP1Energy());\r
359 header->SetZDCN2Energy(esd.GetZDCN2Energy());\r
360 header->SetZDCP2Energy(esd.GetZDCP2Energy());\r
361 header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));\r
362 \r
f7ce7a37 363 // ITS Cluster Multiplicty\r
364 const AliMultiplicity *mult = esd.GetMultiplicity();\r
365 for (Int_t ilay = 0; ilay < 6; ilay++) header->SetITSClusters(ilay, mult->GetNumberOfITSClusters(ilay));\r
c7ef1c47 366 \r
f7ce7a37 367 // TPC only Reference Multiplicty\r
2f5ee3b7 368 Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;\r
f7ce7a37 369 header->SetTPConlyRefMultiplicity(refMult);\r
370 \r
371 //\r
c7ef1c47 372 Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};\r
373 Float_t diamcov[3]; \r
374 esd.GetDiamondCovXY(diamcov);\r
375 header->SetDiamond(diamxy,diamcov);\r
376 header->SetDiamondZ(esd.GetDiamondZ(),esd.GetSigma2DiamondZ());\r
377 \r
da4870e8 378 // VZERO channel equalization factors for event-plane reconstruction \r
379 header->SetVZEROEqFactors(esd.GetVZEROEqFactors());\r
380\r
c7ef1c47 381 return header;\r
382}\r
a98c78e5 383\r
c7ef1c47 384//______________________________________________________________________________\r
385void AliAnalysisTaskESDfilter::ConvertCascades(const AliESDEvent& esd) \r
386{\r
b8d29a28 387\r
c7ef1c47 388 // Convert the cascades part of the ESD.\r
389 // Return the number of cascades\r
390 \r
391 AliCodeTimerAuto("",0);\r
392 \r
393 // Create vertices starting from the most complex objects\r
394 Double_t chi2 = 0.;\r
395 \r
396 const AliESDVertex* vtx = esd.GetPrimaryVertex();\r
397 Double_t pos[3] = { 0. };\r
398 Double_t covVtx[6] = { 0. };\r
399 Double_t momBach[3]={0.};\r
400 Double_t covTr[21]={0.};\r
401 Double_t pid[10]={0.};\r
402 AliAODPid* detpid(0x0);\r
403 AliAODVertex* vV0FromCascade(0x0);\r
404 AliAODv0* aodV0(0x0);\r
405 AliAODcascade* aodCascade(0x0);\r
406 AliAODTrack* aodTrack(0x0);\r
407 Double_t momPos[3]={0.};\r
408 Double_t momNeg[3] = { 0. };\r
409 Double_t momPosAtV0vtx[3]={0.};\r
410 Double_t momNegAtV0vtx[3]={0.};\r
411\r
412 TClonesArray& verticesArray = Vertices();\r
413 TClonesArray& tracksArray = Tracks();\r
414 TClonesArray& cascadesArray = Cascades();\r
415 \r
416 // Cascades (Modified by A.Maire - February 2009)\r
417 for (Int_t nCascade = 0; nCascade < esd.GetNumberOfCascades(); ++nCascade) {\r
6878d51e 418 \r
c7ef1c47 419 // 0- Preparation\r
420 //\r
421 AliESDcascade *esdCascade = esd.GetCascade(nCascade);\r
422 Int_t idxPosFromV0Dghter = esdCascade->GetPindex();\r
423 Int_t idxNegFromV0Dghter = esdCascade->GetNindex();\r
424 Int_t idxBachFromCascade = esdCascade->GetBindex();\r
b13bcc35 425 \r
c7ef1c47 426 AliESDtrack *esdCascadePos = esd.GetTrack( idxPosFromV0Dghter);\r
427 AliESDtrack *esdCascadeNeg = esd.GetTrack( idxNegFromV0Dghter);\r
428 AliESDtrack *esdCascadeBach = esd.GetTrack( idxBachFromCascade);\r
253cab77 429 \r
c7ef1c47 430 // Identification of the V0 within the esdCascade (via both daughter track indices)\r
431 AliESDv0 * currentV0 = 0x0;\r
432 Int_t idxV0FromCascade = -1;\r
433 \r
434 for (Int_t iV0=0; iV0<esd.GetNumberOfV0s(); ++iV0) {\r
435 \r
436 currentV0 = esd.GetV0(iV0);\r
437 Int_t posCurrentV0 = currentV0->GetPindex();\r
438 Int_t negCurrentV0 = currentV0->GetNindex();\r
439 \r
440 if (posCurrentV0==idxPosFromV0Dghter && negCurrentV0==idxNegFromV0Dghter) {\r
441 idxV0FromCascade = iV0;\r
442 break;\r
443 }\r
b13bcc35 444 }\r
f7ed7e88 445 \r
c7ef1c47 446 if(idxV0FromCascade < 0){\r
447 printf("Cascade - no matching for the V0 (index V0 = -1) ! Skip ... \n");\r
448 continue;\r
449 }// a priori, useless check, but safer ... in case of pb with tracks "out of bounds"\r
450 \r
451 AliESDv0 *esdV0FromCascade = esd.GetV0(idxV0FromCascade);\r
452 \r
453 // 1 - Cascade selection \r
454 \r
455 // AliESDVertex *esdPrimVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));\r
456 // TList cascadeObjects;\r
457 // cascadeObjects.AddAt(esdV0FromCascade, 0);\r
458 // cascadeObjects.AddAt(esdCascadePos, 1);\r
459 // cascadeObjects.AddAt(esdCascadeNeg, 2);\r
460 // cascadeObjects.AddAt(esdCascade, 3);\r
461 // cascadeObjects.AddAt(esdCascadeBach, 4);\r
462 // cascadeObjects.AddAt(esdPrimVtx, 5);\r
463 // \r
464 // UInt_t selectCascade = 0;\r
465 // if (fCascadeFilter) {\r
466 // // selectCascade = fCascadeFilter->IsSelected(&cascadeObjects); \r
467 // // FIXME AliESDCascadeCuts to be implemented ...\r
468 // \r
469 // // Here we may encounter a moot point at the V0 level \r
470 // // between the cascade selections and the V0 ones :\r
471 // // the V0 selected along with the cascade (secondary V0) may \r
472 // // usually be removed from the dedicated V0 selections (prim V0) ...\r
473 // // -> To be discussed !\r
474 // \r
475 // // this is a little awkward but otherwise the \r
476 // // list wants to access the pointer (delete it) \r
477 // // again when going out of scope\r
478 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct\r
479 // esdPrimVtx = 0;\r
480 // if (!selectCascade) \r
481 // continue;\r
482 // }\r
483 // else{\r
484 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct\r
485 // esdPrimVtx = 0;\r
486 // }\r
487 \r
488 // 2 - Add the cascade vertex\r
489 \r
490 esdCascade->GetXYZcascade(pos[0], pos[1], pos[2]);\r
491 esdCascade->GetPosCovXi(covVtx);\r
492 chi2 = esdCascade->GetChi2Xi(); \r
493 \r
494 AliAODVertex *vCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex( pos,\r
495 covVtx,\r
496 chi2, // FIXME = Chi2/NDF will be needed\r
497 fPrimaryVertex,\r
498 nCascade, // id\r
499 AliAODVertex::kCascade);\r
500 fPrimaryVertex->AddDaughter(vCascade);\r
501 \r
502// if (fDebug > 2) {\r
503// printf("---- Cascade / Cascade Vertex (AOD) : \n");\r
504// vCascade->Print();\r
505// }\r
506 \r
7557fd4b 507 if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender. \r
f7ed7e88 508\r
f7ed7e88 509\r
c7ef1c47 510 // 3 - Add the bachelor track from the cascade\r
511 \r
512 if (!fUsedTrack[idxBachFromCascade]) {\r
513 \r
514 esdCascadeBach->GetPxPyPz(momBach);\r
515 esdCascadeBach->GetXYZ(pos);\r
516 esdCascadeBach->GetCovarianceXYZPxPyPz(covTr);\r
517 esdCascadeBach->GetESDpid(pid);\r
518 \r
519 fUsedTrack[idxBachFromCascade] = kTRUE;\r
f7ed7e88 520 UInt_t selectInfo = 0;\r
9eeae5d5 521 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeBach);\r
c7ef1c47 522 if (fMChandler) fMChandler->SelectParticle(esdCascadeBach->GetLabel());\r
523 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack(esdCascadeBach->GetID(),\r
524 esdCascadeBach->GetLabel(), \r
525 momBach, \r
526 kTRUE,\r
527 pos,\r
528 kFALSE, // Why kFALSE for "isDCA" ? FIXME\r
529 covTr, \r
530 (Short_t)esdCascadeBach->GetSign(),\r
531 esdCascadeBach->GetITSClusterMap(), \r
532 pid,\r
533 vCascade,\r
534 kTRUE, // usedForVtxFit = kFALSE ? FIXME\r
535 vtx->UsesTrack(esdCascadeBach->GetID()),\r
536 AliAODTrack::kSecondary,\r
537 selectInfo);\r
bcabd0e4 538 aodTrack->SetTPCFitMap(esdCascadeBach->GetTPCFitMap());\r
f2f21b24 539 aodTrack->SetTPCClusterMap(esdCascadeBach->GetTPCClusterMap());\r
540 aodTrack->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());\r
40a060e5 541 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));\r
3c01c166 542 aodTrack->SetTPCPointsF(esdCascadeBach->GetTPCNclsF());\r
c7ef1c47 543 fAODTrackRefs->AddAt(aodTrack,idxBachFromCascade);\r
f2f21b24 544 \r
c7ef1c47 545 if (esdCascadeBach->GetSign() > 0) ++fNumberOfPositiveTracks;\r
f7ed7e88 546 aodTrack->ConvertAliPIDtoAODPID();\r
547 aodTrack->SetFlags(esdCascadeBach->GetStatus());\r
1a3579a6 548 SetAODPID(esdCascadeBach,aodTrack,detpid);\r
c7ef1c47 549 }\r
550 else {\r
551 aodTrack = static_cast<AliAODTrack*>( fAODTrackRefs->At(idxBachFromCascade) );\r
552 }\r
553 \r
554 vCascade->AddDaughter(aodTrack);\r
555 \r
556// if (fDebug > 4) {\r
557// printf("---- Cascade / bach dghter : \n");\r
558// aodTrack->Print();\r
559// }\r
560 \r
561 \r
562 // 4 - Add the V0 from the cascade. \r
563 // = V0vtx + both pos and neg daughter tracks + the aodV0 itself\r
564 //\r
565 \r
566 if ( !fUsedV0[idxV0FromCascade] ) {\r
567 // 4.A - if VO structure hasn't been created yet\r
568 \r
569 // 4.A.1 - Create the V0 vertex of the cascade\r
570 \r
571 esdV0FromCascade->GetXYZ(pos[0], pos[1], pos[2]);\r
572 esdV0FromCascade->GetPosCov(covVtx);\r
573 chi2 = esdV0FromCascade->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3 ?\r
f7ed7e88 574 \r
c7ef1c47 575 vV0FromCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex(pos,\r
576 covVtx,\r
577 chi2,\r
578 vCascade,\r
579 idxV0FromCascade, //id of ESDv0\r
580 AliAODVertex::kV0);\r
581 // Note:\r
582 // one V0 can be used by several cascades.\r
583 // So, one AOD V0 vtx can have several parent vtx.\r
584 // This is not directly allowed by AliAODvertex.\r
585 // Setting the parent vtx (here = param "vCascade") doesn't lead to a crash\r
586 // but to a problem of consistency within AODEvent.\r
587 // -> See below paragraph 4.B, for the proposed treatment of such a case.\r
588 \r
589 // Add the vV0FromCascade to the aodVOVtxRefs\r
590 fAODV0VtxRefs->AddAt(vV0FromCascade,idxV0FromCascade);\r
591 \r
592 \r
593 // 4.A.2 - Add the positive tracks from the V0\r
594 \r
595 esdCascadePos->GetPxPyPz(momPos);\r
596 esdCascadePos->GetXYZ(pos);\r
597 esdCascadePos->GetCovarianceXYZPxPyPz(covTr);\r
598 esdCascadePos->GetESDpid(pid);\r
599 \r
600 \r
601 if (!fUsedTrack[idxPosFromV0Dghter]) {\r
602 fUsedTrack[idxPosFromV0Dghter] = kTRUE;\r
603 \r
604 UInt_t selectInfo = 0;\r
605 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadePos);\r
606 if(fMChandler) fMChandler->SelectParticle(esdCascadePos->GetLabel());\r
607 aodTrack = new(tracksArray[fNumberOfTracks++]) \r
608 AliAODTrack( esdCascadePos->GetID(),\r
609 esdCascadePos->GetLabel(), \r
610 momPos, \r
611 kTRUE,\r
612 pos,\r
613 kFALSE, // Why kFALSE for "isDCA" ? FIXME\r
614 covTr, \r
615 (Short_t)esdCascadePos->GetSign(),\r
616 esdCascadePos->GetITSClusterMap(), \r
617 pid,\r
618 vV0FromCascade,\r
619 kTRUE, // usedForVtxFit = kFALSE ? FIXME\r
620 vtx->UsesTrack(esdCascadePos->GetID()),\r
621 AliAODTrack::kSecondary,\r
622 selectInfo);\r
bcabd0e4 623 aodTrack->SetTPCFitMap(esdCascadePos->GetTPCFitMap());\r
c7ef1c47 624 aodTrack->SetTPCClusterMap(esdCascadePos->GetTPCClusterMap());\r
625 aodTrack->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());\r
626 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));\r
3c01c166 627 aodTrack->SetTPCPointsF(esdCascadePos->GetTPCNclsF());\r
c7ef1c47 628 fAODTrackRefs->AddAt(aodTrack,idxPosFromV0Dghter);\r
629 \r
630 if (esdCascadePos->GetSign() > 0) ++fNumberOfPositiveTracks;\r
631 aodTrack->ConvertAliPIDtoAODPID();\r
632 aodTrack->SetFlags(esdCascadePos->GetStatus());\r
1a3579a6 633 SetAODPID(esdCascadePos,aodTrack,detpid);\r
c7ef1c47 634 }\r
635 else {\r
636 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxPosFromV0Dghter));\r
637 }\r
638 vV0FromCascade->AddDaughter(aodTrack);\r
639 \r
640 \r
641 // 4.A.3 - Add the negative tracks from the V0\r
642 \r
643 esdCascadeNeg->GetPxPyPz(momNeg);\r
644 esdCascadeNeg->GetXYZ(pos);\r
645 esdCascadeNeg->GetCovarianceXYZPxPyPz(covTr);\r
646 esdCascadeNeg->GetESDpid(pid);\r
647 \r
648 \r
649 if (!fUsedTrack[idxNegFromV0Dghter]) {\r
650 fUsedTrack[idxNegFromV0Dghter] = kTRUE;\r
651 \r
652 UInt_t selectInfo = 0;\r
653 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeNeg);\r
654 if(fMChandler)fMChandler->SelectParticle(esdCascadeNeg->GetLabel());\r
655 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack( esdCascadeNeg->GetID(),\r
656 esdCascadeNeg->GetLabel(),\r
657 momNeg,\r
658 kTRUE,\r
659 pos,\r
660 kFALSE, // Why kFALSE for "isDCA" ? FIXME\r
661 covTr, \r
662 (Short_t)esdCascadeNeg->GetSign(),\r
663 esdCascadeNeg->GetITSClusterMap(), \r
664 pid,\r
665 vV0FromCascade,\r
666 kTRUE, // usedForVtxFit = kFALSE ? FIXME\r
667 vtx->UsesTrack(esdCascadeNeg->GetID()),\r
668 AliAODTrack::kSecondary,\r
669 selectInfo);\r
bcabd0e4 670 aodTrack->SetTPCFitMap(esdCascadeNeg->GetTPCFitMap());\r
c7ef1c47 671 aodTrack->SetTPCClusterMap(esdCascadeNeg->GetTPCClusterMap());\r
672 aodTrack->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());\r
673 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));\r
3c01c166 674 aodTrack->SetTPCPointsF(esdCascadeNeg->GetTPCNclsF());\r
c7ef1c47 675 fAODTrackRefs->AddAt(aodTrack,idxNegFromV0Dghter);\r
676 \r
677 if (esdCascadeNeg->GetSign() > 0) ++fNumberOfPositiveTracks;\r
678 aodTrack->ConvertAliPIDtoAODPID();\r
679 aodTrack->SetFlags(esdCascadeNeg->GetStatus());\r
1a3579a6 680 SetAODPID(esdCascadeNeg,aodTrack,detpid);\r
c7ef1c47 681 }\r
682 else {\r
683 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxNegFromV0Dghter));\r
684 }\r
685 \r
686 vV0FromCascade->AddDaughter(aodTrack);\r
687 \r
f7ed7e88 688 \r
c7ef1c47 689 // 4.A.4 - Add the V0 from cascade to the V0 array\r
690 \r
691 Double_t dcaV0Daughters = esdV0FromCascade->GetDcaV0Daughters();\r
692 Double_t dcaV0ToPrimVertex = esdV0FromCascade->GetD( esd.GetPrimaryVertex()->GetX(),\r
693 esd.GetPrimaryVertex()->GetY(),\r
694 esd.GetPrimaryVertex()->GetZ() );\r
695 esdV0FromCascade->GetPPxPyPz( momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2] ); \r
696 esdV0FromCascade->GetNPxPyPz( momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2] ); \r
697 \r
698 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg\r
699 dcaDaughterToPrimVertex[0] = TMath::Abs(esdCascadePos->GetD( esd.GetPrimaryVertex()->GetX(),\r
700 esd.GetPrimaryVertex()->GetY(),\r
701 esd.GetMagneticField()) );\r
702 dcaDaughterToPrimVertex[1] = TMath::Abs(esdCascadeNeg->GetD( esd.GetPrimaryVertex()->GetX(),\r
703 esd.GetPrimaryVertex()->GetY(),\r
704 esd.GetMagneticField()) );\r
705 \r
706 aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0( vV0FromCascade, \r
707 dcaV0Daughters,\r
708 dcaV0ToPrimVertex, \r
709 momPosAtV0vtx, \r
710 momNegAtV0vtx, \r
711 dcaDaughterToPrimVertex); \r
712 // set the aod v0 on-the-fly status\r
713 aodV0->SetOnFlyStatus(esdV0FromCascade->GetOnFlyStatus());\r
714 \r
715 // Add the aodV0 to the aodVORefs\r
716 fAODV0Refs->AddAt(aodV0,idxV0FromCascade);\r
717 \r
718 fUsedV0[idxV0FromCascade] = kTRUE;\r
719 \r
720 } else { \r
721 // 4.B - if V0 structure already used\r
722 \r
723 // Note :\r
724 // one V0 can be used by several cascades (frequent in PbPb evts) : \r
725 // same V0 which used but attached to different bachelor tracks\r
726 // -> aodVORefs and fAODV0VtxRefs are needed.\r
727 // Goal : avoid a redundancy of the info in "Vertices" and "v0s" clones array.\r
728 \r
729 vV0FromCascade = static_cast<AliAODVertex*>( fAODV0VtxRefs->At(idxV0FromCascade) );\r
730 aodV0 = static_cast<AliAODv0*> ( fAODV0Refs ->At(idxV0FromCascade) );\r
731 \r
732 // - Treatment of the parent for such a "re-used" V0 :\r
733 // Insert the cascade that reuses the V0 vertex in the lineage chain\r
734 // Before : vV0 -> vCascade1 -> vPrimary\r
735 // - Hyp : cascade2 uses the same V0 as cascade1\r
736 // After : vV0 -> vCascade2 -> vCascade1 -> vPrimary\r
737 \r
738 AliAODVertex *vCascadePreviousParent = static_cast<AliAODVertex*> (vV0FromCascade->GetParent());\r
f7ed7e88 739 vV0FromCascade->SetParent(vCascade);\r
740 vCascade ->SetParent(vCascadePreviousParent);\r
c7ef1c47 741 \r
742// if(fDebug > 2) \r
743// printf("---- Cascade / Lineage insertion\n"\r
744// "Parent of V0 vtx = Cascade vtx %p\n"\r
745// "Parent of the cascade vtx = Cascade vtx %p\n"\r
746// "Parent of the parent cascade vtx = Cascade vtx %p\n", \r
747// static_cast<void*> (vV0FromCascade->GetParent()),\r
748// static_cast<void*> (vCascade->GetParent()),\r
749// static_cast<void*> (vCascadePreviousParent->GetParent()) );\r
750 \r
751 }// end if V0 structure already used\r
752 \r
753// if (fDebug > 2) {\r
754// printf("---- Cascade / V0 vertex: \n");\r
755// vV0FromCascade->Print();\r
756// }\r
757// \r
758// if (fDebug > 4) {\r
759// printf("---- Cascade / pos dghter : \n");\r
760// aodTrack->Print();\r
761// printf("---- Cascade / neg dghter : \n");\r
762// aodTrack->Print();\r
763// printf("---- Cascade / aodV0 : \n");\r
764// aodV0->Print();\r
765// }\r
766 \r
767 // In any case (used V0 or not), add the V0 vertex to the cascade one.\r
768 vCascade->AddDaughter(vV0FromCascade); \r
769 \r
f7ed7e88 770 \r
c7ef1c47 771 // 5 - Add the primary track of the cascade (if any)\r
772 \r
773 \r
774 // 6 - Add the cascade to the AOD array of cascades\r
775 \r
776 Double_t dcaBachToPrimVertexXY = TMath::Abs(esdCascadeBach->GetD(esd.GetPrimaryVertex()->GetX(),\r
777 esd.GetPrimaryVertex()->GetY(),\r
778 esd.GetMagneticField()) );\r
779 \r
780 Double_t momBachAtCascadeVtx[3]={0.};\r
f7ed7e88 781\r
c7ef1c47 782 esdCascade->GetBPxPyPz(momBachAtCascadeVtx[0], momBachAtCascadeVtx[1], momBachAtCascadeVtx[2]);\r
783 \r
784 aodCascade = new(cascadesArray[fNumberOfCascades++]) AliAODcascade( vCascade,\r
785 esdCascade->Charge(),\r
786 esdCascade->GetDcaXiDaughters(),\r
787 -999.,\r
788 // DCAXiToPrimVtx -> needs to be calculated ----|\r
789 // doesn't exist at ESD level;\r
790 // See AODcascade::DcaXiToPrimVertex(Double, Double, Double)\r
791 dcaBachToPrimVertexXY,\r
792 momBachAtCascadeVtx,\r
793 *aodV0);\r
794 \r
40771071 795 if (fDebug > 10) {\r
796 printf("---- Cascade / AOD cascade : \n\n");\r
797 aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());\r
798 }\r
c7ef1c47 799 \r
800 } // end of the loop on cascades\r
801 \r
802 Cascades().Expand(fNumberOfCascades);\r
803}\r
f7ed7e88 804\r
c7ef1c47 805//______________________________________________________________________________\r
806void AliAnalysisTaskESDfilter::ConvertV0s(const AliESDEvent& esd)\r
807{\r
808 // Access to the AOD container of V0s\r
809 \r
810 AliCodeTimerAuto("",0);\r
f7ed7e88 811\r
c7ef1c47 812 //\r
813 // V0s\r
814 //\r
815 \r
816 Double_t pos[3] = { 0. }; \r
817 Double_t chi2(0.0);\r
818 Double_t covVtx[6] = { 0. };\r
819 Double_t momPos[3]={0.};\r
820 Double_t covTr[21]={0.};\r
821 Double_t pid[10]={0.};\r
822 AliAODTrack* aodTrack(0x0);\r
823 AliAODPid* detpid(0x0);\r
824 Double_t momNeg[3]={0.};\r
825 Double_t momPosAtV0vtx[3]={0.};\r
826 Double_t momNegAtV0vtx[3]={0.};\r
827 \r
828 for (Int_t nV0 = 0; nV0 < esd.GetNumberOfV0s(); ++nV0) \r
829 {\r
830 if (fUsedV0[nV0]) continue; // skip if already added to the AOD\r
831 \r
832 AliESDv0 *v0 = esd.GetV0(nV0);\r
833 Int_t posFromV0 = v0->GetPindex();\r
834 Int_t negFromV0 = v0->GetNindex();\r
835 \r
836 // V0 selection \r
f7ed7e88 837 //\r
c7ef1c47 838 AliESDVertex *esdVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));\r
839 AliESDtrack *esdV0Pos = esd.GetTrack(posFromV0);\r
840 AliESDtrack *esdV0Neg = esd.GetTrack(negFromV0);\r
841 TList v0objects;\r
842 v0objects.AddAt(v0, 0);\r
843 v0objects.AddAt(esdV0Pos, 1);\r
844 v0objects.AddAt(esdV0Neg, 2);\r
845 v0objects.AddAt(esdVtx, 3);\r
846 UInt_t selectV0 = 0;\r
847 if (fV0Filter) {\r
848 selectV0 = fV0Filter->IsSelected(&v0objects);\r
849 // this is a little awkward but otherwise the \r
850 // list wants to access the pointer (delete it) \r
851 // again when going out of scope\r
852 delete v0objects.RemoveAt(3); // esdVtx created via copy construct\r
853 esdVtx = 0;\r
854 if (!selectV0) \r
855 continue;\r
856 }\r
857 else{\r
858 delete v0objects.RemoveAt(3); // esdVtx created via copy construct\r
859 esdVtx = 0;\r
860 }\r
861 \r
862 v0->GetXYZ(pos[0], pos[1], pos[2]);\r
f7ed7e88 863 \r
c7ef1c47 864 if (!fOldESDformat) {\r
f7ed7e88 865 chi2 = v0->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3\r
866 v0->GetPosCov(covVtx);\r
c7ef1c47 867 } else {\r
f7ed7e88 868 chi2 = -999.;\r
869 for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;\r
c7ef1c47 870 }\r
871 \r
872 \r
873 AliAODVertex * vV0 = \r
874 new(Vertices()[fNumberOfVertices++]) AliAODVertex(pos,\r
875 covVtx,\r
876 chi2,\r
877 fPrimaryVertex,\r
878 nV0,\r
879 AliAODVertex::kV0);\r
880 fPrimaryVertex->AddDaughter(vV0);\r
881 \r
882 \r
883 // Add the positive tracks from the V0\r
884 \r
885\r
886 esdV0Pos->GetPxPyPz(momPos);\r
887 esdV0Pos->GetXYZ(pos);\r
888 esdV0Pos->GetCovarianceXYZPxPyPz(covTr);\r
889 esdV0Pos->GetESDpid(pid);\r
890 \r
891 const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
892\r
893 if (!fUsedTrack[posFromV0]) {\r
894 fUsedTrack[posFromV0] = kTRUE;\r
f7ed7e88 895 UInt_t selectInfo = 0;\r
9eeae5d5 896 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Pos);\r
c7ef1c47 897 if(fMChandler)fMChandler->SelectParticle(esdV0Pos->GetLabel());\r
898 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Pos->GetID(),\r
899 esdV0Pos->GetLabel(), \r
900 momPos, \r
901 kTRUE,\r
902 pos,\r
903 kFALSE,\r
904 covTr, \r
905 (Short_t)esdV0Pos->GetSign(),\r
906 esdV0Pos->GetITSClusterMap(), \r
907 pid,\r
908 vV0,\r
909 kTRUE, // check if this is right\r
910 vtx->UsesTrack(esdV0Pos->GetID()),\r
911 AliAODTrack::kSecondary,\r
912 selectInfo);\r
bcabd0e4 913 aodTrack->SetTPCFitMap(esdV0Pos->GetTPCFitMap());\r
f2f21b24 914 aodTrack->SetTPCClusterMap(esdV0Pos->GetTPCClusterMap());\r
915 aodTrack->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());\r
40a060e5 916 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));\r
3c01c166 917 aodTrack->SetTPCPointsF(esdV0Pos->GetTPCNclsF());\r
c7ef1c47 918 fAODTrackRefs->AddAt(aodTrack,posFromV0);\r
f7ed7e88 919 // if (fDebug > 0) printf("-------------------Bo: pos track from original pt %.3f \n",aodTrack->Pt());\r
c7ef1c47 920 if (esdV0Pos->GetSign() > 0) ++fNumberOfPositiveTracks;\r
f7ed7e88 921 aodTrack->ConvertAliPIDtoAODPID();\r
922 aodTrack->SetFlags(esdV0Pos->GetStatus());\r
1a3579a6 923 SetAODPID(esdV0Pos,aodTrack,detpid);\r
c7ef1c47 924 }\r
925 else {\r
926 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(posFromV0));\r
f7ed7e88 927 // if (fDebug > 0) printf("-------------------Bo pos track from refArray pt %.3f \n",aodTrack->Pt());\r
c7ef1c47 928 }\r
929 vV0->AddDaughter(aodTrack);\r
930 \r
931 // Add the negative tracks from the V0\r
932 \r
933 esdV0Neg->GetPxPyPz(momNeg);\r
934 esdV0Neg->GetXYZ(pos);\r
935 esdV0Neg->GetCovarianceXYZPxPyPz(covTr);\r
936 esdV0Neg->GetESDpid(pid);\r
937 \r
938 if (!fUsedTrack[negFromV0]) {\r
939 fUsedTrack[negFromV0] = kTRUE;\r
f7ed7e88 940 UInt_t selectInfo = 0;\r
9eeae5d5 941 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Neg);\r
c7ef1c47 942 if(fMChandler)fMChandler->SelectParticle(esdV0Neg->GetLabel());\r
943 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Neg->GetID(),\r
944 esdV0Neg->GetLabel(),\r
945 momNeg,\r
946 kTRUE,\r
947 pos,\r
948 kFALSE,\r
949 covTr, \r
950 (Short_t)esdV0Neg->GetSign(),\r
951 esdV0Neg->GetITSClusterMap(), \r
952 pid,\r
953 vV0,\r
954 kTRUE, // check if this is right\r
955 vtx->UsesTrack(esdV0Neg->GetID()),\r
956 AliAODTrack::kSecondary,\r
957 selectInfo);\r
bcabd0e4 958 aodTrack->SetTPCFitMap(esdV0Neg->GetTPCFitMap());\r
f2f21b24 959 aodTrack->SetTPCClusterMap(esdV0Neg->GetTPCClusterMap());\r
960 aodTrack->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());\r
40a060e5 961 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));\r
3c01c166 962 aodTrack->SetTPCPointsF(esdV0Neg->GetTPCNclsF());\r
f7ed7e88 963 \r
c7ef1c47 964 fAODTrackRefs->AddAt(aodTrack,negFromV0);\r
f7ed7e88 965 // if (fDebug > 0) printf("-------------------Bo: neg track from original pt %.3f \n",aodTrack->Pt());\r
c7ef1c47 966 if (esdV0Neg->GetSign() > 0) ++fNumberOfPositiveTracks;\r
f7ed7e88 967 aodTrack->ConvertAliPIDtoAODPID();\r
968 aodTrack->SetFlags(esdV0Neg->GetStatus());\r
1a3579a6 969 SetAODPID(esdV0Neg,aodTrack,detpid);\r
c7ef1c47 970 }\r
971 else {\r
972 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(negFromV0));\r
f7ed7e88 973 // if (fDebug > 0) printf("-------------------Bo neg track from refArray pt %.3f \n",aodTrack->Pt());\r
f7ed7e88 974 }\r
c7ef1c47 975 vV0->AddDaughter(aodTrack);\r
976 \r
977 \r
978 // Add the V0 the V0 array as well\r
979 \r
980 Double_t dcaV0Daughters = v0->GetDcaV0Daughters();\r
981 Double_t dcaV0ToPrimVertex = v0->GetD(esd.GetPrimaryVertex()->GetX(),\r
982 esd.GetPrimaryVertex()->GetY(),\r
983 esd.GetPrimaryVertex()->GetZ());\r
984 \r
985 v0->GetPPxPyPz(momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2]); \r
986 v0->GetNPxPyPz(momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2]); \r
987 \r
988 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg\r
989 dcaDaughterToPrimVertex[0] = TMath::Abs(esdV0Pos->GetD( esd.GetPrimaryVertex()->GetX(),\r
990 esd.GetPrimaryVertex()->GetY(),\r
991 esd.GetMagneticField()) );\r
992 dcaDaughterToPrimVertex[1] = TMath::Abs(esdV0Neg->GetD( esd.GetPrimaryVertex()->GetX(),\r
993 esd.GetPrimaryVertex()->GetY(),\r
994 esd.GetMagneticField()) );\r
f7ed7e88 995 \r
c7ef1c47 996 AliAODv0* aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0(vV0, \r
997 dcaV0Daughters,\r
998 dcaV0ToPrimVertex,\r
999 momPosAtV0vtx,\r
1000 momNegAtV0vtx,\r
1001 dcaDaughterToPrimVertex);\r
1002 \r
1003 // set the aod v0 on-the-fly status\r
1004 aodV0->SetOnFlyStatus(v0->GetOnFlyStatus());\r
1005 }//End of loop on V0s \r
f7ed7e88 1006 \r
c7ef1c47 1007 V0s().Expand(fNumberOfV0s); \r
1008}\r
f7ed7e88 1009\r
c7ef1c47 1010//______________________________________________________________________________\r
1011void AliAnalysisTaskESDfilter::ConvertTPCOnlyTracks(const AliESDEvent& esd)\r
1012{\r
1013 // Convert TPC only tracks\r
25a60d41 1014 // Here we have wo hybrid appraoch to remove fakes\r
1015 // ******* ITSTPC ********\r
1016 // Uses a cut on the ITS properties to select global tracks\r
67abcce9 1017 // which are than marked as HybdridITSTPC for the remainder \r
1018 // the TPC only tracks are flagged as HybridITSTPConly. \r
1019 // Note, in order not to get fakes back in the TPC cuts, one needs \r
25a60d41 1020 // two "ITS" cuts one tight (1) (to throw out fakes) and one lose (2) (to NOT flag the trakcs in the TPC only)\r
1021 // using cut number (3)\r
1022 // so fHybridFilterMask == (1)|(2) fTPCFilterMask = (3), Usercode needs to slect with mask = (1)|(3) and track->IsHybridITSTPC()\r
1023 // ******* TPC ********\r
1024 // Here, only TPC tracks are flagged that pass the tight ITS cuts and tracks that pass the TPC cuts and NOT the loose ITS cuts\r
1025 // the ITS cuts neeed to be added to the filter as extra cuts, since here the selections info is reset in the global and put to the TPC only track\r
1026\r
c7ef1c47 1027 AliCodeTimerAuto("",0);\r
1028 \r
1029 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks\r
1030 for(int it = 0;it < fNumberOfTracks;++it)\r
1031 {\r
1032 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));\r
1033 if(!tr)continue;\r
1034 UInt_t map = tr->GetFilterMap();\r
67abcce9 1035 if(map&fTPCConstrainedFilterMask){\r
c7ef1c47 1036 // we only reset the track select ionfo, no deletion...\r
67abcce9 1037 tr->SetFilterMap(map&~fTPCConstrainedFilterMask);\r
c7ef1c47 1038 }\r
67abcce9 1039 if(map&fHybridFilterMaskTPCCG){\r
25a60d41 1040 // this is one part of the hybrid tracks\r
1041 // the others not passing the selection will be TPC only selected below\r
041743e4 1042 tr->SetIsHybridTPCConstrainedGlobal(kTRUE);\r
25a60d41 1043 }\r
c7ef1c47 1044 }\r
1045 // Loop over the ESD trcks and pick out the tracks passing TPC only cuts\r
1046 \r
1047 \r
1048 const AliESDVertex *vtxSPD = esd.GetPrimaryVertexSPD();\r
1049 const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
1050\r
1051 Double_t pos[3] = { 0. }; \r
1052 Double_t covTr[21]={0.};\r
1053 Double_t pid[10]={0.}; \r
bcab9a54 1054\r
1055\r
c7ef1c47 1056 Double_t p[3] = { 0. };\r
4b6f9f24 1057\r
1058 Double_t pDCA[3] = { 0. }; // momentum at DCA\r
1059 Double_t rDCA[3] = { 0. }; // position at DCA\r
1060 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z\r
1061 Float_t cDCA[3] = {0.}; // covariance of impact parameters\r
1062\r
1063\r
c7ef1c47 1064 AliAODTrack* aodTrack(0x0);\r
ceb821c3 1065 // AliAODPid* detpid(0x0);\r
bcab9a54 1066\r
041743e4 1067 // account for change in pT after the constraint\r
1068 Float_t ptMax = 1E10;\r
1069 Float_t ptMin = 0;\r
1070 for(int i = 0;i<32;i++){\r
1071 if(fTPCConstrainedFilterMask&(1<<i)){\r
1072 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);\r
1073 Float_t tmp1= 0,tmp2 = 0;\r
1074 cuts->GetPtRange(tmp1,tmp2);\r
1075 if(tmp1>ptMin)ptMin=tmp1;\r
1076 if(tmp2<ptMax)ptMax=tmp2;\r
1077 }\r
1078 } \r
1079\r
c7ef1c47 1080 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
1081 {\r
1082 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy \r
1083 \r
1084 UInt_t selectInfo = 0;\r
25a60d41 1085 Bool_t isHybridITSTPC = false;\r
c7ef1c47 1086 //\r
1087 // Track selection\r
1088 if (fTrackFilter) {\r
1089 selectInfo = fTrackFilter->IsSelected(esdTrack);\r
1090 }\r
25a60d41 1091\r
67abcce9 1092 if(!(selectInfo&fHybridFilterMaskTPCCG)){\r
25a60d41 1093 // not already selected tracks, use second part of hybrid tracks\r
1094 isHybridITSTPC = true;\r
1095 // too save space one could only store these...\r
1096 }\r
1097\r
67abcce9 1098 selectInfo &= fTPCConstrainedFilterMask;\r
c7ef1c47 1099 if (!selectInfo)continue;\r
67abcce9 1100 if (fWriteHybridTPCCOnly&&!isHybridITSTPC)continue; // write only complementary tracks\r
c7ef1c47 1101 // create a tpc only tracl\r
1102 AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(&esd),esdTrack->GetID());\r
1103 if(!track) continue;\r
1104 \r
1105 if(track->Pt()>0.)\r
1106 {\r
1107 // only constrain tracks above threshold\r
1108 AliExternalTrackParam exParam;\r
1109 // take the B-field from the ESD, no 3D fieldMap available at this point\r
1110 Bool_t relate = false;\r
2fb345ad 1111 relate = track->RelateToVertexTPC(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);\r
c7ef1c47 1112 if(!relate){\r
1113 delete track;\r
1114 continue;\r
a7b1466d 1115 }\r
4b6f9f24 1116 // fetch the track parameters at the DCA (unconstraint)\r
1117 if(track->GetTPCInnerParam()){\r
1118 track->GetTPCInnerParam()->GetPxPyPz(pDCA);\r
1119 track->GetTPCInnerParam()->GetXYZ(rDCA);\r
1120 }\r
1121 // get the DCA to the vertex:\r
1122 track->GetImpactParametersTPC(dDCA,cDCA);\r
67abcce9 1123 // set the constrained parameters to the track\r
c7ef1c47 1124 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());\r
1125 }\r
1126 \r
1127 track->GetPxPyPz(p);\r
041743e4 1128\r
1129 Float_t pT = track->Pt();\r
1130 if(pT<ptMin||pT>ptMax){\r
1131 delete track;\r
1132 continue;\r
1133 }\r
1134\r
1135 // \r
1136\r
1137\r
c7ef1c47 1138 track->GetXYZ(pos);\r
1139 track->GetCovarianceXYZPxPyPz(covTr);\r
bcab9a54 1140 esdTrack->GetESDpid(pid);// original PID\r
041743e4 1141\r
c7ef1c47 1142 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
1143 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,\r
1144 track->GetLabel(),\r
1145 p,\r
1146 kTRUE,\r
1147 pos,\r
1148 kFALSE,\r
1149 covTr, \r
1150 (Short_t)track->GetSign(),\r
1151 track->GetITSClusterMap(), \r
1152 pid,\r
1153 fPrimaryVertex,\r
1154 kTRUE, // check if this is right\r
1155 vtx->UsesTrack(track->GetID()),\r
1156 AliAODTrack::kPrimary, \r
1157 selectInfo);\r
041743e4 1158 aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC); \r
bcabd0e4 1159 aodTrack->SetTPCFitMap(track->GetTPCFitMap());\r
c7ef1c47 1160 aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());\r
1161 aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());\r
041743e4 1162 aodTrack->SetIsTPCConstrained(kTRUE); \r
bcab9a54 1163 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack)); // original track\r
4b6f9f24 1164 // set the DCA values to the AOD track\r
1165 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);\r
1166 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);\r
1167 aodTrack->SetDCA(dDCA[0],dDCA[1]);\r
1168\r
c7ef1c47 1169 aodTrack->SetFlags(track->GetStatus());\r
3c01c166 1170 aodTrack->SetTPCPointsF(track->GetTPCNclsF());\r
1171\r
bcab9a54 1172 // do not duplicate PID information \r
1173 // aodTrack->ConvertAliPIDtoAODPID();\r
1174 // SetAODPID(esdTrack,aodTrack,detpid);\r
1175\r
c7ef1c47 1176 delete track;\r
1177 } // end of loop on tracks\r
1178 \r
1179}\r
1180\r
67abcce9 1181\r
1182void AliAnalysisTaskESDfilter::ConvertGlobalConstrainedTracks(const AliESDEvent& esd)\r
1183{\r
1184\r
1185 // Here we have the option to store the complement from global constraint information\r
1186 // to tracks passing tight cuts (1) in order not to get fakes back in, one needs \r
1187 // two sets of cuts one tight (1) (to throw out fakes) and one lose (2) (fakes/bad tracks would pass (2) but not (1))\r
1188 // using cut number (3) selects the tracks that complement (1) e.g. tracks witout ITS refit or cluster requirement\r
1189\r
1190\r
1191 AliCodeTimerAuto("",0);\r
1192 \r
1193 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks\r
1194 for(int it = 0;it < fNumberOfTracks;++it)\r
1195 {\r
1196 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));\r
1197 if(!tr)continue;\r
1198 UInt_t map = tr->GetFilterMap();\r
1199 if(map&fGlobalConstrainedFilterMask){\r
1200 // we only reset the track select info, no deletion...\r
1201 // mask reset mask in case track is already taken\r
1202 tr->SetFilterMap(map&~fGlobalConstrainedFilterMask);\r
1203 }\r
1204 if(map&fHybridFilterMaskGCG){\r
1205 // this is one part of the hybrid tracks\r
1206 // the others not passing the selection will be the ones selected below\r
041743e4 1207 tr->SetIsHybridGlobalConstrainedGlobal(kTRUE);\r
67abcce9 1208 }\r
1209 }\r
1210 // Loop over the ESD trcks and pick out the tracks passing the GlobalConstraint cuts\r
1211 \r
1212\r
1213 Double_t pos[3] = { 0. }; \r
1214 Double_t covTr[21]={0.};\r
1215 Double_t pid[10]={0.}; \r
1216 Double_t p[3] = { 0. };\r
1217\r
1218 Double_t pDCA[3] = { 0. }; // momentum at DCA\r
1219 Double_t rDCA[3] = { 0. }; // position at DCA\r
1220 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z\r
1221 Float_t cDCA[3] = {0.}; // covariance of impact parameters\r
1222\r
1223\r
1224 AliAODTrack* aodTrack(0x0);\r
bcab9a54 1225 AliAODPid* detpid(0x0);\r
67abcce9 1226 const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
041743e4 1227\r
1228 // account for change in pT after the constraint\r
1229 Float_t ptMax = 1E10;\r
1230 Float_t ptMin = 0;\r
1231 for(int i = 0;i<32;i++){\r
1232 if(fGlobalConstrainedFilterMask&(1<<i)){\r
1233 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);\r
1234 Float_t tmp1= 0,tmp2 = 0;\r
1235 cuts->GetPtRange(tmp1,tmp2);\r
1236 if(tmp1>ptMin)ptMin=tmp1;\r
1237 if(tmp2<ptMax)ptMax=tmp2;\r
1238 }\r
1239 } \r
1240\r
1241\r
1242\r
1243 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
67abcce9 1244 {\r
1245 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy \r
1246 const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam();\r
1247 if(!exParamGC)continue;\r
1248\r
1249 UInt_t selectInfo = 0;\r
1250 Bool_t isHybridGC = false;\r
1251\r
1252 //\r
1253 // Track selection\r
1254 if (fTrackFilter) {\r
1255 selectInfo = fTrackFilter->IsSelected(esdTrack);\r
1256 }\r
1257\r
1258\r
1259 if(!(selectInfo&fHybridFilterMaskGCG))isHybridGC = true;\r
1260 if (fWriteHybridGCOnly&&!isHybridGC)continue; // write only complementary tracks\r
1261\r
1262 selectInfo &= fGlobalConstrainedFilterMask;\r
1263 if (!selectInfo)continue;\r
1264 // fetch the track parameters at the DCA (unconstrained)\r
1265 esdTrack->GetPxPyPz(pDCA);\r
1266 esdTrack->GetXYZ(rDCA);\r
1267 // get the DCA to the vertex:\r
1268 esdTrack->GetImpactParameters(dDCA,cDCA);\r
1269\r
f7317b61 1270 if (!esdTrack->GetConstrainedPxPyPz(p)) continue;\r
041743e4 1271\r
1272\r
1273 Float_t pT = exParamGC->Pt();\r
1274 if(pT<ptMin||pT>ptMax){\r
1275 continue;\r
1276 }\r
1277\r
1278\r
67abcce9 1279 esdTrack->GetConstrainedXYZ(pos);\r
1280 exParamGC->GetCovarianceXYZPxPyPz(covTr);\r
1281 esdTrack->GetESDpid(pid);\r
1282 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
1283 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((esdTrack->GetID()+1)*-1,\r
1284 esdTrack->GetLabel(),\r
1285 p,\r
1286 kTRUE,\r
1287 pos,\r
1288 kFALSE,\r
1289 covTr, \r
1290 (Short_t)esdTrack->GetSign(),\r
1291 esdTrack->GetITSClusterMap(), \r
1292 pid,\r
1293 fPrimaryVertex,\r
1294 kTRUE, // check if this is right\r
1295 vtx->UsesTrack(esdTrack->GetID()),\r
1296 AliAODTrack::kPrimary, \r
1297 selectInfo);\r
041743e4 1298 aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC); \r
1299 aodTrack->SetIsGlobalConstrained(kTRUE); \r
bcabd0e4 1300 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());\r
67abcce9 1301 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());\r
1302 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());\r
bcab9a54 1303 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));\r
1304\r
67abcce9 1305\r
1306 // set the DCA values to the AOD track\r
1307 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);\r
1308 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);\r
1309 aodTrack->SetDCA(dDCA[0],dDCA[1]);\r
1310\r
1311 aodTrack->SetFlags(esdTrack->GetStatus());\r
1312 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());\r
bcab9a54 1313\r
1314 if(isHybridGC){\r
1315 // only copy AOD information for hybrid, no duplicate information\r
1316 aodTrack->ConvertAliPIDtoAODPID();\r
1317 SetAODPID(esdTrack,aodTrack,detpid);\r
1318 }\r
67abcce9 1319 } // end of loop on tracks\r
1320 \r
1321}\r
1322\r
1323\r
c7ef1c47 1324//______________________________________________________________________________\r
1325void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)\r
1326{\r
1327 // Tracks (primary and orphan)\r
1328\r
1329 AliCodeTimerAuto("",0);\r
1330 \r
1331 AliDebug(1,Form("NUMBER OF ESD TRACKS %5d\n", esd.GetNumberOfTracks()));\r
1332 \r
1333 const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
1334 Double_t p[3] = { 0. };\r
1335 Double_t pos[3] = { 0. };\r
1336 Double_t covTr[21] = { 0. };\r
1337 Double_t pid[10] = { 0. };\r
1338 AliAODTrack* aodTrack(0x0);\r
1339 AliAODPid* detpid(0x0);\r
1340 \r
1341 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack) \r
1342 {\r
1343 if (fUsedTrack[nTrack]) continue;\r
1344 \r
1345 AliESDtrack *esdTrack = esd.GetTrack(nTrack);\r
1346 UInt_t selectInfo = 0;\r
1347 //\r
1348 // Track selection\r
1349 if (fTrackFilter) {\r
9eeae5d5 1350 selectInfo = fTrackFilter->IsSelected(esdTrack);\r
f7ed7e88 1351 if (!selectInfo && !vtx->UsesTrack(esdTrack->GetID())) continue;\r
f7ed7e88 1352 }\r
c7ef1c47 1353 \r
1354 \r
1355 esdTrack->GetPxPyPz(p);\r
1356 esdTrack->GetXYZ(pos);\r
1357 esdTrack->GetCovarianceXYZPxPyPz(covTr);\r
1358 esdTrack->GetESDpid(pid);\r
1359 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());\r
1360 fPrimaryVertex->AddDaughter(aodTrack =\r
1361 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrack->GetID(),\r
1362 esdTrack->GetLabel(),\r
1363 p,\r
1364 kTRUE,\r
1365 pos,\r
1366 kFALSE,\r
1367 covTr, \r
1368 (Short_t)esdTrack->GetSign(),\r
1369 esdTrack->GetITSClusterMap(), \r
1370 pid,\r
1371 fPrimaryVertex,\r
1372 kTRUE, // check if this is right\r
1373 vtx->UsesTrack(esdTrack->GetID()),\r
1374 AliAODTrack::kPrimary, \r
1375 selectInfo)\r
1376 );\r
bcabd0e4 1377 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());\r
c7ef1c47 1378 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());\r
1379 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());\r
1380 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));\r
3c01c166 1381 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());\r
a7d9ab9e 1382 if(esdTrack->IsEMCAL()) aodTrack->SetEMCALcluster(esdTrack->GetEMCALcluster());\r
1383 if(esdTrack->IsPHOS()) aodTrack->SetPHOScluster(esdTrack->GetPHOScluster());\r
3c01c166 1384\r
c7ef1c47 1385 fAODTrackRefs->AddAt(aodTrack, nTrack);\r
1386 \r
1387 \r
1388 if (esdTrack->GetSign() > 0) ++fNumberOfPositiveTracks;\r
1389 aodTrack->SetFlags(esdTrack->GetStatus());\r
1390 aodTrack->ConvertAliPIDtoAODPID();\r
1a3579a6 1391 SetAODPID(esdTrack,aodTrack,detpid);\r
c7ef1c47 1392 } // end of loop on tracks\r
1393}\r
f7ed7e88 1394\r
c7ef1c47 1395//______________________________________________________________________________\r
1396void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)\r
1397{\r
5204c278 1398// Convert PMD Clusters \r
c7ef1c47 1399 AliCodeTimerAuto("",0);\r
1400 Int_t jPmdClusters=0;\r
1401 // Access to the AOD container of PMD clusters\r
1402 TClonesArray &pmdClusters = *(AODEvent()->GetPmdClusters());\r
1403 for (Int_t iPmd = 0; iPmd < esd.GetNumberOfPmdTracks(); ++iPmd) {\r
1404 // file pmd clusters, to be revised!\r
1405 AliESDPmdTrack *pmdTrack = esd.GetPmdTrack(iPmd);\r
1406 Int_t nLabel = 0;\r
1407 Int_t *label = 0x0;\r
1408 Double_t posPmd[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ()};\r
1409 Double_t pidPmd[13] = { 0.}; // to be revised!\r
1410 // type not set!\r
1411 // assoc cluster not set\r
1412 new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), posPmd, pidPmd);\r
1413 }\r
1414}\r
f7ed7e88 1415\r
c7ef1c47 1416//______________________________________________________________________________\r
1417void AliAnalysisTaskESDfilter::ConvertCaloClusters(const AliESDEvent& esd)\r
1418{\r
5204c278 1419// Convert Calorimeter Clusters\r
c7ef1c47 1420 AliCodeTimerAuto("",0);\r
1421 \r
1422 // Access to the AOD container of clusters\r
1423 TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());\r
1424 Int_t jClusters(0);\r
1425 \r
1426 for (Int_t iClust=0; iClust<esd.GetNumberOfCaloClusters(); ++iClust) {\r
1427 \r
1428 AliESDCaloCluster * cluster = esd.GetCaloCluster(iClust);\r
1429 \r
1430 Int_t id = cluster->GetID();\r
1431 Int_t nLabel = cluster->GetNLabels();\r
1432 Int_t *labels = cluster->GetLabels();\r
1433 if(labels){ \r
c8fe2783 1434 for(int i = 0;i < nLabel;++i){\r
c7ef1c47 1435 if(fMChandler)fMChandler->SelectParticle(labels[i]);\r
c8fe2783 1436 }\r
1437 } \r
c7ef1c47 1438 \r
1439 Float_t energy = cluster->E();\r
1440 Float_t posF[3] = { 0.};\r
1441 cluster->GetPosition(posF);\r
1442 \r
1443 AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,\r
1444 nLabel,\r
1445 labels,\r
1446 energy,\r
1447 posF,\r
1448 NULL,\r
1449 cluster->GetType(),0);\r
1450 \r
1451 caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),\r
1452 cluster->GetDispersion(),\r
1453 cluster->GetM20(), cluster->GetM02(),\r
1454 cluster->GetEmcCpvDistance(), \r
1455 cluster->GetNExMax(),cluster->GetTOF()) ;\r
1456 \r
1457 caloCluster->SetPIDFromESD(cluster->GetPID());\r
1458 caloCluster->SetNCells(cluster->GetNCells());\r
1459 caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());\r
1460 caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());\r
da4870e8 1461\r
1462 caloCluster->SetTrackDistance(cluster->GetTrackDx(), cluster->GetTrackDz());\r
c7ef1c47 1463 \r
1464 TArrayI* matchedT = cluster->GetTracksMatched();\r
1465 if (fNumberOfTracks>0 && matchedT && cluster->GetTrackMatchedIndex() >= 0) { \r
1466 for (Int_t im = 0; im < matchedT->GetSize(); im++) {\r
1467 Int_t iESDtrack = matchedT->At(im);;\r
1468 if (fAODTrackRefs->At(iESDtrack) != 0) {\r
1469 caloCluster->AddTrackMatched((AliAODTrack*)fAODTrackRefs->At(iESDtrack));\r
1470 }\r
1471 }\r
1472 }\r
1473 \r
1474 } \r
1475 caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters \r
1476}\r
f7ed7e88 1477\r
720f7306 1478//______________________________________________________________________________\r
1479void AliAnalysisTaskESDfilter::ConvertCaloTrigger(TString calo, const AliESDEvent& esd)\r
1480{\r
1481 AliCodeTimerAuto("",0);\r
1482 \r
1483 if (calo == "PHOS") \r
1484 {\r
6929fd98 1485 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));\r
1486 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));\r
1487\r
1488 aodTrigger.Allocate(esdTrigger.GetEntries());\r
1489 esdTrigger.Reset();\r
1490\r
1491 Float_t a;\r
1492 Int_t tmod,tabsId;\r
1493\r
1494 while (esdTrigger.Next()) {\r
1495 esdTrigger.GetPosition(tmod,tabsId);\r
1496 esdTrigger.GetAmplitude(a);\r
1497 aodTrigger.Add(tmod,tabsId,a,0.,(Int_t*)NULL,0,0,0);\r
1498 }\r
1499\r
1500 return;\r
720f7306 1501 }\r
1502 \r
1503 AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()); \r
1504 \r
1505 if (aodHandler)\r
1506 {\r
1507 TTree *aodTree = aodHandler->GetTree();\r
1508 \r
1509 if (aodTree)\r
1510 {\r
1511 Int_t *type = esd.GetCaloTriggerType();\r
1512 \r
1513 for (Int_t i = 0; i < 8; i++) \r
1514 {\r
1515 aodTree->GetUserInfo()->Add(new TParameter<int>(Form("EMCALCaloTrigger%d",i), type[i]));\r
1516 }\r
1517 }\r
1518 }\r
1519 \r
1520 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));\r
1521 \r
1522 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));\r
1523 \r
1524 aodTrigger.Allocate(esdTrigger.GetEntries());\r
1525 \r
1526 esdTrigger.Reset();\r
1527 while (esdTrigger.Next())\r
1528 { \r
1529 Int_t px, py, ts, nTimes, times[10], b; \r
1530 Float_t a, t;\r
1531 \r
1532 esdTrigger.GetPosition(px, py);\r
1533 \r
1534 esdTrigger.GetAmplitude(a);\r
1535 esdTrigger.GetTime(t);\r
1536 \r
1537 esdTrigger.GetL0Times(times);\r
1538 esdTrigger.GetNL0Times(nTimes);\r
1539 \r
1540 esdTrigger.GetL1TimeSum(ts);\r
1541 \r
1542 esdTrigger.GetTriggerBits(b);\r
1543 \r
1544 aodTrigger.Add(px, py, a, t, times, nTimes, ts, b);\r
1545 }\r
1546 \r
1547 aodTrigger.SetL1Threshold(0, esdTrigger.GetL1Threshold(0));\r
1548 aodTrigger.SetL1Threshold(1, esdTrigger.GetL1Threshold(1));\r
1549 \r
1550 Int_t v0[2] = \r
1551 {\r
1552 esdTrigger.GetL1V0(0),\r
1553 esdTrigger.GetL1V0(1)\r
1554 }; \r
1555 \r
1556 aodTrigger.SetL1V0(v0); \r
1557 aodTrigger.SetL1FrameMask(esdTrigger.GetL1FrameMask());\r
1558}\r
1559\r
c7ef1c47 1560//______________________________________________________________________________\r
1561void AliAnalysisTaskESDfilter::ConvertEMCALCells(const AliESDEvent& esd)\r
1562{\r
5204c278 1563// Convert EMCAL Cells\r
c7ef1c47 1564 AliCodeTimerAuto("",0);\r
1565 // fill EMCAL cell info\r
1566 if (esd.GetEMCALCells()) { // protection against missing ESD information\r
1567 AliESDCaloCells &esdEMcells = *(esd.GetEMCALCells());\r
1568 Int_t nEMcell = esdEMcells.GetNumberOfCells() ;\r
1569 \r
1570 AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());\r
1571 aodEMcells.CreateContainer(nEMcell);\r
1572 aodEMcells.SetType(AliAODCaloCells::kEMCALCell);\r
1573 for (Int_t iCell = 0; iCell < nEMcell; iCell++) { \r
1574 aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));\r
1575 }\r
1576 aodEMcells.Sort();\r
1577 }\r
1578}\r
f7ed7e88 1579\r
c7ef1c47 1580//______________________________________________________________________________\r
1581void AliAnalysisTaskESDfilter::ConvertPHOSCells(const AliESDEvent& esd)\r
1582{\r
5204c278 1583// Convert PHOS Cells\r
c7ef1c47 1584 AliCodeTimerAuto("",0);\r
1585 // fill PHOS cell info\r
1586 if (esd.GetPHOSCells()) { // protection against missing ESD information\r
1587 AliESDCaloCells &esdPHcells = *(esd.GetPHOSCells());\r
1588 Int_t nPHcell = esdPHcells.GetNumberOfCells() ;\r
1589 \r
1590 AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());\r
1591 aodPHcells.CreateContainer(nPHcell);\r
1592 aodPHcells.SetType(AliAODCaloCells::kPHOSCell);\r
1593 for (Int_t iCell = 0; iCell < nPHcell; iCell++) { \r
1594 aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));\r
f7ed7e88 1595 }\r
c7ef1c47 1596 aodPHcells.Sort();\r
1597 }\r
1598}\r
f7ed7e88 1599\r
c7ef1c47 1600//______________________________________________________________________________\r
1601void AliAnalysisTaskESDfilter::ConvertTracklets(const AliESDEvent& esd)\r
1602{\r
1603 // tracklets \r
1604 AliCodeTimerAuto("",0);\r
1605\r
1606 AliAODTracklets &SPDTracklets = *(AODEvent()->GetTracklets());\r
1607 const AliMultiplicity *mult = esd.GetMultiplicity();\r
1608 if (mult) {\r
1609 if (mult->GetNumberOfTracklets()>0) {\r
1610 SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());\r
f7ed7e88 1611 \r
c7ef1c47 1612 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {\r
1613 if(fMChandler){\r
1614 fMChandler->SelectParticle(mult->GetLabel(n, 0));\r
1615 fMChandler->SelectParticle(mult->GetLabel(n, 1));\r
1616 }\r
1617 SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));\r
f7ed7e88 1618 }\r
f7ed7e88 1619 }\r
c7ef1c47 1620 } else {\r
1621 //Printf("ERROR: AliMultiplicity could not be retrieved from ESD");\r
1622 }\r
1623}\r
f7ed7e88 1624\r
c7ef1c47 1625//______________________________________________________________________________\r
1626void AliAnalysisTaskESDfilter::ConvertKinks(const AliESDEvent& esd)\r
1627{\r
1628 AliCodeTimerAuto("",0);\r
1629 \r
1630 // Kinks: it is a big mess the access to the information in the kinks\r
1631 // The loop is on the tracks in order to find the mother and daugther of each kink\r
1632 \r
1633 Double_t covTr[21]={0.};\r
1634 Double_t pid[10]={0.};\r
1635 AliAODPid* detpid(0x0);\r
1636 \r
1637 fNumberOfKinks = esd.GetNumberOfKinks();\r
1638\r
1639 const AliESDVertex* vtx = esd.GetPrimaryVertex();\r
1640 \r
1641 for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack) \r
1642 {\r
1643 AliESDtrack * esdTrack = esd.GetTrack(iTrack);\r
1644 \r
1645 Int_t ikink = esdTrack->GetKinkIndex(0);\r
1646 \r
1647 if (ikink && fNumberOfKinks) {\r
1648 // Negative kink index: mother, positive: daughter\r
1649 \r
1650 // Search for the second track of the kink\r
1651 \r
1652 for (Int_t jTrack = iTrack+1; jTrack<esd.GetNumberOfTracks(); ++jTrack) {\r
1653 \r
1654 AliESDtrack * esdTrack1 = esd.GetTrack(jTrack);\r
1655 \r
1656 Int_t jkink = esdTrack1->GetKinkIndex(0);\r
1657 \r
1658 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {\r
1659 \r
1660 // The two tracks are from the same kink\r
1661 \r
1662 if (fUsedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks\r
1663 \r
1664 Int_t imother = -1;\r
1665 Int_t idaughter = -1;\r
1666 \r
1667 if (ikink<0 && jkink>0) {\r
1668 \r
1669 imother = iTrack;\r
1670 idaughter = jTrack;\r
1671 }\r
1672 else if (ikink>0 && jkink<0) {\r
1673 \r
1674 imother = jTrack;\r
1675 idaughter = iTrack;\r
1676 }\r
1677 else {\r
1678 // cerr << "Error: Wrong combination of kink indexes: "\r
1679 // << ikink << " " << jkink << endl;\r
1680 continue;\r
1681 }\r
1682 \r
1683 // Add the mother track if it passed primary track selection cuts\r
1684 \r
1685 AliAODTrack * mother = NULL;\r
1686 \r
1687 UInt_t selectInfo = 0;\r
1688 if (fTrackFilter) {\r
1689 selectInfo = fTrackFilter->IsSelected(esd.GetTrack(imother));\r
1690 if (!selectInfo) continue;\r
1691 }\r
1692 \r
1693 if (!fUsedTrack[imother]) {\r
1694 \r
1695 fUsedTrack[imother] = kTRUE;\r
1696 \r
1697 AliESDtrack *esdTrackM = esd.GetTrack(imother);\r
1698 Double_t p[3] = { 0. };\r
1699 Double_t pos[3] = { 0. };\r
1700 esdTrackM->GetPxPyPz(p);\r
1701 esdTrackM->GetXYZ(pos);\r
1702 esdTrackM->GetCovarianceXYZPxPyPz(covTr);\r
1703 esdTrackM->GetESDpid(pid);\r
1704 if(fMChandler)fMChandler->SelectParticle(esdTrackM->GetLabel());\r
1705 mother = \r
1706 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackM->GetID(),\r
1707 esdTrackM->GetLabel(),\r
1708 p,\r
1709 kTRUE,\r
1710 pos,\r
1711 kFALSE,\r
1712 covTr, \r
1713 (Short_t)esdTrackM->GetSign(),\r
1714 esdTrackM->GetITSClusterMap(), \r
1715 pid,\r
1716 fPrimaryVertex,\r
1717 kTRUE, // check if this is right\r
1718 vtx->UsesTrack(esdTrack->GetID()),\r
1719 AliAODTrack::kPrimary,\r
1720 selectInfo);\r
bcabd0e4 1721 mother->SetTPCFitMap(esdTrackM->GetTPCFitMap());\r
c7ef1c47 1722 mother->SetTPCClusterMap(esdTrackM->GetTPCClusterMap());\r
1723 mother->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());\r
1724 mother->SetChi2perNDF(Chi2perNDF(esdTrackM));\r
3c01c166 1725 mother->SetTPCPointsF(esdTrackM->GetTPCNclsF());\r
1726\r
c7ef1c47 1727 fAODTrackRefs->AddAt(mother, imother);\r
1728 \r
1729 if (esdTrackM->GetSign() > 0) ++fNumberOfPositiveTracks;\r
1730 mother->SetFlags(esdTrackM->GetStatus());\r
1731 mother->ConvertAliPIDtoAODPID();\r
1732 fPrimaryVertex->AddDaughter(mother);\r
1733 mother->ConvertAliPIDtoAODPID();\r
1a3579a6 1734 SetAODPID(esdTrackM,mother,detpid);\r
c7ef1c47 1735 }\r
1736 else {\r
1737 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1\r
1738 // << " track " << imother << " has already been used!" << endl;\r
1739 }\r
1740 \r
1741 // Add the kink vertex\r
1742 AliESDkink * kink = esd.GetKink(TMath::Abs(ikink)-1);\r
1743 \r
1744 AliAODVertex * vkink = \r
1745 new(Vertices()[fNumberOfVertices++]) AliAODVertex(kink->GetPosition(),\r
1746 NULL,\r
1747 0.,\r
1748 mother,\r
1749 esdTrack->GetID(), // This is the track ID of the mother's track!\r
1750 AliAODVertex::kKink);\r
1751 // Add the daughter track\r
1752 \r
1753 AliAODTrack * daughter = NULL;\r
1754 \r
1755 if (!fUsedTrack[idaughter]) {\r
1756 \r
1757 fUsedTrack[idaughter] = kTRUE;\r
1758 \r
1759 AliESDtrack *esdTrackD = esd.GetTrack(idaughter);\r
1760 Double_t p[3] = { 0. };\r
1761 Double_t pos[3] = { 0. };\r
1762\r
1763 esdTrackD->GetPxPyPz(p);\r
1764 esdTrackD->GetXYZ(pos);\r
1765 esdTrackD->GetCovarianceXYZPxPyPz(covTr);\r
1766 esdTrackD->GetESDpid(pid);\r
1767 selectInfo = 0;\r
1768 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdTrackD);\r
1769 if(fMChandler)fMChandler->SelectParticle(esdTrackD->GetLabel());\r
1770 daughter = \r
1771 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackD->GetID(),\r
1772 esdTrackD->GetLabel(),\r
1773 p,\r
1774 kTRUE,\r
1775 pos,\r
1776 kFALSE,\r
1777 covTr, \r
1778 (Short_t)esdTrackD->GetSign(),\r
1779 esdTrackD->GetITSClusterMap(), \r
1780 pid,\r
1781 vkink,\r
1782 kTRUE, // check if this is right\r
1783 vtx->UsesTrack(esdTrack->GetID()),\r
1784 AliAODTrack::kSecondary,\r
1785 selectInfo);\r
bcabd0e4 1786 daughter->SetTPCFitMap(esdTrackD->GetTPCFitMap());\r
c7ef1c47 1787 daughter->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());\r
1788 daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());\r
3c01c166 1789 daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());\r
c7ef1c47 1790 fAODTrackRefs->AddAt(daughter, idaughter);\r
1791 \r
1792 if (esdTrackD->GetSign() > 0) ++fNumberOfPositiveTracks;\r
1793 daughter->SetFlags(esdTrackD->GetStatus());\r
1794 daughter->ConvertAliPIDtoAODPID();\r
1795 vkink->AddDaughter(daughter);\r
1796 daughter->ConvertAliPIDtoAODPID();\r
1a3579a6 1797 SetAODPID(esdTrackD,daughter,detpid);\r
c7ef1c47 1798 }\r
1799 else {\r
1800 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1\r
1801 // << " track " << idaughter << " has already been used!" << endl;\r
1802 }\r
1803 }\r
1804 }\r
1805 } \r
1806 }\r
1807}\r
1808\r
1809//______________________________________________________________________________\r
1810void AliAnalysisTaskESDfilter::ConvertPrimaryVertices(const AliESDEvent& esd)\r
1811{\r
1812 AliCodeTimerAuto("",0);\r
1813 \r
1814 // Access to the AOD container of vertices\r
1815 fNumberOfVertices = 0;\r
1816 \r
1817 Double_t pos[3] = { 0. };\r
1818 Double_t covVtx[6] = { 0. };\r
f7ed7e88 1819\r
c7ef1c47 1820 // Add primary vertex. The primary tracks will be defined\r
1821 // after the loops on the composite objects (V0, cascades, kinks)\r
1822 const AliESDVertex *vtx = esd.GetPrimaryVertex();\r
1823 \r
1824 vtx->GetXYZ(pos); // position\r
1825 vtx->GetCovMatrix(covVtx); //covariance matrix\r
1826 \r
1827 fPrimaryVertex = new(Vertices()[fNumberOfVertices++])\r
1828 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);\r
1829 fPrimaryVertex->SetName(vtx->GetName());\r
1830 fPrimaryVertex->SetTitle(vtx->GetTitle());\r
1831 \r
1832 TString vtitle = vtx->GetTitle();\r
1833 if (!vtitle.Contains("VertexerTracks")) \r
1834 fPrimaryVertex->SetNContributors(vtx->GetNContributors());\r
1835 \r
1836 if (fDebug > 0) fPrimaryVertex->Print(); \r
1837 \r
1838 // Add SPD "main" vertex \r
1839 const AliESDVertex *vtxS = esd.GetPrimaryVertexSPD();\r
1840 vtxS->GetXYZ(pos); // position\r
1841 vtxS->GetCovMatrix(covVtx); //covariance matrix\r
1842 AliAODVertex * mVSPD = new(Vertices()[fNumberOfVertices++])\r
1843 AliAODVertex(pos, covVtx, vtxS->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainSPD);\r
1844 mVSPD->SetName(vtxS->GetName());\r
1845 mVSPD->SetTitle(vtxS->GetTitle());\r
1846 mVSPD->SetNContributors(vtxS->GetNContributors()); \r
1847 \r
1848 // Add SPD pileup vertices\r
1849 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesSPD(); ++iV)\r
1850 {\r
1851 const AliESDVertex *vtxP = esd.GetPileupVertexSPD(iV);\r
1852 vtxP->GetXYZ(pos); // position\r
1853 vtxP->GetCovMatrix(covVtx); //covariance matrix\r
1854 AliAODVertex * pVSPD = new(Vertices()[fNumberOfVertices++])\r
1855 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupSPD);\r
1856 pVSPD->SetName(vtxP->GetName());\r
1857 pVSPD->SetTitle(vtxP->GetTitle());\r
1858 pVSPD->SetNContributors(vtxP->GetNContributors()); \r
0249e9b8 1859 pVSPD->SetBC(vtxP->GetBC());\r
c7ef1c47 1860 }\r
1861 \r
1862 // Add TRK pileup vertices\r
1863 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesTracks(); ++iV)\r
1864 {\r
1865 const AliESDVertex *vtxP = esd.GetPileupVertexTracks(iV);\r
1866 vtxP->GetXYZ(pos); // position\r
1867 vtxP->GetCovMatrix(covVtx); //covariance matrix\r
1868 AliAODVertex * pVTRK = new(Vertices()[fNumberOfVertices++])\r
1869 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupTracks);\r
1870 pVTRK->SetName(vtxP->GetName());\r
1871 pVTRK->SetTitle(vtxP->GetTitle());\r
1872 pVTRK->SetNContributors(vtxP->GetNContributors());\r
0249e9b8 1873 pVTRK->SetBC(vtxP->GetBC());\r
c7ef1c47 1874 }\r
f7ed7e88 1875}\r
1876\r
c7ef1c47 1877//______________________________________________________________________________\r
1878void AliAnalysisTaskESDfilter::ConvertVZERO(const AliESDEvent& esd)\r
1879{\r
1880 // Convert VZERO data\r
1881 AliAODVZERO* vzeroData = AODEvent()->GetVZEROData();\r
1882 *vzeroData = *(esd.GetVZEROData());\r
1883}\r
f7ed7e88 1884\r
a1f96974 1885//______________________________________________________________________________\r
1886void AliAnalysisTaskESDfilter::ConvertTZERO(const AliESDEvent& esd)\r
1887{\r
1888 // Convert TZERO data\r
1889 const AliESDTZERO* esdTzero = esd.GetESDTZERO(); \r
1890 AliAODTZERO* aodTzero = AODEvent()->GetTZEROData();\r
1891\r
1892 for (Int_t icase=0; icase<3; icase++){ \r
1893 aodTzero->SetT0TOF( icase, esdTzero->GetT0TOF(icase));\r
1894 aodTzero->SetT0TOFbest(icase, esdTzero->GetT0TOFbest(icase)); \r
1895 }\r
1896 aodTzero->SetBackgroundFlag(esdTzero->GetBackgroundFlag());\r
1897 aodTzero->SetPileupFlag(esdTzero->GetPileupFlag());\r
1898 aodTzero->SetSatelliteFlag(esdTzero->GetSatellite()); \r
1899\r
c78a7768 1900 Float_t rawTime[24];\r
1901 for(Int_t ipmt=0; ipmt<24; ipmt++)\r
1902 rawTime[ipmt] = esdTzero->GetTimeFull(ipmt,0);\r
1903 \r
1904 Int_t idxOfFirstPmtA = -1, idxOfFirstPmtC = -1;\r
1905 Float_t timeOfFirstPmtA = 9999, timeOfFirstPmtC = 9999;\r
1906 for(int ipmt=0; ipmt<12; ipmt++){\r
1907 if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtC && rawTime[ipmt]!=0){\r
1908 timeOfFirstPmtC = rawTime[ipmt];\r
1909 idxOfFirstPmtC = ipmt;\r
1910 }\r
1911 }\r
1912 for(int ipmt=12; ipmt<24; ipmt++){\r
1913 if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtA && rawTime[ipmt]!=0 ){\r
1914 timeOfFirstPmtA = rawTime[ipmt];\r
1915 idxOfFirstPmtA = ipmt;\r
1916 }\r
1917 }\r
1918\r
1919 if(idxOfFirstPmtA != -1 && idxOfFirstPmtC != -1){\r
1920 //speed of light in cm/ns TMath::C()*1e-7 \r
1921 Float_t vertexraw = TMath::C()*1e-7 * (rawTime[idxOfFirstPmtA] - rawTime[idxOfFirstPmtC])/2;\r
1922 aodTzero->SetT0VertexRaw( vertexraw );\r
1923 }else{\r
1924 aodTzero->SetT0VertexRaw(99999);\r
1925 }\r
1926\r
a1f96974 1927}\r
1928\r
1929\r
8c87d22c 1930//______________________________________________________________________________\r
1931void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)\r
1932{\r
1933 // Convert ZDC data\r
1934 AliESDZDC* esdZDC = esd.GetZDCData();\r
1935 \r
1936 const Double_t zem1Energy = esdZDC->GetZEM1Energy();\r
1937 const Double_t zem2Energy = esdZDC->GetZEM2Energy();\r
1938 \r
1939 const Double_t *towZNC = esdZDC->GetZNCTowerEnergy();\r
1940 const Double_t *towZPC = esdZDC->GetZPCTowerEnergy();\r
1941 const Double_t *towZNA = esdZDC->GetZNATowerEnergy();\r
1942 const Double_t *towZPA = esdZDC->GetZPATowerEnergy();\r
1943 const Double_t *towZNCLG = esdZDC->GetZNCTowerEnergyLR();\r
1944 const Double_t *towZNALG = esdZDC->GetZNATowerEnergyLR();\r
1945 \r
1946 AliAODZDC* zdcAOD = AODEvent()->GetZDCData();\r
1947\r
1948 zdcAOD->SetZEM1Energy(zem1Energy);\r
1949 zdcAOD->SetZEM2Energy(zem2Energy);\r
1950 zdcAOD->SetZNCTowers(towZNC, towZNCLG);\r
1951 zdcAOD->SetZNATowers(towZNA, towZNALG);\r
1952 zdcAOD->SetZPCTowers(towZPC);\r
1953 zdcAOD->SetZPATowers(towZPA);\r
1954 \r
1955 zdcAOD->SetZDCParticipants(esdZDC->GetZDCParticipants(), esdZDC->GetZDCPartSideA(), esdZDC->GetZDCPartSideC());\r
1956 zdcAOD->SetZDCImpactParameter(esdZDC->GetImpactParameter(), esdZDC->GetImpactParamSideA(), \r
1957 esdZDC->GetImpactParamSideC());\r
1958 zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0)); \r
1959 zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0)); \r
1960\r
1961}\r
1962\r
c7ef1c47 1963//______________________________________________________________________________\r
1964void AliAnalysisTaskESDfilter::ConvertESDtoAOD() \r
1965{\r
1966 // ESD Filter analysis task executed for each event\r
1967 \r
1968 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());\r
1969 \r
1970 if(!esd)return;\r
1971\r
1972 AliCodeTimerAuto("",0);\r
1973 \r
1974 fOldESDformat = ( esd->GetAliESDOld() != 0x0 );\r
b8d29a28 1975 \r
1976 // Reconstruct cascades and V0 here\r
1977 if (fIsV0CascadeRecoEnabled) {\r
1978 esd->ResetCascades();\r
1979 esd->ResetV0s();\r
1980\r
1981 AliV0vertexer lV0vtxer;\r
1982 AliCascadeVertexer lCascVtxer;\r
1983\r
1984 lV0vtxer.SetCuts(fV0Cuts);\r
1985 lCascVtxer.SetCuts(fCascadeCuts);\r
1986\r
1987\r
1988 lV0vtxer.Tracks2V0vertices(esd);\r
1989 lCascVtxer.V0sTracks2CascadeVertices(esd);\r
1990 }\r
1991\r
1992 \r
c7ef1c47 1993 fNumberOfTracks = 0;\r
1994 fNumberOfPositiveTracks = 0;\r
1995 fNumberOfV0s = 0;\r
1996 fNumberOfVertices = 0;\r
1997 fNumberOfCascades = 0;\r
1998 fNumberOfKinks = 0;\r
1999 \r
2000 AliAODHeader* header = ConvertHeader(*esd);\r
2001\r
2002 if ( fIsVZEROEnabled ) ConvertVZERO(*esd);\r
a1f96974 2003 if ( fIsTZEROEnabled ) ConvertTZERO(*esd);\r
c7ef1c47 2004 \r
2005 // Fetch Stack for debuggging if available \r
2006 fMChandler=0x0;\r
2007 if(MCEvent())\r
2008 {\r
2009 fMChandler = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()); \r
2010 }\r
2011 \r
2012 // loop over events and fill them\r
2013 // Multiplicity information needed by the header (to be revised!)\r
2014 Int_t nTracks = esd->GetNumberOfTracks();\r
2015 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);\r
2016\r
2017 // Update the header\r
2018\r
2019 Int_t nV0s = esd->GetNumberOfV0s();\r
2020 Int_t nCascades = esd->GetNumberOfCascades();\r
2021 Int_t nKinks = esd->GetNumberOfKinks();\r
2022 Int_t nVertices = nV0s + nCascades /*V0 wihtin cascade already counted*/+ nKinks + 1 /* = prim. vtx*/;\r
2023 Int_t nPileSPDVertices=1+esd->GetNumberOfPileupVerticesSPD(); // also SPD main vertex\r
2024 Int_t nPileTrkVertices=esd->GetNumberOfPileupVerticesTracks();\r
2025 nVertices+=nPileSPDVertices;\r
2026 nVertices+=nPileTrkVertices;\r
2027 Int_t nJets = 0;\r
2028 Int_t nCaloClus = esd->GetNumberOfCaloClusters();\r
2029 Int_t nFmdClus = 0;\r
2030 Int_t nPmdClus = esd->GetNumberOfPmdTracks();\r
2031 \r
2032 AliDebug(1,Form(" NV0=%d NCASCADES=%d NKINKS=%d", nV0s, nCascades, nKinks));\r
2033 \r
2034 AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);\r
2035\r
2036 if (nV0s > 0) \r
2037 {\r
2038 // RefArray to store a mapping between esd V0 number and newly created AOD-Vertex V0\r
2039 fAODV0VtxRefs = new TRefArray(nV0s);\r
2040 // RefArray to store the mapping between esd V0 number and newly created AOD-V0\r
2041 fAODV0Refs = new TRefArray(nV0s); \r
2042 // Array to take into account the V0s already added to the AOD (V0 within cascades)\r
2043 fUsedV0 = new Bool_t[nV0s];\r
2044 for (Int_t iV0=0; iV0<nV0s; ++iV0) fUsedV0[iV0]=kFALSE;\r
2045 }\r
2046 \r
2047 if (nTracks>0) \r
2048 {\r
2049 // RefArray to store the mapping between esd track number and newly created AOD-Track\r
2050 \r
2051 fAODTrackRefs = new TRefArray(nTracks);\r
2052\r
2053 // Array to take into account the tracks already added to the AOD \r
2054 fUsedTrack = new Bool_t[nTracks];\r
2055 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) fUsedTrack[iTrack]=kFALSE;\r
2056 }\r
2057 \r
2058 // Array to take into account the kinks already added to the AOD\r
2059 if (nKinks>0) \r
2060 {\r
2061 fUsedKink = new Bool_t[nKinks];\r
2062 for (Int_t iKink=0; iKink<nKinks; ++iKink) fUsedKink[iKink]=kFALSE;\r
2063 }\r
2064 \r
2065 ConvertPrimaryVertices(*esd);\r
2066\r
2067 //setting best TOF PID\r
39d6c296 2068 AliESDInputHandler* esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
2069 if (esdH)\r
2070 fESDpid = esdH->GetESDpid();\r
c7ef1c47 2071\r
39d6c296 2072 if (fIsPidOwner && fESDpid){\r
75a996ab 2073 delete fESDpid;\r
2074 fESDpid = 0;\r
2075 }\r
c7ef1c47 2076 if(!fESDpid)\r
2077 { //in case of no Tender attached \r
2078 fESDpid = new AliESDpid;\r
2079 fIsPidOwner = kTRUE;\r
2080 }\r
2081 \r
2082 if(!esd->GetTOFHeader())\r
2083 { //protection in case the pass2 LHC10b,c,d have been processed without tender. \r
2084 Float_t t0spread[10];\r
2085 Float_t intrinsicTOFres=100; //ps ok for LHC10b,c,d pass2!! \r
2086 for (Int_t i=0; i<10; i++) t0spread[i] = (TMath::Sqrt(esd->GetSigma2DiamondZ()))/0.03; //0.03 to convert from cm to ps\r
2087 fESDpid->GetTOFResponse().SetT0resolution(t0spread);\r
2088 fESDpid->GetTOFResponse().SetTimeResolution(intrinsicTOFres);\r
2089 \r
2090 fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); \r
2091 }\r
2092 \r
2093 if(esd->GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender. \r
2094 \r
2095 if ( fAreCascadesEnabled ) ConvertCascades(*esd);\r
2096\r
2097 if ( fAreV0sEnabled ) ConvertV0s(*esd);\r
2098 \r
2099 if ( fAreKinksEnabled ) ConvertKinks(*esd);\r
2100 \r
2101 if ( fAreTracksEnabled ) ConvertTracks(*esd);\r
2102 \r
2103 // Update number of AOD tracks in header at the end of track loop (M.G.)\r
2104 header->SetRefMultiplicity(fNumberOfTracks);\r
2105 header->SetRefMultiplicityPos(fNumberOfPositiveTracks);\r
2106 header->SetRefMultiplicityNeg(fNumberOfTracks - fNumberOfPositiveTracks);\r
2107\r
67abcce9 2108 if ( fTPCConstrainedFilterMask ) ConvertTPCOnlyTracks(*esd);\r
2109 if( fGlobalConstrainedFilterMask) ConvertGlobalConstrainedTracks(*esd); \r
2110\r
c7ef1c47 2111 if ( fArePmdClustersEnabled ) ConvertPmdClusters(*esd);\r
2112 \r
2113 if ( fAreCaloClustersEnabled ) ConvertCaloClusters(*esd);\r
2114 \r
2115 if ( fAreEMCALCellsEnabled )ConvertEMCALCells(*esd);\r
2116 \r
2117 if ( fArePHOSCellsEnabled )ConvertPHOSCells(*esd);\r
720f7306 2118 \r
2119 if ( fAreEMCALTriggerEnabled )ConvertCaloTrigger(TString("EMCAL"), *esd);\r
2120\r
2121 if ( fArePHOSTriggerEnabled )ConvertCaloTrigger(TString("PHOS"), *esd);\r
c7ef1c47 2122 \r
2123 if ( fAreTrackletsEnabled ) ConvertTracklets(*esd);\r
d87bed27 2124 if ( fIsZDCEnabled ) ConvertZDC(*esd);\r
c7ef1c47 2125 \r
2126 delete fAODTrackRefs; fAODTrackRefs=0x0;\r
2127 delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;\r
2128 delete fAODV0Refs; fAODV0Refs=0x0;\r
2129 \r
2130 delete[] fUsedTrack; fUsedTrack=0x0;\r
2131 delete[] fUsedV0; fUsedV0=0x0;\r
2132 delete[] fUsedKink; fUsedKink=0x0;\r
67456c92 2133\r
2134 if ( fIsPidOwner){\r
2135 delete fESDpid;\r
2136 fESDpid = 0x0;\r
2137 }\r
2138\r
2139\r
c7ef1c47 2140}\r
2141\r
2142\r
2143//______________________________________________________________________________\r
1a3579a6 2144void AliAnalysisTaskESDfilter::SetAODPID(AliESDtrack *esdtrack, AliAODTrack *aodtrack, AliAODPid *detpid)\r
f7ed7e88 2145{\r
2146 //\r
2147 // Setter for the raw PID detector signals\r
2148 //\r
2149\r
2150 // Save PID object for candidate electrons\r
2151 Bool_t pidSave = kFALSE;\r
2152 if (fTrackFilter) {\r
0c6c629b 2153 Bool_t selectInfo = fTrackFilter->IsSelected((char*) "Electrons");\r
f7ed7e88 2154 if (selectInfo) pidSave = kTRUE;\r
2155 }\r
2156\r
2157\r
2158 // Tracks passing pt cut \r
2159 if(esdtrack->Pt()>fHighPthreshold) {\r
2160 pidSave = kTRUE;\r
2161 } else {\r
2162 if(fPtshape){\r
2163 if(esdtrack->Pt()> fPtshape->GetXmin()){\r
2164 Double_t y = fPtshape->Eval(esdtrack->Pt())/fPtshape->Eval(fHighPthreshold);\r
2165 if(gRandom->Rndm(0)<1./y){\r
2166 pidSave = kTRUE;\r
2167 }//end rndm\r
2168 }//end if p < pmin\r
2169 }//end if p function\r
2170 }// end else\r
2171\r
2172 if (pidSave) {\r
6ece2430 2173 if(!aodtrack->GetDetPid()){// prevent memory leak when calling SetAODPID twice for the same track\r
f7ed7e88 2174 detpid = new AliAODPid();\r
1a3579a6 2175 SetDetectorRawSignals(detpid,esdtrack);\r
f7ed7e88 2176 aodtrack->SetDetPID(detpid);\r
6ece2430 2177 }\r
f7ed7e88 2178 }\r
2179}\r
2180\r
c7ef1c47 2181//______________________________________________________________________________\r
1a3579a6 2182void AliAnalysisTaskESDfilter::SetDetectorRawSignals(AliAODPid *aodpid, AliESDtrack *track)\r
f7ed7e88 2183{\r
2184//\r
2185//assignment of the detector signals (AliXXXesdPID inspired)\r
2186//\r
2187 if(!track){\r
2188 AliInfo("no ESD track found. .....exiting");\r
2189 return;\r
2190 }\r
febefa51 2191 // TPC momentum\r
2192 const AliExternalTrackParam *in=track->GetInnerParam();\r
2193 if (in) {\r
2194 aodpid->SetTPCmomentum(in->GetP());\r
2195 }else{\r
2196 aodpid->SetTPCmomentum(-1.);\r
2197 }\r
2198\r
f7ed7e88 2199\r
2200 aodpid->SetITSsignal(track->GetITSsignal());\r
6d354ed1 2201 Double_t itsdedx[4]; // dE/dx samples for individual ITS layers\r
2202 track->GetITSdEdxSamples(itsdedx);\r
2203 aodpid->SetITSdEdxSamples(itsdedx);\r
2204\r
f7ed7e88 2205 aodpid->SetTPCsignal(track->GetTPCsignal());\r
597b16d8 2206 aodpid->SetTPCsignalN(track->GetTPCsignalN());\r
f7ed7e88 2207\r
febefa51 2208 //n TRD planes = 6\r
f7ed7e88 2209 Int_t nslices = track->GetNumberOfTRDslices()*6;\r
59a8e853 2210 TArrayD trdslices(nslices);\r
f7ed7e88 2211 for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {\r
febefa51 2212 for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);\r
2213 }\r
2214 \r
2215//TRD momentum\r
2216 for(Int_t iPl=0;iPl<6;iPl++){\r
2217 Double_t trdmom=track->GetTRDmomentum(iPl);\r
2218 aodpid->SetTRDmomentum(iPl,trdmom);\r
2219 }\r
f7ed7e88 2220\r
59a8e853 2221 aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices.GetArray());\r
b13bcc35 2222\r
59a8e853 2223 //TRD clusters and tracklets\r
2224 aodpid->SetTRDncls(track->GetTRDncls());\r
2225 aodpid->SetTRDntrackletsPID(track->GetTRDntrackletsPID());\r
2226 \r
b13bcc35 2227 //TOF PID \r
f7ed7e88 2228 Double_t times[AliAODPid::kSPECIES]; track->GetIntegratedTimes(times);\r
2229 aodpid->SetIntegratedTimes(times);\r
2230\r
c7ef1c47 2231 Float_t tzeroTrack = fESDpid->GetTOFResponse().GetStartTime(track->P());\r
2232 aodpid->SetTOFsignal(track->GetTOFsignal()-tzeroTrack);\r
2233 \r
2234 Double_t tofRes[5];\r
2235 for (Int_t iMass=0; iMass<5; iMass++){\r
2236 tofRes[iMass]=(Double_t)fESDpid->GetTOFResponse().GetExpectedSigma(track->P(), times[iMass], AliPID::ParticleMass(iMass));\r
2237 }\r
2238 aodpid->SetTOFpidResolution(tofRes);\r
2239\r
2240 aodpid->SetHMPIDsignal(track->GetHMPIDsignal());\r
f7ed7e88 2241\r
2242 //Extrapolate track to EMCAL surface for AOD-level track-cluster matching\r
2243 Double_t emcpos[3] = {0.,0.,0.};\r
2244 Double_t emcmom[3] = {0.,0.,0.};\r
2245 aodpid->SetEMCALPosition(emcpos);\r
2246 aodpid->SetEMCALMomentum(emcmom);\r
2247\r
028c7a2c 2248 Double_t hmpPid[5] = {0};\r
2249 track->GetHMPIDpid(hmpPid);\r
2250 aodpid->SetHMPIDprobs(hmpPid);\r
2251\r
f7ed7e88 2252 AliExternalTrackParam *outerparam = (AliExternalTrackParam*)track->GetOuterParam();\r
2253 if(!outerparam) return;\r
2254\r
2255 //To be replaced by call to AliEMCALGeoUtils when the class becomes available\r
1a3579a6 2256 Bool_t okpos = outerparam->GetXYZ(emcpos);\r
2257 Bool_t okmom = outerparam->GetPxPyPz(emcmom);\r
f7ed7e88 2258 if(!(okpos && okmom)) return;\r
2259\r
2260 aodpid->SetEMCALPosition(emcpos);\r
2261 aodpid->SetEMCALMomentum(emcmom);\r
2262\r
2263}\r
2264\r
40a060e5 2265Double_t AliAnalysisTaskESDfilter::Chi2perNDF(AliESDtrack* track)\r
2266{\r
2267 // Calculate chi2 per ndf for track\r
2268 Int_t nClustersTPC = track->GetTPCNcls();\r
2269\r
2270 if ( nClustersTPC > 5) {\r
762fdfb5 2271 return (track->GetTPCchi2()/Float_t(nClustersTPC - 5));\r
40a060e5 2272 } else {\r
2273 return (-1.);\r
2274 }\r
2275 }\r
2276\r
2277\r
c7ef1c47 2278//______________________________________________________________________________\r
f7ed7e88 2279void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)\r
2280{\r
2281// Terminate analysis\r
2282//\r
2283 if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");\r
2284}\r
2285\r
c7ef1c47 2286//______________________________________________________________________________\r
f7ed7e88 2287void AliAnalysisTaskESDfilter::PrintMCInfo(AliStack *pStack,Int_t label){\r
f690bf48 2288// Print MC info\r
f7ed7e88 2289 if(!pStack)return;\r
2290 label = TMath::Abs(label);\r
2291 TParticle *part = pStack->Particle(label);\r
2292 Printf("########################");\r
2293 Printf("%s:%d %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,label,part->GetUniqueID(),part->GetPdgCode(),part->P());\r
2294 part->Print();\r
2295 TParticle* mother = part;\r
2296 Int_t imo = part->GetFirstMother();\r
2297 Int_t nprim = pStack->GetNprimary();\r
2298 // while((imo >= nprim) && (mother->GetUniqueID() == 4)) {\r
2299 while((imo >= nprim)) {\r
2300 mother = pStack->Particle(imo);\r
2301 Printf("Mother %s:%d Label %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,imo,mother->GetUniqueID(),mother->GetPdgCode(),mother->P());\r
2302 mother->Print();\r
2303 imo = mother->GetFirstMother();\r
2304 }\r
2305 Printf("########################");\r
2306}\r
b8d29a28 2307\r
2308//______________________________________________________\r
2309\r