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