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