1 /**************************************************************************
\r
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
\r
4 * Author: The ALICE Off-line Project. *
\r
5 * Contributors are mentioned in the code where appropriate. *
\r
7 * Permission to use, copy, modify and distribute this software and its *
\r
8 * documentation strictly for non-commercial purposes is hereby granted *
\r
9 * without fee, provided that the above copyright notice appears in all *
\r
10 * copies and that both the copyright notice and this permission notice *
\r
11 * appear in the supporting documentation. The authors make no claims *
\r
12 * about the suitability of this software for any purpose. It is *
\r
13 * provided "as is" without express or implied warranty. *
\r
14 **************************************************************************/
\r
21 #include <TArrayI.h>
\r
22 #include <TParameter.h>
\r
23 #include <TRandom.h>
\r
24 #include <TParticle.h>
\r
27 #include "AliAnalysisTaskESDfilter.h"
\r
28 #include "AliAnalysisManager.h"
\r
29 #include "AliESDEvent.h"
\r
30 #include "AliESDRun.h"
\r
31 #include "AliStack.h"
\r
32 #include "AliAODEvent.h"
\r
33 #include "AliMCEvent.h"
\r
34 #include "AliMCEventHandler.h"
\r
35 #include "AliESDInputHandler.h"
\r
36 #include "AliAODHandler.h"
\r
37 #include "AliAODMCParticle.h"
\r
38 #include "AliAnalysisFilter.h"
\r
39 #include "AliESDMuonTrack.h"
\r
40 #include "AliESDVertex.h"
\r
41 #include "AliCentrality.h"
\r
42 #include "AliEventplane.h"
\r
43 #include "AliESDv0.h"
\r
44 #include "AliESDkink.h"
\r
45 #include "AliESDcascade.h"
\r
46 #include "AliESDPmdTrack.h"
\r
47 #include "AliESDCaloCluster.h"
\r
48 #include "AliESDCaloCells.h"
\r
49 #include "AliMultiplicity.h"
\r
51 #include "AliCodeTimer.h"
\r
52 #include "AliESDtrackCuts.h"
\r
53 #include "AliESDpid.h"
\r
54 #include "AliV0vertexer.h"
\r
55 #include "AliCascadeVertexer.h"
\r
56 #include "Riostream.h"
\r
58 ClassImp(AliAnalysisTaskESDfilter)
\r
60 ////////////////////////////////////////////////////////////////////////
\r
62 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():
\r
63 AliAnalysisTaskSE(),
\r
67 fCascadeFilter(0x0),
\r
70 fEnableFillAOD(kTRUE),
\r
79 fNumberOfPositiveTracks(0),
\r
81 fNumberOfVertices(0),
\r
82 fNumberOfCascades(0),
\r
84 fOldESDformat(kFALSE),
\r
85 fPrimaryVertex(0x0),
\r
86 fTPCConstrainedFilterMask(0),
\r
87 fHybridFilterMaskTPCCG(0),
\r
88 fWriteHybridTPCCOnly(kFALSE),
\r
89 fGlobalConstrainedFilterMask(0),
\r
90 fHybridFilterMaskGCG(0),
\r
91 fWriteHybridGCOnly(kFALSE),
\r
92 fIsVZEROEnabled(kTRUE),
\r
93 fIsTZEROEnabled(kTRUE),
\r
94 fIsZDCEnabled(kTRUE),
\r
95 fIsV0CascadeRecoEnabled(kFALSE),
\r
96 fAreCascadesEnabled(kTRUE),
\r
97 fAreV0sEnabled(kTRUE),
\r
98 fAreKinksEnabled(kTRUE),
\r
99 fAreTracksEnabled(kTRUE),
\r
100 fArePmdClustersEnabled(kTRUE),
\r
101 fAreCaloClustersEnabled(kTRUE),
\r
102 fAreEMCALCellsEnabled(kTRUE),
\r
103 fArePHOSCellsEnabled(kTRUE),
\r
104 fAreEMCALTriggerEnabled(kTRUE),
\r
105 fArePHOSTriggerEnabled(kFALSE),
\r
106 fAreTrackletsEnabled(kTRUE),
\r
108 fIsPidOwner(kFALSE),
\r
109 fTimeZeroType(AliESDpid::kTOF_T0),
\r
110 fTPCaloneTrackCuts(0)
\r
112 // Default constructor
\r
113 fV0Cuts[0] = 33. ; // max allowed chi2
\r
114 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter
\r
115 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter
\r
116 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks
\r
117 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle
\r
118 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume
\r
119 fV0Cuts[6] = 100. ; // max radius of the fiducial volume
\r
121 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)
\r
122 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter
\r
123 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass
\r
124 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter
\r
125 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor
\r
126 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle
\r
127 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume
\r
128 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume
\r
131 //______________________________________________________________________________
\r
132 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):
\r
133 AliAnalysisTaskSE(name),
\r
137 fCascadeFilter(0x0),
\r
138 fHighPthreshold(0),
\r
140 fEnableFillAOD(kTRUE),
\r
144 fAODTrackRefs(0x0),
\r
145 fAODV0VtxRefs(0x0),
\r
148 fNumberOfTracks(0),
\r
149 fNumberOfPositiveTracks(0),
\r
151 fNumberOfVertices(0),
\r
152 fNumberOfCascades(0),
\r
154 fOldESDformat(kFALSE),
\r
155 fPrimaryVertex(0x0),
\r
156 fTPCConstrainedFilterMask(0),
\r
157 fHybridFilterMaskTPCCG(0),
\r
158 fWriteHybridTPCCOnly(kFALSE),
\r
159 fGlobalConstrainedFilterMask(0),
\r
160 fHybridFilterMaskGCG(0),
\r
161 fWriteHybridGCOnly(kFALSE),
\r
162 fIsVZEROEnabled(kTRUE),
\r
163 fIsTZEROEnabled(kTRUE),
\r
164 fIsZDCEnabled(kTRUE),
\r
165 fIsV0CascadeRecoEnabled(kFALSE),
\r
166 fAreCascadesEnabled(kTRUE),
\r
167 fAreV0sEnabled(kTRUE),
\r
168 fAreKinksEnabled(kTRUE),
\r
169 fAreTracksEnabled(kTRUE),
\r
170 fArePmdClustersEnabled(kTRUE),
\r
171 fAreCaloClustersEnabled(kTRUE),
\r
172 fAreEMCALCellsEnabled(kTRUE),
\r
173 fArePHOSCellsEnabled(kTRUE),
\r
174 fAreEMCALTriggerEnabled(kTRUE),
\r
175 fArePHOSTriggerEnabled(kFALSE),
\r
176 fAreTrackletsEnabled(kTRUE),
\r
178 fIsPidOwner(kFALSE),
\r
179 fTimeZeroType(AliESDpid::kTOF_T0),
\r
180 fTPCaloneTrackCuts(0)
\r
184 fV0Cuts[0] = 33. ; // max allowed chi2
\r
185 fV0Cuts[1] = 0.1 ; // min allowed impact parameter for the 1st daughter
\r
186 fV0Cuts[2] = 0.1 ; // min allowed impact parameter for the 2nd daughter
\r
187 fV0Cuts[3] = 1. ; // max allowed DCA between the daughter tracks
\r
188 fV0Cuts[4] = .998; // min allowed cosine of V0's pointing angle
\r
189 fV0Cuts[5] = 0.9 ; // min radius of the fiducial volume
\r
190 fV0Cuts[6] = 100. ; // max radius of the fiducial volume
\r
192 fCascadeCuts[0] = 33. ; // max allowed chi2 (same as PDC07)
\r
193 fCascadeCuts[1] = 0.05 ; // min allowed V0 impact parameter
\r
194 fCascadeCuts[2] = 0.008; // "window" around the Lambda mass
\r
195 fCascadeCuts[3] = 0.03 ; // min allowed bachelor's impact parameter
\r
196 fCascadeCuts[4] = 0.3 ; // max allowed DCA between the V0 and the bachelor
\r
197 fCascadeCuts[5] = 0.999; // min allowed cosine of the cascade pointing angle
\r
198 fCascadeCuts[6] = 0.9 ; // min radius of the fiducial volume
\r
199 fCascadeCuts[7] = 100. ; // max radius of the fiducial volume
\r
204 AliAnalysisTaskESDfilter::~AliAnalysisTaskESDfilter(){
\r
205 if(fIsPidOwner) delete fESDpid;
\r
207 //______________________________________________________________________________
\r
208 void AliAnalysisTaskESDfilter::UserCreateOutputObjects()
\r
211 // Create Output Objects conenct filter to outputtree
\r
215 OutputTree()->GetUserInfo()->Add(fTrackFilter);
\r
219 AliError("No OutputTree() for adding the track filter");
\r
221 fTPCaloneTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
\r
224 //______________________________________________________________________________
\r
225 void AliAnalysisTaskESDfilter::Init()
\r
228 if (fDebug > 1) AliInfo("Init() \n");
\r
229 // Call configuration file
\r
232 //______________________________________________________________________________
\r
233 void AliAnalysisTaskESDfilter::PrintTask(Option_t *option, Int_t indent) const
\r
235 // Print selection task information
\r
238 AliAnalysisTaskSE::PrintTask(option,indent);
\r
240 TString spaces(' ',indent+3);
\r
242 cout << spaces.Data() << Form("Cascades are %s",fAreCascadesEnabled ? "ENABLED":"DISABLED") << endl;
\r
243 cout << spaces.Data() << Form("V0s are %s",fAreV0sEnabled ? "ENABLED":"DISABLED") << endl;
\r
244 cout << spaces.Data() << Form("Kinks are %s",fAreKinksEnabled ? "ENABLED":"DISABLED") << endl;
\r
245 cout << spaces.Data() << Form("Tracks are %s",fAreTracksEnabled ? "ENABLED":"DISABLED") << endl;
\r
246 cout << spaces.Data() << Form("PmdClusters are %s",fArePmdClustersEnabled ? "ENABLED":"DISABLED") << endl;
\r
247 cout << spaces.Data() << Form("CaloClusters are %s",fAreCaloClustersEnabled ? "ENABLED":"DISABLED") << endl;
\r
248 cout << spaces.Data() << Form("EMCAL cells are %s",fAreEMCALCellsEnabled ? "ENABLED":"DISABLED") << endl;
\r
249 cout << spaces.Data() << Form("EMCAL triggers are %s",fAreEMCALTriggerEnabled ? "ENABLED":"DISABLED") << endl;
\r
250 cout << spaces.Data() << Form("PHOS triggers are %s",fArePHOSTriggerEnabled ? "ENABLED":"DISABLED") << endl;
\r
251 cout << spaces.Data() << Form("Tracklets are %s",fAreTrackletsEnabled ? "ENABLED":"DISABLED") << endl;
\r
254 //______________________________________________________________________________
\r
255 void AliAnalysisTaskESDfilter::UserExec(Option_t */*option*/)
\r
257 // Execute analysis for current event
\r
260 Long64_t ientry = Entry();
\r
263 printf("Filter: Analysing event # %5d\n", (Int_t) ientry);
\r
264 if (fHighPthreshold == 0) AliInfo("detector PID signals are stored in each track");
\r
265 if (!fPtshape) AliInfo("detector PID signals are not stored below the pt threshold");
\r
267 // Filters must explicitely enable AOD filling in their UserExec (AG)
\r
268 if (!AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()) AliFatal("Cannot run ESD filter without an output event handler");
\r
269 if(fEnableFillAOD) {
\r
270 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
\r
271 AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);
\r
276 //______________________________________________________________________________
\r
277 TClonesArray& AliAnalysisTaskESDfilter::Cascades()
\r
279 return *(AODEvent()->GetCascades());
\r
282 //______________________________________________________________________________
\r
283 TClonesArray& AliAnalysisTaskESDfilter::Tracks()
\r
285 return *(AODEvent()->GetTracks());
\r
288 //______________________________________________________________________________
\r
289 TClonesArray& AliAnalysisTaskESDfilter::V0s()
\r
291 return *(AODEvent()->GetV0s());
\r
294 //______________________________________________________________________________
\r
295 TClonesArray& AliAnalysisTaskESDfilter::Vertices()
\r
297 return *(AODEvent()->GetVertices());
\r
300 //______________________________________________________________________________
\r
301 AliAODHeader* AliAnalysisTaskESDfilter::ConvertHeader(const AliESDEvent& esd)
\r
303 // Convert header information
\r
305 AliCodeTimerAuto("",0);
\r
307 AliAODHeader* header = AODEvent()->GetHeader();
\r
309 header->SetRunNumber(esd.GetRunNumber());
\r
310 header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
\r
312 TTree* tree = fInputHandler->GetTree();
\r
314 TFile* file = tree->GetCurrentFile();
\r
315 if (file) header->SetESDFileName(file->GetName());
\r
318 if (fOldESDformat) {
\r
319 header->SetBunchCrossNumber(0);
\r
320 header->SetOrbitNumber(0);
\r
321 header->SetPeriodNumber(0);
\r
322 header->SetEventType(0);
\r
323 header->SetMuonMagFieldScale(-999.);
\r
324 header->SetCentrality(0);
\r
325 header->SetEventplane(0);
\r
327 header->SetBunchCrossNumber(esd.GetBunchCrossNumber());
\r
328 header->SetOrbitNumber(esd.GetOrbitNumber());
\r
329 header->SetPeriodNumber(esd.GetPeriodNumber());
\r
330 header->SetEventType(esd.GetEventType());
\r
332 header->SetEventNumberESDFile(esd.GetHeader()->GetEventNumberInFile());
\r
333 if(const_cast<AliESDEvent&>(esd).GetCentrality()){
\r
334 header->SetCentrality(const_cast<AliESDEvent&>(esd).GetCentrality());
\r
337 header->SetCentrality(0);
\r
339 if(const_cast<AliESDEvent&>(esd).GetEventplane()){
\r
340 header->SetEventplane(const_cast<AliESDEvent&>(esd).GetEventplane());
\r
343 header->SetEventplane(0);
\r
348 header->SetFiredTriggerClasses(esd.GetFiredTriggerClasses());
\r
349 header->SetTriggerMask(esd.GetTriggerMask());
\r
350 header->SetTriggerCluster(esd.GetTriggerCluster());
\r
351 header->SetL0TriggerInputs(esd.GetHeader()->GetL0TriggerInputs());
\r
352 header->SetL1TriggerInputs(esd.GetHeader()->GetL1TriggerInputs());
\r
353 header->SetL2TriggerInputs(esd.GetHeader()->GetL2TriggerInputs());
\r
355 header->SetMagneticField(esd.GetMagneticField());
\r
356 header->SetMuonMagFieldScale(esd.GetCurrentDip()/6000.);
\r
357 header->SetZDCN1Energy(esd.GetZDCN1Energy());
\r
358 header->SetZDCP1Energy(esd.GetZDCP1Energy());
\r
359 header->SetZDCN2Energy(esd.GetZDCN2Energy());
\r
360 header->SetZDCP2Energy(esd.GetZDCP2Energy());
\r
361 header->SetZDCEMEnergy(esd.GetZDCEMEnergy(0),esd.GetZDCEMEnergy(1));
\r
363 // ITS Cluster Multiplicty
\r
364 const AliMultiplicity *mult = esd.GetMultiplicity();
\r
365 for (Int_t ilay = 0; ilay < 6; ilay++) header->SetITSClusters(ilay, mult->GetNumberOfITSClusters(ilay));
\r
367 // TPC only Reference Multiplicty
\r
368 Int_t refMult = fTPCaloneTrackCuts ? (Short_t)fTPCaloneTrackCuts->GetReferenceMultiplicity(&esd, kTRUE) : -1;
\r
369 header->SetTPConlyRefMultiplicity(refMult);
\r
372 Float_t diamxy[2]={esd.GetDiamondX(),esd.GetDiamondY()};
\r
373 Float_t diamcov[3];
\r
374 esd.GetDiamondCovXY(diamcov);
\r
375 header->SetDiamond(diamxy,diamcov);
\r
376 header->SetDiamondZ(esd.GetDiamondZ(),esd.GetSigma2DiamondZ());
\r
378 // VZERO channel equalization factors for event-plane reconstruction
\r
379 header->SetVZEROEqFactors(esd.GetVZEROEqFactors());
\r
384 //______________________________________________________________________________
\r
385 void AliAnalysisTaskESDfilter::ConvertCascades(const AliESDEvent& esd)
\r
388 // Convert the cascades part of the ESD.
\r
389 // Return the number of cascades
\r
391 AliCodeTimerAuto("",0);
\r
393 // Create vertices starting from the most complex objects
\r
394 Double_t chi2 = 0.;
\r
396 const AliESDVertex* vtx = esd.GetPrimaryVertex();
\r
397 Double_t pos[3] = { 0. };
\r
398 Double_t covVtx[6] = { 0. };
\r
399 Double_t momBach[3]={0.};
\r
400 Double_t covTr[21]={0.};
\r
401 Double_t pid[10]={0.};
\r
402 AliAODPid* detpid(0x0);
\r
403 AliAODVertex* vV0FromCascade(0x0);
\r
404 AliAODv0* aodV0(0x0);
\r
405 AliAODcascade* aodCascade(0x0);
\r
406 AliAODTrack* aodTrack(0x0);
\r
407 Double_t momPos[3]={0.};
\r
408 Double_t momNeg[3] = { 0. };
\r
409 Double_t momPosAtV0vtx[3]={0.};
\r
410 Double_t momNegAtV0vtx[3]={0.};
\r
412 TClonesArray& verticesArray = Vertices();
\r
413 TClonesArray& tracksArray = Tracks();
\r
414 TClonesArray& cascadesArray = Cascades();
\r
416 // Cascades (Modified by A.Maire - February 2009)
\r
417 for (Int_t nCascade = 0; nCascade < esd.GetNumberOfCascades(); ++nCascade) {
\r
421 AliESDcascade *esdCascade = esd.GetCascade(nCascade);
\r
422 Int_t idxPosFromV0Dghter = esdCascade->GetPindex();
\r
423 Int_t idxNegFromV0Dghter = esdCascade->GetNindex();
\r
424 Int_t idxBachFromCascade = esdCascade->GetBindex();
\r
426 AliESDtrack *esdCascadePos = esd.GetTrack( idxPosFromV0Dghter);
\r
427 AliESDtrack *esdCascadeNeg = esd.GetTrack( idxNegFromV0Dghter);
\r
428 AliESDtrack *esdCascadeBach = esd.GetTrack( idxBachFromCascade);
\r
430 // Identification of the V0 within the esdCascade (via both daughter track indices)
\r
431 AliESDv0 * currentV0 = 0x0;
\r
432 Int_t idxV0FromCascade = -1;
\r
434 for (Int_t iV0=0; iV0<esd.GetNumberOfV0s(); ++iV0) {
\r
436 currentV0 = esd.GetV0(iV0);
\r
437 Int_t posCurrentV0 = currentV0->GetPindex();
\r
438 Int_t negCurrentV0 = currentV0->GetNindex();
\r
440 if (posCurrentV0==idxPosFromV0Dghter && negCurrentV0==idxNegFromV0Dghter) {
\r
441 idxV0FromCascade = iV0;
\r
446 if(idxV0FromCascade < 0){
\r
447 printf("Cascade - no matching for the V0 (index V0 = -1) ! Skip ... \n");
\r
449 }// a priori, useless check, but safer ... in case of pb with tracks "out of bounds"
\r
451 AliESDv0 *esdV0FromCascade = esd.GetV0(idxV0FromCascade);
\r
453 // 1 - Cascade selection
\r
455 // AliESDVertex *esdPrimVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));
\r
456 // TList cascadeObjects;
\r
457 // cascadeObjects.AddAt(esdV0FromCascade, 0);
\r
458 // cascadeObjects.AddAt(esdCascadePos, 1);
\r
459 // cascadeObjects.AddAt(esdCascadeNeg, 2);
\r
460 // cascadeObjects.AddAt(esdCascade, 3);
\r
461 // cascadeObjects.AddAt(esdCascadeBach, 4);
\r
462 // cascadeObjects.AddAt(esdPrimVtx, 5);
\r
464 // UInt_t selectCascade = 0;
\r
465 // if (fCascadeFilter) {
\r
466 // // selectCascade = fCascadeFilter->IsSelected(&cascadeObjects);
\r
467 // // FIXME AliESDCascadeCuts to be implemented ...
\r
469 // // Here we may encounter a moot point at the V0 level
\r
470 // // between the cascade selections and the V0 ones :
\r
471 // // the V0 selected along with the cascade (secondary V0) may
\r
472 // // usually be removed from the dedicated V0 selections (prim V0) ...
\r
473 // // -> To be discussed !
\r
475 // // this is a little awkward but otherwise the
\r
476 // // list wants to access the pointer (delete it)
\r
477 // // again when going out of scope
\r
478 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct
\r
480 // if (!selectCascade)
\r
484 // delete cascadeObjects.RemoveAt(5); // esdPrimVtx created via copy construct
\r
488 // 2 - Add the cascade vertex
\r
490 esdCascade->GetXYZcascade(pos[0], pos[1], pos[2]);
\r
491 esdCascade->GetPosCovXi(covVtx);
\r
492 chi2 = esdCascade->GetChi2Xi();
\r
494 AliAODVertex *vCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex( pos,
\r
496 chi2, // FIXME = Chi2/NDF will be needed
\r
499 AliAODVertex::kCascade);
\r
500 fPrimaryVertex->AddDaughter(vCascade);
\r
502 // if (fDebug > 2) {
\r
503 // printf("---- Cascade / Cascade Vertex (AOD) : \n");
\r
504 // vCascade->Print();
\r
507 if(esd.GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(const_cast<AliESDEvent*>(&esd), (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender.
\r
510 // 3 - Add the bachelor track from the cascade
\r
512 if (!fUsedTrack[idxBachFromCascade]) {
\r
514 esdCascadeBach->GetPxPyPz(momBach);
\r
515 esdCascadeBach->GetXYZ(pos);
\r
516 esdCascadeBach->GetCovarianceXYZPxPyPz(covTr);
\r
517 esdCascadeBach->GetESDpid(pid);
\r
519 fUsedTrack[idxBachFromCascade] = kTRUE;
\r
520 UInt_t selectInfo = 0;
\r
521 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeBach);
\r
522 if (fMChandler) fMChandler->SelectParticle(esdCascadeBach->GetLabel());
\r
523 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack(esdCascadeBach->GetID(),
\r
524 esdCascadeBach->GetLabel(),
\r
528 kFALSE, // Why kFALSE for "isDCA" ? FIXME
\r
530 (Short_t)esdCascadeBach->GetSign(),
\r
531 esdCascadeBach->GetITSClusterMap(),
\r
534 kTRUE, // usedForVtxFit = kFALSE ? FIXME
\r
535 vtx->UsesTrack(esdCascadeBach->GetID()),
\r
536 AliAODTrack::kSecondary,
\r
538 aodTrack->SetTPCFitMap(esdCascadeBach->GetTPCFitMap());
\r
539 aodTrack->SetTPCClusterMap(esdCascadeBach->GetTPCClusterMap());
\r
540 aodTrack->SetTPCSharedMap (esdCascadeBach->GetTPCSharedMap());
\r
541 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeBach));
\r
542 aodTrack->SetTPCPointsF(esdCascadeBach->GetTPCNclsF());
\r
543 fAODTrackRefs->AddAt(aodTrack,idxBachFromCascade);
\r
545 if (esdCascadeBach->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
546 aodTrack->ConvertAliPIDtoAODPID();
\r
547 aodTrack->SetFlags(esdCascadeBach->GetStatus());
\r
548 SetAODPID(esdCascadeBach,aodTrack,detpid);
\r
551 aodTrack = static_cast<AliAODTrack*>( fAODTrackRefs->At(idxBachFromCascade) );
\r
554 vCascade->AddDaughter(aodTrack);
\r
556 // if (fDebug > 4) {
\r
557 // printf("---- Cascade / bach dghter : \n");
\r
558 // aodTrack->Print();
\r
562 // 4 - Add the V0 from the cascade.
\r
563 // = V0vtx + both pos and neg daughter tracks + the aodV0 itself
\r
566 if ( !fUsedV0[idxV0FromCascade] ) {
\r
567 // 4.A - if VO structure hasn't been created yet
\r
569 // 4.A.1 - Create the V0 vertex of the cascade
\r
571 esdV0FromCascade->GetXYZ(pos[0], pos[1], pos[2]);
\r
572 esdV0FromCascade->GetPosCov(covVtx);
\r
573 chi2 = esdV0FromCascade->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3 ?
\r
575 vV0FromCascade = new(verticesArray[fNumberOfVertices++]) AliAODVertex(pos,
\r
579 idxV0FromCascade, //id of ESDv0
\r
580 AliAODVertex::kV0);
\r
582 // one V0 can be used by several cascades.
\r
583 // So, one AOD V0 vtx can have several parent vtx.
\r
584 // This is not directly allowed by AliAODvertex.
\r
585 // Setting the parent vtx (here = param "vCascade") doesn't lead to a crash
\r
586 // but to a problem of consistency within AODEvent.
\r
587 // -> See below paragraph 4.B, for the proposed treatment of such a case.
\r
589 // Add the vV0FromCascade to the aodVOVtxRefs
\r
590 fAODV0VtxRefs->AddAt(vV0FromCascade,idxV0FromCascade);
\r
593 // 4.A.2 - Add the positive tracks from the V0
\r
595 esdCascadePos->GetPxPyPz(momPos);
\r
596 esdCascadePos->GetXYZ(pos);
\r
597 esdCascadePos->GetCovarianceXYZPxPyPz(covTr);
\r
598 esdCascadePos->GetESDpid(pid);
\r
601 if (!fUsedTrack[idxPosFromV0Dghter]) {
\r
602 fUsedTrack[idxPosFromV0Dghter] = kTRUE;
\r
604 UInt_t selectInfo = 0;
\r
605 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadePos);
\r
606 if(fMChandler) fMChandler->SelectParticle(esdCascadePos->GetLabel());
\r
607 aodTrack = new(tracksArray[fNumberOfTracks++])
\r
608 AliAODTrack( esdCascadePos->GetID(),
\r
609 esdCascadePos->GetLabel(),
\r
613 kFALSE, // Why kFALSE for "isDCA" ? FIXME
\r
615 (Short_t)esdCascadePos->GetSign(),
\r
616 esdCascadePos->GetITSClusterMap(),
\r
619 kTRUE, // usedForVtxFit = kFALSE ? FIXME
\r
620 vtx->UsesTrack(esdCascadePos->GetID()),
\r
621 AliAODTrack::kSecondary,
\r
623 aodTrack->SetTPCFitMap(esdCascadePos->GetTPCFitMap());
\r
624 aodTrack->SetTPCClusterMap(esdCascadePos->GetTPCClusterMap());
\r
625 aodTrack->SetTPCSharedMap (esdCascadePos->GetTPCSharedMap());
\r
626 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadePos));
\r
627 aodTrack->SetTPCPointsF(esdCascadePos->GetTPCNclsF());
\r
628 fAODTrackRefs->AddAt(aodTrack,idxPosFromV0Dghter);
\r
630 if (esdCascadePos->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
631 aodTrack->ConvertAliPIDtoAODPID();
\r
632 aodTrack->SetFlags(esdCascadePos->GetStatus());
\r
633 SetAODPID(esdCascadePos,aodTrack,detpid);
\r
636 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxPosFromV0Dghter));
\r
638 vV0FromCascade->AddDaughter(aodTrack);
\r
641 // 4.A.3 - Add the negative tracks from the V0
\r
643 esdCascadeNeg->GetPxPyPz(momNeg);
\r
644 esdCascadeNeg->GetXYZ(pos);
\r
645 esdCascadeNeg->GetCovarianceXYZPxPyPz(covTr);
\r
646 esdCascadeNeg->GetESDpid(pid);
\r
649 if (!fUsedTrack[idxNegFromV0Dghter]) {
\r
650 fUsedTrack[idxNegFromV0Dghter] = kTRUE;
\r
652 UInt_t selectInfo = 0;
\r
653 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdCascadeNeg);
\r
654 if(fMChandler)fMChandler->SelectParticle(esdCascadeNeg->GetLabel());
\r
655 aodTrack = new(tracksArray[fNumberOfTracks++]) AliAODTrack( esdCascadeNeg->GetID(),
\r
656 esdCascadeNeg->GetLabel(),
\r
660 kFALSE, // Why kFALSE for "isDCA" ? FIXME
\r
662 (Short_t)esdCascadeNeg->GetSign(),
\r
663 esdCascadeNeg->GetITSClusterMap(),
\r
666 kTRUE, // usedForVtxFit = kFALSE ? FIXME
\r
667 vtx->UsesTrack(esdCascadeNeg->GetID()),
\r
668 AliAODTrack::kSecondary,
\r
670 aodTrack->SetTPCFitMap(esdCascadeNeg->GetTPCFitMap());
\r
671 aodTrack->SetTPCClusterMap(esdCascadeNeg->GetTPCClusterMap());
\r
672 aodTrack->SetTPCSharedMap (esdCascadeNeg->GetTPCSharedMap());
\r
673 aodTrack->SetChi2perNDF(Chi2perNDF(esdCascadeNeg));
\r
674 aodTrack->SetTPCPointsF(esdCascadeNeg->GetTPCNclsF());
\r
675 fAODTrackRefs->AddAt(aodTrack,idxNegFromV0Dghter);
\r
677 if (esdCascadeNeg->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
678 aodTrack->ConvertAliPIDtoAODPID();
\r
679 aodTrack->SetFlags(esdCascadeNeg->GetStatus());
\r
680 SetAODPID(esdCascadeNeg,aodTrack,detpid);
\r
683 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(idxNegFromV0Dghter));
\r
686 vV0FromCascade->AddDaughter(aodTrack);
\r
689 // 4.A.4 - Add the V0 from cascade to the V0 array
\r
691 Double_t dcaV0Daughters = esdV0FromCascade->GetDcaV0Daughters();
\r
692 Double_t dcaV0ToPrimVertex = esdV0FromCascade->GetD( esd.GetPrimaryVertex()->GetX(),
\r
693 esd.GetPrimaryVertex()->GetY(),
\r
694 esd.GetPrimaryVertex()->GetZ() );
\r
695 esdV0FromCascade->GetPPxPyPz( momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2] );
\r
696 esdV0FromCascade->GetNPxPyPz( momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2] );
\r
698 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg
\r
699 dcaDaughterToPrimVertex[0] = TMath::Abs(esdCascadePos->GetD( esd.GetPrimaryVertex()->GetX(),
\r
700 esd.GetPrimaryVertex()->GetY(),
\r
701 esd.GetMagneticField()) );
\r
702 dcaDaughterToPrimVertex[1] = TMath::Abs(esdCascadeNeg->GetD( esd.GetPrimaryVertex()->GetX(),
\r
703 esd.GetPrimaryVertex()->GetY(),
\r
704 esd.GetMagneticField()) );
\r
706 aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0( vV0FromCascade,
\r
708 dcaV0ToPrimVertex,
\r
711 dcaDaughterToPrimVertex);
\r
712 // set the aod v0 on-the-fly status
\r
713 aodV0->SetOnFlyStatus(esdV0FromCascade->GetOnFlyStatus());
\r
715 // Add the aodV0 to the aodVORefs
\r
716 fAODV0Refs->AddAt(aodV0,idxV0FromCascade);
\r
718 fUsedV0[idxV0FromCascade] = kTRUE;
\r
721 // 4.B - if V0 structure already used
\r
724 // one V0 can be used by several cascades (frequent in PbPb evts) :
\r
725 // same V0 which used but attached to different bachelor tracks
\r
726 // -> aodVORefs and fAODV0VtxRefs are needed.
\r
727 // Goal : avoid a redundancy of the info in "Vertices" and "v0s" clones array.
\r
729 vV0FromCascade = static_cast<AliAODVertex*>( fAODV0VtxRefs->At(idxV0FromCascade) );
\r
730 aodV0 = static_cast<AliAODv0*> ( fAODV0Refs ->At(idxV0FromCascade) );
\r
732 // - Treatment of the parent for such a "re-used" V0 :
\r
733 // Insert the cascade that reuses the V0 vertex in the lineage chain
\r
734 // Before : vV0 -> vCascade1 -> vPrimary
\r
735 // - Hyp : cascade2 uses the same V0 as cascade1
\r
736 // After : vV0 -> vCascade2 -> vCascade1 -> vPrimary
\r
738 AliAODVertex *vCascadePreviousParent = static_cast<AliAODVertex*> (vV0FromCascade->GetParent());
\r
739 vV0FromCascade->SetParent(vCascade);
\r
740 vCascade ->SetParent(vCascadePreviousParent);
\r
743 // printf("---- Cascade / Lineage insertion\n"
\r
744 // "Parent of V0 vtx = Cascade vtx %p\n"
\r
745 // "Parent of the cascade vtx = Cascade vtx %p\n"
\r
746 // "Parent of the parent cascade vtx = Cascade vtx %p\n",
\r
747 // static_cast<void*> (vV0FromCascade->GetParent()),
\r
748 // static_cast<void*> (vCascade->GetParent()),
\r
749 // static_cast<void*> (vCascadePreviousParent->GetParent()) );
\r
751 }// end if V0 structure already used
\r
753 // if (fDebug > 2) {
\r
754 // printf("---- Cascade / V0 vertex: \n");
\r
755 // vV0FromCascade->Print();
\r
758 // if (fDebug > 4) {
\r
759 // printf("---- Cascade / pos dghter : \n");
\r
760 // aodTrack->Print();
\r
761 // printf("---- Cascade / neg dghter : \n");
\r
762 // aodTrack->Print();
\r
763 // printf("---- Cascade / aodV0 : \n");
\r
767 // In any case (used V0 or not), add the V0 vertex to the cascade one.
\r
768 vCascade->AddDaughter(vV0FromCascade);
\r
771 // 5 - Add the primary track of the cascade (if any)
\r
774 // 6 - Add the cascade to the AOD array of cascades
\r
776 Double_t dcaBachToPrimVertexXY = TMath::Abs(esdCascadeBach->GetD(esd.GetPrimaryVertex()->GetX(),
\r
777 esd.GetPrimaryVertex()->GetY(),
\r
778 esd.GetMagneticField()) );
\r
780 Double_t momBachAtCascadeVtx[3]={0.};
\r
782 esdCascade->GetBPxPyPz(momBachAtCascadeVtx[0], momBachAtCascadeVtx[1], momBachAtCascadeVtx[2]);
\r
784 aodCascade = new(cascadesArray[fNumberOfCascades++]) AliAODcascade( vCascade,
\r
785 esdCascade->Charge(),
\r
786 esdCascade->GetDcaXiDaughters(),
\r
788 // DCAXiToPrimVtx -> needs to be calculated ----|
\r
789 // doesn't exist at ESD level;
\r
790 // See AODcascade::DcaXiToPrimVertex(Double, Double, Double)
\r
791 dcaBachToPrimVertexXY,
\r
792 momBachAtCascadeVtx,
\r
796 printf("---- Cascade / AOD cascade : \n\n");
\r
797 aodCascade->PrintXi(fPrimaryVertex->GetX(), fPrimaryVertex->GetY(), fPrimaryVertex->GetZ());
\r
800 } // end of the loop on cascades
\r
802 Cascades().Expand(fNumberOfCascades);
\r
805 //______________________________________________________________________________
\r
806 void AliAnalysisTaskESDfilter::ConvertV0s(const AliESDEvent& esd)
\r
808 // Access to the AOD container of V0s
\r
810 AliCodeTimerAuto("",0);
\r
816 Double_t pos[3] = { 0. };
\r
817 Double_t chi2(0.0);
\r
818 Double_t covVtx[6] = { 0. };
\r
819 Double_t momPos[3]={0.};
\r
820 Double_t covTr[21]={0.};
\r
821 Double_t pid[10]={0.};
\r
822 AliAODTrack* aodTrack(0x0);
\r
823 AliAODPid* detpid(0x0);
\r
824 Double_t momNeg[3]={0.};
\r
825 Double_t momPosAtV0vtx[3]={0.};
\r
826 Double_t momNegAtV0vtx[3]={0.};
\r
828 for (Int_t nV0 = 0; nV0 < esd.GetNumberOfV0s(); ++nV0)
\r
830 if (fUsedV0[nV0]) continue; // skip if already added to the AOD
\r
832 AliESDv0 *v0 = esd.GetV0(nV0);
\r
833 Int_t posFromV0 = v0->GetPindex();
\r
834 Int_t negFromV0 = v0->GetNindex();
\r
838 AliESDVertex *esdVtx = new AliESDVertex(*(esd.GetPrimaryVertex()));
\r
839 AliESDtrack *esdV0Pos = esd.GetTrack(posFromV0);
\r
840 AliESDtrack *esdV0Neg = esd.GetTrack(negFromV0);
\r
842 v0objects.AddAt(v0, 0);
\r
843 v0objects.AddAt(esdV0Pos, 1);
\r
844 v0objects.AddAt(esdV0Neg, 2);
\r
845 v0objects.AddAt(esdVtx, 3);
\r
846 UInt_t selectV0 = 0;
\r
848 selectV0 = fV0Filter->IsSelected(&v0objects);
\r
849 // this is a little awkward but otherwise the
\r
850 // list wants to access the pointer (delete it)
\r
851 // again when going out of scope
\r
852 delete v0objects.RemoveAt(3); // esdVtx created via copy construct
\r
858 delete v0objects.RemoveAt(3); // esdVtx created via copy construct
\r
862 v0->GetXYZ(pos[0], pos[1], pos[2]);
\r
864 if (!fOldESDformat) {
\r
865 chi2 = v0->GetChi2V0(); // = chi2/NDF since NDF = 2*2-3
\r
866 v0->GetPosCov(covVtx);
\r
869 for (Int_t i = 0; i < 6; i++) covVtx[i] = 0.;
\r
873 AliAODVertex * vV0 =
\r
874 new(Vertices()[fNumberOfVertices++]) AliAODVertex(pos,
\r
879 AliAODVertex::kV0);
\r
880 fPrimaryVertex->AddDaughter(vV0);
\r
883 // Add the positive tracks from the V0
\r
886 esdV0Pos->GetPxPyPz(momPos);
\r
887 esdV0Pos->GetXYZ(pos);
\r
888 esdV0Pos->GetCovarianceXYZPxPyPz(covTr);
\r
889 esdV0Pos->GetESDpid(pid);
\r
891 const AliESDVertex *vtx = esd.GetPrimaryVertex();
\r
893 if (!fUsedTrack[posFromV0]) {
\r
894 fUsedTrack[posFromV0] = kTRUE;
\r
895 UInt_t selectInfo = 0;
\r
896 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Pos);
\r
897 if(fMChandler)fMChandler->SelectParticle(esdV0Pos->GetLabel());
\r
898 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Pos->GetID(),
\r
899 esdV0Pos->GetLabel(),
\r
905 (Short_t)esdV0Pos->GetSign(),
\r
906 esdV0Pos->GetITSClusterMap(),
\r
909 kTRUE, // check if this is right
\r
910 vtx->UsesTrack(esdV0Pos->GetID()),
\r
911 AliAODTrack::kSecondary,
\r
913 aodTrack->SetTPCFitMap(esdV0Pos->GetTPCFitMap());
\r
914 aodTrack->SetTPCClusterMap(esdV0Pos->GetTPCClusterMap());
\r
915 aodTrack->SetTPCSharedMap (esdV0Pos->GetTPCSharedMap());
\r
916 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Pos));
\r
917 aodTrack->SetTPCPointsF(esdV0Pos->GetTPCNclsF());
\r
918 fAODTrackRefs->AddAt(aodTrack,posFromV0);
\r
919 // if (fDebug > 0) printf("-------------------Bo: pos track from original pt %.3f \n",aodTrack->Pt());
\r
920 if (esdV0Pos->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
921 aodTrack->ConvertAliPIDtoAODPID();
\r
922 aodTrack->SetFlags(esdV0Pos->GetStatus());
\r
923 SetAODPID(esdV0Pos,aodTrack,detpid);
\r
926 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(posFromV0));
\r
927 // if (fDebug > 0) printf("-------------------Bo pos track from refArray pt %.3f \n",aodTrack->Pt());
\r
929 vV0->AddDaughter(aodTrack);
\r
931 // Add the negative tracks from the V0
\r
933 esdV0Neg->GetPxPyPz(momNeg);
\r
934 esdV0Neg->GetXYZ(pos);
\r
935 esdV0Neg->GetCovarianceXYZPxPyPz(covTr);
\r
936 esdV0Neg->GetESDpid(pid);
\r
938 if (!fUsedTrack[negFromV0]) {
\r
939 fUsedTrack[negFromV0] = kTRUE;
\r
940 UInt_t selectInfo = 0;
\r
941 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdV0Neg);
\r
942 if(fMChandler)fMChandler->SelectParticle(esdV0Neg->GetLabel());
\r
943 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdV0Neg->GetID(),
\r
944 esdV0Neg->GetLabel(),
\r
950 (Short_t)esdV0Neg->GetSign(),
\r
951 esdV0Neg->GetITSClusterMap(),
\r
954 kTRUE, // check if this is right
\r
955 vtx->UsesTrack(esdV0Neg->GetID()),
\r
956 AliAODTrack::kSecondary,
\r
958 aodTrack->SetTPCFitMap(esdV0Neg->GetTPCFitMap());
\r
959 aodTrack->SetTPCClusterMap(esdV0Neg->GetTPCClusterMap());
\r
960 aodTrack->SetTPCSharedMap (esdV0Neg->GetTPCSharedMap());
\r
961 aodTrack->SetChi2perNDF(Chi2perNDF(esdV0Neg));
\r
962 aodTrack->SetTPCPointsF(esdV0Neg->GetTPCNclsF());
\r
964 fAODTrackRefs->AddAt(aodTrack,negFromV0);
\r
965 // if (fDebug > 0) printf("-------------------Bo: neg track from original pt %.3f \n",aodTrack->Pt());
\r
966 if (esdV0Neg->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
967 aodTrack->ConvertAliPIDtoAODPID();
\r
968 aodTrack->SetFlags(esdV0Neg->GetStatus());
\r
969 SetAODPID(esdV0Neg,aodTrack,detpid);
\r
972 aodTrack = static_cast<AliAODTrack*>(fAODTrackRefs->At(negFromV0));
\r
973 // if (fDebug > 0) printf("-------------------Bo neg track from refArray pt %.3f \n",aodTrack->Pt());
\r
975 vV0->AddDaughter(aodTrack);
\r
978 // Add the V0 the V0 array as well
\r
980 Double_t dcaV0Daughters = v0->GetDcaV0Daughters();
\r
981 Double_t dcaV0ToPrimVertex = v0->GetD(esd.GetPrimaryVertex()->GetX(),
\r
982 esd.GetPrimaryVertex()->GetY(),
\r
983 esd.GetPrimaryVertex()->GetZ());
\r
985 v0->GetPPxPyPz(momPosAtV0vtx[0],momPosAtV0vtx[1],momPosAtV0vtx[2]);
\r
986 v0->GetNPxPyPz(momNegAtV0vtx[0],momNegAtV0vtx[1],momNegAtV0vtx[2]);
\r
988 Double_t dcaDaughterToPrimVertex[2] = { 999., 999.}; // ..[0] = DCA in (x,y) for Pos and ..[1] = Neg
\r
989 dcaDaughterToPrimVertex[0] = TMath::Abs(esdV0Pos->GetD( esd.GetPrimaryVertex()->GetX(),
\r
990 esd.GetPrimaryVertex()->GetY(),
\r
991 esd.GetMagneticField()) );
\r
992 dcaDaughterToPrimVertex[1] = TMath::Abs(esdV0Neg->GetD( esd.GetPrimaryVertex()->GetX(),
\r
993 esd.GetPrimaryVertex()->GetY(),
\r
994 esd.GetMagneticField()) );
\r
996 AliAODv0* aodV0 = new(V0s()[fNumberOfV0s++]) AliAODv0(vV0,
\r
1001 dcaDaughterToPrimVertex);
\r
1003 // set the aod v0 on-the-fly status
\r
1004 aodV0->SetOnFlyStatus(v0->GetOnFlyStatus());
\r
1005 }//End of loop on V0s
\r
1007 V0s().Expand(fNumberOfV0s);
\r
1010 //______________________________________________________________________________
\r
1011 void AliAnalysisTaskESDfilter::ConvertTPCOnlyTracks(const AliESDEvent& esd)
\r
1013 // Convert TPC only tracks
\r
1014 // Here we have wo hybrid appraoch to remove fakes
\r
1015 // ******* ITSTPC ********
\r
1016 // Uses a cut on the ITS properties to select global tracks
\r
1017 // which are than marked as HybdridITSTPC for the remainder
\r
1018 // the TPC only tracks are flagged as HybridITSTPConly.
\r
1019 // Note, in order not to get fakes back in the TPC cuts, one needs
\r
1020 // two "ITS" cuts one tight (1) (to throw out fakes) and one lose (2) (to NOT flag the trakcs in the TPC only)
\r
1021 // using cut number (3)
\r
1022 // so fHybridFilterMask == (1)|(2) fTPCFilterMask = (3), Usercode needs to slect with mask = (1)|(3) and track->IsHybridITSTPC()
\r
1023 // ******* TPC ********
\r
1024 // Here, only TPC tracks are flagged that pass the tight ITS cuts and tracks that pass the TPC cuts and NOT the loose ITS cuts
\r
1025 // the ITS cuts neeed to be added to the filter as extra cuts, since here the selections info is reset in the global and put to the TPC only track
\r
1027 AliCodeTimerAuto("",0);
\r
1029 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks
\r
1030 for(int it = 0;it < fNumberOfTracks;++it)
\r
1032 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));
\r
1034 UInt_t map = tr->GetFilterMap();
\r
1035 if(map&fTPCConstrainedFilterMask){
\r
1036 // we only reset the track select ionfo, no deletion...
\r
1037 tr->SetFilterMap(map&~fTPCConstrainedFilterMask);
\r
1039 if(map&fHybridFilterMaskTPCCG){
\r
1040 // this is one part of the hybrid tracks
\r
1041 // the others not passing the selection will be TPC only selected below
\r
1042 tr->SetIsHybridTPCConstrainedGlobal(kTRUE);
\r
1045 // Loop over the ESD trcks and pick out the tracks passing TPC only cuts
\r
1048 const AliESDVertex *vtxSPD = esd.GetPrimaryVertexSPD();
\r
1049 const AliESDVertex *vtx = esd.GetPrimaryVertex();
\r
1051 Double_t pos[3] = { 0. };
\r
1052 Double_t covTr[21]={0.};
\r
1053 Double_t pid[10]={0.};
\r
1056 Double_t p[3] = { 0. };
\r
1058 Double_t pDCA[3] = { 0. }; // momentum at DCA
\r
1059 Double_t rDCA[3] = { 0. }; // position at DCA
\r
1060 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
\r
1061 Float_t cDCA[3] = {0.}; // covariance of impact parameters
\r
1064 AliAODTrack* aodTrack(0x0);
\r
1065 // AliAODPid* detpid(0x0);
\r
1067 // account for change in pT after the constraint
\r
1068 Float_t ptMax = 1E10;
\r
1069 Float_t ptMin = 0;
\r
1070 for(int i = 0;i<32;i++){
\r
1071 if(fTPCConstrainedFilterMask&(1<<i)){
\r
1072 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);
\r
1073 Float_t tmp1= 0,tmp2 = 0;
\r
1074 cuts->GetPtRange(tmp1,tmp2);
\r
1075 if(tmp1>ptMin)ptMin=tmp1;
\r
1076 if(tmp2<ptMax)ptMax=tmp2;
\r
1080 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
\r
1082 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy
\r
1084 UInt_t selectInfo = 0;
\r
1085 Bool_t isHybridITSTPC = false;
\r
1087 // Track selection
\r
1088 if (fTrackFilter) {
\r
1089 selectInfo = fTrackFilter->IsSelected(esdTrack);
\r
1092 if(!(selectInfo&fHybridFilterMaskTPCCG)){
\r
1093 // not already selected tracks, use second part of hybrid tracks
\r
1094 isHybridITSTPC = true;
\r
1095 // too save space one could only store these...
\r
1098 selectInfo &= fTPCConstrainedFilterMask;
\r
1099 if (!selectInfo)continue;
\r
1100 if (fWriteHybridTPCCOnly&&!isHybridITSTPC)continue; // write only complementary tracks
\r
1101 // create a tpc only tracl
\r
1102 AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast<AliESDEvent*>(&esd),esdTrack->GetID());
\r
1103 if(!track) continue;
\r
1105 if(track->Pt()>0.)
\r
1107 // only constrain tracks above threshold
\r
1108 AliExternalTrackParam exParam;
\r
1109 // take the B-field from the ESD, no 3D fieldMap available at this point
\r
1110 Bool_t relate = false;
\r
1111 relate = track->RelateToVertexTPC(vtxSPD,esd.GetMagneticField(),kVeryBig,&exParam);
\r
1116 // fetch the track parameters at the DCA (unconstraint)
\r
1117 if(track->GetTPCInnerParam()){
\r
1118 track->GetTPCInnerParam()->GetPxPyPz(pDCA);
\r
1119 track->GetTPCInnerParam()->GetXYZ(rDCA);
\r
1121 // get the DCA to the vertex:
\r
1122 track->GetImpactParametersTPC(dDCA,cDCA);
\r
1123 // set the constrained parameters to the track
\r
1124 track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
\r
1127 track->GetPxPyPz(p);
\r
1129 Float_t pT = track->Pt();
\r
1130 if(pT<ptMin||pT>ptMax){
\r
1138 track->GetXYZ(pos);
\r
1139 track->GetCovarianceXYZPxPyPz(covTr);
\r
1140 esdTrack->GetESDpid(pid);// original PID
\r
1142 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
\r
1143 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((track->GetID()+1)*-1,
\r
1144 track->GetLabel(),
\r
1150 (Short_t)track->GetSign(),
\r
1151 track->GetITSClusterMap(),
\r
1154 kTRUE, // check if this is right
\r
1155 vtx->UsesTrack(track->GetID()),
\r
1156 AliAODTrack::kPrimary,
\r
1158 aodTrack->SetIsHybridTPCConstrainedGlobal(isHybridITSTPC);
\r
1159 aodTrack->SetTPCFitMap(track->GetTPCFitMap());
\r
1160 aodTrack->SetTPCClusterMap(track->GetTPCClusterMap());
\r
1161 aodTrack->SetTPCSharedMap (track->GetTPCSharedMap());
\r
1162 aodTrack->SetIsTPCConstrained(kTRUE);
\r
1163 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack)); // original track
\r
1164 // set the DCA values to the AOD track
\r
1165 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
\r
1166 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);
\r
1167 aodTrack->SetDCA(dDCA[0],dDCA[1]);
\r
1169 aodTrack->SetFlags(track->GetStatus());
\r
1170 aodTrack->SetTPCPointsF(track->GetTPCNclsF());
\r
1172 // do not duplicate PID information
\r
1173 // aodTrack->ConvertAliPIDtoAODPID();
\r
1174 // SetAODPID(esdTrack,aodTrack,detpid);
\r
1177 } // end of loop on tracks
\r
1182 void AliAnalysisTaskESDfilter::ConvertGlobalConstrainedTracks(const AliESDEvent& esd)
\r
1185 // Here we have the option to store the complement from global constraint information
\r
1186 // to tracks passing tight cuts (1) in order not to get fakes back in, one needs
\r
1187 // two sets of cuts one tight (1) (to throw out fakes) and one lose (2) (fakes/bad tracks would pass (2) but not (1))
\r
1188 // using cut number (3) selects the tracks that complement (1) e.g. tracks witout ITS refit or cluster requirement
\r
1191 AliCodeTimerAuto("",0);
\r
1193 // Loop over the tracks and extract and mask out all aod tracks that pass the selections for AODt racks
\r
1194 for(int it = 0;it < fNumberOfTracks;++it)
\r
1196 AliAODTrack *tr = (AliAODTrack*)(Tracks().At(it));
\r
1198 UInt_t map = tr->GetFilterMap();
\r
1199 if(map&fGlobalConstrainedFilterMask){
\r
1200 // we only reset the track select info, no deletion...
\r
1201 // mask reset mask in case track is already taken
\r
1202 tr->SetFilterMap(map&~fGlobalConstrainedFilterMask);
\r
1204 if(map&fHybridFilterMaskGCG){
\r
1205 // this is one part of the hybrid tracks
\r
1206 // the others not passing the selection will be the ones selected below
\r
1207 tr->SetIsHybridGlobalConstrainedGlobal(kTRUE);
\r
1210 // Loop over the ESD trcks and pick out the tracks passing the GlobalConstraint cuts
\r
1213 Double_t pos[3] = { 0. };
\r
1214 Double_t covTr[21]={0.};
\r
1215 Double_t pid[10]={0.};
\r
1216 Double_t p[3] = { 0. };
\r
1218 Double_t pDCA[3] = { 0. }; // momentum at DCA
\r
1219 Double_t rDCA[3] = { 0. }; // position at DCA
\r
1220 Float_t dDCA[2] = {0.}; // DCA to the vertex d and z
\r
1221 Float_t cDCA[3] = {0.}; // covariance of impact parameters
\r
1224 AliAODTrack* aodTrack(0x0);
\r
1225 AliAODPid* detpid(0x0);
\r
1226 const AliESDVertex *vtx = esd.GetPrimaryVertex();
\r
1228 // account for change in pT after the constraint
\r
1229 Float_t ptMax = 1E10;
\r
1230 Float_t ptMin = 0;
\r
1231 for(int i = 0;i<32;i++){
\r
1232 if(fGlobalConstrainedFilterMask&(1<<i)){
\r
1233 AliESDtrackCuts*cuts = (AliESDtrackCuts*)fTrackFilter->GetCuts()->At(i);
\r
1234 Float_t tmp1= 0,tmp2 = 0;
\r
1235 cuts->GetPtRange(tmp1,tmp2);
\r
1236 if(tmp1>ptMin)ptMin=tmp1;
\r
1237 if(tmp2<ptMax)ptMax=tmp2;
\r
1243 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
\r
1245 AliESDtrack* esdTrack = esd.GetTrack(nTrack); //carefull do not modify it othwise need to work with a copy
\r
1246 const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam();
\r
1247 if(!exParamGC)continue;
\r
1249 UInt_t selectInfo = 0;
\r
1250 Bool_t isHybridGC = false;
\r
1253 // Track selection
\r
1254 if (fTrackFilter) {
\r
1255 selectInfo = fTrackFilter->IsSelected(esdTrack);
\r
1259 if(!(selectInfo&fHybridFilterMaskGCG))isHybridGC = true;
\r
1260 if (fWriteHybridGCOnly&&!isHybridGC)continue; // write only complementary tracks
\r
1262 selectInfo &= fGlobalConstrainedFilterMask;
\r
1263 if (!selectInfo)continue;
\r
1264 // fetch the track parameters at the DCA (unconstrained)
\r
1265 esdTrack->GetPxPyPz(pDCA);
\r
1266 esdTrack->GetXYZ(rDCA);
\r
1267 // get the DCA to the vertex:
\r
1268 esdTrack->GetImpactParameters(dDCA,cDCA);
\r
1270 esdTrack->GetConstrainedPxPyPz(p);
\r
1273 Float_t pT = exParamGC->Pt();
\r
1274 if(pT<ptMin||pT>ptMax){
\r
1279 esdTrack->GetConstrainedXYZ(pos);
\r
1280 exParamGC->GetCovarianceXYZPxPyPz(covTr);
\r
1281 esdTrack->GetESDpid(pid);
\r
1282 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
\r
1283 aodTrack = new(Tracks()[fNumberOfTracks++]) AliAODTrack((esdTrack->GetID()+1)*-1,
\r
1284 esdTrack->GetLabel(),
\r
1290 (Short_t)esdTrack->GetSign(),
\r
1291 esdTrack->GetITSClusterMap(),
\r
1294 kTRUE, // check if this is right
\r
1295 vtx->UsesTrack(esdTrack->GetID()),
\r
1296 AliAODTrack::kPrimary,
\r
1298 aodTrack->SetIsHybridGlobalConstrainedGlobal(isHybridGC);
\r
1299 aodTrack->SetIsGlobalConstrained(kTRUE);
\r
1300 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());
\r
1301 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
\r
1302 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
\r
1303 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
\r
1306 // set the DCA values to the AOD track
\r
1307 aodTrack->SetPxPyPzAtDCA(pDCA[0],pDCA[1],pDCA[2]);
\r
1308 aodTrack->SetXYAtDCA(rDCA[0],rDCA[1]);
\r
1309 aodTrack->SetDCA(dDCA[0],dDCA[1]);
\r
1311 aodTrack->SetFlags(esdTrack->GetStatus());
\r
1312 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
\r
1315 // only copy AOD information for hybrid, no duplicate information
\r
1316 aodTrack->ConvertAliPIDtoAODPID();
\r
1317 SetAODPID(esdTrack,aodTrack,detpid);
\r
1319 } // end of loop on tracks
\r
1324 //______________________________________________________________________________
\r
1325 void AliAnalysisTaskESDfilter::ConvertTracks(const AliESDEvent& esd)
\r
1327 // Tracks (primary and orphan)
\r
1329 AliCodeTimerAuto("",0);
\r
1331 AliDebug(1,Form("NUMBER OF ESD TRACKS %5d\n", esd.GetNumberOfTracks()));
\r
1333 const AliESDVertex *vtx = esd.GetPrimaryVertex();
\r
1334 Double_t p[3] = { 0. };
\r
1335 Double_t pos[3] = { 0. };
\r
1336 Double_t covTr[21] = { 0. };
\r
1337 Double_t pid[10] = { 0. };
\r
1338 AliAODTrack* aodTrack(0x0);
\r
1339 AliAODPid* detpid(0x0);
\r
1341 for (Int_t nTrack = 0; nTrack < esd.GetNumberOfTracks(); ++nTrack)
\r
1343 if (fUsedTrack[nTrack]) continue;
\r
1345 AliESDtrack *esdTrack = esd.GetTrack(nTrack);
\r
1346 UInt_t selectInfo = 0;
\r
1348 // Track selection
\r
1349 if (fTrackFilter) {
\r
1350 selectInfo = fTrackFilter->IsSelected(esdTrack);
\r
1351 if (!selectInfo && !vtx->UsesTrack(esdTrack->GetID())) continue;
\r
1355 esdTrack->GetPxPyPz(p);
\r
1356 esdTrack->GetXYZ(pos);
\r
1357 esdTrack->GetCovarianceXYZPxPyPz(covTr);
\r
1358 esdTrack->GetESDpid(pid);
\r
1359 if(fMChandler)fMChandler->SelectParticle(esdTrack->GetLabel());
\r
1360 fPrimaryVertex->AddDaughter(aodTrack =
\r
1361 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrack->GetID(),
\r
1362 esdTrack->GetLabel(),
\r
1368 (Short_t)esdTrack->GetSign(),
\r
1369 esdTrack->GetITSClusterMap(),
\r
1372 kTRUE, // check if this is right
\r
1373 vtx->UsesTrack(esdTrack->GetID()),
\r
1374 AliAODTrack::kPrimary,
\r
1377 aodTrack->SetTPCFitMap(esdTrack->GetTPCFitMap());
\r
1378 aodTrack->SetTPCClusterMap(esdTrack->GetTPCClusterMap());
\r
1379 aodTrack->SetTPCSharedMap (esdTrack->GetTPCSharedMap());
\r
1380 aodTrack->SetChi2perNDF(Chi2perNDF(esdTrack));
\r
1381 aodTrack->SetTPCPointsF(esdTrack->GetTPCNclsF());
\r
1382 if(esdTrack->IsEMCAL()) aodTrack->SetEMCALcluster(esdTrack->GetEMCALcluster());
\r
1383 if(esdTrack->IsPHOS()) aodTrack->SetPHOScluster(esdTrack->GetPHOScluster());
\r
1385 fAODTrackRefs->AddAt(aodTrack, nTrack);
\r
1388 if (esdTrack->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
1389 aodTrack->SetFlags(esdTrack->GetStatus());
\r
1390 aodTrack->ConvertAliPIDtoAODPID();
\r
1391 SetAODPID(esdTrack,aodTrack,detpid);
\r
1392 } // end of loop on tracks
\r
1395 //______________________________________________________________________________
\r
1396 void AliAnalysisTaskESDfilter::ConvertPmdClusters(const AliESDEvent& esd)
\r
1398 // Convert PMD Clusters
\r
1399 AliCodeTimerAuto("",0);
\r
1400 Int_t jPmdClusters=0;
\r
1401 // Access to the AOD container of PMD clusters
\r
1402 TClonesArray &pmdClusters = *(AODEvent()->GetPmdClusters());
\r
1403 for (Int_t iPmd = 0; iPmd < esd.GetNumberOfPmdTracks(); ++iPmd) {
\r
1404 // file pmd clusters, to be revised!
\r
1405 AliESDPmdTrack *pmdTrack = esd.GetPmdTrack(iPmd);
\r
1407 Int_t *label = 0x0;
\r
1408 Double_t posPmd[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ()};
\r
1409 Double_t pidPmd[13] = { 0.}; // to be revised!
\r
1411 // assoc cluster not set
\r
1412 new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), posPmd, pidPmd);
\r
1416 //______________________________________________________________________________
\r
1417 void AliAnalysisTaskESDfilter::ConvertCaloClusters(const AliESDEvent& esd)
\r
1419 // Convert Calorimeter Clusters
\r
1420 AliCodeTimerAuto("",0);
\r
1422 // Access to the AOD container of clusters
\r
1423 TClonesArray &caloClusters = *(AODEvent()->GetCaloClusters());
\r
1424 Int_t jClusters(0);
\r
1426 for (Int_t iClust=0; iClust<esd.GetNumberOfCaloClusters(); ++iClust) {
\r
1428 AliESDCaloCluster * cluster = esd.GetCaloCluster(iClust);
\r
1430 Int_t id = cluster->GetID();
\r
1431 Int_t nLabel = cluster->GetNLabels();
\r
1432 Int_t *labels = cluster->GetLabels();
\r
1434 for(int i = 0;i < nLabel;++i){
\r
1435 if(fMChandler)fMChandler->SelectParticle(labels[i]);
\r
1439 Float_t energy = cluster->E();
\r
1440 Float_t posF[3] = { 0.};
\r
1441 cluster->GetPosition(posF);
\r
1443 AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
\r
1449 cluster->GetType(),0);
\r
1451 caloCluster->SetCaloCluster(cluster->GetDistanceToBadChannel(),
\r
1452 cluster->GetDispersion(),
\r
1453 cluster->GetM20(), cluster->GetM02(),
\r
1454 cluster->GetEmcCpvDistance(),
\r
1455 cluster->GetNExMax(),cluster->GetTOF()) ;
\r
1457 caloCluster->SetPIDFromESD(cluster->GetPID());
\r
1458 caloCluster->SetNCells(cluster->GetNCells());
\r
1459 caloCluster->SetCellsAbsId(cluster->GetCellsAbsId());
\r
1460 caloCluster->SetCellsAmplitudeFraction(cluster->GetCellsAmplitudeFraction());
\r
1462 caloCluster->SetTrackDistance(cluster->GetTrackDx(), cluster->GetTrackDz());
\r
1464 TArrayI* matchedT = cluster->GetTracksMatched();
\r
1465 if (fNumberOfTracks>0 && matchedT && cluster->GetTrackMatchedIndex() >= 0) {
\r
1466 for (Int_t im = 0; im < matchedT->GetSize(); im++) {
\r
1467 Int_t iESDtrack = matchedT->At(im);;
\r
1468 if (fAODTrackRefs->At(iESDtrack) != 0) {
\r
1469 caloCluster->AddTrackMatched((AliAODTrack*)fAODTrackRefs->At(iESDtrack));
\r
1475 caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
\r
1478 //______________________________________________________________________________
\r
1479 void AliAnalysisTaskESDfilter::ConvertCaloTrigger(TString calo, const AliESDEvent& esd)
\r
1481 AliCodeTimerAuto("",0);
\r
1483 if (calo == "PHOS")
\r
1485 AliLog::Message(AliLog::kError, "PHOS ESD filter not yet implemented", MODULENAME(), "ConvertCaloTrigger", FUNCTIONNAME(), __FILE__, __LINE__);
\r
1489 AliAODHandler *aodHandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
\r
1493 TTree *aodTree = aodHandler->GetTree();
\r
1497 Int_t *type = esd.GetCaloTriggerType();
\r
1499 for (Int_t i = 0; i < 8; i++)
\r
1501 aodTree->GetUserInfo()->Add(new TParameter<int>(Form("EMCALCaloTrigger%d",i), type[i]));
\r
1506 AliAODCaloTrigger &aodTrigger = *(AODEvent()->GetCaloTrigger(calo));
\r
1508 AliESDCaloTrigger &esdTrigger = *(esd.GetCaloTrigger(calo));
\r
1510 aodTrigger.Allocate(esdTrigger.GetEntries());
\r
1512 esdTrigger.Reset();
\r
1513 while (esdTrigger.Next())
\r
1515 Int_t px, py, ts, nTimes, times[10], b;
\r
1518 esdTrigger.GetPosition(px, py);
\r
1520 esdTrigger.GetAmplitude(a);
\r
1521 esdTrigger.GetTime(t);
\r
1523 esdTrigger.GetL0Times(times);
\r
1524 esdTrigger.GetNL0Times(nTimes);
\r
1526 esdTrigger.GetL1TimeSum(ts);
\r
1528 esdTrigger.GetTriggerBits(b);
\r
1530 aodTrigger.Add(px, py, a, t, times, nTimes, ts, b);
\r
1533 aodTrigger.SetL1Threshold(0, esdTrigger.GetL1Threshold(0));
\r
1534 aodTrigger.SetL1Threshold(1, esdTrigger.GetL1Threshold(1));
\r
1538 esdTrigger.GetL1V0(0),
\r
1539 esdTrigger.GetL1V0(1)
\r
1542 aodTrigger.SetL1V0(v0);
\r
1543 aodTrigger.SetL1FrameMask(esdTrigger.GetL1FrameMask());
\r
1546 //______________________________________________________________________________
\r
1547 void AliAnalysisTaskESDfilter::ConvertEMCALCells(const AliESDEvent& esd)
\r
1549 // Convert EMCAL Cells
\r
1550 AliCodeTimerAuto("",0);
\r
1551 // fill EMCAL cell info
\r
1552 if (esd.GetEMCALCells()) { // protection against missing ESD information
\r
1553 AliESDCaloCells &esdEMcells = *(esd.GetEMCALCells());
\r
1554 Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
\r
1556 AliAODCaloCells &aodEMcells = *(AODEvent()->GetEMCALCells());
\r
1557 aodEMcells.CreateContainer(nEMcell);
\r
1558 aodEMcells.SetType(AliAODCaloCells::kEMCALCell);
\r
1559 for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
\r
1560 aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
\r
1562 aodEMcells.Sort();
\r
1566 //______________________________________________________________________________
\r
1567 void AliAnalysisTaskESDfilter::ConvertPHOSCells(const AliESDEvent& esd)
\r
1569 // Convert PHOS Cells
\r
1570 AliCodeTimerAuto("",0);
\r
1571 // fill PHOS cell info
\r
1572 if (esd.GetPHOSCells()) { // protection against missing ESD information
\r
1573 AliESDCaloCells &esdPHcells = *(esd.GetPHOSCells());
\r
1574 Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
\r
1576 AliAODCaloCells &aodPHcells = *(AODEvent()->GetPHOSCells());
\r
1577 aodPHcells.CreateContainer(nPHcell);
\r
1578 aodPHcells.SetType(AliAODCaloCells::kPHOSCell);
\r
1579 for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
\r
1580 aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
\r
1582 aodPHcells.Sort();
\r
1586 //______________________________________________________________________________
\r
1587 void AliAnalysisTaskESDfilter::ConvertTracklets(const AliESDEvent& esd)
\r
1590 AliCodeTimerAuto("",0);
\r
1592 AliAODTracklets &SPDTracklets = *(AODEvent()->GetTracklets());
\r
1593 const AliMultiplicity *mult = esd.GetMultiplicity();
\r
1595 if (mult->GetNumberOfTracklets()>0) {
\r
1596 SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
\r
1598 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
\r
1600 fMChandler->SelectParticle(mult->GetLabel(n, 0));
\r
1601 fMChandler->SelectParticle(mult->GetLabel(n, 1));
\r
1603 SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n, 0),mult->GetLabel(n, 1));
\r
1607 //Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
\r
1611 //______________________________________________________________________________
\r
1612 void AliAnalysisTaskESDfilter::ConvertKinks(const AliESDEvent& esd)
\r
1614 AliCodeTimerAuto("",0);
\r
1616 // Kinks: it is a big mess the access to the information in the kinks
\r
1617 // The loop is on the tracks in order to find the mother and daugther of each kink
\r
1619 Double_t covTr[21]={0.};
\r
1620 Double_t pid[10]={0.};
\r
1621 AliAODPid* detpid(0x0);
\r
1623 fNumberOfKinks = esd.GetNumberOfKinks();
\r
1625 const AliESDVertex* vtx = esd.GetPrimaryVertex();
\r
1627 for (Int_t iTrack=0; iTrack<esd.GetNumberOfTracks(); ++iTrack)
\r
1629 AliESDtrack * esdTrack = esd.GetTrack(iTrack);
\r
1631 Int_t ikink = esdTrack->GetKinkIndex(0);
\r
1633 if (ikink && fNumberOfKinks) {
\r
1634 // Negative kink index: mother, positive: daughter
\r
1636 // Search for the second track of the kink
\r
1638 for (Int_t jTrack = iTrack+1; jTrack<esd.GetNumberOfTracks(); ++jTrack) {
\r
1640 AliESDtrack * esdTrack1 = esd.GetTrack(jTrack);
\r
1642 Int_t jkink = esdTrack1->GetKinkIndex(0);
\r
1644 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
\r
1646 // The two tracks are from the same kink
\r
1648 if (fUsedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
\r
1650 Int_t imother = -1;
\r
1651 Int_t idaughter = -1;
\r
1653 if (ikink<0 && jkink>0) {
\r
1656 idaughter = jTrack;
\r
1658 else if (ikink>0 && jkink<0) {
\r
1661 idaughter = iTrack;
\r
1664 // cerr << "Error: Wrong combination of kink indexes: "
\r
1665 // << ikink << " " << jkink << endl;
\r
1669 // Add the mother track if it passed primary track selection cuts
\r
1671 AliAODTrack * mother = NULL;
\r
1673 UInt_t selectInfo = 0;
\r
1674 if (fTrackFilter) {
\r
1675 selectInfo = fTrackFilter->IsSelected(esd.GetTrack(imother));
\r
1676 if (!selectInfo) continue;
\r
1679 if (!fUsedTrack[imother]) {
\r
1681 fUsedTrack[imother] = kTRUE;
\r
1683 AliESDtrack *esdTrackM = esd.GetTrack(imother);
\r
1684 Double_t p[3] = { 0. };
\r
1685 Double_t pos[3] = { 0. };
\r
1686 esdTrackM->GetPxPyPz(p);
\r
1687 esdTrackM->GetXYZ(pos);
\r
1688 esdTrackM->GetCovarianceXYZPxPyPz(covTr);
\r
1689 esdTrackM->GetESDpid(pid);
\r
1690 if(fMChandler)fMChandler->SelectParticle(esdTrackM->GetLabel());
\r
1692 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackM->GetID(),
\r
1693 esdTrackM->GetLabel(),
\r
1699 (Short_t)esdTrackM->GetSign(),
\r
1700 esdTrackM->GetITSClusterMap(),
\r
1703 kTRUE, // check if this is right
\r
1704 vtx->UsesTrack(esdTrack->GetID()),
\r
1705 AliAODTrack::kPrimary,
\r
1707 mother->SetTPCFitMap(esdTrackM->GetTPCFitMap());
\r
1708 mother->SetTPCClusterMap(esdTrackM->GetTPCClusterMap());
\r
1709 mother->SetTPCSharedMap (esdTrackM->GetTPCSharedMap());
\r
1710 mother->SetChi2perNDF(Chi2perNDF(esdTrackM));
\r
1711 mother->SetTPCPointsF(esdTrackM->GetTPCNclsF());
\r
1713 fAODTrackRefs->AddAt(mother, imother);
\r
1715 if (esdTrackM->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
1716 mother->SetFlags(esdTrackM->GetStatus());
\r
1717 mother->ConvertAliPIDtoAODPID();
\r
1718 fPrimaryVertex->AddDaughter(mother);
\r
1719 mother->ConvertAliPIDtoAODPID();
\r
1720 SetAODPID(esdTrackM,mother,detpid);
\r
1723 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
\r
1724 // << " track " << imother << " has already been used!" << endl;
\r
1727 // Add the kink vertex
\r
1728 AliESDkink * kink = esd.GetKink(TMath::Abs(ikink)-1);
\r
1730 AliAODVertex * vkink =
\r
1731 new(Vertices()[fNumberOfVertices++]) AliAODVertex(kink->GetPosition(),
\r
1735 esdTrack->GetID(), // This is the track ID of the mother's track!
\r
1736 AliAODVertex::kKink);
\r
1737 // Add the daughter track
\r
1739 AliAODTrack * daughter = NULL;
\r
1741 if (!fUsedTrack[idaughter]) {
\r
1743 fUsedTrack[idaughter] = kTRUE;
\r
1745 AliESDtrack *esdTrackD = esd.GetTrack(idaughter);
\r
1746 Double_t p[3] = { 0. };
\r
1747 Double_t pos[3] = { 0. };
\r
1749 esdTrackD->GetPxPyPz(p);
\r
1750 esdTrackD->GetXYZ(pos);
\r
1751 esdTrackD->GetCovarianceXYZPxPyPz(covTr);
\r
1752 esdTrackD->GetESDpid(pid);
\r
1754 if (fTrackFilter) selectInfo = fTrackFilter->IsSelected(esdTrackD);
\r
1755 if(fMChandler)fMChandler->SelectParticle(esdTrackD->GetLabel());
\r
1757 new(Tracks()[fNumberOfTracks++]) AliAODTrack(esdTrackD->GetID(),
\r
1758 esdTrackD->GetLabel(),
\r
1764 (Short_t)esdTrackD->GetSign(),
\r
1765 esdTrackD->GetITSClusterMap(),
\r
1768 kTRUE, // check if this is right
\r
1769 vtx->UsesTrack(esdTrack->GetID()),
\r
1770 AliAODTrack::kSecondary,
\r
1772 daughter->SetTPCFitMap(esdTrackD->GetTPCFitMap());
\r
1773 daughter->SetTPCClusterMap(esdTrackD->GetTPCClusterMap());
\r
1774 daughter->SetTPCSharedMap (esdTrackD->GetTPCSharedMap());
\r
1775 daughter->SetTPCPointsF(esdTrackD->GetTPCNclsF());
\r
1776 fAODTrackRefs->AddAt(daughter, idaughter);
\r
1778 if (esdTrackD->GetSign() > 0) ++fNumberOfPositiveTracks;
\r
1779 daughter->SetFlags(esdTrackD->GetStatus());
\r
1780 daughter->ConvertAliPIDtoAODPID();
\r
1781 vkink->AddDaughter(daughter);
\r
1782 daughter->ConvertAliPIDtoAODPID();
\r
1783 SetAODPID(esdTrackD,daughter,detpid);
\r
1786 // cerr << "Error: event " << esd.GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
\r
1787 // << " track " << idaughter << " has already been used!" << endl;
\r
1795 //______________________________________________________________________________
\r
1796 void AliAnalysisTaskESDfilter::ConvertPrimaryVertices(const AliESDEvent& esd)
\r
1798 AliCodeTimerAuto("",0);
\r
1800 // Access to the AOD container of vertices
\r
1801 fNumberOfVertices = 0;
\r
1803 Double_t pos[3] = { 0. };
\r
1804 Double_t covVtx[6] = { 0. };
\r
1806 // Add primary vertex. The primary tracks will be defined
\r
1807 // after the loops on the composite objects (V0, cascades, kinks)
\r
1808 const AliESDVertex *vtx = esd.GetPrimaryVertex();
\r
1810 vtx->GetXYZ(pos); // position
\r
1811 vtx->GetCovMatrix(covVtx); //covariance matrix
\r
1813 fPrimaryVertex = new(Vertices()[fNumberOfVertices++])
\r
1814 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
\r
1815 fPrimaryVertex->SetName(vtx->GetName());
\r
1816 fPrimaryVertex->SetTitle(vtx->GetTitle());
\r
1818 TString vtitle = vtx->GetTitle();
\r
1819 if (!vtitle.Contains("VertexerTracks"))
\r
1820 fPrimaryVertex->SetNContributors(vtx->GetNContributors());
\r
1822 if (fDebug > 0) fPrimaryVertex->Print();
\r
1824 // Add SPD "main" vertex
\r
1825 const AliESDVertex *vtxS = esd.GetPrimaryVertexSPD();
\r
1826 vtxS->GetXYZ(pos); // position
\r
1827 vtxS->GetCovMatrix(covVtx); //covariance matrix
\r
1828 AliAODVertex * mVSPD = new(Vertices()[fNumberOfVertices++])
\r
1829 AliAODVertex(pos, covVtx, vtxS->GetChi2toNDF(), NULL, -1, AliAODVertex::kMainSPD);
\r
1830 mVSPD->SetName(vtxS->GetName());
\r
1831 mVSPD->SetTitle(vtxS->GetTitle());
\r
1832 mVSPD->SetNContributors(vtxS->GetNContributors());
\r
1834 // Add SPD pileup vertices
\r
1835 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesSPD(); ++iV)
\r
1837 const AliESDVertex *vtxP = esd.GetPileupVertexSPD(iV);
\r
1838 vtxP->GetXYZ(pos); // position
\r
1839 vtxP->GetCovMatrix(covVtx); //covariance matrix
\r
1840 AliAODVertex * pVSPD = new(Vertices()[fNumberOfVertices++])
\r
1841 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupSPD);
\r
1842 pVSPD->SetName(vtxP->GetName());
\r
1843 pVSPD->SetTitle(vtxP->GetTitle());
\r
1844 pVSPD->SetNContributors(vtxP->GetNContributors());
\r
1845 pVSPD->SetBC(vtxP->GetBC());
\r
1848 // Add TRK pileup vertices
\r
1849 for(Int_t iV=0; iV<esd.GetNumberOfPileupVerticesTracks(); ++iV)
\r
1851 const AliESDVertex *vtxP = esd.GetPileupVertexTracks(iV);
\r
1852 vtxP->GetXYZ(pos); // position
\r
1853 vtxP->GetCovMatrix(covVtx); //covariance matrix
\r
1854 AliAODVertex * pVTRK = new(Vertices()[fNumberOfVertices++])
\r
1855 AliAODVertex(pos, covVtx, vtxP->GetChi2toNDF(), NULL, -1, AliAODVertex::kPileupTracks);
\r
1856 pVTRK->SetName(vtxP->GetName());
\r
1857 pVTRK->SetTitle(vtxP->GetTitle());
\r
1858 pVTRK->SetNContributors(vtxP->GetNContributors());
\r
1859 pVTRK->SetBC(vtxP->GetBC());
\r
1863 //______________________________________________________________________________
\r
1864 void AliAnalysisTaskESDfilter::ConvertVZERO(const AliESDEvent& esd)
\r
1866 // Convert VZERO data
\r
1867 AliAODVZERO* vzeroData = AODEvent()->GetVZEROData();
\r
1868 *vzeroData = *(esd.GetVZEROData());
\r
1871 //______________________________________________________________________________
\r
1872 void AliAnalysisTaskESDfilter::ConvertTZERO(const AliESDEvent& esd)
\r
1874 // Convert TZERO data
\r
1875 const AliESDTZERO* esdTzero = esd.GetESDTZERO();
\r
1876 AliAODTZERO* aodTzero = AODEvent()->GetTZEROData();
\r
1878 for (Int_t icase=0; icase<3; icase++){
\r
1879 aodTzero->SetT0TOF( icase, esdTzero->GetT0TOF(icase));
\r
1880 aodTzero->SetT0TOFbest(icase, esdTzero->GetT0TOFbest(icase));
\r
1882 aodTzero->SetBackgroundFlag(esdTzero->GetBackgroundFlag());
\r
1883 aodTzero->SetPileupFlag(esdTzero->GetPileupFlag());
\r
1884 aodTzero->SetSatelliteFlag(esdTzero->GetSatellite());
\r
1889 //______________________________________________________________________________
\r
1890 void AliAnalysisTaskESDfilter::ConvertZDC(const AliESDEvent& esd)
\r
1892 // Convert ZDC data
\r
1893 AliESDZDC* esdZDC = esd.GetZDCData();
\r
1895 const Double_t zem1Energy = esdZDC->GetZEM1Energy();
\r
1896 const Double_t zem2Energy = esdZDC->GetZEM2Energy();
\r
1898 const Double_t *towZNC = esdZDC->GetZNCTowerEnergy();
\r
1899 const Double_t *towZPC = esdZDC->GetZPCTowerEnergy();
\r
1900 const Double_t *towZNA = esdZDC->GetZNATowerEnergy();
\r
1901 const Double_t *towZPA = esdZDC->GetZPATowerEnergy();
\r
1902 const Double_t *towZNCLG = esdZDC->GetZNCTowerEnergyLR();
\r
1903 const Double_t *towZNALG = esdZDC->GetZNATowerEnergyLR();
\r
1905 AliAODZDC* zdcAOD = AODEvent()->GetZDCData();
\r
1907 zdcAOD->SetZEM1Energy(zem1Energy);
\r
1908 zdcAOD->SetZEM2Energy(zem2Energy);
\r
1909 zdcAOD->SetZNCTowers(towZNC, towZNCLG);
\r
1910 zdcAOD->SetZNATowers(towZNA, towZNALG);
\r
1911 zdcAOD->SetZPCTowers(towZPC);
\r
1912 zdcAOD->SetZPATowers(towZPA);
\r
1914 zdcAOD->SetZDCParticipants(esdZDC->GetZDCParticipants(), esdZDC->GetZDCPartSideA(), esdZDC->GetZDCPartSideC());
\r
1915 zdcAOD->SetZDCImpactParameter(esdZDC->GetImpactParameter(), esdZDC->GetImpactParamSideA(),
\r
1916 esdZDC->GetImpactParamSideC());
\r
1917 zdcAOD->SetZDCTDCSum(esdZDC->GetZNTDCSum(0));
\r
1918 zdcAOD->SetZDCTDCDiff(esdZDC->GetZNTDCDiff(0));
\r
1922 //______________________________________________________________________________
\r
1923 void AliAnalysisTaskESDfilter::ConvertESDtoAOD()
\r
1925 // ESD Filter analysis task executed for each event
\r
1927 AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
\r
1931 AliCodeTimerAuto("",0);
\r
1933 fOldESDformat = ( esd->GetAliESDOld() != 0x0 );
\r
1935 // Reconstruct cascades and V0 here
\r
1936 if (fIsV0CascadeRecoEnabled) {
\r
1937 esd->ResetCascades();
\r
1940 AliV0vertexer lV0vtxer;
\r
1941 AliCascadeVertexer lCascVtxer;
\r
1943 lV0vtxer.SetCuts(fV0Cuts);
\r
1944 lCascVtxer.SetCuts(fCascadeCuts);
\r
1947 lV0vtxer.Tracks2V0vertices(esd);
\r
1948 lCascVtxer.V0sTracks2CascadeVertices(esd);
\r
1952 fNumberOfTracks = 0;
\r
1953 fNumberOfPositiveTracks = 0;
\r
1955 fNumberOfVertices = 0;
\r
1956 fNumberOfCascades = 0;
\r
1957 fNumberOfKinks = 0;
\r
1959 AliAODHeader* header = ConvertHeader(*esd);
\r
1961 if ( fIsVZEROEnabled ) ConvertVZERO(*esd);
\r
1962 if ( fIsTZEROEnabled ) ConvertTZERO(*esd);
\r
1964 // Fetch Stack for debuggging if available
\r
1968 fMChandler = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
\r
1971 // loop over events and fill them
\r
1972 // Multiplicity information needed by the header (to be revised!)
\r
1973 Int_t nTracks = esd->GetNumberOfTracks();
\r
1974 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
\r
1976 // Update the header
\r
1978 Int_t nV0s = esd->GetNumberOfV0s();
\r
1979 Int_t nCascades = esd->GetNumberOfCascades();
\r
1980 Int_t nKinks = esd->GetNumberOfKinks();
\r
1981 Int_t nVertices = nV0s + nCascades /*V0 wihtin cascade already counted*/+ nKinks + 1 /* = prim. vtx*/;
\r
1982 Int_t nPileSPDVertices=1+esd->GetNumberOfPileupVerticesSPD(); // also SPD main vertex
\r
1983 Int_t nPileTrkVertices=esd->GetNumberOfPileupVerticesTracks();
\r
1984 nVertices+=nPileSPDVertices;
\r
1985 nVertices+=nPileTrkVertices;
\r
1987 Int_t nCaloClus = esd->GetNumberOfCaloClusters();
\r
1988 Int_t nFmdClus = 0;
\r
1989 Int_t nPmdClus = esd->GetNumberOfPmdTracks();
\r
1991 AliDebug(1,Form(" NV0=%d NCASCADES=%d NKINKS=%d", nV0s, nCascades, nKinks));
\r
1993 AODEvent()->ResetStd(nTracks, nVertices, nV0s, nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
\r
1997 // RefArray to store a mapping between esd V0 number and newly created AOD-Vertex V0
\r
1998 fAODV0VtxRefs = new TRefArray(nV0s);
\r
1999 // RefArray to store the mapping between esd V0 number and newly created AOD-V0
\r
2000 fAODV0Refs = new TRefArray(nV0s);
\r
2001 // Array to take into account the V0s already added to the AOD (V0 within cascades)
\r
2002 fUsedV0 = new Bool_t[nV0s];
\r
2003 for (Int_t iV0=0; iV0<nV0s; ++iV0) fUsedV0[iV0]=kFALSE;
\r
2008 // RefArray to store the mapping between esd track number and newly created AOD-Track
\r
2010 fAODTrackRefs = new TRefArray(nTracks);
\r
2012 // Array to take into account the tracks already added to the AOD
\r
2013 fUsedTrack = new Bool_t[nTracks];
\r
2014 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) fUsedTrack[iTrack]=kFALSE;
\r
2017 // Array to take into account the kinks already added to the AOD
\r
2020 fUsedKink = new Bool_t[nKinks];
\r
2021 for (Int_t iKink=0; iKink<nKinks; ++iKink) fUsedKink[iKink]=kFALSE;
\r
2024 ConvertPrimaryVertices(*esd);
\r
2026 //setting best TOF PID
\r
2027 AliESDInputHandler* esdH = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
\r
2029 fESDpid = esdH->GetESDpid();
\r
2031 if (fIsPidOwner && fESDpid){
\r
2036 { //in case of no Tender attached
\r
2037 fESDpid = new AliESDpid;
\r
2038 fIsPidOwner = kTRUE;
\r
2041 if(!esd->GetTOFHeader())
\r
2042 { //protection in case the pass2 LHC10b,c,d have been processed without tender.
\r
2043 Float_t t0spread[10];
\r
2044 Float_t intrinsicTOFres=100; //ps ok for LHC10b,c,d pass2!!
\r
2045 for (Int_t i=0; i<10; i++) t0spread[i] = (TMath::Sqrt(esd->GetSigma2DiamondZ()))/0.03; //0.03 to convert from cm to ps
\r
2046 fESDpid->GetTOFResponse().SetT0resolution(t0spread);
\r
2047 fESDpid->GetTOFResponse().SetTimeResolution(intrinsicTOFres);
\r
2049 fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType);
\r
2052 if(esd->GetTOFHeader() && fIsPidOwner) fESDpid->SetTOFResponse(esd, (AliESDpid::EStartTimeType_t)fTimeZeroType); //in case of AOD production strating form LHC10e without Tender.
\r
2054 if ( fAreCascadesEnabled ) ConvertCascades(*esd);
\r
2056 if ( fAreV0sEnabled ) ConvertV0s(*esd);
\r
2058 if ( fAreKinksEnabled ) ConvertKinks(*esd);
\r
2060 if ( fAreTracksEnabled ) ConvertTracks(*esd);
\r
2062 // Update number of AOD tracks in header at the end of track loop (M.G.)
\r
2063 header->SetRefMultiplicity(fNumberOfTracks);
\r
2064 header->SetRefMultiplicityPos(fNumberOfPositiveTracks);
\r
2065 header->SetRefMultiplicityNeg(fNumberOfTracks - fNumberOfPositiveTracks);
\r
2067 if ( fTPCConstrainedFilterMask ) ConvertTPCOnlyTracks(*esd);
\r
2068 if( fGlobalConstrainedFilterMask) ConvertGlobalConstrainedTracks(*esd);
\r
2070 if ( fArePmdClustersEnabled ) ConvertPmdClusters(*esd);
\r
2072 if ( fAreCaloClustersEnabled ) ConvertCaloClusters(*esd);
\r
2074 if ( fAreEMCALCellsEnabled )ConvertEMCALCells(*esd);
\r
2076 if ( fArePHOSCellsEnabled )ConvertPHOSCells(*esd);
\r
2078 if ( fAreEMCALTriggerEnabled )ConvertCaloTrigger(TString("EMCAL"), *esd);
\r
2080 if ( fArePHOSTriggerEnabled )ConvertCaloTrigger(TString("PHOS"), *esd);
\r
2082 if ( fAreTrackletsEnabled ) ConvertTracklets(*esd);
\r
2083 if ( fIsZDCEnabled ) ConvertZDC(*esd);
\r
2085 delete fAODTrackRefs; fAODTrackRefs=0x0;
\r
2086 delete fAODV0VtxRefs; fAODV0VtxRefs=0x0;
\r
2087 delete fAODV0Refs; fAODV0Refs=0x0;
\r
2089 delete[] fUsedTrack; fUsedTrack=0x0;
\r
2090 delete[] fUsedV0; fUsedV0=0x0;
\r
2091 delete[] fUsedKink; fUsedKink=0x0;
\r
2093 if ( fIsPidOwner){
\r
2102 //______________________________________________________________________________
\r
2103 void AliAnalysisTaskESDfilter::SetAODPID(AliESDtrack *esdtrack, AliAODTrack *aodtrack, AliAODPid *detpid)
\r
2106 // Setter for the raw PID detector signals
\r
2109 // Save PID object for candidate electrons
\r
2110 Bool_t pidSave = kFALSE;
\r
2111 if (fTrackFilter) {
\r
2112 Bool_t selectInfo = fTrackFilter->IsSelected((char*) "Electrons");
\r
2113 if (selectInfo) pidSave = kTRUE;
\r
2117 // Tracks passing pt cut
\r
2118 if(esdtrack->Pt()>fHighPthreshold) {
\r
2122 if(esdtrack->Pt()> fPtshape->GetXmin()){
\r
2123 Double_t y = fPtshape->Eval(esdtrack->Pt())/fPtshape->Eval(fHighPthreshold);
\r
2124 if(gRandom->Rndm(0)<1./y){
\r
2127 }//end if p < pmin
\r
2128 }//end if p function
\r
2132 if(!aodtrack->GetDetPid()){// prevent memory leak when calling SetAODPID twice for the same track
\r
2133 detpid = new AliAODPid();
\r
2134 SetDetectorRawSignals(detpid,esdtrack);
\r
2135 aodtrack->SetDetPID(detpid);
\r
2140 //______________________________________________________________________________
\r
2141 void AliAnalysisTaskESDfilter::SetDetectorRawSignals(AliAODPid *aodpid, AliESDtrack *track)
\r
2144 //assignment of the detector signals (AliXXXesdPID inspired)
\r
2147 AliInfo("no ESD track found. .....exiting");
\r
2151 const AliExternalTrackParam *in=track->GetInnerParam();
\r
2153 aodpid->SetTPCmomentum(in->GetP());
\r
2155 aodpid->SetTPCmomentum(-1.);
\r
2159 aodpid->SetITSsignal(track->GetITSsignal());
\r
2160 Double_t itsdedx[4]; // dE/dx samples for individual ITS layers
\r
2161 track->GetITSdEdxSamples(itsdedx);
\r
2162 aodpid->SetITSdEdxSamples(itsdedx);
\r
2164 aodpid->SetTPCsignal(track->GetTPCsignal());
\r
2165 aodpid->SetTPCsignalN(track->GetTPCsignalN());
\r
2167 //n TRD planes = 6
\r
2168 Int_t nslices = track->GetNumberOfTRDslices()*6;
\r
2169 TArrayD trdslices(nslices);
\r
2170 for(Int_t iSl =0; iSl < track->GetNumberOfTRDslices(); iSl++) {
\r
2171 for(Int_t iPl =0; iPl<6; iPl++) trdslices[iPl*track->GetNumberOfTRDslices()+iSl] = track->GetTRDslice(iPl,iSl);
\r
2175 for(Int_t iPl=0;iPl<6;iPl++){
\r
2176 Double_t trdmom=track->GetTRDmomentum(iPl);
\r
2177 aodpid->SetTRDmomentum(iPl,trdmom);
\r
2180 aodpid->SetTRDsignal(track->GetNumberOfTRDslices()*6,trdslices.GetArray());
\r
2182 //TRD clusters and tracklets
\r
2183 aodpid->SetTRDncls(track->GetTRDncls());
\r
2184 aodpid->SetTRDntrackletsPID(track->GetTRDntrackletsPID());
\r
2187 Double_t times[AliAODPid::kSPECIES]; track->GetIntegratedTimes(times);
\r
2188 aodpid->SetIntegratedTimes(times);
\r
2190 Float_t tzeroTrack = fESDpid->GetTOFResponse().GetStartTime(track->P());
\r
2191 aodpid->SetTOFsignal(track->GetTOFsignal()-tzeroTrack);
\r
2193 Double_t tofRes[5];
\r
2194 for (Int_t iMass=0; iMass<5; iMass++){
\r
2195 tofRes[iMass]=(Double_t)fESDpid->GetTOFResponse().GetExpectedSigma(track->P(), times[iMass], AliPID::ParticleMass(iMass));
\r
2197 aodpid->SetTOFpidResolution(tofRes);
\r
2199 aodpid->SetHMPIDsignal(track->GetHMPIDsignal());
\r
2201 //Extrapolate track to EMCAL surface for AOD-level track-cluster matching
\r
2202 Double_t emcpos[3] = {0.,0.,0.};
\r
2203 Double_t emcmom[3] = {0.,0.,0.};
\r
2204 aodpid->SetEMCALPosition(emcpos);
\r
2205 aodpid->SetEMCALMomentum(emcmom);
\r
2207 Double_t hmpPid[5] = {0};
\r
2208 track->GetHMPIDpid(hmpPid);
\r
2209 aodpid->SetHMPIDprobs(hmpPid);
\r
2211 AliExternalTrackParam *outerparam = (AliExternalTrackParam*)track->GetOuterParam();
\r
2212 if(!outerparam) return;
\r
2214 //To be replaced by call to AliEMCALGeoUtils when the class becomes available
\r
2215 Bool_t okpos = outerparam->GetXYZ(emcpos);
\r
2216 Bool_t okmom = outerparam->GetPxPyPz(emcmom);
\r
2217 if(!(okpos && okmom)) return;
\r
2219 aodpid->SetEMCALPosition(emcpos);
\r
2220 aodpid->SetEMCALMomentum(emcmom);
\r
2224 Double_t AliAnalysisTaskESDfilter::Chi2perNDF(AliESDtrack* track)
\r
2226 // Calculate chi2 per ndf for track
\r
2227 Int_t nClustersTPC = track->GetTPCNcls();
\r
2229 if ( nClustersTPC > 5) {
\r
2230 return (track->GetTPCchi2()/Float_t(nClustersTPC - 5));
\r
2237 //______________________________________________________________________________
\r
2238 void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)
\r
2240 // Terminate analysis
\r
2242 if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
\r
2245 //______________________________________________________________________________
\r
2246 void AliAnalysisTaskESDfilter::PrintMCInfo(AliStack *pStack,Int_t label){
\r
2248 if(!pStack)return;
\r
2249 label = TMath::Abs(label);
\r
2250 TParticle *part = pStack->Particle(label);
\r
2251 Printf("########################");
\r
2252 Printf("%s:%d %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,label,part->GetUniqueID(),part->GetPdgCode(),part->P());
\r
2254 TParticle* mother = part;
\r
2255 Int_t imo = part->GetFirstMother();
\r
2256 Int_t nprim = pStack->GetNprimary();
\r
2257 // while((imo >= nprim) && (mother->GetUniqueID() == 4)) {
\r
2258 while((imo >= nprim)) {
\r
2259 mother = pStack->Particle(imo);
\r
2260 Printf("Mother %s:%d Label %d UniqueID %d PDG %d P %3.3f",(char*)__FILE__,__LINE__,imo,mother->GetUniqueID(),mother->GetPdgCode(),mother->P());
\r
2262 imo = mother->GetFirstMother();
\r
2264 Printf("########################");
\r
2267 //______________________________________________________
\r