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