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