1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
22 #include <TParameter.h>
24 #include <TParticle.h>
27 #include "AliAnalysisTaskESDfilter.h"
28 #include "AliAnalysisManager.h"
29 #include "AliESDEvent.h"
30 #include "AliESDRun.h"
32 #include "AliAODEvent.h"
33 #include "AliMCEvent.h"
34 #include "AliMCEventHandler.h"
35 #include "AliESDInputHandler.h"
36 #include "AliAODHandler.h"
37 #include "AliAODMCParticle.h"
38 #include "AliAnalysisFilter.h"
39 #include "AliESDMuonTrack.h"
40 #include "AliESDVertex.h"
41 #include "AliCentrality.h"
42 #include "AliEventplane.h"
44 #include "AliESDkink.h"
45 #include "AliESDcascade.h"
46 #include "AliESDPmdTrack.h"
47 #include "AliESDCaloCluster.h"
48 #include "AliESDCaloCells.h"
49 #include "AliMultiplicity.h"
51 #include "AliCodeTimer.h"
52 #include "AliESDtrackCuts.h"
53 #include "AliESDpid.h"
54 #include "AliAODHMPIDrings.h"
55 #include "AliV0vertexer.h"
56 #include "AliCascadeVertexer.h"
57 #include "Riostream.h"
58 #include "AliExternalTrackParam.h"
59 #include "AliTrackerBase.h"
61 #include "AliTPCdEdxInfo.h"
65 ClassImp(AliAnalysisTaskESDfilter)
67 ////////////////////////////////////////////////////////////////////////
69 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():
77 fEnableFillAOD(kTRUE),
86 fNumberOfPositiveTracks(0),
91 fOldESDformat(kFALSE),
93 fTPCConstrainedFilterMask(0),
94 fHybridFilterMaskTPCCG(0),
95 fWriteHybridTPCCOnly(kFALSE),
96 fGlobalConstrainedFilterMask(0),
97 fHybridFilterMaskGCG(0),
98 fWriteHybridGCOnly(kFALSE),
99 fIsVZEROEnabled(kTRUE),
100 fIsTZEROEnabled(kTRUE),
101 fIsZDCEnabled(kTRUE),
102 fIsHMPIDEnabled(kTRUE),
103 fIsV0CascadeRecoEnabled(kFALSE),
104 fAreCascadesEnabled(kTRUE),
105 fAreV0sEnabled(kTRUE),
106 fAreKinksEnabled(kTRUE),
107 fAreTracksEnabled(kTRUE),
108 fArePmdClustersEnabled(kTRUE),
109 fAreCaloClustersEnabled(kTRUE),
110 fAreEMCALCellsEnabled(kTRUE),
111 fArePHOSCellsEnabled(kTRUE),
112 fAreEMCALTriggerEnabled(kTRUE),
113 fArePHOSTriggerEnabled(kTRUE),
114 fAreTrackletsEnabled(kTRUE),
117 fTPCaloneTrackCuts(0),
118 fDoPropagateTrackToEMCal(kTRUE)
120 // Default constructor
121 fV0Cuts[0] = 33. ; // max allowed chi2
122 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter
123 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter
124 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks
125 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle
126 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume
127 fV0Cuts[6] = 100. ; // max radius of the fiducial volume
129 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)
130 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter
131 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass
132 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter
133 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor
134 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle
135 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume
136 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume
139 //______________________________________________________________________________
140 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):
141 AliAnalysisTaskSE(name),
148 fEnableFillAOD(kTRUE),
157 fNumberOfPositiveTracks(0),
159 fNumberOfVertices(0),
160 fNumberOfCascades(0),
162 fOldESDformat(kFALSE),
164 fTPCConstrainedFilterMask(0),
165 fHybridFilterMaskTPCCG(0),
166 fWriteHybridTPCCOnly(kFALSE),
167 fGlobalConstrainedFilterMask(0),
168 fHybridFilterMaskGCG(0),
169 fWriteHybridGCOnly(kFALSE),
170 fIsVZEROEnabled(kTRUE),
171 fIsTZEROEnabled(kTRUE),
172 fIsZDCEnabled(kTRUE),
173 fIsHMPIDEnabled(kTRUE),
174 fIsV0CascadeRecoEnabled(kFALSE),
175 fAreCascadesEnabled(kTRUE),
176 fAreV0sEnabled(kTRUE),
177 fAreKinksEnabled(kTRUE),
178 fAreTracksEnabled(kTRUE),
179 fArePmdClustersEnabled(kTRUE),
180 fAreCaloClustersEnabled(kTRUE),
181 fAreEMCALCellsEnabled(kTRUE),
182 fArePHOSCellsEnabled(kTRUE),
183 fAreEMCALTriggerEnabled(kTRUE),
184 fArePHOSTriggerEnabled(kTRUE),
185 fAreTrackletsEnabled(kTRUE),
188 fTPCaloneTrackCuts(0),
189 fDoPropagateTrackToEMCal(kTRUE)
193 fV0Cuts[0] = 33. ; // max allowed chi2
194 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter
195 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter
196 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks
197 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle
198 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume
199 fV0Cuts[6] = 100. ; // max radius of the fiducial volume
201 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)
202 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter
203 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass
204 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter
205 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor
206 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle
207 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume
208 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume
213 AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){
214 if(fIsPidOwner) delete fESDpid;
216 //______________________________________________________________________________
217 void AliAnalysisTaskESDfilter::UserCreateOutputObjects()
220 // Create Output Objects conenct filter to outputtree
224 OutputTree()->GetUserInfo()->Add(fTrackFilter);
228 AliError("No OutputTree() for adding the track filter");
230 fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
233 //______________________________________________________________________________
234 void AliAnalysisTaskESDfilter::Init()
237 if (fDebug > 1) AliInfo("Init() \n");
238 // Call configuration file
241 //______________________________________________________________________________
242 Bool_t AliAnalysisTaskESDfilter::Notify()
245 AddMetadataToUserInfo();
249 //______________________________________________________________________________
250 Bool_t AliAnalysisTaskESDfilter::AddMetadataToUserInfo()
252 // Copy metadata to AOD user info.
253 static Bool_t copyFirst = kFALSE;
255 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
257 AliError("AliAnalysisTaskESDfilter::AddMetadataToUserInfo() : No analysis manager !");
260 TTree *esdTree = mgr->GetTree()->GetTree();
261 if (!esdTree) return kFALSE;
262 TNamed *alirootVersion = (TNamed*)esdTree->GetUserInfo()->FindObject("alirootVersion");
263 if (!alirootVersion) return kFALSE;
264 AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(mgr->GetOutputEventHandler());
265 if (!aodHandler) return kFALSE;
266 TTree *aodTree = aodHandler->GetTree();
267 if (!aodTree) return kFALSE;
268 aodTree->GetUserInfo()->Add(new TNamed(*alirootVersion));
274 //______________________________________________________________________________
275 void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const
277 // Print selection task information
280 AliAnalysisTaskSE::PrintTask(option,indent);
282 TString spaces(' ',indent+3);
284 cout << spaces.Data() << Form("Cascades are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;
285 cout << spaces.Data() << Form("V0s are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;
286 cout << spaces.Data() << Form("Kinks are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;
287 cout << spaces.Data() << Form("Tracks are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;
288 cout << spaces.Data() << Form("PmdClusters are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;
289 cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;
290 cout << spaces.Data() << Form("EMCAL cells are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;
291 cout << spaces.Data() << Form("EMCAL triggers are %s",fAreEMCALTriggerEnabled ? "ENABLED":"DISABLED") << endl;
292 cout << spaces.Data() << Form("PHOS triggers are %s",fArePHOSTriggerEnabled ? "ENABLED":"DISABLED") << endl;
293 cout << spaces.Data() << Form("Tracklets are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl;
294 cout << spaces.Data() << Form("PropagateTrackToEMCal is %s", fDoPropagateTrackToEMCal ? "ENABLED":"DISABLED") << endl;
297 //______________________________________________________________________________
298 void AliAnalysisTaskESDfilter::UserExec(Option_t */*option*/)
300 // Execute analysis for current event
303 Long64_t ientry = Entry();
306 printf("Filter: Analysing event # %5d\n", (Int_t) ientry);
307 if (fHighPthreshold == 0) AliInfo("detector PID signals are stored in each track");
308 if (!fPtshape) AliInfo("detector PID signals are not stored below the pt threshold");
310 // Filters must explicitely enable AOD filling in their UserExec (AG)
311 if (!AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()) AliFatal("Cannot run ESD filter without an output event handler");
313 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
314 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);
319 //______________________________________________________________________________
320 TClonesArray& AliAnalysisTaskESDfilter::Cascades()
322 return *(AODEvent()->GetCascades());
325 //______________________________________________________________________________
326 TClonesArray& AliAnalysisTaskESDfilter::Tracks()
328 return *(AODEvent()->GetTracks());
331 //______________________________________________________________________________
332 TClonesArray& AliAnalysisTaskESDfilter::V0s()
334 return *(AODEvent()->GetV0s());
337 //______________________________________________________________________________
338 TClonesArray& AliAnalysisTaskESDfilter::Vertices()
340 return *(AODEvent()->GetVertices());
343 //______________________________________________________________________________
344 AliAODHeader* AliAnalysisTaskESDfilter::ConvertHeader(const AliESDEvent& esd)
346 // Convert header information
348 AliCodeTimerAuto("",0);
350 AliAODHeader* header = AODEvent()->GetHeader();
352 header->SetRunNumber(esd.GetRunNumber());
353 header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
355 TTree* tree = fInputHandler->GetTree();
357 TFile* file = tree->GetCurrentFile();
358 if (file) header->SetESDFileName(file->GetName());
362 header->SetBunchCrossNumber(0);
363 header->SetOrbitNumber(0);
364 header->SetPeriodNumber(0);
365 header->SetEventType(0);
366 header->SetMuonMagFieldScale(-999.);
367 header->SetCentrality(0);
368 header->SetEventplane(0);
370 header->SetBunchCrossNumber(esd.GetBunchCrossNumber());
371 header->SetOrbitNumber(esd.GetOrbitNumber());
372 header->SetPeriodNumber(esd.GetPeriodNumber());
373 header->SetEventType(esd.GetEventType());
375 header->SetEventNumberESDFile(esd.GetHeader()->GetEventNumberInFile());
376 if(const_cast<AliESDEvent&>(esd).GetCentrality()){
377 header->SetCentrality(const_cast<AliESDEvent&>(esd).GetCentrality());
380 header->SetCentrality(0);
382 if(const_cast<AliESDEvent&>(esd).GetEventplane()){
383 header->SetEventplane(const_cast<AliESDEvent&>(esd).GetEventplane());
386 header->SetEventplane(0);
391 header->SetFiredTriggerClasses(esd.GetFiredTriggerClasses());
392 header->SetTriggerMask(esd.GetTriggerMask());
393 header->SetTriggerCluster(esd.GetTriggerCluster());
394 header->SetL0TriggerInputs(esd.GetHeader()->GetL0TriggerInputs());
395 header->SetL1TriggerInputs(esd.GetHeader()->GetL1TriggerInputs());
396 header->SetL2TriggerInputs(esd.GetHeader()->GetL2TriggerInputs());
398 header->SetMagneticField(esd.GetMagneticField());
399 header->SetMuonMagFieldScale(esd.GetCurrentDip()/6000.);
400 header->SetZDCN1Energy(esd.GetZDCN1Energy());
401 header->SetZDCP1Energy(esd.GetZDCP1Energy());
402 header->SetZDCN2Energy(esd.GetZDCN2Energy());
403 header->SetZDCP2Energy(esd.GetZDCP2Energy());
404 header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));
406 // ITS Cluster Multiplicty
407 const AliMultiplicity *mult = esd.GetMultiplicity();
408 for (Int_t ilay = 0; ilay < 6; ilay++) header->SetITSClusters(ilay, mult->GetNumberOfITSClusters(ilay));
410 // TPC only Reference Multiplicty
411 Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;
412 header->SetTPConlyRefMultiplicity(refMult);
414 header->SetRefMultiplicityComb05(AliESDtrackCuts::GetReferenceMultiplicity(&esd,AliESDtrackCuts::kTrackletsITSTPC,0.5));
415 header->SetRefMultiplicityComb08(AliESDtrackCuts::GetReferenceMultiplicity(&esd,AliESDtrackCuts::kTrackletsITSTPC,0.8));
417 Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};
419 esd.GetDiamondCovXY(diamcov);
420 header->SetDiamond(diamxy,diamcov);
421 header->SetDiamondZ(esd.GetDiamondZ(),esd.GetSigma2DiamondZ());
423 // VZERO channel equalization factors for event-plane reconstruction
424 header->SetVZEROEqFactors(esd.GetVZEROEqFactors());
426 // T0 Resolution information
427 const AliESDRun* esdRun = esd.GetESDRun();
428 for (Int_t i=0;i<AliESDRun::kT0spreadSize;i++) header->SetT0spread(i,esdRun->GetT0spread(i));
433 //______________________________________________________________________________
434 void AliAnalysisTaskESDfilter::ConvertCascades(const AliESDEvent& esd)
437 // Convert the cascades part of the ESD.
438 // Return the number of cascades
440 AliCodeTimerAuto("",0);
442 // Create vertices starting from the most complex objects
445 const AliESDVertex* vtx = esd.GetPrimaryVertex();
446 Double_t pos[3] = { 0. };
447 Double_t covVtx[6] = { 0. };
448 Double_t momBach[3]={0.};
449 Double_t covTr[21]={0.};
450 Double_t pid[10]={0.};
451 AliAODPid* detpid(0x0);
452 AliAODVertex* vV0FromCascade(0x0);
453 AliAODv0* aodV0(0x0);
454 AliAODcascade* aodCascade(0x0);
455 AliAODTrack* aodTrack(0x0);
456 Double_t momPos[3]={0.};
457 Double_t momNeg[3] = { 0. };
458 Double_t momPosAtV0vtx[3]={0.};
459 Double_t momNegAtV0vtx[3]={0.};
461 TClonesArray& verticesArray = Vertices();
462 TClonesArray& tracksArray = Tracks();
463 TClonesArray& cascadesArray = Cascades();
465 // Cascades (Modified by A.Maire - February 2009)
466 for (Int_t nCascade = 0; nCascade < esd.GetNumberOfCascades(); ++nCascade) {
470 AliESDcascade *esdCascade = esd.GetCascade(nCascade);
471 Int_t idxPosFromV0Dghter = esdCascade->GetPindex();
472 Int_t idxNegFromV0Dghter = esdCascade->GetNindex();
473 Int_t idxBachFromCascade = esdCascade->GetBindex();
475 AliESDtrack *esdCascadePos = esd.GetTrack( idxPosFromV0Dghter);
476 AliESDtrack *esdCascadeNeg = esd.GetTrack( idxNegFromV0Dghter);
477 AliESDtrack *esdCascadeBach = esd.GetTrack( idxBachFromCascade);
479 // Identification of the V0 within the esdCascade (via both daughter track indices)
480 AliESDv0 * currentV0 = 0x0;
481 Int_t idxV0FromCascade = -1;
483 for (Int_t iV0=0; iV0<esd.GetNumberOfV0s(); ++iV0) {
485 currentV0 = esd.GetV0(iV0);
486 Int_t posCurrentV0 = currentV0->GetPindex();
487 Int_t negCurrentV0 = currentV0->GetNindex();
489 if (posCurrentV0==idxPosFromV0Dghter && negCurrentV0==idxNegFromV0Dghter) {
490 idxV0FromCascade = iV0;
495 if(idxV0FromCascade < 0){
496 printf("Cascade - no matching for the V0 (index V0 = -1) ! Skip ... \n");
498 }// a priori, useless check, but safer ... in case of pb with tracks "out of bounds"
500 AliESDv0 *esdV0FromCascade = esd.GetV0(idxV0FromCascade);
502 // 1 - Cascade selection
504 // AliESDVertex *esdPrimVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));
505 // TList cascadeObjects;
506 // cascadeObjects.AddAt(esdV0FromCascade, 0);
507 // cascadeObjects.AddAt(esdCascadePos, 1);
508 // cascadeObjects.AddAt(esdCascadeNeg, 2);
509 // cascadeObjects.AddAt(esdCascade, 3);
510 // cascadeObjects.AddAt(esdCascadeBach, 4);
511 // cascadeObjects.AddAt(esdPrimVtx, 5);
513 // UInt_t selectCascade = 0;
514 // if (fCascadeFilter) {
515 // // selectCascade = fCascadeFilter->IsSelected(&cascadeObjects);
516 // // FIXME AliESDCascadeCuts to be implemented ...
518 // // Here we may encounter a moot point at the V0 level
519 // // between the cascade selections and the V0 ones :
520 // // the V0 selected along with the cascade (secondary V0) may
521 // // usually be removed from the dedicated V0 selections (prim V0) ...
522 // // -> To be discussed !
524 // // this is a little awkward but otherwise the
525 // // list wants to access the pointer (delete it)
526 // // again when going out of scope
527 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct
529 // if (!selectCascade)
533 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct
537 // 2 - Add the cascade vertex
539 esdCascade->GetXYZcascade(pos[0], pos[1], pos[2]);
540 esdCascade->GetPosCovXi(covVtx);
541 chi2 = esdCascade->GetChi2Xi();
543 AliAODVertex *vCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex( pos,
545 chi2, // FIXME = Chi2/NDF will be needed
548 AliAODVertex::kCascade);
549 fPrimaryVertex->AddDaughter(vCascade);
552 // printf("---- Cascade / Cascade Vertex (AOD) : \n");
553 // vCascade->Print();
556 // if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production starting form LHC10e without Tender.
559 // 3 - Add the bachelor track from the cascade
561 if (!fUsedTrack[idxBachFromCascade]) {
563 esdCascadeBach->GetPxPyPz(momBach);
564 esdCascadeBach->GetXYZ(pos);
565 esdCascadeBach->GetCovarianceXYZPxPyPz(covTr);
566 esdCascadeBach->GetESDpid(pid);
568 fUsedTrack[idxBachFromCascade] = kTRUE;
569 UInt_t selectInfo = 0;
570 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeBach);
571 if (fMChandler) fMChandler->SelectParticle(esdCascadeBach->GetLabel());
572 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack(esdCascadeBach->GetID(),
573 esdCascadeBach->GetLabel(),
577 kFALSE, // Why kFALSE for "isDCA" ? FIXME
579 (Short_t)esdCascadeBach->GetSign(),
580 esdCascadeBach->GetITSClusterMap(),
583 kTRUE, // usedForVtxFit = kFALSE ? FIXME
584 vtx->UsesTrack(esdCascadeBach->GetID()),
585 AliAODTrack::kSecondary,
587 aodTrack->SetTPCFitMap(esdCascadeBach->GetTPCFitMap());
588 aodTrack->SetTPCClusterMap(esdCascadeBach->GetTPCClusterMap());
589 aodTrack->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());
590 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));
591 aodTrack->SetTPCPointsF(esdCascadeBach->GetTPCNclsF());
592 aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadeBach->GetTPCCrossedRows()));
593 fAODTrackRefs->AddAt(aodTrack,idxBachFromCascade);
595 if (esdCascadeBach->GetSign() > 0) ++fNumberOfPositiveTracks;
596 aodTrack->ConvertAliPIDtoAODPID();
597 aodTrack->SetFlags(esdCascadeBach->GetStatus());
598 SetAODPID(esdCascadeBach,aodTrack,detpid);
601 aodTrack = static_cast<AliAODTrack*>( fAODTrackRefs->At(idxBachFromCascade) );
604 vCascade->AddDaughter(aodTrack);
607 // printf("---- Cascade / bach dghter : \n");
608 // aodTrack->Print();
612 // 4 - Add the V0 from the cascade.
613 // = V0vtx + both pos and neg daughter tracks + the aodV0 itself
616 if ( !fUsedV0[idxV0FromCascade] ) {
617 // 4.A - if VO structure hasn't been created yet
619 // 4.A.1 - Create the V0 vertex of the cascade
621 esdV0FromCascade->GetXYZ(pos[0], pos[1], pos[2]);
622 esdV0FromCascade->GetPosCov(covVtx);
623 chi2 = esdV0FromCascade->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3 ?
625 vV0FromCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex(pos,
629 idxV0FromCascade, //id of ESDv0
632 // one V0 can be used by several cascades.
633 // So, one AOD V0 vtx can have several parent vtx.
634 // This is not directly allowed by AliAODvertex.
635 // Setting the parent vtx (here = param "vCascade") doesn't lead to a crash
636 // but to a problem of consistency within AODEvent.
637 // -> See below paragraph 4.B, for the proposed treatment of such a case.
639 // Add the vV0FromCascade to the aodVOVtxRefs
640 fAODV0VtxRefs->AddAt(vV0FromCascade,idxV0FromCascade);
643 // 4.A.2 - Add the positive tracks from the V0
645 esdCascadePos->GetPxPyPz(momPos);
646 esdCascadePos->GetXYZ(pos);
647 esdCascadePos->GetCovarianceXYZPxPyPz(covTr);
648 esdCascadePos->GetESDpid(pid);
651 if (!fUsedTrack[idxPosFromV0Dghter]) {
652 fUsedTrack[idxPosFromV0Dghter] = kTRUE;
654 UInt_t selectInfo = 0;
655 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadePos);
656 if(fMChandler) fMChandler->SelectParticle(esdCascadePos->GetLabel());
657 aodTrack = new(tracksArray[fNumberOfTracks++])
658 AliAODTrack( esdCascadePos->GetID(),
659 esdCascadePos->GetLabel(),
663 kFALSE, // Why kFALSE for "isDCA" ? FIXME
665 (Short_t)esdCascadePos->GetSign(),
666 esdCascadePos->GetITSClusterMap(),
669 kTRUE, // usedForVtxFit = kFALSE ? FIXME
670 vtx->UsesTrack(esdCascadePos->GetID()),
671 AliAODTrack::kSecondary,
673 aodTrack->SetTPCFitMap(esdCascadePos->GetTPCFitMap());
674 aodTrack->SetTPCClusterMap(esdCascadePos->GetTPCClusterMap());
675 aodTrack->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());
676 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));
677 aodTrack->SetTPCPointsF(esdCascadePos->GetTPCNclsF());
678 aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadePos->GetTPCCrossedRows()));
679 fAODTrackRefs->AddAt(aodTrack,idxPosFromV0Dghter);
681 if (esdCascadePos->GetSign() > 0) ++fNumberOfPositiveTracks;
682 aodTrack->ConvertAliPIDtoAODPID();
683 aodTrack->SetFlags(esdCascadePos->GetStatus());
684 SetAODPID(esdCascadePos,aodTrack,detpid);
687 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxPosFromV0Dghter));
689 vV0FromCascade->AddDaughter(aodTrack);
692 // 4.A.3 - Add the negative tracks from the V0
694 esdCascadeNeg->GetPxPyPz(momNeg);
695 esdCascadeNeg->GetXYZ(pos);
696 esdCascadeNeg->GetCovarianceXYZPxPyPz(covTr);
697 esdCascadeNeg->GetESDpid(pid);
700 if (!fUsedTrack[idxNegFromV0Dghter]) {
701 fUsedTrack[idxNegFromV0Dghter] = kTRUE;
703 UInt_t selectInfo = 0;
704 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeNeg);
705 if(fMChandler)fMChandler->SelectParticle(esdCascadeNeg->GetLabel());
706 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack( esdCascadeNeg->GetID(),
707 esdCascadeNeg->GetLabel(),
711 kFALSE, // Why kFALSE for "isDCA" ? FIXME
713 (Short_t)esdCascadeNeg->GetSign(),
714 esdCascadeNeg->GetITSClusterMap(),
717 kTRUE, // usedForVtxFit = kFALSE ? FIXME
718 vtx->UsesTrack(esdCascadeNeg->GetID()),
719 AliAODTrack::kSecondary,
721 aodTrack->SetTPCFitMap(esdCascadeNeg->GetTPCFitMap());
722 aodTrack->SetTPCClusterMap(esdCascadeNeg->GetTPCClusterMap());
723 aodTrack->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());
724 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));
725 aodTrack->SetTPCPointsF(esdCascadeNeg->GetTPCNclsF());
726 aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadeNeg->GetTPCCrossedRows()));
727 fAODTrackRefs->AddAt(aodTrack,idxNegFromV0Dghter);
729 if (esdCascadeNeg->GetSign() > 0) ++fNumberOfPositiveTracks;
730 aodTrack->ConvertAliPIDtoAODPID();
731 aodTrack->SetFlags(esdCascadeNeg->GetStatus());
732 SetAODPID(esdCascadeNeg,aodTrack,detpid);
735 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxNegFromV0Dghter));
738 vV0FromCascade->AddDaughter(aodTrack);
741 // 4.A.4 - Add the V0 from cascade to the V0 array
743 Double_t dcaV0Daughters = esdV0FromCascade->GetDcaV0Daughters();
744 Double_t dcaV0ToPrimVertex = esdV0FromCascade->GetD( esd.GetPrimaryVertex()->GetX(),
745 esd.GetPrimaryVertex()->GetY(),
746 esd.GetPrimaryVertex()->GetZ() );
747 esdV0FromCascade->GetPPxPyPz( momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2] );
748 esdV0FromCascade->GetNPxPyPz( momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2] );
750 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg
751 dcaDaughterToPrimVertex[0] = TMath::Abs(esdCascadePos->GetD( esd.GetPrimaryVertex()->GetX(),
752 esd.GetPrimaryVertex()->GetY(),
753 esd.GetMagneticField()) );
754 dcaDaughterToPrimVertex[1] = TMath::Abs(esdCascadeNeg->GetD( esd.GetPrimaryVertex()->GetX(),
755 esd.GetPrimaryVertex()->GetY(),
756 esd.GetMagneticField()) );
758 aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0( vV0FromCascade,
763 dcaDaughterToPrimVertex);
764 // set the aod v0 on-the-fly status
765 aodV0->SetOnFlyStatus(esdV0FromCascade->GetOnFlyStatus());
767 // Add the aodV0 to the aodVORefs
768 fAODV0Refs->AddAt(aodV0,idxV0FromCascade);
770 fUsedV0[idxV0FromCascade] = kTRUE;
773 // 4.B - if V0 structure already used
776 // one V0 can be used by several cascades (frequent in PbPb evts) :
777 // same V0 which used but attached to different bachelor tracks
778 // -> aodVORefs and fAODV0VtxRefs are needed.
779 // Goal : avoid a redundancy of the info in "Vertices" and "v0s" clones array.
781 vV0FromCascade = static_cast<AliAODVertex*>( fAODV0VtxRefs->At(idxV0FromCascade) );
782 aodV0 = static_cast<AliAODv0*> ( fAODV0Refs ->At(idxV0FromCascade) );
784 // - Treatment of the parent for such a "re-used" V0 :
785 // Insert the cascade that reuses the V0 vertex in the lineage chain
786 // Before : vV0 -> vCascade1 -> vPrimary
787 // - Hyp : cascade2 uses the same V0 as cascade1
788 // After : vV0 -> vCascade2 -> vCascade1 -> vPrimary
790 AliAODVertex *vCascadePreviousParent = static_cast<AliAODVertex*> (vV0FromCascade->GetParent());
791 vV0FromCascade->SetParent(vCascade);
792 vCascade ->SetParent(vCascadePreviousParent);
795 // printf("---- Cascade / Lineage insertion\n"
796 // "Parent of V0 vtx = Cascade vtx %p\n"
797 // "Parent of the cascade vtx = Cascade vtx %p\n"
798 // "Parent of the parent cascade vtx = Cascade vtx %p\n",
799 // static_cast<void*> (vV0FromCascade->GetParent()),
800 // static_cast<void*> (vCascade->GetParent()),
801 // static_cast<void*> (vCascadePreviousParent->GetParent()) );
803 }// end if V0 structure already used
806 // printf("---- Cascade / V0 vertex: \n");
807 // vV0FromCascade->Print();
811 // printf("---- Cascade / pos dghter : \n");
812 // aodTrack->Print();
813 // printf("---- Cascade / neg dghter : \n");
814 // aodTrack->Print();
815 // printf("---- Cascade / aodV0 : \n");
819 // In any case (used V0 or not), add the V0 vertex to the cascade one.
820 vCascade->AddDaughter(vV0FromCascade);
823 // 5 - Add the primary track of the cascade (if any)
826 // 6 - Add the cascade to the AOD array of cascades
828 Double_t dcaBachToPrimVertexXY = TMath::Abs(esdCascadeBach->GetD(esd.GetPrimaryVertex()->GetX(),
829 esd.GetPrimaryVertex()->GetY(),
830 esd.GetMagneticField()) );
832 Double_t momBachAtCascadeVtx[3]={0.};
834 esdCascade->GetBPxPyPz(momBachAtCascadeVtx[0], momBachAtCascadeVtx[1], momBachAtCascadeVtx[2]);
836 aodCascade = new(cascadesArray[fNumberOfCascades++]) AliAODcascade( vCascade,
837 esdCascade->Charge(),
838 esdCascade->GetDcaXiDaughters(),
840 // DCAXiToPrimVtx -> needs to be calculated ----|
841 // doesn't exist at ESD level;
842 // See AODcascade::DcaXiToPrimVertex(Double, Double, Double)
843 dcaBachToPrimVertexXY,
848 printf("---- Cascade / AOD cascade : \n\n");
849 aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());
852 } // end of the loop on cascades
854 Cascades().Expand(fNumberOfCascades);
857 //______________________________________________________________________________
858 void AliAnalysisTaskESDfilter::ConvertV0s(const AliESDEvent& esd)
860 // Access to the AOD container of V0s
862 AliCodeTimerAuto("",0);
868 Double_t pos[3] = { 0. };
870 Double_t covVtx[6] = { 0. };
871 Double_t momPos[3]={0.};
872 Double_t covTr[21]={0.};
873 Double_t pid[10]={0.};
874 AliAODTrack* aodTrack(0x0);
875 AliAODPid* detpid(0x0);
876 Double_t momNeg[3]={0.};
877 Double_t momPosAtV0vtx[3]={0.};
878 Double_t momNegAtV0vtx[3]={0.};
880 for (Int_t nV0 = 0; nV0 < esd.GetNumberOfV0s(); ++nV0)
882 if (fUsedV0[nV0]) continue; // skip if already added to the AOD
884 AliESDv0 *v0 = esd.GetV0(nV0);
885 Int_t posFromV0 = v0->GetPindex();
886 Int_t negFromV0 = v0->GetNindex();
890 AliESDVertex *esdVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));
891 AliESDtrack *esdV0Pos = esd.GetTrack(posFromV0);
892 AliESDtrack *esdV0Neg = esd.GetTrack(negFromV0);
894 v0objects.AddAt(v0, 0);
895 v0objects.AddAt(esdV0Pos, 1);
896 v0objects.AddAt(esdV0Neg, 2);
897 v0objects.AddAt(esdVtx, 3);
900 selectV0 = fV0Filter->IsSelected(&v0objects);
901 // this is a little awkward but otherwise the
902 // list wants to access the pointer (delete it)
903 // again when going out of scope
904 delete v0objects.RemoveAt(3); // esdVtx created via copy construct
910 delete v0objects.RemoveAt(3); // esdVtx created via copy construct
914 v0->GetXYZ(pos[0], pos[1], pos[2]);
916 if (!fOldESDformat) {
917 chi2 = v0->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3
918 v0->GetPosCov(covVtx);
921 for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;
926 new(Vertices()[fNumberOfVertices++]) AliAODVertex(pos,
932 fPrimaryVertex->AddDaughter(vV0);
935 // Add the positive tracks from the V0
938 esdV0Pos->GetPxPyPz(momPos);
939 esdV0Pos->GetXYZ(pos);
940 esdV0Pos->GetCovarianceXYZPxPyPz(covTr);
941 esdV0Pos->GetESDpid(pid);
943 const AliESDVertex *vtx = esd.GetPrimaryVertex();
945 if (!fUsedTrack[posFromV0]) {
946 fUsedTrack[posFromV0] = kTRUE;
947 UInt_t selectInfo = 0;
948 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Pos);
949 if(fMChandler)fMChandler->SelectParticle(esdV0Pos->GetLabel());
950 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Pos->GetID(),
951 esdV0Pos->GetLabel(),
957 (Short_t)esdV0Pos->GetSign(),
958 esdV0Pos->GetITSClusterMap(),
961 kTRUE, // check if this is right
962 vtx->UsesTrack(esdV0Pos->GetID()),
963 AliAODTrack::kSecondary,
965 aodTrack->SetTPCFitMap(esdV0Pos->GetTPCFitMap());
966 aodTrack->SetTPCClusterMap(esdV0Pos->GetTPCClusterMap());
967 aodTrack->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());
968 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));
969 aodTrack->SetTPCPointsF(esdV0Pos->GetTPCNclsF());
970 aodTrack->SetTPCNCrossedRows(UShort_t(esdV0Pos->GetTPCCrossedRows()));
971 fAODTrackRefs->AddAt(aodTrack,posFromV0);
972 // if (fDebug > 0) printf("-------------------Bo: pos track from original pt %.3f \n",aodTrack->Pt());
973 if (esdV0Pos->GetSign() > 0) ++fNumberOfPositiveTracks;
974 aodTrack->ConvertAliPIDtoAODPID();
975 aodTrack->SetFlags(esdV0Pos->GetStatus());
976 SetAODPID(esdV0Pos,aodTrack,detpid);
979 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(posFromV0));
980 // if (fDebug > 0) printf("-------------------Bo pos track from refArray pt %.3f \n",aodTrack->Pt());
982 vV0->AddDaughter(aodTrack);
984 // Add the negative tracks from the V0
986 esdV0Neg->GetPxPyPz(momNeg);
987 esdV0Neg->GetXYZ(pos);
988 esdV0Neg->GetCovarianceXYZPxPyPz(covTr);
989 esdV0Neg->GetESDpid(pid);
991 if (!fUsedTrack[negFromV0]) {
992 fUsedTrack[negFromV0] = kTRUE;
993 UInt_t selectInfo = 0;
994 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Neg);
995 if(fMChandler)fMChandler->SelectParticle(esdV0Neg->GetLabel());
996 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Neg->GetID(),
997 esdV0Neg->GetLabel(),
1003 (Short_t)esdV0Neg->GetSign(),
1004 esdV0Neg->GetITSClusterMap(),
1007 kTRUE, // check if this is right
1008 vtx->UsesTrack(esdV0Neg->GetID()),
1009 AliAODTrack::kSecondary,
1011 aodTrack->SetTPCFitMap(esdV0Neg->GetTPCFitMap());
1012 aodTrack->SetTPCClusterMap(esdV0Neg->GetTPCClusterMap());
1013 aodTrack->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());
1014 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));
1015 aodTrack->SetTPCPointsF(esdV0Neg->GetTPCNclsF());
1016 aodTrack->SetTPCNCrossedRows(UShort_t(esdV0Neg->GetTPCCrossedRows()));
1018 fAODTrackRefs->AddAt(aodTrack,negFromV0);
1019 // if (fDebug > 0) printf("-------------------Bo: neg track from original pt %.3f \n",aodTrack->Pt());
1020 if (esdV0Neg->GetSign() > 0) ++fNumberOfPositiveTracks;
1021 aodTrack->ConvertAliPIDtoAODPID();
1022 aodTrack->SetFlags(esdV0Neg->GetStatus());
1023 SetAODPID(esdV0Neg,aodTrack,detpid);
1026 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(negFromV0));
1027 // if (fDebug > 0) printf("-------------------Bo neg track from refArray pt %.3f \n",aodTrack->Pt());
1029 vV0->AddDaughter(aodTrack);
1032 // Add the V0 the V0 array as well
1034 Double_t dcaV0Daughters = v0->GetDcaV0Daughters();
1035 Double_t dcaV0ToPrimVertex = v0->GetD(esd.GetPrimaryVertex()->GetX(),
1036 esd.GetPrimaryVertex()->GetY(),
1037 esd.GetPrimaryVertex()->GetZ());
1039 v0->GetPPxPyPz(momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2]);
1040 v0->GetNPxPyPz(momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2]);
1042 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg
1043 dcaDaughterToPrimVertex[0] = TMath::Abs(esdV0Pos->GetD( esd.GetPrimaryVertex()->GetX(),
1044 esd.GetPrimaryVertex()->GetY(),
1045 esd.GetMagneticField()) );
1046 dcaDaughterToPrimVertex[1] = TMath::Abs(esdV0Neg->GetD( esd.GetPrimaryVertex()->GetX(),
1047 esd.GetPrimaryVertex()->GetY(),
1048 esd.GetMagneticField()) );
1050 AliAODv0* aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0(vV0,
1055 dcaDaughterToPrimVertex);
1057 // set the aod v0 on-the-fly status
1058 aodV0->SetOnFlyStatus(v0->GetOnFlyStatus());
1059 }//End of loop on V0s
1061 V0s().Expand(fNumberOfV0s);
1064 //______________________________________________________________________________
1065 void AliAnalysisTaskESDfilter::ConvertTPCOnlyTracks(const AliESDEvent& esd)
1067 // Convert TPC only tracks
1068 // Here we have wo hybrid appraoch to remove fakes
1069 // ******* ITSTPC ********
1070 // Uses a cut on the ITS properties to select global tracks
1071 // which are than marked as HybdridITSTPC for the remainder
1072 // the TPC only tracks are flagged as HybridITSTPConly.
1073 // Note, in order not to get fakes back in the TPC cuts, one needs
1074 // two "ITS" cuts one tight (1) (to throw out fakes) and one lose (2) (to NOT flag the trakcs in the TPC only)
1075 // using cut number (3)
1076 // so fHybridFilterMask == (1)|(2) fTPCFilterMask = (3), Usercode needs to slect with mask = (1)|(3) and track->IsHybridITSTPC()
1077 // ******* TPC ********
1078 // 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
1079 // 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
1081 AliCodeTimerAuto("",0);
1083 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks
1084 for(int it = 0;it < fNumberOfTracks;++it)
1086 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));
1088 UInt_t map = tr->GetFilterMap();
1089 if(map&fTPCConstrainedFilterMask){
1090 // we only reset the track select ionfo, no deletion...
1091 tr->SetFilterMap(map&~fTPCConstrainedFilterMask);
1093 if(map&fHybridFilterMaskTPCCG){
1094 // this is one part of the hybrid tracks
1095 // the others not passing the selection will be TPC only selected below
1096 tr->SetIsHybridTPCConstrainedGlobal(kTRUE);
1099 // Loop over the ESD trcks and pick out the tracks passing TPC only cuts
1102 const AliESDVertex *vtxSPD = esd.GetPrimaryVertexSPD();
1103 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1105 Double_t pos[3] = { 0. };
1106 Double_t covTr[21]={0.};
1107 Double_t pid[10]={0.};
1110 Double_t p[3] = { 0. };
1112 Double_t pDCA[3] = { 0. }; // momentum at DCA
1113 Double_t rDCA[3] = { 0. }; // position at DCA
1114 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
1115 Float_t cDCA[3] = {0.}; // covariance of impact parameters
1118 AliAODTrack* aodTrack(0x0);
1119 // AliAODPid* detpid(0x0);
1121 // account for change in pT after the constraint
1122 Float_t ptMax = 1E10;
1124 for(int i = 0;i<32;i++){
1125 if(fTPCConstrainedFilterMask&(1<<i)){
1126 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);
1127 Float_t tmp1= 0,tmp2 = 0;
1128 cuts->GetPtRange(tmp1,tmp2);
1129 if(tmp1>ptMin)ptMin=tmp1;
1130 if(tmp2<ptMax)ptMax=tmp2;
1134 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
1136 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy
1138 UInt_t selectInfo = 0;
1139 Bool_t isHybridITSTPC = false;
1143 selectInfo = fTrackFilter->IsSelected(esdTrack);
1146 if(!(selectInfo&fHybridFilterMaskTPCCG)){
1147 // not already selected tracks, use second part of hybrid tracks
1148 isHybridITSTPC = true;
1149 // too save space one could only store these...
1152 selectInfo &= fTPCConstrainedFilterMask;
1153 if (!selectInfo)continue;
1154 if (fWriteHybridTPCCOnly&&!isHybridITSTPC)continue; // write only complementary tracks
1155 // create a tpc only tracl
1156 AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(&esd),esdTrack->GetID());
1157 if(!track) continue;
1161 // only constrain tracks above threshold
1162 AliExternalTrackParam exParam;
1163 // take the B-field from the ESD, no 3D fieldMap available at this point
1164 Bool_t relate = false;
1165 relate = track->RelateToVertexTPC(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);
1170 // fetch the track parameters at the DCA (unconstraint)
1171 if(track->GetTPCInnerParam()){
1172 track->GetTPCInnerParam()->GetPxPyPz(pDCA);
1173 track->GetTPCInnerParam()->GetXYZ(rDCA);
1175 // get the DCA to the vertex:
1176 track->GetImpactParametersTPC(dDCA,cDCA);
1177 // set the constrained parameters to the track
1178 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
1181 track->GetPxPyPz(p);
1183 Float_t pT = track->Pt();
1184 if(pT<ptMin||pT>ptMax){
1193 track->GetCovarianceXYZPxPyPz(covTr);
1194 esdTrack->GetESDpid(pid);// original PID
1196 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
1197 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,
1204 (Short_t)track->GetSign(),
1205 track->GetITSClusterMap(),
1208 kTRUE, // check if this is right
1209 vtx->UsesTrack(track->GetID()),
1210 AliAODTrack::kPrimary,
1212 aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC);
1213 aodTrack->SetTPCFitMap(track->GetTPCFitMap());
1214 aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());
1215 aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());
1216 aodTrack->SetIsTPCConstrained(kTRUE);
1217 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack)); // original track
1218 // set the DCA values to the AOD track
1219 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
1220 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);
1221 aodTrack->SetDCA(dDCA[0],dDCA[1]);
1223 aodTrack->SetFlags(track->GetStatus());
1224 aodTrack->SetTPCPointsF(track->GetTPCNclsF());
1225 aodTrack->SetTPCNCrossedRows(UShort_t(track->GetTPCCrossedRows()));
1227 //Perform progagation of tracks if needed
1228 if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
1229 aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
1231 // do not duplicate PID information
1232 // aodTrack->ConvertAliPIDtoAODPID();
1233 // SetAODPID(esdTrack,aodTrack,detpid);
1236 } // end of loop on tracks
1240 //______________________________________________________________________________
1241 void AliAnalysisTaskESDfilter::ConvertGlobalConstrainedTracks(const AliESDEvent& esd)
1244 // Here we have the option to store the complement from global constraint information
1245 // to tracks passing tight cuts (1) in order not to get fakes back in, one needs
1246 // two sets of cuts one tight (1) (to throw out fakes) and one lose (2) (fakes/bad tracks would pass (2) but not (1))
1247 // using cut number (3) selects the tracks that complement (1) e.g. tracks witout ITS refit or cluster requirement
1250 AliCodeTimerAuto("",0);
1252 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks
1253 for(int it = 0;it < fNumberOfTracks;++it)
1255 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));
1257 UInt_t map = tr->GetFilterMap();
1258 if(map&fGlobalConstrainedFilterMask){
1259 // we only reset the track select info, no deletion...
1260 // mask reset mask in case track is already taken
1261 tr->SetFilterMap(map&~fGlobalConstrainedFilterMask);
1263 if(map&fHybridFilterMaskGCG){
1264 // this is one part of the hybrid tracks
1265 // the others not passing the selection will be the ones selected below
1266 tr->SetIsHybridGlobalConstrainedGlobal(kTRUE);
1269 // Loop over the ESD trcks and pick out the tracks passing the GlobalConstraint cuts
1272 Double_t pos[3] = { 0. };
1273 Double_t covTr[21]={0.};
1274 Double_t pid[10]={0.};
1275 Double_t p[3] = { 0. };
1277 Double_t pDCA[3] = { 0. }; // momentum at DCA
1278 Double_t rDCA[3] = { 0. }; // position at DCA
1279 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
1280 Float_t cDCA[3] = {0.}; // covariance of impact parameters
1283 AliAODTrack* aodTrack(0x0);
1284 AliAODPid* detpid(0x0);
1285 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1287 // account for change in pT after the constraint
1288 Float_t ptMax = 1E10;
1290 for(int i = 0;i<32;i++){
1291 if(fGlobalConstrainedFilterMask&(1<<i)){
1292 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);
1293 Float_t tmp1= 0,tmp2 = 0;
1294 cuts->GetPtRange(tmp1,tmp2);
1295 if(tmp1>ptMin)ptMin=tmp1;
1296 if(tmp2<ptMax)ptMax=tmp2;
1302 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
1304 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy
1305 const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam();
1306 if(!exParamGC)continue;
1308 UInt_t selectInfo = 0;
1309 Bool_t isHybridGC = false;
1314 selectInfo = fTrackFilter->IsSelected(esdTrack);
1318 if(!(selectInfo&fHybridFilterMaskGCG))isHybridGC = true;
1319 if (fWriteHybridGCOnly&&!isHybridGC)continue; // write only complementary tracks
1321 selectInfo &= fGlobalConstrainedFilterMask;
1322 if (!selectInfo)continue;
1323 // fetch the track parameters at the DCA (unconstrained)
1324 esdTrack->GetPxPyPz(pDCA);
1325 esdTrack->GetXYZ(rDCA);
1326 // get the DCA to the vertex:
1327 esdTrack->GetImpactParameters(dDCA,cDCA);
1329 if (!esdTrack->GetConstrainedPxPyPz(p)) continue;
1332 Float_t pT = exParamGC->Pt();
1333 if(pT<ptMin||pT>ptMax){
1338 esdTrack->GetConstrainedXYZ(pos);
1339 exParamGC->GetCovarianceXYZPxPyPz(covTr);
1340 esdTrack->GetESDpid(pid);
1341 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
1342 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((esdTrack->GetID()+1)*-1,
1343 esdTrack->GetLabel(),
1349 (Short_t)esdTrack->GetSign(),
1350 esdTrack->GetITSClusterMap(),
1353 kTRUE, // check if this is right
1354 vtx->UsesTrack(esdTrack->GetID()),
1355 AliAODTrack::kPrimary,
1357 aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC);
1358 aodTrack->SetIsGlobalConstrained(kTRUE);
1359 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());
1360 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
1361 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
1362 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
1365 // set the DCA values to the AOD track
1366 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
1367 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);
1368 aodTrack->SetDCA(dDCA[0],dDCA[1]);
1370 aodTrack->SetFlags(esdTrack->GetStatus());
1371 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
1372 aodTrack->SetTPCNCrossedRows(UShort_t(esdTrack->GetTPCCrossedRows()));
1375 // only copy AOD information for hybrid, no duplicate information
1376 aodTrack->ConvertAliPIDtoAODPID();
1377 SetAODPID(esdTrack,aodTrack,detpid);
1380 //Perform progagation of tracks if needed
1381 if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
1382 aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
1383 } // end of loop on tracks
1388 //______________________________________________________________________________
1389 void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)
1391 // Tracks (primary and orphan)
1393 AliCodeTimerAuto("",0);
1395 AliDebug(1,Form("NUMBER OF ESD TRACKS %5d\n", esd.GetNumberOfTracks()));
1397 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1398 Double_t p[3] = { 0. };
1399 Double_t pos[3] = { 0. };
1400 Double_t covTr[21] = { 0. };
1401 Double_t pid[10] = { 0. };
1402 AliAODTrack* aodTrack(0x0);
1403 AliAODPid* detpid(0x0);
1405 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
1407 if (fUsedTrack[nTrack]) continue;
1409 AliESDtrack *esdTrack = esd.GetTrack(nTrack);
1410 UInt_t selectInfo = 0;
1414 selectInfo = fTrackFilter->IsSelected(esdTrack);
1415 if (!selectInfo && !vtx->UsesTrack(esdTrack->GetID())) continue;
1419 esdTrack->GetPxPyPz(p);
1420 esdTrack->GetXYZ(pos);
1421 esdTrack->GetCovarianceXYZPxPyPz(covTr);
1422 esdTrack->GetESDpid(pid);
1423 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
1424 fPrimaryVertex->AddDaughter(aodTrack =
1425 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrack->GetID(),
1426 esdTrack->GetLabel(),
1432 (Short_t)esdTrack->GetSign(),
1433 esdTrack->GetITSClusterMap(),
1436 kTRUE, // check if this is right
1437 vtx->UsesTrack(esdTrack->GetID()),
1438 AliAODTrack::kPrimary,
1441 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());
1442 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
1443 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
1444 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
1445 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
1446 aodTrack->SetTPCNCrossedRows(UShort_t(esdTrack->GetTPCCrossedRows()));
1447 if(esdTrack->IsEMCAL()) aodTrack->SetEMCALcluster(esdTrack->GetEMCALcluster());
1448 if(esdTrack->IsPHOS()) aodTrack->SetPHOScluster(esdTrack->GetPHOScluster());
1450 //Perform progagation of tracks if needed
1451 if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
1452 aodTrack->SetTrackPhiEtaOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal());
1454 fAODTrackRefs->AddAt(aodTrack, nTrack);
1457 if (esdTrack->GetSign() > 0) ++fNumberOfPositiveTracks;
1458 aodTrack->SetFlags(esdTrack->GetStatus());
1459 aodTrack->ConvertAliPIDtoAODPID();
1460 SetAODPID(esdTrack,aodTrack,detpid);
1461 } // end of loop on tracks
1464 //______________________________________________________________________________
1465 void AliAnalysisTaskESDfilter::PropagateTrackToEMCal(AliESDtrack *esdTrack)
1467 Double_t trkPos[3] = {0.,0.,0.};
1468 Double_t EMCalEta=-999, EMCalPhi=-999;
1469 Double_t trkphi = esdTrack->Phi()*TMath::RadToDeg();
1470 if(TMath::Abs(esdTrack->Eta())<0.9 && trkphi > 10 && trkphi < 250 )
1472 AliExternalTrackParam *trkParam = const_cast<AliExternalTrackParam*>(esdTrack->GetInnerParam());
1475 AliExternalTrackParam trkParamTmp(*trkParam);
1476 if(AliTrackerBase::PropagateTrackToBxByBz(&trkParamTmp, 430, esdTrack->GetMass(), 20, kTRUE, 0.8, -1))
1478 trkParamTmp.GetXYZ(trkPos);
1479 TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);
1480 EMCalEta = trkPosVec.Eta();
1481 EMCalPhi = trkPosVec.Phi();
1482 if(EMCalPhi<0) EMCalPhi += 2*TMath::Pi();
1483 esdTrack->SetTrackPhiEtaOnEMCal(EMCalPhi,EMCalEta);
1489 //______________________________________________________________________________
1490 void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)
1492 // Convert PMD Clusters
1493 AliCodeTimerAuto("",0);
1494 Int_t jPmdClusters=0;
1495 // Access to the AOD container of PMD clusters
1496 TClonesArray &pmdClusters = *(AODEvent()->GetPmdClusters());
1497 for (Int_t iPmd = 0; iPmd < esd.GetNumberOfPmdTracks(); ++iPmd) {
1498 // file pmd clusters, to be revised!
1499 AliESDPmdTrack *pmdTrack = esd.GetPmdTrack(iPmd);
1502 Double_t posPmd[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ()};
1503 Double_t pidPmd[13] = { 0.}; // to be revised!
1505 // assoc cluster not set
1506 new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), posPmd, pidPmd);
1511 //______________________________________________________________________________
1512 void AliAnalysisTaskESDfilter::ConvertCaloClusters(const AliESDEvent& esd)
1514 // Convert Calorimeter Clusters
1515 AliCodeTimerAuto("",0);
1517 // Access to the AOD container of clusters
1518 TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
1521 for (Int_t iClust=0; iClust<esd.GetNumberOfCaloClusters(); ++iClust) {
1523 AliESDCaloCluster * cluster = esd.GetCaloCluster(iClust);
1525 Int_t id = cluster->GetID();
1526 Int_t nLabel = cluster->GetNLabels();
1527 Int_t *labels = cluster->GetLabels();
1529 for(int i = 0;i < nLabel;++i){
1530 if(fMChandler)fMChandler->SelectParticle(labels[i]);
1534 Float_t energy = cluster->E();
1535 Float_t posF[3] = { 0.};
1536 cluster->GetPosition(posF);
1538 AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
1544 cluster->GetType(),0);
1546 caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),
1547 cluster->GetDispersion(),
1548 cluster->GetM20(), cluster->GetM02(),
1549 cluster->GetEmcCpvDistance(),
1550 cluster->GetNExMax(),cluster->GetTOF()) ;
1552 caloCluster->SetPIDFromESD(cluster->GetPID());
1553 caloCluster->SetNCells(cluster->GetNCells());
1554 caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
1555 caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
1557 caloCluster->SetTrackDistance(cluster->GetTrackDx(), cluster->GetTrackDz());
1559 Int_t nMatchCount = 0;
1560 TArrayI* matchedT = cluster->GetTracksMatched();
1561 if (fNumberOfTracks>0 && matchedT && cluster->GetTrackMatchedIndex() >= 0) {
1562 for (Int_t im = 0; im < matchedT->GetSize(); im++) {
1563 Int_t iESDtrack = matchedT->At(im);;
1564 if (fAODTrackRefs->At(iESDtrack) != 0) {
1565 caloCluster->AddTrackMatched((AliAODTrack*)fAODTrackRefs->At(iESDtrack));
1571 caloCluster->SetTrackDistance(-999,-999);
1574 caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
1577 //______________________________________________________________________________
1578 void AliAnalysisTaskESDfilter::ConvertCaloTrigger(TString calo, const AliESDEvent& esd)
1580 AliCodeTimerAuto("",0);
1584 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));
1585 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));
1587 aodTrigger.Allocate(esdTrigger.GetEntries());
1593 while (esdTrigger.Next()) {
1594 esdTrigger.GetPosition(tmod,tabsId);
1595 esdTrigger.GetAmplitude(a);
1596 aodTrigger.Add(tmod,tabsId,a,0.,(Int_t*)NULL,0,0,0);
1602 AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
1606 TTree *aodTree = aodHandler->GetTree();
1610 Int_t *type = esd.GetCaloTriggerType();
1612 for (Int_t i = 0; i < 15; i++)
1614 aodTree->GetUserInfo()->Add(new TParameter<int>(Form("EMCALCaloTrigger%d",i), type[i]));
1619 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));
1621 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));
1623 aodTrigger.Allocate(esdTrigger.GetEntries());
1626 while (esdTrigger.Next())
1628 Int_t px, py, ts, nTimes, times[10], b;
1631 esdTrigger.GetPosition(px, py);
1633 esdTrigger.GetAmplitude(a);
1634 esdTrigger.GetTime(t);
1636 esdTrigger.GetL0Times(times);
1637 esdTrigger.GetNL0Times(nTimes);
1639 esdTrigger.GetL1TimeSum(ts);
1641 esdTrigger.GetTriggerBits(b);
1643 aodTrigger.Add(px, py, a, t, times, nTimes, ts, b);
1646 for (int i = 0; i < 4; i++) aodTrigger.SetL1Threshold(i, esdTrigger.GetL1Threshold(i));
1650 esdTrigger.GetL1V0(0),
1651 esdTrigger.GetL1V0(1)
1654 aodTrigger.SetL1V0(v0);
1655 aodTrigger.SetL1FrameMask(esdTrigger.GetL1FrameMask());
1658 //______________________________________________________________________________
1659 void AliAnalysisTaskESDfilter::ConvertEMCALCells(const AliESDEvent& esd)
1661 // Convert EMCAL Cells
1662 AliCodeTimerAuto("",0);
1663 // fill EMCAL cell info
1664 if (esd.GetEMCALCells()) { // protection against missing ESD information
1665 AliESDCaloCells &esdEMcells = *(esd.GetEMCALCells());
1666 Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
1668 AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
1669 aodEMcells.CreateContainer(nEMcell);
1670 aodEMcells.SetType(AliAODCaloCells::kEMCALCell);
1671 for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
1672 aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell),
1673 esdEMcells.GetTime(iCell), esdEMcells.GetMCLabel(iCell), esdEMcells.GetEFraction(iCell));
1679 //______________________________________________________________________________
1680 void AliAnalysisTaskESDfilter::ConvertPHOSCells(const AliESDEvent& esd)
1682 // Convert PHOS Cells
1683 AliCodeTimerAuto("",0);
1684 // fill PHOS cell info
1685 if (esd.GetPHOSCells()) { // protection against missing ESD information
1686 AliESDCaloCells &esdPHcells = *(esd.GetPHOSCells());
1687 Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
1689 AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
1690 aodPHcells.CreateContainer(nPHcell);
1691 aodPHcells.SetType(AliAODCaloCells::kPHOSCell);
1692 for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
1693 aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell),
1694 esdPHcells.GetTime(iCell), esdPHcells.GetMCLabel(iCell), esdPHcells.GetEFraction(iCell));
1700 //______________________________________________________________________________
1701 void AliAnalysisTaskESDfilter::ConvertTracklets(const AliESDEvent& esd)
1704 AliCodeTimerAuto("",0);
1706 AliAODTracklets &SPDTracklets = *(AODEvent()->GetTracklets());
1707 const AliMultiplicity *mult = esd.GetMultiplicity();
1709 if (mult->GetNumberOfTracklets()>0) {
1710 SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
1712 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
1714 fMChandler->SelectParticle(mult->GetLabel(n, 0));
1715 fMChandler->SelectParticle(mult->GetLabel(n, 1));
1717 SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));
1721 //Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
1725 //______________________________________________________________________________
1726 void AliAnalysisTaskESDfilter::ConvertKinks(const AliESDEvent& esd)
1728 AliCodeTimerAuto("",0);
1730 // Kinks: it is a big mess the access to the information in the kinks
1731 // The loop is on the tracks in order to find the mother and daugther of each kink
1733 Double_t covTr[21]={0.};
1734 Double_t pid[10]={0.};
1735 AliAODPid* detpid(0x0);
1737 fNumberOfKinks = esd.GetNumberOfKinks();
1739 const AliESDVertex* vtx = esd.GetPrimaryVertex();
1741 for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack)
1743 AliESDtrack * esdTrack = esd.GetTrack(iTrack);
1745 Int_t ikink = esdTrack->GetKinkIndex(0);
1747 if (ikink && fNumberOfKinks) {
1748 // Negative kink index: mother, positive: daughter
1750 // Search for the second track of the kink
1752 for (Int_t jTrack = iTrack+1; jTrack<esd.GetNumberOfTracks(); ++jTrack) {
1754 AliESDtrack * esdTrack1 = esd.GetTrack(jTrack);
1756 Int_t jkink = esdTrack1->GetKinkIndex(0);
1758 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
1760 // The two tracks are from the same kink
1762 if (fUsedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
1765 Int_t idaughter = -1;
1767 if (ikink<0 && jkink>0) {
1772 else if (ikink>0 && jkink<0) {
1778 // cerr << "Error: Wrong combination of kink indexes: "
1779 // << ikink << " " << jkink << endl;
1783 // Add the mother track if it passed primary track selection cuts
1785 AliAODTrack * mother = NULL;
1787 UInt_t selectInfo = 0;
1789 selectInfo = fTrackFilter->IsSelected(esd.GetTrack(imother));
1790 if (!selectInfo) continue;
1793 if (!fUsedTrack[imother]) {
1795 fUsedTrack[imother] = kTRUE;
1797 AliESDtrack *esdTrackM = esd.GetTrack(imother);
1798 Double_t p[3] = { 0. };
1799 Double_t pos[3] = { 0. };
1800 esdTrackM->GetPxPyPz(p);
1801 esdTrackM->GetXYZ(pos);
1802 esdTrackM->GetCovarianceXYZPxPyPz(covTr);
1803 esdTrackM->GetESDpid(pid);
1804 if(fMChandler)fMChandler->SelectParticle(esdTrackM->GetLabel());
1806 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackM->GetID(),
1807 esdTrackM->GetLabel(),
1813 (Short_t)esdTrackM->GetSign(),
1814 esdTrackM->GetITSClusterMap(),
1817 kTRUE, // check if this is right
1818 vtx->UsesTrack(esdTrack->GetID()),
1819 AliAODTrack::kPrimary,
1821 mother->SetTPCFitMap(esdTrackM->GetTPCFitMap());
1822 mother->SetTPCClusterMap(esdTrackM->GetTPCClusterMap());
1823 mother->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());
1824 mother->SetChi2perNDF(Chi2perNDF(esdTrackM));
1825 mother->SetTPCPointsF(esdTrackM->GetTPCNclsF());
1826 mother->SetTPCNCrossedRows(UShort_t(esdTrackM->GetTPCCrossedRows()));
1828 fAODTrackRefs->AddAt(mother, imother);
1830 if (esdTrackM->GetSign() > 0) ++fNumberOfPositiveTracks;
1831 mother->SetFlags(esdTrackM->GetStatus());
1832 mother->ConvertAliPIDtoAODPID();
1833 fPrimaryVertex->AddDaughter(mother);
1834 mother->ConvertAliPIDtoAODPID();
1835 SetAODPID(esdTrackM,mother,detpid);
1838 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
1839 // << " track " << imother << " has already been used!" << endl;
1842 // Add the kink vertex
1843 AliESDkink * kink = esd.GetKink(TMath::Abs(ikink)-1);
1845 AliAODVertex * vkink =
1846 new(Vertices()[fNumberOfVertices++]) AliAODVertex(kink->GetPosition(),
1850 esdTrack->GetID(), // This is the track ID of the mother's track!
1851 AliAODVertex::kKink);
1852 // Add the daughter track
1854 AliAODTrack * daughter = NULL;
1856 if (!fUsedTrack[idaughter]) {
1858 fUsedTrack[idaughter] = kTRUE;
1860 AliESDtrack *esdTrackD = esd.GetTrack(idaughter);
1861 Double_t p[3] = { 0. };
1862 Double_t pos[3] = { 0. };
1864 esdTrackD->GetPxPyPz(p);
1865 esdTrackD->GetXYZ(pos);
1866 esdTrackD->GetCovarianceXYZPxPyPz(covTr);
1867 esdTrackD->GetESDpid(pid);
1869 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdTrackD);
1870 if(fMChandler)fMChandler->SelectParticle(esdTrackD->GetLabel());
1872 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackD->GetID(),
1873 esdTrackD->GetLabel(),
1879 (Short_t)esdTrackD->GetSign(),
1880 esdTrackD->GetITSClusterMap(),
1883 kTRUE, // check if this is right
1884 vtx->UsesTrack(esdTrack->GetID()),
1885 AliAODTrack::kSecondary,
1887 daughter->SetTPCFitMap(esdTrackD->GetTPCFitMap());
1888 daughter->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());
1889 daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());
1890 daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());
1891 daughter->SetTPCNCrossedRows(UShort_t(esdTrackD->GetTPCCrossedRows()));
1892 fAODTrackRefs->AddAt(daughter, idaughter);
1894 if (esdTrackD->GetSign() > 0) ++fNumberOfPositiveTracks;
1895 daughter->SetFlags(esdTrackD->GetStatus());
1896 daughter->ConvertAliPIDtoAODPID();
1897 vkink->AddDaughter(daughter);
1898 daughter->ConvertAliPIDtoAODPID();
1899 SetAODPID(esdTrackD,daughter,detpid);
1902 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
1903 // << " track " << idaughter << " has already been used!" << endl;
1911 //______________________________________________________________________________
1912 void AliAnalysisTaskESDfilter::ConvertPrimaryVertices(const AliESDEvent& esd)
1914 AliCodeTimerAuto("",0);
1916 // Access to the AOD container of vertices
1917 fNumberOfVertices = 0;
1919 Double_t pos[3] = { 0. };
1920 Double_t covVtx[6] = { 0. };
1922 // Add primary vertex. The primary tracks will be defined
1923 // after the loops on the composite objects (V0, cascades, kinks)
1924 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1926 vtx->GetXYZ(pos); // position
1927 vtx->GetCovMatrix(covVtx); //covariance matrix
1929 fPrimaryVertex = new(Vertices()[fNumberOfVertices++])
1930 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
1931 fPrimaryVertex->SetName(vtx->GetName());
1932 fPrimaryVertex->SetTitle(vtx->GetTitle());
1933 fPrimaryVertex->SetBC(vtx->GetBC());
1935 TString vtitle = vtx->GetTitle();
1936 if (!vtitle.Contains("VertexerTracks"))
1937 fPrimaryVertex->SetNContributors(vtx->GetNContributors());
1939 if (fDebug > 0) fPrimaryVertex->Print();
1941 // Add SPD "main" vertex
1942 const AliESDVertex *vtxS = esd.GetPrimaryVertexSPD();
1943 vtxS->GetXYZ(pos); // position
1944 vtxS->GetCovMatrix(covVtx); //covariance matrix
1945 AliAODVertex * mVSPD = new(Vertices()[fNumberOfVertices++])
1946 AliAODVertex(pos, covVtx, vtxS->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainSPD);
1947 mVSPD->SetName(vtxS->GetName());
1948 mVSPD->SetTitle(vtxS->GetTitle());
1949 mVSPD->SetNContributors(vtxS->GetNContributors());
1951 // Add SPD pileup vertices
1952 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesSPD(); ++iV)
1954 const AliESDVertex *vtxP = esd.GetPileupVertexSPD(iV);
1955 vtxP->GetXYZ(pos); // position
1956 vtxP->GetCovMatrix(covVtx); //covariance matrix
1957 AliAODVertex * pVSPD = new(Vertices()[fNumberOfVertices++])
1958 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupSPD);
1959 pVSPD->SetName(vtxP->GetName());
1960 pVSPD->SetTitle(vtxP->GetTitle());
1961 pVSPD->SetNContributors(vtxP->GetNContributors());
1962 pVSPD->SetBC(vtxP->GetBC());
1965 // Add TRK pileup vertices
1966 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesTracks(); ++iV)
1968 const AliESDVertex *vtxP = esd.GetPileupVertexTracks(iV);
1969 vtxP->GetXYZ(pos); // position
1970 vtxP->GetCovMatrix(covVtx); //covariance matrix
1971 AliAODVertex * pVTRK = new(Vertices()[fNumberOfVertices++])
1972 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupTracks);
1973 pVTRK->SetName(vtxP->GetName());
1974 pVTRK->SetTitle(vtxP->GetTitle());
1975 pVTRK->SetNContributors(vtxP->GetNContributors());
1976 pVTRK->SetBC(vtxP->GetBC());
1979 // Add TPC "main" vertex
1980 const AliESDVertex *vtxT = esd.GetPrimaryVertexTPC();
1981 vtxT->GetXYZ(pos); // position
1982 vtxT->GetCovMatrix(covVtx); //covariance matrix
1983 AliAODVertex * mVTPC = new(Vertices()[fNumberOfVertices++])
1984 AliAODVertex(pos, covVtx, vtxT->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainTPC);
1985 mVTPC->SetName(vtxT->GetName());
1986 mVTPC->SetTitle(vtxT->GetTitle());
1987 mVTPC->SetNContributors(vtxT->GetNContributors());
1992 //______________________________________________________________________________
1993 void AliAnalysisTaskESDfilter::ConvertVZERO(const AliESDEvent& esd)
1995 // Convert VZERO data
1996 AliAODVZERO* vzeroData = AODEvent()->GetVZEROData();
1997 *vzeroData = *(esd.GetVZEROData());
2000 //______________________________________________________________________________
2001 void AliAnalysisTaskESDfilter::ConvertTZERO(const AliESDEvent& esd)
2003 // Convert TZERO data
2004 const AliESDTZERO* esdTzero = esd.GetESDTZERO();
2005 AliAODTZERO* aodTzero = AODEvent()->GetTZEROData();
2007 for (Int_t icase=0; icase<3; icase++){
2008 aodTzero->SetT0TOF( icase, esdTzero->GetT0TOF(icase));
2009 aodTzero->SetT0TOFbest(icase, esdTzero->GetT0TOFbest(icase));
2011 aodTzero->SetBackgroundFlag(esdTzero->GetBackgroundFlag());
2012 aodTzero->SetPileupFlag(esdTzero->GetPileupFlag());
2013 aodTzero->SetSatelliteFlag(esdTzero->GetSatellite());
2015 Float_t rawTime[24];
2016 for(Int_t ipmt=0; ipmt<24; ipmt++)
2017 rawTime[ipmt] = esdTzero->GetTimeFull(ipmt,0);
2019 Int_t idxOfFirstPmtA = -1, idxOfFirstPmtC = -1;
2020 Float_t timeOfFirstPmtA = 9999, timeOfFirstPmtC = 9999;
2021 for(int ipmt=0; ipmt<12; ipmt++){
2022 if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtC && rawTime[ipmt]!=0){
2023 timeOfFirstPmtC = rawTime[ipmt];
2024 idxOfFirstPmtC = ipmt;
2027 for(int ipmt=12; ipmt<24; ipmt++){
2028 if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtA && rawTime[ipmt]!=0 ){
2029 timeOfFirstPmtA = rawTime[ipmt];
2030 idxOfFirstPmtA = ipmt;
2034 if(idxOfFirstPmtA != -1 && idxOfFirstPmtC != -1){
2035 //speed of light in cm/ns TMath::C()*1e-7
2036 Float_t vertexraw = TMath::C()*1e-7 * (rawTime[idxOfFirstPmtA] - rawTime[idxOfFirstPmtC])/2;
2037 aodTzero->SetT0VertexRaw( vertexraw );
2039 aodTzero->SetT0VertexRaw(99999);
2042 aodTzero->SetT0zVertex(esdTzero->GetT0zVertex());
2046 //______________________________________________________________________________
2047 void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)
2050 AliESDZDC* esdZDC = esd.GetZDCData();
2052 const Double_t zem1Energy = esdZDC->GetZEM1Energy();
2053 const Double_t zem2Energy = esdZDC->GetZEM2Energy();
2055 const Double_t *towZNC = esdZDC->GetZNCTowerEnergy();
2056 const Double_t *towZPC = esdZDC->GetZPCTowerEnergy();
2057 const Double_t *towZNA = esdZDC->GetZNATowerEnergy();
2058 const Double_t *towZPA = esdZDC->GetZPATowerEnergy();
2059 const Double_t *towZNCLG = esdZDC->GetZNCTowerEnergyLR();
2060 const Double_t *towZNALG = esdZDC->GetZNATowerEnergyLR();
2062 AliAODZDC* zdcAOD = AODEvent()->GetZDCData();
2064 zdcAOD->SetZEM1Energy(zem1Energy);
2065 zdcAOD->SetZEM2Energy(zem2Energy);
2066 zdcAOD->SetZNCTowers(towZNC, towZNCLG);
2067 zdcAOD->SetZNATowers(towZNA, towZNALG);
2068 zdcAOD->SetZPCTowers(towZPC);
2069 zdcAOD->SetZPATowers(towZPA);
2071 zdcAOD->SetZDCParticipants(esdZDC->GetZDCParticipants(), esdZDC->GetZDCPartSideA(), esdZDC->GetZDCPartSideC());
2072 zdcAOD->SetZDCImpactParameter(esdZDC->GetImpactParameter(), esdZDC->GetImpactParamSideA(),
2073 esdZDC->GetImpactParamSideC());
2074 zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0));
2075 zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0));
2076 if(esdZDC->IsZNChit()) zdcAOD->SetZNCTDC(esdZDC->GetZDCTDCCorrected(10,0));
2077 if(esdZDC->IsZNAhit()) zdcAOD->SetZNATDC(esdZDC->GetZDCTDCCorrected(12,0));
2080 //_______________________________________________________________________________________________________________________________________
2081 Int_t AliAnalysisTaskESDfilter::ConvertHMPID(const AliESDEvent& esd) // clm
2084 // Convtert ESD HMPID info to AOD and return the number of good tracks with HMPID signal.
2085 // We need to return an int since there is no signal counter in the ESD.
2088 AliCodeTimerAuto("",0);
2090 Int_t cntHmpidGoodTracks = 0;
2099 Float_t thetaTrk = 0;
2102 Double_t hmpPid[5]={0};
2103 Double_t hmpMom[3]={0};
2105 TClonesArray &hmpidRings = *(AODEvent()->GetHMPIDrings());
2107 for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack)
2109 if(! esd.GetTrack(iTrack) ) continue;
2111 if(esd.GetTrack(iTrack)->GetHMPIDsignal() > -20 ) { //
2113 (esd.GetTrack(iTrack))->GetHMPIDmip(xMip, yMip, qMip, nphMip); // Get MIP properties
2114 (esd.GetTrack(iTrack))->GetHMPIDtrk(xTrk,yTrk,thetaTrk,phiTrk);
2115 (esd.GetTrack(iTrack))->GetHMPIDpid(hmpPid);
2116 if((esd.GetTrack(iTrack))->GetOuterHmpParam()) (esd.GetTrack(iTrack))->GetOuterHmpPxPyPz(hmpMom);
2118 if(esd.GetTrack(iTrack)->GetHMPIDsignal() == 0 && thetaTrk == 0 && qMip == 0 && nphMip ==0 ) continue; //
2120 new(hmpidRings[cntHmpidGoodTracks++]) AliAODHMPIDrings(
2121 (esd.GetTrack(iTrack))->GetID(), // Unique track id to attach the ring to
2122 1000000*nphMip+qMip, // MIP charge and number of photons
2123 (esd.GetTrack(iTrack))->GetHMPIDcluIdx(), // 1000000*chamber id + cluster idx of the assigned MIP cluster
2124 thetaTrk, // track inclination angle theta
2125 phiTrk, // track inclination angle phi
2126 (esd.GetTrack(iTrack))->GetHMPIDsignal(), // Cherenkov angle
2127 (esd.GetTrack(iTrack))->GetHMPIDoccupancy(), // Occupancy claculated for the given chamber
2128 (esd.GetTrack(iTrack))->GetHMPIDchi2(), // Ring resolution squared
2129 xTrk, // Track x coordinate (LORS)
2130 yTrk, // Track y coordinate (LORS)
2131 xMip, // MIP x coordinate (LORS)
2132 yMip, // MIP y coordinate (LORS)
2133 hmpPid, // PID probablities from ESD, remove later once it is in CombinedPid
2134 hmpMom // Track momentum in HMPID at ring reconstruction
2137 // Printf(Form("+++++++++ yes/no: %d %lf %lf %lf %lf %lf %lf ",(esd.GetTrack(iTrack))->IsHMPID(),thetaTrk, (esd.GetTrack(iTrack))->GetHMPIDchi2(),xTrk, yTrk , xMip, yMip));
2140 }// HMPID signal > -20
2141 }//___esd track loop
2143 return cntHmpidGoodTracks;
2146 //______________________________________________________________________________
2147 void AliAnalysisTaskESDfilter::ConvertESDtoAOD()
2149 // ESD Filter analysis task executed for each event
2151 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
2155 AliCodeTimerAuto("",0);
2157 fOldESDformat = ( esd->GetAliESDOld() != 0x0 );
2159 // Reconstruct cascades and V0 here
2160 if (fIsV0CascadeRecoEnabled) {
2161 esd->ResetCascades();
2164 AliV0vertexer lV0vtxer;
2165 AliCascadeVertexer lCascVtxer;
2167 lV0vtxer.SetCuts(fV0Cuts);
2168 lCascVtxer.SetCuts(fCascadeCuts);
2171 lV0vtxer.Tracks2V0vertices(esd);
2172 lCascVtxer.V0sTracks2CascadeVertices(esd);
2176 fNumberOfTracks = 0;
2177 fNumberOfPositiveTracks = 0;
2179 fNumberOfVertices = 0;
2180 fNumberOfCascades = 0;
2183 AliAODHeader* header = ConvertHeader(*esd);
2185 if ( fIsVZEROEnabled ) ConvertVZERO(*esd);
2186 if ( fIsTZEROEnabled ) ConvertTZERO(*esd);
2188 // Fetch Stack for debuggging if available
2192 fMChandler = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
2195 // loop over events and fill them
2196 // Multiplicity information needed by the header (to be revised!)
2197 Int_t nTracks = esd->GetNumberOfTracks();
2198 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
2200 // Update the header
2202 Int_t nV0s = esd->GetNumberOfV0s();
2203 Int_t nCascades = esd->GetNumberOfCascades();
2204 Int_t nKinks = esd->GetNumberOfKinks();
2205 Int_t nVertices = nV0s + nCascades /*V0 wihtin cascade already counted*/+ nKinks + 1 /* = prim. vtx*/;
2206 Int_t nPileSPDVertices=1+esd->GetNumberOfPileupVerticesSPD(); // also SPD main vertex
2207 Int_t nPileTrkVertices=esd->GetNumberOfPileupVerticesTracks();
2208 nVertices+=nPileSPDVertices;
2209 nVertices+=nPileTrkVertices;
2211 Int_t nCaloClus = esd->GetNumberOfCaloClusters();
2213 Int_t nPmdClus = esd->GetNumberOfPmdTracks();
2214 Int_t nHmpidRings = 0;
2216 AliDebug(1,Form(" NV0=%d NCASCADES=%d NKINKS=%d", nV0s, nCascades, nKinks));
2218 AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus,nHmpidRings);
2222 // RefArray to store a mapping between esd V0 number and newly created AOD-Vertex V0
2223 fAODV0VtxRefs = new TRefArray(nV0s);
2224 // RefArray to store the mapping between esd V0 number and newly created AOD-V0
2225 fAODV0Refs = new TRefArray(nV0s);
2226 // Array to take into account the V0s already added to the AOD (V0 within cascades)
2227 fUsedV0 = new Bool_t[nV0s];
2228 for (Int_t iV0=0; iV0<nV0s; ++iV0) fUsedV0[iV0]=kFALSE;
2233 // RefArray to store the mapping between esd track number and newly created AOD-Track
2235 fAODTrackRefs = new TRefArray(nTracks);
2237 // Array to take into account the tracks already added to the AOD
2238 fUsedTrack = new Bool_t[nTracks];
2239 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) fUsedTrack[iTrack]=kFALSE;
2242 // Array to take into account the kinks already added to the AOD
2245 fUsedKink = new Bool_t[nKinks];
2246 for (Int_t iKink=0; iKink<nKinks; ++iKink) fUsedKink[iKink]=kFALSE;
2249 ConvertPrimaryVertices(*esd);
2251 //setting best TOF PID
2252 AliESDInputHandler* esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
2254 fESDpid = esdH->GetESDpid();
2256 if (fIsPidOwner && fESDpid){
2261 { //in case of no Tender attached
2262 fESDpid = new AliESDpid;
2263 fIsPidOwner = kTRUE;
2266 if(!esd->GetTOFHeader())
2267 { //protection in case the pass2 LHC10b,c,d have been processed without tender.
2268 Float_t t0spread[10];
2269 Float_t intrinsicTOFres=100; //ps ok for LHC10b,c,d pass2!!
2270 for (Int_t i=0; i<10; i++) t0spread[i] = (TMath::Sqrt(esd->GetSigma2DiamondZ()))/0.03; //0.03 to convert from cm to ps
2271 fESDpid->GetTOFResponse().SetT0resolution(t0spread);
2272 fESDpid->GetTOFResponse().SetTimeResolution(intrinsicTOFres);
2273 // fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType);
2274 AliTOFHeader tmpTOFHeader(0,t0spread[0],0,NULL,NULL,NULL,intrinsicTOFres,t0spread[0]);
2275 AODEvent()->SetTOFHeader(&tmpTOFHeader); // write dummy TOF header in AOD
2277 AODEvent()->SetTOFHeader(esd->GetTOFHeader()); // write TOF header in AOD
2280 // if(esd->GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender.
2282 if ( fAreCascadesEnabled ) ConvertCascades(*esd);
2284 if ( fAreV0sEnabled ) ConvertV0s(*esd);
2286 if ( fAreKinksEnabled ) ConvertKinks(*esd);
2288 if ( fAreTracksEnabled ) ConvertTracks(*esd);
2290 // Update number of AOD tracks in header at the end of track loop (M.G.)
2291 header->SetRefMultiplicity(fNumberOfTracks);
2292 header->SetRefMultiplicityPos(fNumberOfPositiveTracks);
2293 header->SetRefMultiplicityNeg(fNumberOfTracks - fNumberOfPositiveTracks);
2295 if ( fTPCConstrainedFilterMask ) ConvertTPCOnlyTracks(*esd);
2296 if( fGlobalConstrainedFilterMask) ConvertGlobalConstrainedTracks(*esd);
2298 if ( fArePmdClustersEnabled ) ConvertPmdClusters(*esd);
2300 if ( fAreCaloClustersEnabled ) ConvertCaloClusters(*esd);
2302 if ( fAreEMCALCellsEnabled )ConvertEMCALCells(*esd);
2304 if ( fArePHOSCellsEnabled )ConvertPHOSCells(*esd);
2306 if ( fAreEMCALTriggerEnabled )ConvertCaloTrigger(TString("EMCAL"), *esd);
2308 if ( fArePHOSTriggerEnabled )ConvertCaloTrigger(TString("PHOS"), *esd);
2310 if ( fAreTrackletsEnabled ) ConvertTracklets(*esd);
2311 if ( fIsZDCEnabled ) ConvertZDC(*esd);
2313 if(fIsHMPIDEnabled) nHmpidRings = ConvertHMPID(*esd);
2315 delete fAODTrackRefs; fAODTrackRefs=0x0;
2316 delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;
2317 delete fAODV0Refs; fAODV0Refs=0x0;
2319 delete[] fUsedTrack; fUsedTrack=0x0;
2320 delete[] fUsedV0; fUsedV0=0x0;
2321 delete[] fUsedKink; fUsedKink=0x0;
2332 //______________________________________________________________________________
2333 void AliAnalysisTaskESDfilter::SetAODPID(AliESDtrack *esdtrack, AliAODTrack *aodtrack, AliAODPid *detpid)
2336 // Setter for the raw PID detector signals
2339 // Save PID object for candidate electrons
2340 Bool_t pidSave = kFALSE;
2342 Bool_t selectInfo = fTrackFilter->IsSelected((char*) "Electrons");
2343 if (selectInfo) pidSave = kTRUE;
2347 // Tracks passing pt cut
2348 if(esdtrack->Pt()>fHighPthreshold) {
2352 if(esdtrack->Pt()> fPtshape->GetXmin()){
2353 Double_t y = fPtshape->Eval(esdtrack->Pt())/fPtshape->Eval(fHighPthreshold);
2354 if(gRandom->Rndm(0)<1./y){
2358 }//end if p function
2362 if(!aodtrack->GetDetPid()){// prevent memory leak when calling SetAODPID twice for the same track
2363 detpid = new AliAODPid();
2364 SetDetectorRawSignals(detpid,esdtrack);
2365 aodtrack->SetDetPID(detpid);
2370 //______________________________________________________________________________
2371 void AliAnalysisTaskESDfilter::SetDetectorRawSignals(AliAODPid *aodpid, AliESDtrack *track)
2374 //assignment of the detector signals (AliXXXesdPID inspired)
2377 AliInfo("no ESD track found. .....exiting");
2381 const AliExternalTrackParam *in=track->GetInnerParam();
2383 aodpid->SetTPCmomentum(in->GetP());
2385 aodpid->SetTPCmomentum(-1.);
2389 aodpid->SetITSsignal(track->GetITSsignal());
2390 Double_t itsdedx[4]; // dE/dx samples for individual ITS layers
2391 track->GetITSdEdxSamples(itsdedx);
2392 aodpid->SetITSdEdxSamples(itsdedx);
2394 aodpid->SetTPCsignal(track->GetTPCsignal());
2395 aodpid->SetTPCsignalN(track->GetTPCsignalN());
2396 if(track->GetTPCdEdxInfo()) aodpid->SetTPCdEdxInfo(track->GetTPCdEdxInfo());
2399 Int_t nslices = track->GetNumberOfTRDslices()*6;
2400 TArrayD trdslices(nslices);
2401 for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {
2402 for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);
2406 for(Int_t iPl=0;iPl<6;iPl++){
2407 Double_t trdmom=track->GetTRDmomentum(iPl);
2408 aodpid->SetTRDmomentum(iPl,trdmom);
2411 aodpid->SetTRDslices(track->GetNumberOfTRDslices()*6,trdslices.GetArray());
2412 aodpid->SetTRDsignal(track->GetTRDsignal());
2414 //TRD clusters and tracklets
2415 aodpid->SetTRDncls(track->GetTRDncls());
2416 aodpid->SetTRDntrackletsPID(track->GetTRDntrackletsPID());
2418 aodpid->SetTRDChi2(track->GetTRDchi2());
2421 Double_t times[AliPID::kSPECIES]; track->GetIntegratedTimes(times);
2422 aodpid->SetIntegratedTimes(times);
2424 // Float_t tzeroTrack = fESDpid->GetTOFResponse().GetStartTime(track->P());
2425 // aodpid->SetTOFsignal(track->GetTOFsignal()-tzeroTrack);
2426 aodpid->SetTOFsignal(track->GetTOFsignal());
2429 for (Int_t iMass=0; iMass<5; iMass++){
2430 // tofRes[iMass]=(Double_t)fESDpid->GetTOFResponse().GetExpectedSigma(track->P(), times[iMass], AliPID::ParticleMass(iMass));
2431 tofRes[iMass]=0; //backward compatibility
2433 aodpid->SetTOFpidResolution(tofRes);
2435 // aodpid->SetHMPIDsignal(0); // set to zero for compression but it will be removed later
2439 Double_t AliAnalysisTaskESDfilter::Chi2perNDF(AliESDtrack* track)
2441 // Calculate chi2 per ndf for track
2442 Int_t nClustersTPC = track->GetTPCNcls();
2444 if ( nClustersTPC > 5) {
2445 return (track->GetTPCchi2()/Float_t(nClustersTPC - 5));
2452 //______________________________________________________________________________
2453 void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)
2455 // Terminate analysis
2457 if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
2460 //______________________________________________________________________________
2461 void AliAnalysisTaskESDfilter::PrintMCInfo(AliStack *pStack,Int_t label){
2464 label = TMath::Abs(label);
2465 TParticle *part = pStack->Particle(label);
2466 Printf("########################");
2467 Printf("%s:%d %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,label,part->GetUniqueID(),part->GetPdgCode(),part->P());
2469 TParticle* mother = part;
2470 Int_t imo = part->GetFirstMother();
2471 Int_t nprim = pStack->GetNprimary();
2472 // while((imo >= nprim) && (mother->GetUniqueID() == 4)) {
2473 while((imo >= nprim)) {
2474 mother = pStack->Particle(imo);
2475 Printf("Mother %s:%d Label %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,imo,mother->GetUniqueID(),mother->GetPdgCode(),mother->P());
2477 imo = mother->GetFirstMother();
2479 Printf("########################");
2482 //______________________________________________________