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