0a83e00fc0ab9e1dec92200431f35f21c1ed20ef
[u/mrichter/AliRoot.git] / PWG0 / base / AliAnalysisTaskESDfilter.cxx
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 <TChain.h>
19 #include <TFile.h>
20
21 #include "AliAnalysisTaskESDfilter.h"
22 #include "AliAnalysisManager.h"
23 #include "AliESDEvent.h"
24 #include "AliAODEvent.h"
25 #include "AliAODHandler.h"
26 #include "AliAnalysisFilter.h"
27 #include "AliESDtrack.h"
28 #include "AliESDMuonTrack.h"
29 #include "AliESDVertex.h"
30 #include "AliESDv0.h"
31 #include "AliESDkink.h"
32 #include "AliESDcascade.h"
33 #include "AliLog.h"
34
35 ClassImp(AliAnalysisTaskESDfilter)
36
37 ////////////////////////////////////////////////////////////////////////
38
39 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter():
40     fDebug(0),
41     fChain(0x0),
42     fESD(0x0),
43     fAOD(0x0),
44     fTreeA(0x0),
45     fTrackFilter(0x0),
46     fKinkFilter(0x0),
47     fV0Filter(0x0)
48 {
49   // Default constructor
50 }
51
52 AliAnalysisTaskESDfilter::AliAnalysisTaskESDfilter(const char* name):
53     AliAnalysisTask(name, "AnalysisTaskESDfilter"),
54     fDebug(0),
55     fChain(0x0),
56     fESD(0x0),
57     fAOD(0x0),
58     fTreeA(0x0),
59     fTrackFilter(0x0),
60     fKinkFilter(0x0),
61     fV0Filter(0x0)
62 {
63   // Default constructor
64     DefineInput (0, TChain::Class());
65     DefineOutput(0, TTree::Class());
66 }
67
68 void AliAnalysisTaskESDfilter::CreateOutputObjects()
69 {
70 // Create the output container
71     if (fDebug > 1) AliInfo("CreateOutPutData() \n");
72     AliAODHandler* handler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
73     
74     fAOD   = handler->GetAOD();
75     fTreeA = handler->GetTree();
76     fTreeA->GetUserInfo()->Add(fTrackFilter);
77 }
78
79 void AliAnalysisTaskESDfilter::Init()
80 {
81     // Initialization
82     if (fDebug > 1) AliInfo("Init() \n");
83     // Call configuration file
84 }
85
86 void AliAnalysisTaskESDfilter::ConnectInputData(Option_t */*option*/)
87 {
88 // Connect the input data
89 //
90     if (fDebug > 1) AliInfo("ConnectInputData() \n");
91     fChain = (TChain*)GetInputData(0);
92     fESD = new AliESDEvent();
93     fESD->ReadFromTree(fChain);
94 }
95
96 void AliAnalysisTaskESDfilter::Exec(Option_t */*option*/)
97 {
98 // Execute analysis for current event
99 //
100     AliESD* old = fESD->GetAliESDOld();
101     if (old) fESD->CopyFromOldESD();
102     
103     Long64_t ientry = fChain->GetReadEntry();
104     AliInfo(Form("ESD Filter: Analysing event # %5d\n", (Int_t) ientry));
105     
106     
107     // ESD Filter analysis task executed for each event
108     
109     // set arrays and pointers
110     Double_t pos[3];
111     Double_t p[3];
112     Double_t covVtx[6];
113     Double_t covTr[21];
114     Double_t pid[10];
115
116     for (Int_t i = 0; i < 6; i++)  covVtx[i] = 0.;
117     for (Int_t i = 0; i < 21; i++) covTr [i] = 0.;
118
119     
120   // loop over events and fill them
121   
122   // Multiplicity information needed by the header (to be revised!)
123     Int_t nTracks    = fESD->GetNumberOfTracks();
124     Int_t nPosTracks = 0;
125     for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) 
126         if (fESD->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;
127     
128     // Update the header
129
130     AliAODHeader* header = fAOD->GetHeader();
131     header->SetRunNumber(fESD->GetRunNumber());
132     if (old) {
133         header->SetBunchCrossNumber(0);
134         header->SetOrbitNumber(0);
135         header->SetPeriodNumber(0);
136         header->SetEventType(0);
137         header->SetMuonMagFieldScale(-999.);
138         header->SetCentrality(-999.);
139     } else {
140         header->SetBunchCrossNumber(fESD->GetBunchCrossNumber());
141         header->SetOrbitNumber(fESD->GetOrbitNumber());
142         header->SetPeriodNumber(fESD->GetPeriodNumber());
143         header->SetEventType(fESD->GetEventType());
144         header->SetMuonMagFieldScale(-999.);
145         header->SetCentrality(-999.);
146     }
147     
148     header->SetTriggerMask(fESD->GetTriggerMask()); 
149     header->SetTriggerCluster(fESD->GetTriggerCluster());
150     header->SetMagneticField(fESD->GetMagneticField());
151     header->SetZDCN1Energy(fESD->GetZDCN1Energy());
152     header->SetZDCP1Energy(fESD->GetZDCP1Energy());
153     header->SetZDCN2Energy(fESD->GetZDCN2Energy());
154     header->SetZDCP2Energy(fESD->GetZDCP2Energy());
155     header->SetZDCEMEnergy(fESD->GetZDCEMEnergy(0),fESD->GetZDCEMEnergy(1));
156     header->SetRefMultiplicity(nTracks);
157     header->SetRefMultiplicityPos(nPosTracks);
158     header->SetRefMultiplicityNeg(nTracks - nPosTracks);
159 //
160 //    
161     Int_t nV0s      = fESD->GetNumberOfV0s();
162     Int_t nCascades = fESD->GetNumberOfCascades();
163     Int_t nKinks    = fESD->GetNumberOfKinks();
164     
165     printf("   NV0=%d  NCASCADES=%d  NKINKS=%d\n", nV0s, nCascades, nKinks);
166
167     Int_t nVertices = nV0s + nCascades + nKinks;
168     
169     fAOD->ResetStd(nTracks, nVertices);
170     AliAODTrack *aodTrack;
171     
172     
173     // Array to take into account the tracks already added to the AOD
174     Bool_t * usedTrack = NULL;
175     if (nTracks>0) {
176         usedTrack = new Bool_t[nTracks];
177         for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
178     }
179     // Array to take into account the V0s already added to the AOD
180     Bool_t * usedV0 = NULL;
181     if (nV0s>0) {
182         usedV0 = new Bool_t[nV0s];
183         for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
184     }
185     // Array to take into account the kinks already added to the AOD
186     Bool_t * usedKink = NULL;
187     if (nKinks>0) {
188         usedKink = new Bool_t[nKinks];
189         for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
190     }
191     
192     // Access to the AOD container of vertices
193     TClonesArray &vertices = *(fAOD->GetVertices());
194     Int_t jVertices=0;
195     
196     // Access to the AOD container of tracks
197     TClonesArray &tracks = *(fAOD->GetTracks());
198     Int_t jTracks=0; 
199     
200     // Add primary vertex. The primary tracks will be defined
201     // after the loops on the composite objects (V0, cascades, kinks)
202     const AliESDVertex *vtx = fESD->GetPrimaryVertex();
203     
204     vtx->GetXYZ(pos); // position
205     vtx->GetCovMatrix(covVtx); //covariance matrix
206     
207     AliAODVertex * primary = new(vertices[jVertices++])
208         AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary);
209     primary->Print();
210
211
212     // Create vertices starting from the most complex objects
213     Double_t chi2 = 0.;
214     
215     // Cascades
216     for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
217         AliESDcascade *cascade = fESD->GetCascade(nCascade);
218         
219         cascade->GetXYZ(pos[0], pos[1], pos[2]);
220
221         if (!old) {
222             chi2 = vtx->GetChi2toNDF();
223             cascade->GetPosCovXi(covVtx);
224         } else {
225             chi2 = -999.;
226         }
227         // Add the cascade vertex
228         AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
229                                                                           covVtx,
230                                                                           chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
231                                                                           primary,
232                                                                           AliAODVertex::kCascade);
233         
234         primary->AddDaughter(vcascade);
235         
236         // Add the V0 from the cascade. The ESD class have to be optimized...
237         // Now we have to search for the corresponding Vo in the list of V0s
238         // using the indeces of the positive and negative tracks
239         
240         Int_t posFromV0 = cascade->GetPindex();
241         Int_t negFromV0 = cascade->GetNindex();
242         
243       
244         AliESDv0 * v0 = 0x0;
245         Int_t indV0 = -1;
246         
247         for (Int_t iV0=0; iV0<nV0s; ++iV0) {
248             
249             v0 = fESD->GetV0(iV0);
250             Int_t posV0 = v0->GetPindex();
251             Int_t negV0 = v0->GetNindex();
252             
253             if (posV0==posFromV0 && negV0==negFromV0) {
254                 indV0 = iV0;
255                 break;
256             }
257         }
258         
259         AliAODVertex * vV0FromCascade = 0x0;
260         
261         if (indV0>-1 && !usedV0[indV0] ) {
262             
263             // the V0 exists in the array of V0s and is not used
264             
265             usedV0[indV0] = kTRUE;
266             
267             v0->GetXYZ(pos[0], pos[1], pos[2]);
268             if (!old) {
269                 chi2 = v0->GetChi2V0();
270                 v0->GetPosCov(covVtx);
271             } else {
272                 chi2 = -999.;
273             }
274
275             vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
276                                                                      covVtx,
277                                                                      chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
278                                                                      vcascade,
279                                                                      AliAODVertex::kV0);
280         } else {
281             
282             // the V0 doesn't exist in the array of V0s or was used
283 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
284 //               << " The V0 " << indV0 
285 //               << " doesn't exist in the array of V0s or was used!" << endl;
286             
287             cascade->GetXYZ(pos[0], pos[1], pos[2]);
288             
289             if (!old) {
290                 chi2 = v0->GetChi2V0();
291                 cascade->GetPosCov(covVtx);
292             } else {
293                 chi2 = -999.;
294             }
295
296             vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
297                                                                      covVtx,
298                                                                      chi2, // = chi2/NDF since NDF = 2*2-3 (AM)
299                                                                      vcascade,
300                                                                      AliAODVertex::kV0);
301             vcascade->AddDaughter(vV0FromCascade);
302         }
303         
304         // Add the positive tracks from the V0
305         
306         if (posFromV0>-1 && !usedTrack[posFromV0]) {
307             
308             usedTrack[posFromV0] = kTRUE;
309             
310             AliESDtrack *esdTrack = fESD->GetTrack(posFromV0);
311             esdTrack->GetPxPyPz(p);
312             esdTrack->GetXYZ(pos);
313             esdTrack->GetCovarianceXYZPxPyPz(covTr);
314             esdTrack->GetESDpid(pid);
315             
316             vV0FromCascade->AddDaughter(aodTrack =
317                                         new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
318                                                                            esdTrack->GetLabel(), 
319                                                                            p, 
320                                                                            kTRUE,
321                                                                            pos,
322                                                                            kFALSE,
323                                                                            covTr, 
324                                                                            (Short_t)esdTrack->GetSign(),
325                                                                            esdTrack->GetITSClusterMap(), 
326                                                                            pid,
327                                                                            vV0FromCascade,
328                                                                            kTRUE,  // check if this is right
329                                                                            kFALSE, // check if this is right
330                                                                            AliAODTrack::kSecondary)
331                 );
332             aodTrack->ConvertAliPIDtoAODPID();
333         }
334         else {
335 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
336 //               << " track " << posFromV0 << " has already been used!" << endl;
337         }
338         
339         // Add the negative tracks from the V0
340         
341         if (negFromV0>-1 && !usedTrack[negFromV0]) {
342             
343             usedTrack[negFromV0] = kTRUE;
344             
345             AliESDtrack *esdTrack = fESD->GetTrack(negFromV0);
346             esdTrack->GetPxPyPz(p);
347             esdTrack->GetXYZ(pos);
348             esdTrack->GetCovarianceXYZPxPyPz(covTr);
349             esdTrack->GetESDpid(pid);
350             
351             vV0FromCascade->AddDaughter(aodTrack =
352                                         new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
353                                                                            esdTrack->GetLabel(),
354                                                                            p,
355                                                                            kTRUE,
356                                                                            pos,
357                                                                            kFALSE,
358                                                                            covTr, 
359                                                                            (Short_t)esdTrack->GetSign(),
360                                                                            esdTrack->GetITSClusterMap(), 
361                                                                            pid,
362                                                                            vV0FromCascade,
363                                                                            kTRUE,  // check if this is right
364                                                                            kFALSE, // check if this is right
365                                                                            AliAODTrack::kSecondary)
366                 );
367             aodTrack->ConvertAliPIDtoAODPID();
368         }
369         else {
370 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
371 //               << " track " << negFromV0 << " has already been used!" << endl;
372         }
373         
374         // Add the bachelor track from the cascade
375         
376         Int_t bachelor = cascade->GetBindex();
377         
378         if(bachelor>-1 && !usedTrack[bachelor]) {
379             
380             usedTrack[bachelor] = kTRUE;
381             
382             AliESDtrack *esdTrack = fESD->GetTrack(bachelor);
383             esdTrack->GetPxPyPz(p);
384             esdTrack->GetXYZ(pos);
385             esdTrack->GetCovarianceXYZPxPyPz(covTr);
386             esdTrack->GetESDpid(pid);
387             
388             vcascade->AddDaughter(aodTrack =
389                                   new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
390                                                                      esdTrack->GetLabel(),
391                                                                      p,
392                                                                      kTRUE,
393                                                                      pos,
394                                                                      kFALSE,
395                                                                      covTr, 
396                                                                      (Short_t)esdTrack->GetSign(),
397                                                                      esdTrack->GetITSClusterMap(), 
398                                                                      pid,
399                                                                      vcascade,
400                                                                      kTRUE,  // check if this is right
401                                                                      kFALSE, // check if this is right
402                                                                      AliAODTrack::kSecondary)
403                 );
404             aodTrack->ConvertAliPIDtoAODPID();
405         }
406         else {
407 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " cascade " << nCascade
408 //               << " track " << bachelor << " has already been used!" << endl;
409         }
410         
411         // Add the primary track of the cascade (if any)
412         
413     } // end of the loop on cascades
414    
415     // V0s
416     
417     for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
418         
419         if (usedV0[nV0]) continue; // skip if aready added to the AOD
420         
421         AliESDv0 *v0 = fESD->GetV0(nV0);
422         
423         v0->GetXYZ(pos[0], pos[1], pos[2]);
424
425         if (!old) {
426             chi2 = v0->GetChi2V0();
427             v0->GetPosCov(covVtx);
428         } else {
429             chi2 = -999.;
430         }
431
432
433         AliAODVertex * vV0 = 
434             new(vertices[jVertices++]) AliAODVertex(pos,
435                                                     covVtx,
436                                                     chi2, // = chi2/NDF since NDF = 2*2-3
437                                                     primary,
438                                                     AliAODVertex::kV0);
439         primary->AddDaughter(vV0);
440         
441         Int_t posFromV0 = v0->GetPindex();
442         Int_t negFromV0 = v0->GetNindex();
443         
444         // Add the positive tracks from the V0
445         
446         if (posFromV0>-1 && !usedTrack[posFromV0]) {
447             
448             usedTrack[posFromV0] = kTRUE;
449             
450             AliESDtrack *esdTrack = fESD->GetTrack(posFromV0);
451             esdTrack->GetPxPyPz(p);
452             esdTrack->GetXYZ(pos);
453             esdTrack->GetCovarianceXYZPxPyPz(covTr);
454             esdTrack->GetESDpid(pid);
455             
456             vV0->AddDaughter(aodTrack =
457                              new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
458                                                                 esdTrack->GetLabel(), 
459                                                                 p, 
460                                                                 kTRUE,
461                                                                 pos,
462                                                                 kFALSE,
463                                                                 covTr, 
464                                                                 (Short_t)esdTrack->GetSign(),
465                                                                 esdTrack->GetITSClusterMap(), 
466                                                                 pid,
467                                                                 vV0,
468                                                                 kTRUE,  // check if this is right
469                                                                 kFALSE, // check if this is right
470                                                                 AliAODTrack::kSecondary)
471                 );
472             aodTrack->ConvertAliPIDtoAODPID();
473         }
474         else {
475 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " V0 " << nV0
476 //               << " track " << posFromV0 << " has already been used!" << endl;
477         }
478         
479         // Add the negative tracks from the V0
480         
481         if (negFromV0>-1 && !usedTrack[negFromV0]) {
482             
483             usedTrack[negFromV0] = kTRUE;
484             
485             AliESDtrack *esdTrack = fESD->GetTrack(negFromV0);
486             esdTrack->GetPxPyPz(p);
487             esdTrack->GetXYZ(pos);
488             esdTrack->GetCovarianceXYZPxPyPz(covTr);
489             esdTrack->GetESDpid(pid);
490             
491             vV0->AddDaughter(aodTrack =
492                              new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
493                                                                 esdTrack->GetLabel(),
494                                                                 p,
495                                                                 kTRUE,
496                                                                 pos,
497                                                                 kFALSE,
498                                                                 covTr, 
499                                                                 (Short_t)esdTrack->GetSign(),
500                                                                 esdTrack->GetITSClusterMap(), 
501                                                                 pid,
502                                                                 vV0,
503                                                                 kTRUE,  // check if this is right
504                                                                 kFALSE, // check if this is right
505                                                                 AliAODTrack::kSecondary)
506                 );
507             aodTrack->ConvertAliPIDtoAODPID();
508         }
509         else {
510 //          cerr << "Error: event " << fESD->GetEventNumberInFile() << " V0 " << nV0
511 //               << " track " << negFromV0 << " has already been used!" << endl;
512         }
513         
514     } // end of the loop on V0s
515     
516     // Kinks: it is a big mess the access to the information in the kinks
517     // The loop is on the tracks in order to find the mother and daugther of each kink
518     
519     
520     for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
521         
522         
523         AliESDtrack * esdTrack = fESD->GetTrack(iTrack);
524         
525         Int_t ikink = esdTrack->GetKinkIndex(0);
526         
527         if (ikink && nKinks) {
528             // Negative kink index: mother, positive: daughter
529             
530             // Search for the second track of the kink
531             
532             for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
533                 
534                 AliESDtrack * esdTrack1 = fESD->GetTrack(jTrack);
535                 
536                 Int_t jkink = esdTrack1->GetKinkIndex(0);
537                 
538                 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
539                     
540                     // The two tracks are from the same kink
541                     
542                     if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
543                     
544                     Int_t imother = -1;
545                     Int_t idaughter = -1;
546                     
547                     if (ikink<0 && jkink>0) {
548                         
549                         imother = iTrack;
550                         idaughter = jTrack;
551                     }
552                     else if (ikink>0 && jkink<0) {
553                         
554                         imother = jTrack;
555                         idaughter = iTrack;
556                     }
557                     else {
558 //                      cerr << "Error: Wrong combination of kink indexes: "
559 //                           << ikink << " " << jkink << endl;
560                         continue;
561                     }
562                     
563                     // Add the mother track
564                     
565                     AliAODTrack * mother = NULL;
566                     
567                     if (!usedTrack[imother]) {
568                         
569                         usedTrack[imother] = kTRUE;
570                         
571                         AliESDtrack *esdTrack = fESD->GetTrack(imother);
572                         esdTrack->GetPxPyPz(p);
573                         esdTrack->GetXYZ(pos);
574                         esdTrack->GetCovarianceXYZPxPyPz(covTr);
575                         esdTrack->GetESDpid(pid);
576                         
577                         mother = 
578                             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
579                                                                esdTrack->GetLabel(),
580                                                                p,
581                                                                kTRUE,
582                                                                pos,
583                                                                kFALSE,
584                                                                covTr, 
585                                                                (Short_t)esdTrack->GetSign(),
586                                                                esdTrack->GetITSClusterMap(), 
587                                                                pid,
588                                                                primary,
589                                                                kTRUE, // check if this is right
590                                                                kTRUE, // check if this is right
591                                                                AliAODTrack::kPrimary);
592                         primary->AddDaughter(mother);
593                         mother->ConvertAliPIDtoAODPID();
594                     }
595                     else {
596 //                      cerr << "Error: event " << fESD->GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
597 //                           << " track " << imother << " has already been used!" << endl;
598                   }
599                     
600                     // Add the kink vertex
601                     AliESDkink * kink = fESD->GetKink(TMath::Abs(ikink)-1);
602                     
603                     AliAODVertex * vkink = 
604                         new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
605                                                                 NULL,
606                                                                 0.,
607                                                                 mother,
608                                                                 AliAODVertex::kKink);
609                     // Add the daughter track
610                   
611                     AliAODTrack * daughter = NULL;
612                     
613                     if (!usedTrack[idaughter]) {
614                         
615                         usedTrack[idaughter] = kTRUE;
616                         
617                         AliESDtrack *esdTrack = fESD->GetTrack(idaughter);
618                         esdTrack->GetPxPyPz(p);
619                         esdTrack->GetXYZ(pos);
620                         esdTrack->GetCovarianceXYZPxPyPz(covTr);
621                         esdTrack->GetESDpid(pid);
622                         
623                         daughter = 
624                             new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
625                                                                esdTrack->GetLabel(),
626                                                                p,
627                                                                kTRUE,
628                                                                pos,
629                                                                kFALSE,
630                                                                covTr, 
631                                                                (Short_t)esdTrack->GetSign(),
632                                                                esdTrack->GetITSClusterMap(), 
633                                                                pid,
634                                                                vkink,
635                                                                kTRUE, // check if this is right
636                                                                kTRUE, // check if this is right
637                                                                AliAODTrack::kPrimary);
638                         vkink->AddDaughter(daughter);
639                         daughter->ConvertAliPIDtoAODPID();
640                     }
641                     else {
642 //                      cerr << "Error: event " << fESD->GetEventNumberInFile() << " kink " << TMath::Abs(ikink)-1
643 //                           << " track " << idaughter << " has already been used!" << endl;
644                     }
645                 }
646             }
647         }      
648     }
649     
650   
651     // Tracks (primary and orphan)
652
653     printf("NUMBER OF TRACKS %5d\n", nTracks);
654     
655     for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
656         
657         
658         if (usedTrack[nTrack]) continue;
659         AliESDtrack *esdTrack = fESD->GetTrack(nTrack);
660         UInt_t selectInfo = 0;
661         //
662         // Track selection
663         if (fTrackFilter) {
664             selectInfo = fTrackFilter->IsSelected(esdTrack);
665             if (!selectInfo) continue;
666         }
667         
668         //
669         esdTrack->GetPxPyPz(p);
670         esdTrack->GetXYZ(pos);
671         esdTrack->GetCovarianceXYZPxPyPz(covTr);
672         esdTrack->GetESDpid(pid);
673         
674         Float_t impactXY, impactZ;
675         
676         esdTrack->GetImpactParameters(impactXY,impactZ);
677         
678         if (impactXY<3) {
679             // track inside the beam pipe
680             
681             primary->AddDaughter(aodTrack =
682                                  new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
683                                                                     esdTrack->GetLabel(),
684                                                                     p,
685                                                                     kTRUE,
686                                                                     pos,
687                                                                     kFALSE,
688                                                                     covTr, 
689                                                                     (Short_t)esdTrack->GetSign(),
690                                                                     esdTrack->GetITSClusterMap(), 
691                                                                     pid,
692                                                                     primary,
693                                                                     kTRUE, // check if this is right
694                                                                     kTRUE, // check if this is right
695                                                                     AliAODTrack::kPrimary, 
696                                                                     selectInfo)
697                 );
698             aodTrack->ConvertAliPIDtoAODPID();
699         }
700         else {
701             // outside the beam pipe: orphan track
702             aodTrack =
703                 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
704                                                    esdTrack->GetLabel(),
705                                                    p,
706                                                    kTRUE,
707                                                    pos,
708                                                    kFALSE,
709                                                    covTr, 
710                                                    (Short_t)esdTrack->GetSign(),
711                                                    esdTrack->GetITSClusterMap(), 
712                                                    pid,
713                                                    NULL,
714                                                    kFALSE, // check if this is right
715                                                    kFALSE, // check if this is right
716                                                    AliAODTrack::kOrphan,
717                                                    selectInfo);
718             aodTrack->ConvertAliPIDtoAODPID();
719         }       
720     } // end of loop on tracks
721     
722     // muon tracks
723     Int_t nMuTracks = fESD->GetNumberOfMuonTracks();
724     for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
725         
726         AliESDMuonTrack *esdMuTrack = fESD->GetMuonTrack(nMuTrack);     
727         p[0] = esdMuTrack->Px(); 
728         p[1] = esdMuTrack->Py(); 
729         p[2] = esdMuTrack->Pz();
730         pos[0] = primary->GetX(); 
731         pos[1] = primary->GetY(); 
732         pos[2] = primary->GetZ();
733         
734         // has to be changed once the muon pid is provided by the ESD
735         for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
736         
737         primary->AddDaughter(
738             new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
739                                                0, // no label provided
740                                                p,
741                                                kTRUE,
742                                                pos,
743                                                kFALSE,
744                                                NULL, // no covariance matrix provided
745                                                (Short_t)-99, // no charge provided
746                                                0, // no ITSClusterMap
747                                                pid,
748                                                primary,
749                                                kTRUE,  // check if this is right
750                                                kTRUE,  // not used for vertex fit
751                                                AliAODTrack::kPrimary)
752             );
753     }
754   
755     delete [] usedTrack;
756     delete [] usedV0;
757     delete [] usedKink;
758
759
760     //
761     PostData(0, fTreeA);
762     return;
763 }
764
765 void AliAnalysisTaskESDfilter::Terminate(Option_t */*option*/)
766 {
767 // Terminate analysis
768 //
769     if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
770 }
771