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),
119 fEMCalSurfaceDistance(440)
121 // Default constructor
122 fV0Cuts[0] = 33. ; // max allowed chi2
123 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter
124 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter
125 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks
126 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle
127 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume
128 fV0Cuts[6] = 100. ; // max radius of the fiducial volume
130 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)
131 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter
132 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass
133 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter
134 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor
135 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle
136 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume
137 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume
140 //______________________________________________________________________________
141 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):
142 AliAnalysisTaskSE(name),
149 fEnableFillAOD(kTRUE),
158 fNumberOfPositiveTracks(0),
160 fNumberOfVertices(0),
161 fNumberOfCascades(0),
163 fOldESDformat(kFALSE),
165 fTPCConstrainedFilterMask(0),
166 fHybridFilterMaskTPCCG(0),
167 fWriteHybridTPCCOnly(kFALSE),
168 fGlobalConstrainedFilterMask(0),
169 fHybridFilterMaskGCG(0),
170 fWriteHybridGCOnly(kFALSE),
171 fIsVZEROEnabled(kTRUE),
172 fIsTZEROEnabled(kTRUE),
173 fIsZDCEnabled(kTRUE),
174 fIsHMPIDEnabled(kTRUE),
175 fIsV0CascadeRecoEnabled(kFALSE),
176 fAreCascadesEnabled(kTRUE),
177 fAreV0sEnabled(kTRUE),
178 fAreKinksEnabled(kTRUE),
179 fAreTracksEnabled(kTRUE),
180 fArePmdClustersEnabled(kTRUE),
181 fAreCaloClustersEnabled(kTRUE),
182 fAreEMCALCellsEnabled(kTRUE),
183 fArePHOSCellsEnabled(kTRUE),
184 fAreEMCALTriggerEnabled(kTRUE),
185 fArePHOSTriggerEnabled(kTRUE),
186 fAreTrackletsEnabled(kTRUE),
189 fTPCaloneTrackCuts(0),
190 fDoPropagateTrackToEMCal(kTRUE),
191 fEMCalSurfaceDistance(440)
195 fV0Cuts[0] = 33. ; // max allowed chi2
196 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter
197 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter
198 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks
199 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle
200 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume
201 fV0Cuts[6] = 100. ; // max radius of the fiducial volume
203 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)
204 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter
205 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass
206 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter
207 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor
208 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle
209 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume
210 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume
215 AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){
216 if(fIsPidOwner) delete fESDpid;
218 //______________________________________________________________________________
219 void AliAnalysisTaskESDfilter::UserCreateOutputObjects()
222 // Create Output Objects conenct filter to outputtree
226 OutputTree()->GetUserInfo()->Add(fTrackFilter);
230 AliError("No OutputTree() for adding the track filter");
232 fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
235 //______________________________________________________________________________
236 void AliAnalysisTaskESDfilter::Init()
239 if (fDebug > 1) AliInfo("Init() \n");
240 // Call configuration file
243 //______________________________________________________________________________
244 Bool_t AliAnalysisTaskESDfilter::Notify()
247 AddMetadataToUserInfo();
251 //______________________________________________________________________________
252 Bool_t AliAnalysisTaskESDfilter::AddMetadataToUserInfo()
254 // Copy metadata to AOD user info.
255 static Bool_t copyFirst = kFALSE;
257 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
259 AliError("AliAnalysisTaskESDfilter::AddMetadataToUserInfo() : No analysis manager !");
262 TTree *esdTree = mgr->GetTree()->GetTree();
263 if (!esdTree) return kFALSE;
264 TNamed *alirootVersion = (TNamed*)esdTree->GetUserInfo()->FindObject("alirootVersion");
265 if (!alirootVersion) return kFALSE;
266 AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(mgr->GetOutputEventHandler());
267 if (!aodHandler) return kFALSE;
268 TTree *aodTree = aodHandler->GetTree();
269 if (!aodTree) return kFALSE;
270 aodTree->GetUserInfo()->Add(new TNamed(*alirootVersion));
276 //______________________________________________________________________________
277 void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const
279 // Print selection task information
282 AliAnalysisTaskSE::PrintTask(option,indent);
284 TString spaces(' ',indent+3);
286 cout << spaces.Data() << Form("Cascades are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;
287 cout << spaces.Data() << Form("V0s are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;
288 cout << spaces.Data() << Form("Kinks are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;
289 cout << spaces.Data() << Form("Tracks are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;
290 cout << spaces.Data() << Form("PmdClusters are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;
291 cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;
292 cout << spaces.Data() << Form("EMCAL cells are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;
293 cout << spaces.Data() << Form("EMCAL triggers are %s",fAreEMCALTriggerEnabled ? "ENABLED":"DISABLED") << endl;
294 cout << spaces.Data() << Form("PHOS triggers are %s",fArePHOSTriggerEnabled ? "ENABLED":"DISABLED") << endl;
295 cout << spaces.Data() << Form("Tracklets are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl;
296 cout << spaces.Data() << Form("PropagateTrackToEMCal is %s", fDoPropagateTrackToEMCal ? "ENABLED":"DISABLED") << endl;
299 //______________________________________________________________________________
300 void AliAnalysisTaskESDfilter::UserExec(Option_t */*option*/)
302 // Execute analysis for current event
305 Long64_t ientry = Entry();
308 printf("Filter: Analysing event # %5d\n", (Int_t) ientry);
309 if (fHighPthreshold == 0) AliInfo("detector PID signals are stored in each track");
310 if (!fPtshape) AliInfo("detector PID signals are not stored below the pt threshold");
312 // Filters must explicitely enable AOD filling in their UserExec (AG)
313 if (!AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()) AliFatal("Cannot run ESD filter without an output event handler");
315 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
316 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);
321 //______________________________________________________________________________
322 TClonesArray& AliAnalysisTaskESDfilter::Cascades()
324 return *(AODEvent()->GetCascades());
327 //______________________________________________________________________________
328 TClonesArray& AliAnalysisTaskESDfilter::Tracks()
330 return *(AODEvent()->GetTracks());
333 //______________________________________________________________________________
334 TClonesArray& AliAnalysisTaskESDfilter::V0s()
336 return *(AODEvent()->GetV0s());
339 //______________________________________________________________________________
340 TClonesArray& AliAnalysisTaskESDfilter::Vertices()
342 return *(AODEvent()->GetVertices());
345 //______________________________________________________________________________
346 AliAODHeader* AliAnalysisTaskESDfilter::ConvertHeader(const AliESDEvent& esd)
348 // Convert header information
350 AliCodeTimerAuto("",0);
352 AliAODHeader* header = AODEvent()->GetHeader();
354 header->SetRunNumber(esd.GetRunNumber());
355 header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
357 TTree* tree = fInputHandler->GetTree();
359 TFile* file = tree->GetCurrentFile();
360 if (file) header->SetESDFileName(file->GetName());
364 header->SetBunchCrossNumber(0);
365 header->SetOrbitNumber(0);
366 header->SetPeriodNumber(0);
367 header->SetEventType(0);
368 header->SetMuonMagFieldScale(-999.);
369 header->SetCentrality(0);
370 header->SetEventplane(0);
372 header->SetBunchCrossNumber(esd.GetBunchCrossNumber());
373 header->SetOrbitNumber(esd.GetOrbitNumber());
374 header->SetPeriodNumber(esd.GetPeriodNumber());
375 header->SetEventType(esd.GetEventType());
377 header->SetEventNumberESDFile(esd.GetHeader()->GetEventNumberInFile());
378 if(const_cast<AliESDEvent&>(esd).GetCentrality()){
379 header->SetCentrality(const_cast<AliESDEvent&>(esd).GetCentrality());
382 header->SetCentrality(0);
384 if(const_cast<AliESDEvent&>(esd).GetEventplane()){
385 header->SetEventplane(const_cast<AliESDEvent&>(esd).GetEventplane());
388 header->SetEventplane(0);
393 header->SetFiredTriggerClasses(esd.GetFiredTriggerClasses());
394 header->SetTriggerMask(esd.GetTriggerMask());
395 header->SetTriggerCluster(esd.GetTriggerCluster());
396 header->SetL0TriggerInputs(esd.GetHeader()->GetL0TriggerInputs());
397 header->SetL1TriggerInputs(esd.GetHeader()->GetL1TriggerInputs());
398 header->SetL2TriggerInputs(esd.GetHeader()->GetL2TriggerInputs());
400 header->SetMagneticField(esd.GetMagneticField());
401 header->SetMuonMagFieldScale(esd.GetCurrentDip()/6000.);
402 header->SetZDCN1Energy(esd.GetZDCN1Energy());
403 header->SetZDCP1Energy(esd.GetZDCP1Energy());
404 header->SetZDCN2Energy(esd.GetZDCN2Energy());
405 header->SetZDCP2Energy(esd.GetZDCP2Energy());
406 header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));
408 header->SetIRInt2InteractionMap(esd.GetHeader()->GetIRInt2InteractionMap());
409 header->SetIRInt1InteractionMap(esd.GetHeader()->GetIRInt1InteractionMap());
411 // ITS Cluster Multiplicty
412 const AliMultiplicity *mult = esd.GetMultiplicity();
413 for (Int_t ilay = 0; ilay < 6; ilay++) header->SetITSClusters(ilay, mult->GetNumberOfITSClusters(ilay));
415 // TPC only Reference Multiplicty
416 Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;
417 header->SetTPConlyRefMultiplicity(refMult);
419 AliESDtrackCuts::MultEstTrackType estType = esd.GetPrimaryVertexTracks()->GetStatus() ? AliESDtrackCuts::kTrackletsITSTPC : AliESDtrackCuts::kTracklets;
420 header->SetRefMultiplicityComb05(AliESDtrackCuts::GetReferenceMultiplicity(&esd,estType,0.5));
421 header->SetRefMultiplicityComb08(AliESDtrackCuts::GetReferenceMultiplicity(&esd,estType,0.8));
423 Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};
425 esd.GetDiamondCovXY(diamcov);
426 header->SetDiamond(diamxy,diamcov);
427 header->SetDiamondZ(esd.GetDiamondZ(),esd.GetSigma2DiamondZ());
429 // VZERO channel equalization factors for event-plane reconstruction
430 header->SetVZEROEqFactors(esd.GetVZEROEqFactors());
432 // T0 Resolution information
433 const AliESDRun* esdRun = esd.GetESDRun();
434 for (Int_t i=0;i<AliESDRun::kT0spreadSize;i++) header->SetT0spread(i,esdRun->GetT0spread(i));
439 //______________________________________________________________________________
440 void AliAnalysisTaskESDfilter::ConvertCascades(const AliESDEvent& esd)
443 // Convert the cascades part of the ESD.
444 // Return the number of cascades
446 AliCodeTimerAuto("",0);
448 // Create vertices starting from the most complex objects
451 const AliESDVertex* vtx = esd.GetPrimaryVertex();
452 Double_t pos[3] = { 0. };
453 Double_t covVtx[6] = { 0. };
454 Double_t momBach[3]={0.};
455 Double_t covTr[21]={0.};
456 Double_t pid[10]={0.};
457 AliAODPid* detpid(0x0);
458 AliAODVertex* vV0FromCascade(0x0);
459 AliAODv0* aodV0(0x0);
460 AliAODcascade* aodCascade(0x0);
461 AliAODTrack* aodTrack(0x0);
462 Double_t momPos[3]={0.};
463 Double_t momNeg[3] = { 0. };
464 Double_t momPosAtV0vtx[3]={0.};
465 Double_t momNegAtV0vtx[3]={0.};
467 TClonesArray& verticesArray = Vertices();
468 TClonesArray& tracksArray = Tracks();
469 TClonesArray& cascadesArray = Cascades();
471 // Cascades (Modified by A.Maire - February 2009)
472 for (Int_t nCascade = 0; nCascade < esd.GetNumberOfCascades(); ++nCascade) {
476 AliESDcascade *esdCascade = esd.GetCascade(nCascade);
477 Int_t idxPosFromV0Dghter = esdCascade->GetPindex();
478 Int_t idxNegFromV0Dghter = esdCascade->GetNindex();
479 Int_t idxBachFromCascade = esdCascade->GetBindex();
481 AliESDtrack *esdCascadePos = esd.GetTrack( idxPosFromV0Dghter);
482 AliESDtrack *esdCascadeNeg = esd.GetTrack( idxNegFromV0Dghter);
483 AliESDtrack *esdCascadeBach = esd.GetTrack( idxBachFromCascade);
485 // Identification of the V0 within the esdCascade (via both daughter track indices)
486 AliESDv0 * currentV0 = 0x0;
487 Int_t idxV0FromCascade = -1;
489 for (Int_t iV0=0; iV0<esd.GetNumberOfV0s(); ++iV0) {
491 currentV0 = esd.GetV0(iV0);
492 Int_t posCurrentV0 = currentV0->GetPindex();
493 Int_t negCurrentV0 = currentV0->GetNindex();
495 if (posCurrentV0==idxPosFromV0Dghter && negCurrentV0==idxNegFromV0Dghter) {
496 idxV0FromCascade = iV0;
501 if(idxV0FromCascade < 0){
502 printf("Cascade - no matching for the V0 (index V0 = -1) ! Skip ... \n");
504 }// a priori, useless check, but safer ... in case of pb with tracks "out of bounds"
506 AliESDv0 *esdV0FromCascade = esd.GetV0(idxV0FromCascade);
508 // 1 - Cascade selection
510 // AliESDVertex *esdPrimVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));
511 // TList cascadeObjects;
512 // cascadeObjects.AddAt(esdV0FromCascade, 0);
513 // cascadeObjects.AddAt(esdCascadePos, 1);
514 // cascadeObjects.AddAt(esdCascadeNeg, 2);
515 // cascadeObjects.AddAt(esdCascade, 3);
516 // cascadeObjects.AddAt(esdCascadeBach, 4);
517 // cascadeObjects.AddAt(esdPrimVtx, 5);
519 // UInt_t selectCascade = 0;
520 // if (fCascadeFilter) {
521 // // selectCascade = fCascadeFilter->IsSelected(&cascadeObjects);
522 // // FIXME AliESDCascadeCuts to be implemented ...
524 // // Here we may encounter a moot point at the V0 level
525 // // between the cascade selections and the V0 ones :
526 // // the V0 selected along with the cascade (secondary V0) may
527 // // usually be removed from the dedicated V0 selections (prim V0) ...
528 // // -> To be discussed !
530 // // this is a little awkward but otherwise the
531 // // list wants to access the pointer (delete it)
532 // // again when going out of scope
533 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct
535 // if (!selectCascade)
539 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct
543 // 2 - Add the cascade vertex
545 esdCascade->GetXYZcascade(pos[0], pos[1], pos[2]);
546 esdCascade->GetPosCovXi(covVtx);
547 chi2 = esdCascade->GetChi2Xi();
549 AliAODVertex *vCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex( pos,
551 chi2, // FIXME = Chi2/NDF will be needed
554 AliAODVertex::kCascade);
555 fPrimaryVertex->AddDaughter(vCascade);
558 // printf("---- Cascade / Cascade Vertex (AOD) : \n");
559 // vCascade->Print();
562 // if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production starting form LHC10e without Tender.
565 // 3 - Add the bachelor track from the cascade
567 if (!fUsedTrack[idxBachFromCascade]) {
569 esdCascadeBach->GetPxPyPz(momBach);
570 esdCascadeBach->GetXYZ(pos);
571 esdCascadeBach->GetCovarianceXYZPxPyPz(covTr);
572 esdCascadeBach->GetESDpid(pid);
574 fUsedTrack[idxBachFromCascade] = kTRUE;
575 UInt_t selectInfo = 0;
576 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeBach);
577 if (fMChandler) fMChandler->SelectParticle(esdCascadeBach->GetLabel());
578 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack(esdCascadeBach->GetID(),
579 esdCascadeBach->GetLabel(),
583 kFALSE, // Why kFALSE for "isDCA" ? FIXME
585 (Short_t)esdCascadeBach->GetSign(),
586 esdCascadeBach->GetITSClusterMap(),
589 kTRUE, // usedForVtxFit = kFALSE ? FIXME
590 vtx->UsesTrack(esdCascadeBach->GetID()),
591 AliAODTrack::kSecondary,
593 aodTrack->SetTPCFitMap(esdCascadeBach->GetTPCFitMap());
594 aodTrack->SetTPCClusterMap(esdCascadeBach->GetTPCClusterMap());
595 aodTrack->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());
596 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));
597 aodTrack->SetTPCPointsF(esdCascadeBach->GetTPCNclsF());
598 aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadeBach->GetTPCCrossedRows()));
599 aodTrack->SetIntegratedLength(esdCascadeBach->GetIntegratedLength());
600 fAODTrackRefs->AddAt(aodTrack,idxBachFromCascade);
602 if (esdCascadeBach->GetSign() > 0) ++fNumberOfPositiveTracks;
603 aodTrack->ConvertAliPIDtoAODPID();
604 aodTrack->SetFlags(esdCascadeBach->GetStatus());
605 SetAODPID(esdCascadeBach,aodTrack,detpid);
608 aodTrack = static_cast<AliAODTrack*>( fAODTrackRefs->At(idxBachFromCascade) );
611 vCascade->AddDaughter(aodTrack);
614 // printf("---- Cascade / bach dghter : \n");
615 // aodTrack->Print();
619 // 4 - Add the V0 from the cascade.
620 // = V0vtx + both pos and neg daughter tracks + the aodV0 itself
623 if ( !fUsedV0[idxV0FromCascade] ) {
624 // 4.A - if VO structure hasn't been created yet
626 // 4.A.1 - Create the V0 vertex of the cascade
628 esdV0FromCascade->GetXYZ(pos[0], pos[1], pos[2]);
629 esdV0FromCascade->GetPosCov(covVtx);
630 chi2 = esdV0FromCascade->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3 ?
632 vV0FromCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex(pos,
636 idxV0FromCascade, //id of ESDv0
639 // one V0 can be used by several cascades.
640 // So, one AOD V0 vtx can have several parent vtx.
641 // This is not directly allowed by AliAODvertex.
642 // Setting the parent vtx (here = param "vCascade") doesn't lead to a crash
643 // but to a problem of consistency within AODEvent.
644 // -> See below paragraph 4.B, for the proposed treatment of such a case.
646 // Add the vV0FromCascade to the aodVOVtxRefs
647 fAODV0VtxRefs->AddAt(vV0FromCascade,idxV0FromCascade);
650 // 4.A.2 - Add the positive tracks from the V0
652 esdCascadePos->GetPxPyPz(momPos);
653 esdCascadePos->GetXYZ(pos);
654 esdCascadePos->GetCovarianceXYZPxPyPz(covTr);
655 esdCascadePos->GetESDpid(pid);
658 if (!fUsedTrack[idxPosFromV0Dghter]) {
659 fUsedTrack[idxPosFromV0Dghter] = kTRUE;
661 UInt_t selectInfo = 0;
662 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadePos);
663 if(fMChandler) fMChandler->SelectParticle(esdCascadePos->GetLabel());
664 aodTrack = new(tracksArray[fNumberOfTracks++])
665 AliAODTrack( esdCascadePos->GetID(),
666 esdCascadePos->GetLabel(),
670 kFALSE, // Why kFALSE for "isDCA" ? FIXME
672 (Short_t)esdCascadePos->GetSign(),
673 esdCascadePos->GetITSClusterMap(),
676 kTRUE, // usedForVtxFit = kFALSE ? FIXME
677 vtx->UsesTrack(esdCascadePos->GetID()),
678 AliAODTrack::kSecondary,
680 aodTrack->SetTPCFitMap(esdCascadePos->GetTPCFitMap());
681 aodTrack->SetTPCClusterMap(esdCascadePos->GetTPCClusterMap());
682 aodTrack->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());
683 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));
684 aodTrack->SetTPCPointsF(esdCascadePos->GetTPCNclsF());
685 aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadePos->GetTPCCrossedRows()));
686 aodTrack->SetIntegratedLength(esdCascadePos->GetIntegratedLength());
687 fAODTrackRefs->AddAt(aodTrack,idxPosFromV0Dghter);
689 if (esdCascadePos->GetSign() > 0) ++fNumberOfPositiveTracks;
690 aodTrack->ConvertAliPIDtoAODPID();
691 aodTrack->SetFlags(esdCascadePos->GetStatus());
692 SetAODPID(esdCascadePos,aodTrack,detpid);
695 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxPosFromV0Dghter));
697 vV0FromCascade->AddDaughter(aodTrack);
700 // 4.A.3 - Add the negative tracks from the V0
702 esdCascadeNeg->GetPxPyPz(momNeg);
703 esdCascadeNeg->GetXYZ(pos);
704 esdCascadeNeg->GetCovarianceXYZPxPyPz(covTr);
705 esdCascadeNeg->GetESDpid(pid);
708 if (!fUsedTrack[idxNegFromV0Dghter]) {
709 fUsedTrack[idxNegFromV0Dghter] = kTRUE;
711 UInt_t selectInfo = 0;
712 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeNeg);
713 if(fMChandler)fMChandler->SelectParticle(esdCascadeNeg->GetLabel());
714 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack( esdCascadeNeg->GetID(),
715 esdCascadeNeg->GetLabel(),
719 kFALSE, // Why kFALSE for "isDCA" ? FIXME
721 (Short_t)esdCascadeNeg->GetSign(),
722 esdCascadeNeg->GetITSClusterMap(),
725 kTRUE, // usedForVtxFit = kFALSE ? FIXME
726 vtx->UsesTrack(esdCascadeNeg->GetID()),
727 AliAODTrack::kSecondary,
729 aodTrack->SetTPCFitMap(esdCascadeNeg->GetTPCFitMap());
730 aodTrack->SetTPCClusterMap(esdCascadeNeg->GetTPCClusterMap());
731 aodTrack->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());
732 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));
733 aodTrack->SetTPCPointsF(esdCascadeNeg->GetTPCNclsF());
734 aodTrack->SetTPCNCrossedRows(UShort_t(esdCascadeNeg->GetTPCCrossedRows()));
735 aodTrack->SetIntegratedLength(esdCascadeNeg->GetIntegratedLength());
736 fAODTrackRefs->AddAt(aodTrack,idxNegFromV0Dghter);
738 if (esdCascadeNeg->GetSign() > 0) ++fNumberOfPositiveTracks;
739 aodTrack->ConvertAliPIDtoAODPID();
740 aodTrack->SetFlags(esdCascadeNeg->GetStatus());
741 SetAODPID(esdCascadeNeg,aodTrack,detpid);
744 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxNegFromV0Dghter));
747 vV0FromCascade->AddDaughter(aodTrack);
750 // 4.A.4 - Add the V0 from cascade to the V0 array
752 Double_t dcaV0Daughters = esdV0FromCascade->GetDcaV0Daughters();
753 Double_t dcaV0ToPrimVertex = esdV0FromCascade->GetD( esd.GetPrimaryVertex()->GetX(),
754 esd.GetPrimaryVertex()->GetY(),
755 esd.GetPrimaryVertex()->GetZ() );
756 esdV0FromCascade->GetPPxPyPz( momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2] );
757 esdV0FromCascade->GetNPxPyPz( momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2] );
759 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg
760 dcaDaughterToPrimVertex[0] = TMath::Abs(esdCascadePos->GetD( esd.GetPrimaryVertex()->GetX(),
761 esd.GetPrimaryVertex()->GetY(),
762 esd.GetMagneticField()) );
763 dcaDaughterToPrimVertex[1] = TMath::Abs(esdCascadeNeg->GetD( esd.GetPrimaryVertex()->GetX(),
764 esd.GetPrimaryVertex()->GetY(),
765 esd.GetMagneticField()) );
767 aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0( vV0FromCascade,
772 dcaDaughterToPrimVertex);
773 // set the aod v0 on-the-fly status
774 aodV0->SetOnFlyStatus(esdV0FromCascade->GetOnFlyStatus());
776 // Add the aodV0 to the aodVORefs
777 fAODV0Refs->AddAt(aodV0,idxV0FromCascade);
779 fUsedV0[idxV0FromCascade] = kTRUE;
782 // 4.B - if V0 structure already used
785 // one V0 can be used by several cascades (frequent in PbPb evts) :
786 // same V0 which used but attached to different bachelor tracks
787 // -> aodVORefs and fAODV0VtxRefs are needed.
788 // Goal : avoid a redundancy of the info in "Vertices" and "v0s" clones array.
790 vV0FromCascade = static_cast<AliAODVertex*>( fAODV0VtxRefs->At(idxV0FromCascade) );
791 aodV0 = static_cast<AliAODv0*> ( fAODV0Refs ->At(idxV0FromCascade) );
793 // - Treatment of the parent for such a "re-used" V0 :
794 // Insert the cascade that reuses the V0 vertex in the lineage chain
795 // Before : vV0 -> vCascade1 -> vPrimary
796 // - Hyp : cascade2 uses the same V0 as cascade1
797 // After : vV0 -> vCascade2 -> vCascade1 -> vPrimary
799 AliAODVertex *vCascadePreviousParent = static_cast<AliAODVertex*> (vV0FromCascade->GetParent());
800 vV0FromCascade->SetParent(vCascade);
801 vCascade ->SetParent(vCascadePreviousParent);
804 // printf("---- Cascade / Lineage insertion\n"
805 // "Parent of V0 vtx = Cascade vtx %p\n"
806 // "Parent of the cascade vtx = Cascade vtx %p\n"
807 // "Parent of the parent cascade vtx = Cascade vtx %p\n",
808 // static_cast<void*> (vV0FromCascade->GetParent()),
809 // static_cast<void*> (vCascade->GetParent()),
810 // static_cast<void*> (vCascadePreviousParent->GetParent()) );
812 }// end if V0 structure already used
815 // printf("---- Cascade / V0 vertex: \n");
816 // vV0FromCascade->Print();
820 // printf("---- Cascade / pos dghter : \n");
821 // aodTrack->Print();
822 // printf("---- Cascade / neg dghter : \n");
823 // aodTrack->Print();
824 // printf("---- Cascade / aodV0 : \n");
828 // In any case (used V0 or not), add the V0 vertex to the cascade one.
829 vCascade->AddDaughter(vV0FromCascade);
832 // 5 - Add the primary track of the cascade (if any)
835 // 6 - Add the cascade to the AOD array of cascades
837 Double_t dcaBachToPrimVertexXY = TMath::Abs(esdCascadeBach->GetD(esd.GetPrimaryVertex()->GetX(),
838 esd.GetPrimaryVertex()->GetY(),
839 esd.GetMagneticField()) );
841 Double_t momBachAtCascadeVtx[3]={0.};
843 esdCascade->GetBPxPyPz(momBachAtCascadeVtx[0], momBachAtCascadeVtx[1], momBachAtCascadeVtx[2]);
845 aodCascade = new(cascadesArray[fNumberOfCascades++]) AliAODcascade( vCascade,
846 esdCascade->Charge(),
847 esdCascade->GetDcaXiDaughters(),
849 // DCAXiToPrimVtx -> needs to be calculated ----|
850 // doesn't exist at ESD level;
851 // See AODcascade::DcaXiToPrimVertex(Double, Double, Double)
852 dcaBachToPrimVertexXY,
857 printf("---- Cascade / AOD cascade : \n\n");
858 aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());
861 } // end of the loop on cascades
863 Cascades().Expand(fNumberOfCascades);
866 //______________________________________________________________________________
867 void AliAnalysisTaskESDfilter::ConvertV0s(const AliESDEvent& esd)
869 // Access to the AOD container of V0s
871 AliCodeTimerAuto("",0);
877 Double_t pos[3] = { 0. };
879 Double_t covVtx[6] = { 0. };
880 Double_t momPos[3]={0.};
881 Double_t covTr[21]={0.};
882 Double_t pid[10]={0.};
883 AliAODTrack* aodTrack(0x0);
884 AliAODPid* detpid(0x0);
885 Double_t momNeg[3]={0.};
886 Double_t momPosAtV0vtx[3]={0.};
887 Double_t momNegAtV0vtx[3]={0.};
889 for (Int_t nV0 = 0; nV0 < esd.GetNumberOfV0s(); ++nV0)
891 if (fUsedV0[nV0]) continue; // skip if already added to the AOD
893 AliESDv0 *v0 = esd.GetV0(nV0);
894 Int_t posFromV0 = v0->GetPindex();
895 Int_t negFromV0 = v0->GetNindex();
899 AliESDVertex *esdVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));
900 AliESDtrack *esdV0Pos = esd.GetTrack(posFromV0);
901 AliESDtrack *esdV0Neg = esd.GetTrack(negFromV0);
903 v0objects.AddAt(v0, 0);
904 v0objects.AddAt(esdV0Pos, 1);
905 v0objects.AddAt(esdV0Neg, 2);
906 v0objects.AddAt(esdVtx, 3);
909 selectV0 = fV0Filter->IsSelected(&v0objects);
910 // this is a little awkward but otherwise the
911 // list wants to access the pointer (delete it)
912 // again when going out of scope
913 delete v0objects.RemoveAt(3); // esdVtx created via copy construct
919 delete v0objects.RemoveAt(3); // esdVtx created via copy construct
923 v0->GetXYZ(pos[0], pos[1], pos[2]);
925 if (!fOldESDformat) {
926 chi2 = v0->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3
927 v0->GetPosCov(covVtx);
930 for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;
935 new(Vertices()[fNumberOfVertices++]) AliAODVertex(pos,
941 fPrimaryVertex->AddDaughter(vV0);
944 // Add the positive tracks from the V0
947 esdV0Pos->GetPxPyPz(momPos);
948 esdV0Pos->GetXYZ(pos);
949 esdV0Pos->GetCovarianceXYZPxPyPz(covTr);
950 esdV0Pos->GetESDpid(pid);
952 const AliESDVertex *vtx = esd.GetPrimaryVertex();
954 if (!fUsedTrack[posFromV0]) {
955 fUsedTrack[posFromV0] = kTRUE;
956 UInt_t selectInfo = 0;
957 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Pos);
958 if(fMChandler)fMChandler->SelectParticle(esdV0Pos->GetLabel());
959 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Pos->GetID(),
960 esdV0Pos->GetLabel(),
966 (Short_t)esdV0Pos->GetSign(),
967 esdV0Pos->GetITSClusterMap(),
970 kTRUE, // check if this is right
971 vtx->UsesTrack(esdV0Pos->GetID()),
972 AliAODTrack::kSecondary,
974 aodTrack->SetTPCFitMap(esdV0Pos->GetTPCFitMap());
975 aodTrack->SetTPCClusterMap(esdV0Pos->GetTPCClusterMap());
976 aodTrack->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());
977 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));
978 aodTrack->SetTPCPointsF(esdV0Pos->GetTPCNclsF());
979 aodTrack->SetTPCNCrossedRows(UShort_t(esdV0Pos->GetTPCCrossedRows()));
980 aodTrack->SetIntegratedLength(esdV0Pos->GetIntegratedLength());
981 fAODTrackRefs->AddAt(aodTrack,posFromV0);
982 // if (fDebug > 0) printf("-------------------Bo: pos track from original pt %.3f \n",aodTrack->Pt());
983 if (esdV0Pos->GetSign() > 0) ++fNumberOfPositiveTracks;
984 aodTrack->ConvertAliPIDtoAODPID();
985 aodTrack->SetFlags(esdV0Pos->GetStatus());
986 SetAODPID(esdV0Pos,aodTrack,detpid);
989 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(posFromV0));
990 // if (fDebug > 0) printf("-------------------Bo pos track from refArray pt %.3f \n",aodTrack->Pt());
992 vV0->AddDaughter(aodTrack);
994 // Add the negative tracks from the V0
996 esdV0Neg->GetPxPyPz(momNeg);
997 esdV0Neg->GetXYZ(pos);
998 esdV0Neg->GetCovarianceXYZPxPyPz(covTr);
999 esdV0Neg->GetESDpid(pid);
1001 if (!fUsedTrack[negFromV0]) {
1002 fUsedTrack[negFromV0] = kTRUE;
1003 UInt_t selectInfo = 0;
1004 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Neg);
1005 if(fMChandler)fMChandler->SelectParticle(esdV0Neg->GetLabel());
1006 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Neg->GetID(),
1007 esdV0Neg->GetLabel(),
1013 (Short_t)esdV0Neg->GetSign(),
1014 esdV0Neg->GetITSClusterMap(),
1017 kTRUE, // check if this is right
1018 vtx->UsesTrack(esdV0Neg->GetID()),
1019 AliAODTrack::kSecondary,
1021 aodTrack->SetTPCFitMap(esdV0Neg->GetTPCFitMap());
1022 aodTrack->SetTPCClusterMap(esdV0Neg->GetTPCClusterMap());
1023 aodTrack->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());
1024 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));
1025 aodTrack->SetTPCPointsF(esdV0Neg->GetTPCNclsF());
1026 aodTrack->SetTPCNCrossedRows(UShort_t(esdV0Neg->GetTPCCrossedRows()));
1027 aodTrack->SetIntegratedLength(esdV0Neg->GetIntegratedLength());
1028 fAODTrackRefs->AddAt(aodTrack,negFromV0);
1029 // if (fDebug > 0) printf("-------------------Bo: neg track from original pt %.3f \n",aodTrack->Pt());
1030 if (esdV0Neg->GetSign() > 0) ++fNumberOfPositiveTracks;
1031 aodTrack->ConvertAliPIDtoAODPID();
1032 aodTrack->SetFlags(esdV0Neg->GetStatus());
1033 SetAODPID(esdV0Neg,aodTrack,detpid);
1036 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(negFromV0));
1037 // if (fDebug > 0) printf("-------------------Bo neg track from refArray pt %.3f \n",aodTrack->Pt());
1039 vV0->AddDaughter(aodTrack);
1042 // Add the V0 the V0 array as well
1044 Double_t dcaV0Daughters = v0->GetDcaV0Daughters();
1045 Double_t dcaV0ToPrimVertex = v0->GetD(esd.GetPrimaryVertex()->GetX(),
1046 esd.GetPrimaryVertex()->GetY(),
1047 esd.GetPrimaryVertex()->GetZ());
1049 v0->GetPPxPyPz(momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2]);
1050 v0->GetNPxPyPz(momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2]);
1052 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg
1053 dcaDaughterToPrimVertex[0] = TMath::Abs(esdV0Pos->GetD( esd.GetPrimaryVertex()->GetX(),
1054 esd.GetPrimaryVertex()->GetY(),
1055 esd.GetMagneticField()) );
1056 dcaDaughterToPrimVertex[1] = TMath::Abs(esdV0Neg->GetD( esd.GetPrimaryVertex()->GetX(),
1057 esd.GetPrimaryVertex()->GetY(),
1058 esd.GetMagneticField()) );
1060 AliAODv0* aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0(vV0,
1065 dcaDaughterToPrimVertex);
1067 // set the aod v0 on-the-fly status
1068 aodV0->SetOnFlyStatus(v0->GetOnFlyStatus());
1069 }//End of loop on V0s
1071 V0s().Expand(fNumberOfV0s);
1074 //______________________________________________________________________________
1075 void AliAnalysisTaskESDfilter::ConvertTPCOnlyTracks(const AliESDEvent& esd)
1077 // Convert TPC only tracks
1078 // Here we have wo hybrid appraoch to remove fakes
1079 // ******* ITSTPC ********
1080 // Uses a cut on the ITS properties to select global tracks
1081 // which are than marked as HybdridITSTPC for the remainder
1082 // the TPC only tracks are flagged as HybridITSTPConly.
1083 // Note, in order not to get fakes back in the TPC cuts, one needs
1084 // two "ITS" cuts one tight (1) (to throw out fakes) and one lose (2) (to NOT flag the trakcs in the TPC only)
1085 // using cut number (3)
1086 // so fHybridFilterMask == (1)|(2) fTPCFilterMask = (3), Usercode needs to slect with mask = (1)|(3) and track->IsHybridITSTPC()
1087 // ******* TPC ********
1088 // 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
1089 // 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
1091 AliCodeTimerAuto("",0);
1093 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks
1094 for(int it = 0;it < fNumberOfTracks;++it)
1096 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));
1098 UInt_t map = tr->GetFilterMap();
1099 if(map&fTPCConstrainedFilterMask){
1100 // we only reset the track select ionfo, no deletion...
1101 tr->SetFilterMap(map&~fTPCConstrainedFilterMask);
1103 if(map&fHybridFilterMaskTPCCG){
1104 // this is one part of the hybrid tracks
1105 // the others not passing the selection will be TPC only selected below
1106 tr->SetIsHybridTPCConstrainedGlobal(kTRUE);
1109 // Loop over the ESD trcks and pick out the tracks passing TPC only cuts
1112 const AliESDVertex *vtxSPD = esd.GetPrimaryVertexSPD();
1113 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1115 Double_t pos[3] = { 0. };
1116 Double_t covTr[21]={0.};
1117 Double_t pid[10]={0.};
1120 Double_t p[3] = { 0. };
1122 Double_t pDCA[3] = { 0. }; // momentum at DCA
1123 Double_t rDCA[3] = { 0. }; // position at DCA
1124 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
1125 Float_t cDCA[3] = {0.}; // covariance of impact parameters
1128 AliAODTrack* aodTrack(0x0);
1129 // AliAODPid* detpid(0x0);
1131 // account for change in pT after the constraint
1132 Float_t ptMax = 1E10;
1134 for(int i = 0;i<32;i++){
1135 if(fTPCConstrainedFilterMask&(1<<i)){
1136 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);
1137 Float_t tmp1= 0,tmp2 = 0;
1138 cuts->GetPtRange(tmp1,tmp2);
1139 if(tmp1>ptMin)ptMin=tmp1;
1140 if(tmp2<ptMax)ptMax=tmp2;
1144 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
1146 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy
1148 UInt_t selectInfo = 0;
1149 Bool_t isHybridITSTPC = false;
1153 selectInfo = fTrackFilter->IsSelected(esdTrack);
1156 if(!(selectInfo&fHybridFilterMaskTPCCG)){
1157 // not already selected tracks, use second part of hybrid tracks
1158 isHybridITSTPC = true;
1159 // too save space one could only store these...
1162 selectInfo &= fTPCConstrainedFilterMask;
1163 if (!selectInfo)continue;
1164 if (fWriteHybridTPCCOnly&&!isHybridITSTPC)continue; // write only complementary tracks
1165 // create a tpc only tracl
1166 AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(&esd),esdTrack->GetID());
1167 if(!track) continue;
1171 // only constrain tracks above threshold
1172 AliExternalTrackParam exParam;
1173 // take the B-field from the ESD, no 3D fieldMap available at this point
1174 Bool_t relate = false;
1175 relate = track->RelateToVertexTPC(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);
1180 // fetch the track parameters at the DCA (unconstraint)
1181 if(track->GetTPCInnerParam()){
1182 track->GetTPCInnerParam()->GetPxPyPz(pDCA);
1183 track->GetTPCInnerParam()->GetXYZ(rDCA);
1185 // get the DCA to the vertex:
1186 track->GetImpactParametersTPC(dDCA,cDCA);
1187 // set the constrained parameters to the track
1188 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
1191 track->GetPxPyPz(p);
1193 Float_t pT = track->Pt();
1194 if(pT<ptMin||pT>ptMax){
1203 track->GetCovarianceXYZPxPyPz(covTr);
1204 esdTrack->GetESDpid(pid);// original PID
1206 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
1207 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,
1214 (Short_t)track->GetSign(),
1215 track->GetITSClusterMap(),
1218 kTRUE, // check if this is right
1219 vtx->UsesTrack(track->GetID()),
1220 AliAODTrack::kPrimary,
1222 aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC);
1223 aodTrack->SetTPCFitMap(track->GetTPCFitMap());
1224 aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());
1225 aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());
1226 aodTrack->SetIsTPCConstrained(kTRUE);
1227 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack)); // original track
1228 // set the DCA values to the AOD track
1229 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
1230 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);
1231 aodTrack->SetDCA(dDCA[0],dDCA[1]);
1233 aodTrack->SetFlags(track->GetStatus());
1234 aodTrack->SetTPCPointsF(track->GetTPCNclsF());
1235 aodTrack->SetTPCNCrossedRows(UShort_t(track->GetTPCCrossedRows()));
1236 aodTrack->SetIntegratedLength(track->GetIntegratedLength());
1238 //Perform progagation of tracks if needed
1239 if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
1240 aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
1242 // do not duplicate PID information
1243 // aodTrack->ConvertAliPIDtoAODPID();
1244 // SetAODPID(esdTrack,aodTrack,detpid);
1247 } // end of loop on tracks
1251 //______________________________________________________________________________
1252 void AliAnalysisTaskESDfilter::ConvertGlobalConstrainedTracks(const AliESDEvent& esd)
1255 // Here we have the option to store the complement from global constraint information
1256 // to tracks passing tight cuts (1) in order not to get fakes back in, one needs
1257 // two sets of cuts one tight (1) (to throw out fakes) and one lose (2) (fakes/bad tracks would pass (2) but not (1))
1258 // using cut number (3) selects the tracks that complement (1) e.g. tracks witout ITS refit or cluster requirement
1261 AliCodeTimerAuto("",0);
1263 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks
1264 for(int it = 0;it < fNumberOfTracks;++it)
1266 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));
1268 UInt_t map = tr->GetFilterMap();
1269 if(map&fGlobalConstrainedFilterMask){
1270 // we only reset the track select info, no deletion...
1271 // mask reset mask in case track is already taken
1272 tr->SetFilterMap(map&~fGlobalConstrainedFilterMask);
1274 if(map&fHybridFilterMaskGCG){
1275 // this is one part of the hybrid tracks
1276 // the others not passing the selection will be the ones selected below
1277 tr->SetIsHybridGlobalConstrainedGlobal(kTRUE);
1280 // Loop over the ESD trcks and pick out the tracks passing the GlobalConstraint cuts
1283 Double_t pos[3] = { 0. };
1284 Double_t covTr[21]={0.};
1285 Double_t pid[10]={0.};
1286 Double_t p[3] = { 0. };
1288 Double_t pDCA[3] = { 0. }; // momentum at DCA
1289 Double_t rDCA[3] = { 0. }; // position at DCA
1290 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
1291 Float_t cDCA[3] = {0.}; // covariance of impact parameters
1294 AliAODTrack* aodTrack(0x0);
1295 AliAODPid* detpid(0x0);
1296 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1298 // account for change in pT after the constraint
1299 Float_t ptMax = 1E10;
1301 for(int i = 0;i<32;i++){
1302 if(fGlobalConstrainedFilterMask&(1<<i)){
1303 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);
1304 Float_t tmp1= 0,tmp2 = 0;
1305 cuts->GetPtRange(tmp1,tmp2);
1306 if(tmp1>ptMin)ptMin=tmp1;
1307 if(tmp2<ptMax)ptMax=tmp2;
1313 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
1315 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy
1316 const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam();
1317 if(!exParamGC)continue;
1319 UInt_t selectInfo = 0;
1320 Bool_t isHybridGC = false;
1325 selectInfo = fTrackFilter->IsSelected(esdTrack);
1329 if(!(selectInfo&fHybridFilterMaskGCG))isHybridGC = true;
1330 if (fWriteHybridGCOnly&&!isHybridGC)continue; // write only complementary tracks
1332 selectInfo &= fGlobalConstrainedFilterMask;
1333 if (!selectInfo)continue;
1334 // fetch the track parameters at the DCA (unconstrained)
1335 esdTrack->GetPxPyPz(pDCA);
1336 esdTrack->GetXYZ(rDCA);
1337 // get the DCA to the vertex:
1338 esdTrack->GetImpactParameters(dDCA,cDCA);
1340 if (!esdTrack->GetConstrainedPxPyPz(p)) continue;
1343 Float_t pT = exParamGC->Pt();
1344 if(pT<ptMin||pT>ptMax){
1349 esdTrack->GetConstrainedXYZ(pos);
1350 exParamGC->GetCovarianceXYZPxPyPz(covTr);
1351 esdTrack->GetESDpid(pid);
1352 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
1353 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((esdTrack->GetID()+1)*-1,
1354 esdTrack->GetLabel(),
1360 (Short_t)esdTrack->GetSign(),
1361 esdTrack->GetITSClusterMap(),
1364 kTRUE, // check if this is right
1365 vtx->UsesTrack(esdTrack->GetID()),
1366 AliAODTrack::kPrimary,
1368 aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC);
1369 aodTrack->SetIsGlobalConstrained(kTRUE);
1370 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());
1371 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
1372 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
1373 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
1376 // set the DCA values to the AOD track
1377 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
1378 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);
1379 aodTrack->SetDCA(dDCA[0],dDCA[1]);
1381 aodTrack->SetFlags(esdTrack->GetStatus());
1382 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
1383 aodTrack->SetTPCNCrossedRows(UShort_t(esdTrack->GetTPCCrossedRows()));
1384 aodTrack->SetIntegratedLength(esdTrack->GetIntegratedLength());
1387 // only copy AOD information for hybrid, no duplicate information
1388 aodTrack->ConvertAliPIDtoAODPID();
1389 SetAODPID(esdTrack,aodTrack,detpid);
1392 //Perform progagation of tracks if needed
1393 if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
1394 aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
1395 } // end of loop on tracks
1400 //______________________________________________________________________________
1401 void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)
1403 // Tracks (primary and orphan)
1405 AliCodeTimerAuto("",0);
1407 AliDebug(1,Form("NUMBER OF ESD TRACKS %5d\n", esd.GetNumberOfTracks()));
1409 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1410 Double_t p[3] = { 0. };
1411 Double_t pos[3] = { 0. };
1412 Double_t covTr[21] = { 0. };
1413 Double_t pid[10] = { 0. };
1414 AliAODTrack* aodTrack(0x0);
1415 AliAODPid* detpid(0x0);
1417 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
1419 if (fUsedTrack[nTrack]) continue;
1421 AliESDtrack *esdTrack = esd.GetTrack(nTrack);
1422 UInt_t selectInfo = 0;
1426 selectInfo = fTrackFilter->IsSelected(esdTrack);
1427 if (!selectInfo && !vtx->UsesTrack(esdTrack->GetID())) continue;
1431 esdTrack->GetPxPyPz(p);
1432 esdTrack->GetXYZ(pos);
1433 esdTrack->GetCovarianceXYZPxPyPz(covTr);
1434 esdTrack->GetESDpid(pid);
1435 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
1436 fPrimaryVertex->AddDaughter(aodTrack =
1437 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrack->GetID(),
1438 esdTrack->GetLabel(),
1444 (Short_t)esdTrack->GetSign(),
1445 esdTrack->GetITSClusterMap(),
1448 kTRUE, // check if this is right
1449 vtx->UsesTrack(esdTrack->GetID()),
1450 AliAODTrack::kPrimary,
1453 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());
1454 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
1455 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
1456 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
1457 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
1458 aodTrack->SetTPCNCrossedRows(UShort_t(esdTrack->GetTPCCrossedRows()));
1459 aodTrack->SetIntegratedLength(esdTrack->GetIntegratedLength());
1460 if(esdTrack->IsEMCAL()) aodTrack->SetEMCALcluster(esdTrack->GetEMCALcluster());
1461 if(esdTrack->IsPHOS()) aodTrack->SetPHOScluster(esdTrack->GetPHOScluster());
1463 //Perform progagation of tracks if needed
1464 if(fDoPropagateTrackToEMCal) PropagateTrackToEMCal(esdTrack);
1465 aodTrack->SetTrackPhiEtaPtOnEMCal(esdTrack->GetTrackPhiOnEMCal(),esdTrack->GetTrackEtaOnEMCal(),esdTrack->GetTrackPtOnEMCal());
1467 fAODTrackRefs->AddAt(aodTrack, nTrack);
1470 if (esdTrack->GetSign() > 0) ++fNumberOfPositiveTracks;
1471 aodTrack->SetFlags(esdTrack->GetStatus());
1472 aodTrack->ConvertAliPIDtoAODPID();
1473 SetAODPID(esdTrack,aodTrack,detpid);
1474 } // end of loop on tracks
1477 //______________________________________________________________________________
1478 void AliAnalysisTaskESDfilter::PropagateTrackToEMCal(AliESDtrack *esdTrack)
1480 Double_t trkPos[3] = {0.,0.,0.};
1481 Double_t EMCalEta=-999, EMCalPhi=-999, EMCalPt=-999;
1482 Double_t trkphi = esdTrack->Phi()*TMath::RadToDeg();
1483 if(TMath::Abs(esdTrack->Eta())<0.9 && trkphi > 10 && trkphi < 250 )
1485 AliExternalTrackParam *trkParam = const_cast<AliExternalTrackParam*>(esdTrack->GetInnerParam());
1488 AliExternalTrackParam trkParamTmp(*trkParam);
1489 if(AliTrackerBase::PropagateTrackToBxByBz(&trkParamTmp, fEMCalSurfaceDistance, esdTrack->GetMass(), 20, kTRUE, 0.8, -1))
1491 trkParamTmp.GetXYZ(trkPos);
1492 TVector3 trkPosVec(trkPos[0],trkPos[1],trkPos[2]);
1493 EMCalEta = trkPosVec.Eta();
1494 EMCalPhi = trkPosVec.Phi();
1495 EMCalPt = trkParamTmp.Pt();
1496 if(EMCalPhi<0) EMCalPhi += 2*TMath::Pi();
1497 esdTrack->SetTrackPhiEtaPtOnEMCal(EMCalPhi,EMCalEta,EMCalPt);
1503 //______________________________________________________________________________
1504 void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)
1506 // Convert PMD Clusters
1507 AliCodeTimerAuto("",0);
1508 Int_t jPmdClusters=0;
1509 // Access to the AOD container of PMD clusters
1510 TClonesArray &pmdClusters = *(AODEvent()->GetPmdClusters());
1511 for (Int_t iPmd = 0; iPmd < esd.GetNumberOfPmdTracks(); ++iPmd) {
1512 // file pmd clusters, to be revised!
1513 AliESDPmdTrack *pmdTrack = esd.GetPmdTrack(iPmd);
1516 Double_t posPmd[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ()};
1517 Double_t pidPmd[13] = { 0.}; // to be revised!
1519 // assoc cluster not set
1520 new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), posPmd, pidPmd);
1525 //______________________________________________________________________________
1526 void AliAnalysisTaskESDfilter::ConvertCaloClusters(const AliESDEvent& esd)
1528 // Convert Calorimeter Clusters
1529 AliCodeTimerAuto("",0);
1531 // Access to the AOD container of clusters
1532 TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
1535 for (Int_t iClust=0; iClust<esd.GetNumberOfCaloClusters(); ++iClust) {
1537 AliESDCaloCluster * cluster = esd.GetCaloCluster(iClust);
1539 Int_t id = cluster->GetID();
1540 Int_t nLabel = cluster->GetNLabels();
1541 Int_t *labels = cluster->GetLabels();
1543 for(int i = 0;i < nLabel;++i){
1544 if(fMChandler)fMChandler->SelectParticle(labels[i]);
1548 Float_t energy = cluster->E();
1549 Float_t posF[3] = { 0.};
1550 cluster->GetPosition(posF);
1552 AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
1558 cluster->GetType(),0);
1560 caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),
1561 cluster->GetDispersion(),
1562 cluster->GetM20(), cluster->GetM02(),
1563 cluster->GetEmcCpvDistance(),
1564 cluster->GetNExMax(),cluster->GetTOF()) ;
1566 caloCluster->SetPIDFromESD(cluster->GetPID());
1567 caloCluster->SetNCells(cluster->GetNCells());
1568 caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
1569 caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
1571 caloCluster->SetTrackDistance(cluster->GetTrackDx(), cluster->GetTrackDz());
1573 Int_t nMatchCount = 0;
1574 TArrayI* matchedT = cluster->GetTracksMatched();
1575 if (fNumberOfTracks>0 && matchedT && cluster->GetTrackMatchedIndex() >= 0) {
1576 for (Int_t im = 0; im < matchedT->GetSize(); im++) {
1577 Int_t iESDtrack = matchedT->At(im);;
1578 if (fAODTrackRefs->At(iESDtrack) != 0) {
1579 caloCluster->AddTrackMatched((AliAODTrack*)fAODTrackRefs->At(iESDtrack));
1585 caloCluster->SetTrackDistance(-999,-999);
1588 caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
1591 //______________________________________________________________________________
1592 void AliAnalysisTaskESDfilter::ConvertCaloTrigger(TString calo, const AliESDEvent& esd)
1594 AliCodeTimerAuto("",0);
1598 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));
1599 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));
1601 aodTrigger.Allocate(esdTrigger.GetEntries());
1607 while (esdTrigger.Next()) {
1608 esdTrigger.GetPosition(tmod,tabsId);
1609 esdTrigger.GetAmplitude(a);
1610 aodTrigger.Add(tmod,tabsId,a,0.,(Int_t*)NULL,0,0,0);
1616 AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
1620 TTree *aodTree = aodHandler->GetTree();
1624 Int_t *type = esd.GetCaloTriggerType();
1626 for (Int_t i = 0; i < 15; i++)
1628 aodTree->GetUserInfo()->Add(new TParameter<int>(Form("EMCALCaloTrigger%d",i), type[i]));
1633 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));
1635 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));
1637 aodTrigger.Allocate(esdTrigger.GetEntries());
1640 while (esdTrigger.Next())
1642 Int_t px, py, ts, nTimes, times[10], b;
1645 esdTrigger.GetPosition(px, py);
1647 esdTrigger.GetAmplitude(a);
1648 esdTrigger.GetTime(t);
1650 esdTrigger.GetL0Times(times);
1651 esdTrigger.GetNL0Times(nTimes);
1653 esdTrigger.GetL1TimeSum(ts);
1655 esdTrigger.GetTriggerBits(b);
1657 aodTrigger.Add(px, py, a, t, times, nTimes, ts, b);
1660 for (int i = 0; i < 4; i++) aodTrigger.SetL1Threshold(i, esdTrigger.GetL1Threshold(i));
1664 esdTrigger.GetL1V0(0),
1665 esdTrigger.GetL1V0(1)
1668 aodTrigger.SetL1V0(v0);
1669 aodTrigger.SetL1FrameMask(esdTrigger.GetL1FrameMask());
1672 //______________________________________________________________________________
1673 void AliAnalysisTaskESDfilter::ConvertEMCALCells(const AliESDEvent& esd)
1675 // Convert EMCAL Cells
1676 AliCodeTimerAuto("",0);
1677 // fill EMCAL cell info
1678 if (esd.GetEMCALCells()) { // protection against missing ESD information
1679 AliESDCaloCells &esdEMcells = *(esd.GetEMCALCells());
1680 Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
1682 AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
1683 aodEMcells.CreateContainer(nEMcell);
1684 aodEMcells.SetType(AliAODCaloCells::kEMCALCell);
1685 for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
1686 aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell),
1687 esdEMcells.GetTime(iCell), esdEMcells.GetMCLabel(iCell), esdEMcells.GetEFraction(iCell));
1693 //______________________________________________________________________________
1694 void AliAnalysisTaskESDfilter::ConvertPHOSCells(const AliESDEvent& esd)
1696 // Convert PHOS Cells
1697 AliCodeTimerAuto("",0);
1698 // fill PHOS cell info
1699 if (esd.GetPHOSCells()) { // protection against missing ESD information
1700 AliESDCaloCells &esdPHcells = *(esd.GetPHOSCells());
1701 Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
1703 AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
1704 aodPHcells.CreateContainer(nPHcell);
1705 aodPHcells.SetType(AliAODCaloCells::kPHOSCell);
1706 for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
1707 aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell),
1708 esdPHcells.GetTime(iCell), esdPHcells.GetMCLabel(iCell), esdPHcells.GetEFraction(iCell));
1714 //______________________________________________________________________________
1715 void AliAnalysisTaskESDfilter::ConvertTracklets(const AliESDEvent& esd)
1718 AliCodeTimerAuto("",0);
1720 AliAODTracklets &SPDTracklets = *(AODEvent()->GetTracklets());
1721 const AliMultiplicity *mult = esd.GetMultiplicity();
1723 if (mult->GetNumberOfTracklets()>0) {
1724 SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
1726 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
1728 fMChandler->SelectParticle(mult->GetLabel(n, 0));
1729 fMChandler->SelectParticle(mult->GetLabel(n, 1));
1731 SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));
1735 //Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
1739 //______________________________________________________________________________
1740 void AliAnalysisTaskESDfilter::ConvertKinks(const AliESDEvent& esd)
1742 AliCodeTimerAuto("",0);
1744 // Kinks: it is a big mess the access to the information in the kinks
1745 // The loop is on the tracks in order to find the mother and daugther of each kink
1747 Double_t covTr[21]={0.};
1748 Double_t pid[10]={0.};
1749 AliAODPid* detpid(0x0);
1751 fNumberOfKinks = esd.GetNumberOfKinks();
1753 const AliESDVertex* vtx = esd.GetPrimaryVertex();
1755 for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack)
1757 AliESDtrack * esdTrack = esd.GetTrack(iTrack);
1759 Int_t ikink = esdTrack->GetKinkIndex(0);
1761 if (ikink && fNumberOfKinks) {
1762 // Negative kink index: mother, positive: daughter
1764 // Search for the second track of the kink
1766 for (Int_t jTrack = iTrack+1; jTrack<esd.GetNumberOfTracks(); ++jTrack) {
1768 AliESDtrack * esdTrack1 = esd.GetTrack(jTrack);
1770 Int_t jkink = esdTrack1->GetKinkIndex(0);
1772 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
1774 // The two tracks are from the same kink
1776 if (fUsedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
1779 Int_t idaughter = -1;
1781 if (ikink<0 && jkink>0) {
1786 else if (ikink>0 && jkink<0) {
1792 // cerr << "Error: Wrong combination of kink indexes: "
1793 // << ikink << " " << jkink << endl;
1797 // Add the mother track if it passed primary track selection cuts
1799 AliAODTrack * mother = NULL;
1801 UInt_t selectInfo = 0;
1803 selectInfo = fTrackFilter->IsSelected(esd.GetTrack(imother));
1804 if (!selectInfo) continue;
1807 if (!fUsedTrack[imother]) {
1809 fUsedTrack[imother] = kTRUE;
1811 AliESDtrack *esdTrackM = esd.GetTrack(imother);
1812 Double_t p[3] = { 0. };
1813 Double_t pos[3] = { 0. };
1814 esdTrackM->GetPxPyPz(p);
1815 esdTrackM->GetXYZ(pos);
1816 esdTrackM->GetCovarianceXYZPxPyPz(covTr);
1817 esdTrackM->GetESDpid(pid);
1818 if(fMChandler)fMChandler->SelectParticle(esdTrackM->GetLabel());
1820 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackM->GetID(),
1821 esdTrackM->GetLabel(),
1827 (Short_t)esdTrackM->GetSign(),
1828 esdTrackM->GetITSClusterMap(),
1831 kTRUE, // check if this is right
1832 vtx->UsesTrack(esdTrack->GetID()),
1833 AliAODTrack::kPrimary,
1835 mother->SetTPCFitMap(esdTrackM->GetTPCFitMap());
1836 mother->SetTPCClusterMap(esdTrackM->GetTPCClusterMap());
1837 mother->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());
1838 mother->SetChi2perNDF(Chi2perNDF(esdTrackM));
1839 mother->SetTPCPointsF(esdTrackM->GetTPCNclsF());
1840 mother->SetTPCNCrossedRows(UShort_t(esdTrackM->GetTPCCrossedRows()));
1841 mother->SetIntegratedLength(esdTrackM->GetIntegratedLength());
1843 fAODTrackRefs->AddAt(mother, imother);
1845 if (esdTrackM->GetSign() > 0) ++fNumberOfPositiveTracks;
1846 mother->SetFlags(esdTrackM->GetStatus());
1847 mother->ConvertAliPIDtoAODPID();
1848 fPrimaryVertex->AddDaughter(mother);
1849 mother->ConvertAliPIDtoAODPID();
1850 SetAODPID(esdTrackM,mother,detpid);
1853 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
1854 // << " track " << imother << " has already been used!" << endl;
1857 // Add the kink vertex
1858 AliESDkink * kink = esd.GetKink(TMath::Abs(ikink)-1);
1860 AliAODVertex * vkink =
1861 new(Vertices()[fNumberOfVertices++]) AliAODVertex(kink->GetPosition(),
1865 esdTrack->GetID(), // This is the track ID of the mother's track!
1866 AliAODVertex::kKink);
1867 // Add the daughter track
1869 AliAODTrack * daughter = NULL;
1871 if (!fUsedTrack[idaughter]) {
1873 fUsedTrack[idaughter] = kTRUE;
1875 AliESDtrack *esdTrackD = esd.GetTrack(idaughter);
1876 Double_t p[3] = { 0. };
1877 Double_t pos[3] = { 0. };
1879 esdTrackD->GetPxPyPz(p);
1880 esdTrackD->GetXYZ(pos);
1881 esdTrackD->GetCovarianceXYZPxPyPz(covTr);
1882 esdTrackD->GetESDpid(pid);
1884 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdTrackD);
1885 if(fMChandler)fMChandler->SelectParticle(esdTrackD->GetLabel());
1887 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackD->GetID(),
1888 esdTrackD->GetLabel(),
1894 (Short_t)esdTrackD->GetSign(),
1895 esdTrackD->GetITSClusterMap(),
1898 kTRUE, // check if this is right
1899 vtx->UsesTrack(esdTrack->GetID()),
1900 AliAODTrack::kSecondary,
1902 daughter->SetTPCFitMap(esdTrackD->GetTPCFitMap());
1903 daughter->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());
1904 daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());
1905 daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());
1906 daughter->SetTPCNCrossedRows(UShort_t(esdTrackD->GetTPCCrossedRows()));
1907 daughter->SetIntegratedLength(esdTrackD->GetIntegratedLength());
1908 fAODTrackRefs->AddAt(daughter, idaughter);
1910 if (esdTrackD->GetSign() > 0) ++fNumberOfPositiveTracks;
1911 daughter->SetFlags(esdTrackD->GetStatus());
1912 daughter->ConvertAliPIDtoAODPID();
1913 vkink->AddDaughter(daughter);
1914 daughter->ConvertAliPIDtoAODPID();
1915 SetAODPID(esdTrackD,daughter,detpid);
1918 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
1919 // << " track " << idaughter << " has already been used!" << endl;
1927 //______________________________________________________________________________
1928 void AliAnalysisTaskESDfilter::ConvertPrimaryVertices(const AliESDEvent& esd)
1930 AliCodeTimerAuto("",0);
1932 // Access to the AOD container of vertices
1933 fNumberOfVertices = 0;
1935 Double_t pos[3] = { 0. };
1936 Double_t covVtx[6] = { 0. };
1938 // Add primary vertex. The primary tracks will be defined
1939 // after the loops on the composite objects (V0, cascades, kinks)
1940 const AliESDVertex *vtx = esd.GetPrimaryVertex();
1942 vtx->GetXYZ(pos); // position
1943 vtx->GetCovMatrix(covVtx); //covariance matrix
1945 fPrimaryVertex = new(Vertices()[fNumberOfVertices++])
1946 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
1947 fPrimaryVertex->SetName(vtx->GetName());
1948 fPrimaryVertex->SetTitle(vtx->GetTitle());
1949 fPrimaryVertex->SetBC(vtx->GetBC());
1951 TString vtitle = vtx->GetTitle();
1952 if (!vtitle.Contains("VertexerTracks"))
1953 fPrimaryVertex->SetNContributors(vtx->GetNContributors());
1955 if (fDebug > 0) fPrimaryVertex->Print();
1957 // Add SPD "main" vertex
1958 const AliESDVertex *vtxS = esd.GetPrimaryVertexSPD();
1959 vtxS->GetXYZ(pos); // position
1960 vtxS->GetCovMatrix(covVtx); //covariance matrix
1961 AliAODVertex * mVSPD = new(Vertices()[fNumberOfVertices++])
1962 AliAODVertex(pos, covVtx, vtxS->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainSPD);
1963 mVSPD->SetName(vtxS->GetName());
1964 mVSPD->SetTitle(vtxS->GetTitle());
1965 mVSPD->SetNContributors(vtxS->GetNContributors());
1967 // Add SPD pileup vertices
1968 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesSPD(); ++iV)
1970 const AliESDVertex *vtxP = esd.GetPileupVertexSPD(iV);
1971 vtxP->GetXYZ(pos); // position
1972 vtxP->GetCovMatrix(covVtx); //covariance matrix
1973 AliAODVertex * pVSPD = new(Vertices()[fNumberOfVertices++])
1974 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupSPD);
1975 pVSPD->SetName(vtxP->GetName());
1976 pVSPD->SetTitle(vtxP->GetTitle());
1977 pVSPD->SetNContributors(vtxP->GetNContributors());
1978 pVSPD->SetBC(vtxP->GetBC());
1981 // Add TRK pileup vertices
1982 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesTracks(); ++iV)
1984 const AliESDVertex *vtxP = esd.GetPileupVertexTracks(iV);
1985 vtxP->GetXYZ(pos); // position
1986 vtxP->GetCovMatrix(covVtx); //covariance matrix
1987 AliAODVertex * pVTRK = new(Vertices()[fNumberOfVertices++])
1988 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupTracks);
1989 pVTRK->SetName(vtxP->GetName());
1990 pVTRK->SetTitle(vtxP->GetTitle());
1991 pVTRK->SetNContributors(vtxP->GetNContributors());
1992 pVTRK->SetBC(vtxP->GetBC());
1995 // Add TPC "main" vertex
1996 const AliESDVertex *vtxT = esd.GetPrimaryVertexTPC();
1997 vtxT->GetXYZ(pos); // position
1998 vtxT->GetCovMatrix(covVtx); //covariance matrix
1999 AliAODVertex * mVTPC = new(Vertices()[fNumberOfVertices++])
2000 AliAODVertex(pos, covVtx, vtxT->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainTPC);
2001 mVTPC->SetName(vtxT->GetName());
2002 mVTPC->SetTitle(vtxT->GetTitle());
2003 mVTPC->SetNContributors(vtxT->GetNContributors());
2008 //______________________________________________________________________________
2009 void AliAnalysisTaskESDfilter::ConvertVZERO(const AliESDEvent& esd)
2011 // Convert VZERO data
2012 AliAODVZERO* vzeroData = AODEvent()->GetVZEROData();
2013 *vzeroData = *(esd.GetVZEROData());
2016 //______________________________________________________________________________
2017 void AliAnalysisTaskESDfilter::ConvertTZERO(const AliESDEvent& esd)
2019 // Convert TZERO data
2020 const AliESDTZERO* esdTzero = esd.GetESDTZERO();
2021 AliAODTZERO* aodTzero = AODEvent()->GetTZEROData();
2023 for (Int_t icase=0; icase<3; icase++){
2024 aodTzero->SetT0TOF( icase, esdTzero->GetT0TOF(icase));
2025 aodTzero->SetT0TOFbest(icase, esdTzero->GetT0TOFbest(icase));
2027 aodTzero->SetBackgroundFlag(esdTzero->GetBackgroundFlag());
2028 aodTzero->SetPileupFlag(esdTzero->GetPileupFlag());
2029 aodTzero->SetSatelliteFlag(esdTzero->GetSatellite());
2031 Float_t rawTime[24];
2032 for(Int_t ipmt=0; ipmt<24; ipmt++)
2033 rawTime[ipmt] = esdTzero->GetTimeFull(ipmt,0);
2035 Int_t idxOfFirstPmtA = -1, idxOfFirstPmtC = -1;
2036 Float_t timeOfFirstPmtA = 9999, timeOfFirstPmtC = 9999;
2037 for(int ipmt=0; ipmt<12; ipmt++){
2038 if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtC && rawTime[ipmt]!=0){
2039 timeOfFirstPmtC = rawTime[ipmt];
2040 idxOfFirstPmtC = ipmt;
2043 for(int ipmt=12; ipmt<24; ipmt++){
2044 if( rawTime[ipmt] > -200 && rawTime[ipmt] < timeOfFirstPmtA && rawTime[ipmt]!=0 ){
2045 timeOfFirstPmtA = rawTime[ipmt];
2046 idxOfFirstPmtA = ipmt;
2050 if(idxOfFirstPmtA != -1 && idxOfFirstPmtC != -1){
2051 //speed of light in cm/ns TMath::C()*1e-7
2052 Float_t vertexraw = TMath::C()*1e-7 * (rawTime[idxOfFirstPmtA] - rawTime[idxOfFirstPmtC])/2;
2053 aodTzero->SetT0VertexRaw( vertexraw );
2055 aodTzero->SetT0VertexRaw(99999);
2058 aodTzero->SetT0zVertex(esdTzero->GetT0zVertex());
2061 const Double32_t *amp=esdTzero->GetT0amplitude();
2062 for(int ipmt=0; ipmt<24; ipmt++)
2063 aodTzero->SetAmp(ipmt, amp[ipmt]);
2064 aodTzero->SetAmp(24,esdTzero->GetMultC() );
2065 aodTzero->SetAmp(25,esdTzero->GetMultA() );
2070 //______________________________________________________________________________
2071 void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)
2074 AliESDZDC* esdZDC = esd.GetZDCData();
2076 const Double_t zem1Energy = esdZDC->GetZEM1Energy();
2077 const Double_t zem2Energy = esdZDC->GetZEM2Energy();
2079 const Double_t *towZNC = esdZDC->GetZNCTowerEnergy();
2080 const Double_t *towZPC = esdZDC->GetZPCTowerEnergy();
2081 const Double_t *towZNA = esdZDC->GetZNATowerEnergy();
2082 const Double_t *towZPA = esdZDC->GetZPATowerEnergy();
2083 const Double_t *towZNCLG = esdZDC->GetZNCTowerEnergyLR();
2084 const Double_t *towZNALG = esdZDC->GetZNATowerEnergyLR();
2086 AliAODZDC* zdcAOD = AODEvent()->GetZDCData();
2088 zdcAOD->SetZEM1Energy(zem1Energy);
2089 zdcAOD->SetZEM2Energy(zem2Energy);
2090 zdcAOD->SetZNCTowers(towZNC, towZNCLG);
2091 zdcAOD->SetZNATowers(towZNA, towZNALG);
2092 zdcAOD->SetZPCTowers(towZPC);
2093 zdcAOD->SetZPATowers(towZPA);
2095 zdcAOD->SetZDCParticipants(esdZDC->GetZDCParticipants(), esdZDC->GetZDCPartSideA(), esdZDC->GetZDCPartSideC());
2096 zdcAOD->SetZDCImpactParameter(esdZDC->GetImpactParameter(), esdZDC->GetImpactParamSideA(),
2097 esdZDC->GetImpactParamSideC());
2098 zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0));
2099 zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0));
2100 if(esdZDC->IsZNChit()) zdcAOD->SetZNCTDC(esdZDC->GetZDCTDCCorrected(10,0));
2101 if(esdZDC->IsZNAhit()) zdcAOD->SetZNATDC(esdZDC->GetZDCTDCCorrected(12,0));
2104 //_______________________________________________________________________________________________________________________________________
2105 Int_t AliAnalysisTaskESDfilter::ConvertHMPID(const AliESDEvent& esd) // clm
2108 // Convtert ESD HMPID info to AOD and return the number of good tracks with HMPID signal.
2109 // We need to return an int since there is no signal counter in the ESD.
2112 AliCodeTimerAuto("",0);
2114 Int_t cntHmpidGoodTracks = 0;
2123 Float_t thetaTrk = 0;
2126 Double_t hmpPid[5]={0};
2127 Double_t hmpMom[3]={0};
2129 TClonesArray &hmpidRings = *(AODEvent()->GetHMPIDrings());
2131 for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack)
2133 if(! esd.GetTrack(iTrack) ) continue;
2135 if(esd.GetTrack(iTrack)->GetHMPIDsignal() > -20 ) { //
2137 (esd.GetTrack(iTrack))->GetHMPIDmip(xMip, yMip, qMip, nphMip); // Get MIP properties
2138 (esd.GetTrack(iTrack))->GetHMPIDtrk(xTrk,yTrk,thetaTrk,phiTrk);
2139 (esd.GetTrack(iTrack))->GetHMPIDpid(hmpPid);
2140 if((esd.GetTrack(iTrack))->GetOuterHmpParam()) (esd.GetTrack(iTrack))->GetOuterHmpPxPyPz(hmpMom);
2142 if(esd.GetTrack(iTrack)->GetHMPIDsignal() == 0 && thetaTrk == 0 && qMip == 0 && nphMip ==0 ) continue; //
2144 new(hmpidRings[cntHmpidGoodTracks++]) AliAODHMPIDrings(
2145 (esd.GetTrack(iTrack))->GetID(), // Unique track id to attach the ring to
2146 1000000*nphMip+qMip, // MIP charge and number of photons
2147 (esd.GetTrack(iTrack))->GetHMPIDcluIdx(), // 1000000*chamber id + cluster idx of the assigned MIP cluster
2148 thetaTrk, // track inclination angle theta
2149 phiTrk, // track inclination angle phi
2150 (esd.GetTrack(iTrack))->GetHMPIDsignal(), // Cherenkov angle
2151 (esd.GetTrack(iTrack))->GetHMPIDoccupancy(), // Occupancy claculated for the given chamber
2152 (esd.GetTrack(iTrack))->GetHMPIDchi2(), // Ring resolution squared
2153 xTrk, // Track x coordinate (LORS)
2154 yTrk, // Track y coordinate (LORS)
2155 xMip, // MIP x coordinate (LORS)
2156 yMip, // MIP y coordinate (LORS)
2157 hmpPid, // PID probablities from ESD, remove later once it is in CombinedPid
2158 hmpMom // Track momentum in HMPID at ring reconstruction
2161 // Printf(Form("+++++++++ yes/no: %d %lf %lf %lf %lf %lf %lf ",(esd.GetTrack(iTrack))->IsHMPID(),thetaTrk, (esd.GetTrack(iTrack))->GetHMPIDchi2(),xTrk, yTrk , xMip, yMip));
2164 }// HMPID signal > -20
2165 }//___esd track loop
2167 return cntHmpidGoodTracks;
2170 //______________________________________________________________________________
2171 void AliAnalysisTaskESDfilter::ConvertESDtoAOD()
2173 // ESD Filter analysis task executed for each event
2175 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
2179 AliCodeTimerAuto("",0);
2181 fOldESDformat = ( esd->GetAliESDOld() != 0x0 );
2183 // Reconstruct cascades and V0 here
2184 if (fIsV0CascadeRecoEnabled) {
2185 esd->ResetCascades();
2188 AliV0vertexer lV0vtxer;
2189 AliCascadeVertexer lCascVtxer;
2191 lV0vtxer.SetCuts(fV0Cuts);
2192 lCascVtxer.SetCuts(fCascadeCuts);
2195 lV0vtxer.Tracks2V0vertices(esd);
2196 lCascVtxer.V0sTracks2CascadeVertices(esd);
2200 fNumberOfTracks = 0;
2201 fNumberOfPositiveTracks = 0;
2203 fNumberOfVertices = 0;
2204 fNumberOfCascades = 0;
2207 AliAODHeader* header = ConvertHeader(*esd);
2209 if ( fIsVZEROEnabled ) ConvertVZERO(*esd);
2210 if ( fIsTZEROEnabled ) ConvertTZERO(*esd);
2212 // Fetch Stack for debuggging if available
2216 fMChandler = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
2219 // loop over events and fill them
2220 // Multiplicity information needed by the header (to be revised!)
2221 Int_t nTracks = esd->GetNumberOfTracks();
2222 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
2224 // Update the header
2226 Int_t nV0s = esd->GetNumberOfV0s();
2227 Int_t nCascades = esd->GetNumberOfCascades();
2228 Int_t nKinks = esd->GetNumberOfKinks();
2229 Int_t nVertices = nV0s + nCascades /*V0 wihtin cascade already counted*/+ nKinks + 1 /* = prim. vtx*/;
2230 Int_t nPileSPDVertices=1+esd->GetNumberOfPileupVerticesSPD(); // also SPD main vertex
2231 Int_t nPileTrkVertices=esd->GetNumberOfPileupVerticesTracks();
2232 nVertices+=nPileSPDVertices;
2233 nVertices+=nPileTrkVertices;
2235 Int_t nCaloClus = esd->GetNumberOfCaloClusters();
2237 Int_t nPmdClus = esd->GetNumberOfPmdTracks();
2238 Int_t nHmpidRings = 0;
2240 AliDebug(1,Form(" NV0=%d NCASCADES=%d NKINKS=%d", nV0s, nCascades, nKinks));
2242 AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus,nHmpidRings);
2246 // RefArray to store a mapping between esd V0 number and newly created AOD-Vertex V0
2247 fAODV0VtxRefs = new TRefArray(nV0s);
2248 // RefArray to store the mapping between esd V0 number and newly created AOD-V0
2249 fAODV0Refs = new TRefArray(nV0s);
2250 // Array to take into account the V0s already added to the AOD (V0 within cascades)
2251 fUsedV0 = new Bool_t[nV0s];
2252 for (Int_t iV0=0; iV0<nV0s; ++iV0) fUsedV0[iV0]=kFALSE;
2257 // RefArray to store the mapping between esd track number and newly created AOD-Track
2259 fAODTrackRefs = new TRefArray(nTracks);
2261 // Array to take into account the tracks already added to the AOD
2262 fUsedTrack = new Bool_t[nTracks];
2263 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) fUsedTrack[iTrack]=kFALSE;
2266 // Array to take into account the kinks already added to the AOD
2269 fUsedKink = new Bool_t[nKinks];
2270 for (Int_t iKink=0; iKink<nKinks; ++iKink) fUsedKink[iKink]=kFALSE;
2273 ConvertPrimaryVertices(*esd);
2275 //setting best TOF PID
2276 AliESDInputHandler* esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
2278 fESDpid = esdH->GetESDpid();
2280 if (fIsPidOwner && fESDpid){
2285 { //in case of no Tender attached
2286 fESDpid = new AliESDpid;
2287 fIsPidOwner = kTRUE;
2290 if(!esd->GetTOFHeader())
2291 { //protection in case the pass2 LHC10b,c,d have been processed without tender.
2292 Float_t t0spread[10];
2293 Float_t intrinsicTOFres=100; //ps ok for LHC10b,c,d pass2!!
2294 for (Int_t i=0; i<10; i++) t0spread[i] = (TMath::Sqrt(esd->GetSigma2DiamondZ()))/0.03; //0.03 to convert from cm to ps
2295 fESDpid->GetTOFResponse().SetT0resolution(t0spread);
2296 fESDpid->GetTOFResponse().SetTimeResolution(intrinsicTOFres);
2297 // fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType);
2298 AliTOFHeader tmpTOFHeader(0,t0spread[0],0,NULL,NULL,NULL,intrinsicTOFres,t0spread[0]);
2299 AODEvent()->SetTOFHeader(&tmpTOFHeader); // write dummy TOF header in AOD
2301 AODEvent()->SetTOFHeader(esd->GetTOFHeader()); // write TOF header in AOD
2304 // if(esd->GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender.
2306 if ( fAreCascadesEnabled ) ConvertCascades(*esd);
2308 if ( fAreV0sEnabled ) ConvertV0s(*esd);
2310 if ( fAreKinksEnabled ) ConvertKinks(*esd);
2312 if ( fAreTracksEnabled ) ConvertTracks(*esd);
2314 // Update number of AOD tracks in header at the end of track loop (M.G.)
2315 header->SetRefMultiplicity(fNumberOfTracks);
2316 header->SetRefMultiplicityPos(fNumberOfPositiveTracks);
2317 header->SetRefMultiplicityNeg(fNumberOfTracks - fNumberOfPositiveTracks);
2319 if ( fTPCConstrainedFilterMask ) ConvertTPCOnlyTracks(*esd);
2320 if( fGlobalConstrainedFilterMask) ConvertGlobalConstrainedTracks(*esd);
2322 if ( fArePmdClustersEnabled ) ConvertPmdClusters(*esd);
2324 if ( fAreCaloClustersEnabled ) ConvertCaloClusters(*esd);
2326 if ( fAreEMCALCellsEnabled )ConvertEMCALCells(*esd);
2328 if ( fArePHOSCellsEnabled )ConvertPHOSCells(*esd);
2330 if ( fAreEMCALTriggerEnabled )ConvertCaloTrigger(TString("EMCAL"), *esd);
2332 if ( fArePHOSTriggerEnabled )ConvertCaloTrigger(TString("PHOS"), *esd);
2334 if ( fAreTrackletsEnabled ) ConvertTracklets(*esd);
2335 if ( fIsZDCEnabled ) ConvertZDC(*esd);
2337 if(fIsHMPIDEnabled) nHmpidRings = ConvertHMPID(*esd);
2339 delete fAODTrackRefs; fAODTrackRefs=0x0;
2340 delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;
2341 delete fAODV0Refs; fAODV0Refs=0x0;
2343 delete[] fUsedTrack; fUsedTrack=0x0;
2344 delete[] fUsedV0; fUsedV0=0x0;
2345 delete[] fUsedKink; fUsedKink=0x0;
2356 //______________________________________________________________________________
2357 void AliAnalysisTaskESDfilter::SetAODPID(AliESDtrack *esdtrack, AliAODTrack *aodtrack, AliAODPid *detpid)
2360 // Setter for the raw PID detector signals
2363 // Save PID object for candidate electrons
2364 Bool_t pidSave = kFALSE;
2366 Bool_t selectInfo = fTrackFilter->IsSelected((char*) "Electrons");
2367 if (selectInfo) pidSave = kTRUE;
2371 // Tracks passing pt cut
2372 if(esdtrack->Pt()>fHighPthreshold) {
2376 if(esdtrack->Pt()> fPtshape->GetXmin()){
2377 Double_t y = fPtshape->Eval(esdtrack->Pt())/fPtshape->Eval(fHighPthreshold);
2378 if(gRandom->Rndm(0)<1./y){
2382 }//end if p function
2386 if(!aodtrack->GetDetPid()){// prevent memory leak when calling SetAODPID twice for the same track
2387 detpid = new AliAODPid();
2388 SetDetectorRawSignals(detpid,esdtrack);
2389 aodtrack->SetDetPID(detpid);
2394 //______________________________________________________________________________
2395 void AliAnalysisTaskESDfilter::SetDetectorRawSignals(AliAODPid *aodpid, AliESDtrack *track)
2398 //assignment of the detector signals (AliXXXesdPID inspired)
2401 AliInfo("no ESD track found. .....exiting");
2405 const AliExternalTrackParam *in=track->GetInnerParam();
2407 aodpid->SetTPCmomentum(in->GetP());
2409 aodpid->SetTPCmomentum(-1.);
2413 aodpid->SetITSsignal(track->GetITSsignal());
2414 Double_t itsdedx[4]; // dE/dx samples for individual ITS layers
2415 track->GetITSdEdxSamples(itsdedx);
2416 aodpid->SetITSdEdxSamples(itsdedx);
2418 aodpid->SetTPCsignal(track->GetTPCsignal());
2419 aodpid->SetTPCsignalN(track->GetTPCsignalN());
2420 if(track->GetTPCdEdxInfo()) aodpid->SetTPCdEdxInfo(track->GetTPCdEdxInfo());
2423 Int_t nslices = track->GetNumberOfTRDslices()*6;
2424 TArrayD trdslices(nslices);
2425 for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {
2426 for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);
2430 for(Int_t iPl=0;iPl<6;iPl++){
2431 Double_t trdmom=track->GetTRDmomentum(iPl);
2432 aodpid->SetTRDmomentum(iPl,trdmom);
2435 aodpid->SetTRDslices(track->GetNumberOfTRDslices()*6,trdslices.GetArray());
2436 aodpid->SetTRDsignal(track->GetTRDsignal());
2438 //TRD clusters and tracklets
2439 aodpid->SetTRDncls(track->GetTRDncls());
2440 aodpid->SetTRDntrackletsPID(track->GetTRDntrackletsPID());
2442 aodpid->SetTRDChi2(track->GetTRDchi2());
2445 Double_t times[AliPID::kSPECIES]; track->GetIntegratedTimes(times);
2446 aodpid->SetIntegratedTimes(times);
2448 // Float_t tzeroTrack = fESDpid->GetTOFResponse().GetStartTime(track->P());
2449 // aodpid->SetTOFsignal(track->GetTOFsignal()-tzeroTrack);
2450 aodpid->SetTOFsignal(track->GetTOFsignal());
2453 for (Int_t iMass=0; iMass<5; iMass++){
2454 // tofRes[iMass]=(Double_t)fESDpid->GetTOFResponse().GetExpectedSigma(track->P(), times[iMass], AliPID::ParticleMass(iMass));
2455 tofRes[iMass]=0; //backward compatibility
2457 aodpid->SetTOFpidResolution(tofRes);
2459 // aodpid->SetHMPIDsignal(0); // set to zero for compression but it will be removed later
2463 Double_t AliAnalysisTaskESDfilter::Chi2perNDF(AliESDtrack* track)
2465 // Calculate chi2 per ndf for track
2466 Int_t nClustersTPC = track->GetTPCNcls();
2468 if ( nClustersTPC > 5) {
2469 return (track->GetTPCchi2()/Float_t(nClustersTPC - 5));
2476 //______________________________________________________________________________
2477 void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)
2479 // Terminate analysis
2481 if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
2484 //______________________________________________________________________________
2485 void AliAnalysisTaskESDfilter::PrintMCInfo(AliStack *pStack,Int_t label){
2488 label = TMath::Abs(label);
2489 TParticle *part = pStack->Particle(label);
2490 Printf("########################");
2491 Printf("%s:%d %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,label,part->GetUniqueID(),part->GetPdgCode(),part->P());
2493 TParticle* mother = part;
2494 Int_t imo = part->GetFirstMother();
2495 Int_t nprim = pStack->GetNprimary();
2496 // while((imo >= nprim) && (mother->GetUniqueID() == 4)) {
2497 while((imo >= nprim)) {
2498 mother = pStack->Particle(imo);
2499 Printf("Mother %s:%d Label %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,imo,mother->GetUniqueID(),mother->GetPdgCode(),mother->P());
2501 imo = mother->GetFirstMother();
2503 Printf("########################");
2506 //______________________________________________________