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