Sergey: bug fix with storing cluster id's
[u/mrichter/AliRoot.git] / PWG2 / FLOW / Attic / AliFlowMaker.cxx
1 //////////////////////////////////////////////////////////////////////
2 //
3 // $Id: AliFlowMaker.cxx 18618 2007-05-16 15:38:22Z snelling $
4 //
5 // Author: Emanuele Simili
6 //
7 //////////////////////////////////////////////////////////////////////
8 //_____________________________________________________________
9 //
10 // Description: 
11 //        AliFlowMaker provides the method to create AliFlowEvent(s) 
12 // from AliESD(s). Very basic track cuts are applyed.
13 // The present class can be used in a simple AliRoot macro or in a 
14 // more complex enviroment such as AliSelector or AliTask.
15 //
16 //////////////////////////////////////////////////////////////////////
17
18 #ifndef ALIFLOWMAKER_CXX
19 #define ALIFLOWMAKER_CXX
20
21 // ROOT things
22 #include <TROOT.h>
23 #include <TFile.h>
24 #include <TString.h>
25 #include <TMath.h>
26 #include "TClonesArray.h"
27
28 // AliRoot things
29 #include "AliESD.h"
30 #include "AliESDVertex.h"
31 #include "AliESDtrack.h"
32 #include "AliESDv0.h"
33 //#include "AliKalmanTrack.h"
34
35 // Flow things
36 #include "AliFlowEvent.h"
37 #include "AliFlowTrack.h"
38 #include "AliFlowV0.h"
39 #include "AliFlowConstants.h"
40 #include "AliFlowMaker.h"
41
42 // ANSI things
43 #include <stdlib.h>
44 #include <vector>
45
46 using namespace std; //required for resolving the 'cout' symbol
47
48 ClassImp(AliFlowMaker) 
49 //-----------------------------------------------------------------------
50 AliFlowMaker::AliFlowMaker():
51   fEventNumber(0), fTrackNumber(0), fV0Number(0), fGoodTracks(0), fGoodV0s(0),
52   fGoodTracksEta(0), fPosiTracks(0), fNegaTracks(0), fUnconstrained(0),
53   fSumAll(0), fCutEvts(0), fCutTrks(0), fCutV0s(0), fCounter(0), fMovedTr(0x0),
54   fNewAli(kFALSE), fLoopTrks(kTRUE), fLoopV0s(kTRUE),
55   fESD(0x0), fTrack(0x0), fV0(0x0), fVertex(0x0),
56   fRunID(0), fNumberOfEvents(0), fNumberOfTracks(0), 
57   fNumberOfV0s(0), fMagField(0), 
58   fFlowEvent(0x0), fFlowTrack(0x0), fFlowV0(0x0),
59   fNHits(0), fElow(0.001), fEup(1000.)
60 {
61  // default constructor 
62  // resets counters , sets defaults
63  
64  for(Int_t bb=0;bb<5;bb++) { fBayesianAll[bb] = 0 ; } ;
65
66  // trak cuts
67  fLabel[0] = 0 ; fLabel[1] = -1 ;
68 }
69 //-----------------------------------------------------------------------
70 AliFlowMaker::~AliFlowMaker()
71 {
72  // default destructor (no actions) 
73 }
74 //-----------------------------------------------------------------------
75
76 //-----------------------------------------------------------------------
77 AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
78 {
79  // From the AliESD (input) fills the AliFlowEvent (output) . 
80  // It loops on track & v0 and calls the methods to fill the arrays . 
81  // ... . 
82
83  fFlowEvent = new AliFlowEvent(10000) ; if(!fFlowEvent) { return 0 ; }
84  //cout << " -evt- " << fFlowEvent << endl ;
85
86  fRunID = fESD->GetRunNumber() ;
87  fEventNumber = -1 ;
88  // fEventNumber = fESD->GetEventNumber() ;
89  fNumberOfTracks = fESD->GetNumberOfTracks() ;
90  fNumberOfV0s = fESD->GetNumberOfV0s() ;
91  //
92  cout << " *evt n. " << fEventNumber << " (run " << fRunID << ")  -  tracks: " << fNumberOfTracks << " ,   v0s " << fNumberOfV0s << endl ;
93  
94  // Clean the vector of links esd-flowEvt
95  fMovedTr.clear(); // Remove all elements
96
97  // Event id 
98  fFlowEvent->SetRunID(fRunID) ;                
99  fFlowEvent->SetEventID(fEventNumber) ;         
100  fFlowEvent->SetOrigMult((UInt_t)fNumberOfTracks) ;
101
102  // Run information (fixed - ???)
103  fMagField = fESD->GetMagneticField() ; // cout << " *fMagField " << fMagField << endl ;
104  fFlowEvent->SetMagneticField(fMagField) ;      
105  fFlowEvent->SetCenterOfMassEnergy(AliFlowConstants::fgCenterOfMassEnergy) ;  
106  fFlowEvent->SetBeamMassNumberEast(AliFlowConstants::fgBeamMassNumberEast) ;  
107  fFlowEvent->SetBeamMassNumberWest(AliFlowConstants::fgBeamMassNumberWest) ;  
108
109  // Trigger information (now is: ULon64_t - some trigger mask)
110  fFlowEvent->SetL0TriggerWord((Int_t)fESD->GetTriggerMask()); 
111  
112  // Get primary vertex position
113  fVertex = (AliESDVertex*)fESD->GetVertex() ;
114  Double_t position[3] ; 
115  fVertex->GetXYZ(position) ;
116  fFlowEvent->SetVertexPos((Float_t)position[0],(Float_t)position[1],(Float_t)position[2]) ; 
117
118  // Zero Degree Calorimeter information
119  Int_t zdcp = fESD->GetZDCParticipants() ; 
120  Float_t zdce[3] ; 
121  zdce[0] = fESD->GetZDCN1Energy() + fESD->GetZDCN2Energy(); 
122  zdce[1] = fESD->GetZDCP1Energy() + fESD->GetZDCP2Energy() ; 
123  zdce[2] = fESD->GetZDCEMEnergy() ;
124  fFlowEvent->SetZDCpart(zdcp);                          
125  fFlowEvent->SetZDCenergy(zdce[0],zdce[1],zdce[2]);     
126
127  // Track loop
128  if(fLoopTrks)
129  {
130   Int_t badTrks = 0 ;   
131   for(fTrackNumber=0;fTrackNumber<fNumberOfTracks;fTrackNumber++) 
132   {
133    fTrack = fESD->GetTrack(fTrackNumber) ;
134    if(CheckTrack(fTrack))
135    {
136     FillFlowTrack(fTrack) ;   
137     fGoodTracks++ ;                                   
138     fMovedTr.push_back(fFlowEvent->TrackCollection()->GetLast()) ; 
139    }
140    else { fMovedTr.push_back(-1) ; badTrks++ ; continue ; }
141   }
142   fCutTrks += badTrks ;
143  } // cout << " -track number- :  " << fTrackNumber << endl ;
144
145  // V0 loop
146  if(fLoopV0s)
147  {
148   Int_t badV0s = 0 ;
149   for(fV0Number=0;fV0Number<fNumberOfV0s;fV0Number++) 
150   {
151    fV0 = fESD->GetV0(fV0Number) ;                       
152    if(CheckV0(fV0))
153    {
154     FillFlowV0(fV0) ;
155     fGoodV0s++ ;                        
156    }
157    else { badV0s++ ; continue ; }
158   }
159   fCutV0s += badV0s ;
160  } // cout << " -v0 number- :  " << fV0Number << endl ;
161
162  // Evt setting stuff
163  fFlowEvent->SetCentrality();   
164                                 
165  fCounter++ ; 
166  return fFlowEvent ;
167 }
168 //----------------------------------------------------------------------
169 AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
170 {
171  // From the AliESDtrack (input) fills the AliFlowTrack (output) .
172
173  TString name = "" ; name += fTrackNumber ;
174  Int_t idx = fFlowEvent->TrackCollection()->GetEntries() ;
175  fFlowTrack = (AliFlowTrack*)(fFlowEvent->TrackCollection()->New(idx)) ;
176  fFlowTrack->SetName(name.Data()) ;
177  
178  // cout << " -tr- " << name.Data() << "(" << idx << ")"  << endl ;
179
180  // ESD particle label (link: KineTree-ESD)
181  Int_t label = TMath::Abs(fTrack->GetLabel());
182  fFlowTrack->SetLabel(label) ;                  
183
184  // signed DCA from ESDtrack
185  Float_t xy = 0 ; Float_t z = 0 ; 
186  fTrack->GetImpactParameters(xy,z) ; 
187  fFlowTrack->SetDcaSigned(xy,z) ;                   
188
189  // error on the DCA
190  Float_t dcaBis[2] ; Float_t dcaCov[3] ; 
191  for(Int_t dd=0;dd<3;dd++) { dcaCov[dd] = 0. ; }
192  fTrack->GetImpactParameters(dcaBis, dcaCov) ;
193  fFlowTrack->SetDcaError(dcaCov[0],dcaCov[1],dcaCov[2]) ;                   
194
195  // UnConstrained (global) first
196  Double_t gD[3] ;                               
197  fTrack->GetPxPyPz(gD) ;                        
198  // -
199  Float_t phiGl = (Float_t)Phi(gD) ;  
200  if(phiGl<0) { phiGl += 2*TMath::Pi() ; }
201  fFlowTrack->SetPhiGlobal(phiGl) ;              
202  Float_t ptGl = (Float_t)Pt(gD) ;  if(ptGl<=0) { cout << " !!! ptGlobal = " << ptGl << endl ; }
203  fFlowTrack->SetPtGlobal(ptGl) ;                
204  Float_t etaGl = (Float_t)Eta(gD) ; 
205  fFlowTrack->SetEtaGlobal(etaGl) ;              
206
207  // Constrained (NEW)
208  Double_t cD[3] ;
209  Double_t par1 ; Double_t par2 ;  Double_t par3[3] ;
210  if(fTrack->GetConstrainedExternalParameters(par1,par2,par3))
211  {
212   fTrack->GetConstrainedPxPyPz(cD) ;     
213  }
214  else { for(Int_t iii=0;iii<3;iii++) { cD[iii] =0 ; } }
215
216  if(Norm(cD)!=0.)   // ConstrainedPxPyPz != 0 if ConstrainedChi2 < something ...
217  {                                                      
218   Float_t phi = (Float_t)Phi(cD) ; 
219   if(phi<0) { phi += 2*TMath::Pi() ; }
220   fFlowTrack->SetPhi(phi) ;                             
221   Float_t pt = (Float_t)Pt(cD) ;   if(pt<=0) { cout << " !!! pt = " << pt << endl ; }
222   fFlowTrack->SetPt(pt) ;                               
223   Float_t eta = (Float_t)Eta(cD) ; 
224   fFlowTrack->SetEta(eta) ;                             
225  
226   // number of constrainable tracks with |eta| < AliFlowConstants::fgEtaGood (0.9)
227   if(TMath::Abs(eta) < AliFlowConstants::fgEtaMid)  { fGoodTracksEta++ ; }
228  }
229  else  // in case Constriction impossible for track, fill the UnConstrained (global)
230  {
231   fUnconstrained++ ;    
232   fFlowTrack->SetPhi(0.) ;
233   fFlowTrack->SetPt(0.) ;   
234   fFlowTrack->SetEta(0.) ; 
235  }           
236
237  // positive - negative tracks
238  Int_t trkSign = (Int_t)fTrack->GetSign() ; 
239  fFlowTrack->SetCharge(trkSign) ;               
240  if(trkSign>0)  { fPosiTracks++ ; }
241  else if(trkSign<0)     { fNegaTracks++ ; }
242  else                   { return 0 ; }
243
244  // Tracking parameters (fit , TPC , ITS , dE/dx)
245  fFlowTrack->SetChi2(fTrack->GetConstrainedChi2()) ;            
246  fFlowTrack->SetTrackLength(fTrack->GetIntegratedLength()) ;    
247  // -
248  Int_t idXt[180] ; // used for Cluster Map ( see AliESDtrack::GetTPCclusters() )    // old:    Int
249  Int_t idX[6] ;    // used for Cluster Map ( see AliESDtrack::GetITSclusters() )    // old:    UInt
250  Int_t idxr[130] ; // used for Cluster Map ( see AliESDtrack::GetTRDclusters() )    // old:    UInt
251  Int_t nClus = 0 ;      
252  Int_t fNFound = 0 ;                                    // *!* fNFoundable (in AliTPCtrack) ... added by M.Ianov 
253  // -
254  Double_t detPid[5] ;           
255  Float_t  detPid6[AliFlowConstants::kPid] ; 
256
257  Double_t pVecAt[3] ; 
258  for(Int_t gg=0;gg<3;gg++) { pVecAt[gg] = gD[gg] ; }
259  Bool_t boh ; Float_t pAt = 0 ;                         // to get p at each detector
260  // -
261  if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTPCx, fMagField, pVecAt) ; }
262  else        { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTPCx, fMagField, pVecAt) ; }
263  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
264  nClus = fTrack->GetTPCclusters(idXt) ;
265  fNFound = fTrack->GetTPCNclsF() ;  // was 160
266  if( (fTrack->GetStatus() & AliESDtrack::kTPCpid) != 0 )
267  {
268   fTrack->GetTPCpid(detPid) ; 
269   for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ; 
270   fFlowTrack->SetRespFunTPC(detPid6) ; 
271  }
272  fFlowTrack->SetMaxPtsTPC(fNFound) ;                            
273  fFlowTrack->SetFitPtsTPC(nClus) ;                              
274  fFlowTrack->SetDedxTPC(fTrack->GetTPCsignal()) ;               
275  fFlowTrack->SetChi2TPC((Float_t)(fTrack->GetTPCchi2())) ;      
276  fFlowTrack->SetPatTPC(pAt) ;                                   
277  // -
278  if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgITSx, fMagField, pVecAt) ; }
279  else        { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgITSx, fMagField, pVecAt) ; }
280  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
281  nClus = fTrack->GetITSclusters(idX) ;
282  fNFound = 6 ; // ? fixed
283  if( (fTrack->GetStatus() & AliESDtrack::kITSpid) != 0 )
284  {
285   fTrack->GetITSpid(detPid) ; 
286   for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ; 
287   fFlowTrack->SetRespFunITS(detPid6) ; 
288  } 
289  fFlowTrack->SetMaxPtsITS(fNFound) ;                            
290  fFlowTrack->SetFitPtsITS(nClus) ;                              
291  fFlowTrack->SetDedxITS(fTrack->GetITSsignal()) ;               
292  fFlowTrack->SetChi2ITS((Float_t)(fTrack->GetITSchi2())) ;      
293  fFlowTrack->SetPatITS(pAt) ;                                   
294  // -
295  if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTRDx, fMagField, pVecAt) ; } 
296  else        { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTRDx, fMagField, pVecAt) ; } 
297  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
298  nClus = fTrack->GetTRDclusters(idxr) ;
299  fNFound = fTrack->GetTRDncls() ;  // was 130
300  if( (fTrack->GetStatus() & AliESDtrack::kTRDpid) != 0 )
301  {
302   fTrack->GetTRDpid(detPid) ; 
303   for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ; 
304   fFlowTrack->SetRespFunTRD(detPid6) ; 
305  }
306  fFlowTrack->SetMaxPtsTRD(fNFound) ;                            
307  fFlowTrack->SetNhitsTRD(nClus) ;                               
308  fFlowTrack->SetSigTRD(fTrack->GetTRDsignal()) ;                
309  fFlowTrack->SetChi2TRD((Float_t)fTrack->GetTRDchi2()) ;        
310  fFlowTrack->SetPatTRD(pAt) ;                                   
311  // -
312  if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTOFx, fMagField, pVecAt) ; }
313  else        { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTOFx, fMagField, pVecAt) ; }
314  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
315  nClus = fTrack->GetTOFcluster() ;
316  fNFound = 0 ; if(fTrack->GetTOFCalChannel() > 0) { fNFound = 1 ; }
317  if( (fTrack->GetStatus() & AliESDtrack::kTOFpid) != 0 )
318  {
319   fTrack->GetTOFpid(detPid) ; 
320   for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ; 
321   fFlowTrack->SetRespFunTOF(detPid6) ; 
322  }
323  fFlowTrack->SetMaxPtsTOF(fNFound) ;                            
324  fFlowTrack->SetNhitsTOF(nClus) ;                               
325  fFlowTrack->SetTofTOF(fTrack->GetTOFsignal()) ;                
326  fFlowTrack->SetChi2TOF(fTrack->GetTOFchi2()) ;                 
327  fFlowTrack->SetPatTOF(pAt) ;                                   
328  // -
329  Double_t rIn[3]  ; rIn[0] = 0.  ;  rIn[1] = 0. ;  rIn[2] = 0. ;
330  Double_t rOut[3] ; rOut[0] = 0. ; rOut[1] = 0. ; rOut[2] = 0. ;
331  // -
332  fTrack->GetInnerXYZ(rIn) ;                                     
333  fFlowTrack->SetZFirstPoint(rIn[2]) ; 
334  //fTrack->GetXYZAt(AliFlowConstants::fgTPCx,fMagField,rOut) ;          
335  fTrack->GetOuterXYZ(rOut) ;                                    
336  fFlowTrack->SetZLastPoint(rOut[2]) ; 
337  
338  // ESD-P.Id. = 5-vector of Best detectors probabilities for [e , mu , pi , K , p] 
339  Double_t trkPid[5] ; fTrack->GetESDpid(trkPid) ;               
340  Double_t trkPid6[AliFlowConstants::kPid] ; 
341  for(Int_t bb=0;bb<5;bb++) { trkPid6[bb] = trkPid[bb] ; } 
342  trkPid6[5] = 0. ;                                              // *!* implement P.Id. for Deuterim
343
344  // Bayesian P.Id. method (weighted probabilities for [e , mu , pi , K , p , d])
345  Double_t bsum = 0 ; 
346  Double_t bayePid[AliFlowConstants::kPid] ;    // normalized P.id
347  Double_t storedPid[AliFlowConstants::kPid] ;  // stored P.id
348  for(Int_t nB=0;nB<AliFlowConstants::kPid;nB++)  { bsum += trkPid6[nB]*AliFlowConstants::fgBayesian[nB] ; }
349  if(bsum)
350  {
351   for(Int_t nB=0;nB<AliFlowConstants::kPid;nB++) 
352   { 
353    bayePid[nB] = trkPid6[nB]*AliFlowConstants::fgBayesian[nB] / bsum ; 
354    storedPid[nB] = trkPid6[nB] ; 
355   }
356  }
357  else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
358  
359  fFlowTrack->SetElectronPositronProb(storedPid[0]);               
360  fFlowTrack->SetMuonPlusMinusProb(storedPid[1]);
361  fFlowTrack->SetPionPlusMinusProb(storedPid[2]);
362  fFlowTrack->SetKaonPlusMinusProb(storedPid[3]);
363  fFlowTrack->SetProtonPbarProb(storedPid[4]);
364  fFlowTrack->SetDeuteriumAntiDeuteriumProb(storedPid[5]);       // *!* implement P.Id. for Deuterim
365
366  // P.id. label given via the weighted prob.
367  const Int_t kCode[]   =  {11,13,211,321,2212,10010020} ;
368  Int_t kkk = 2 ;                        // if No id. -> then is a Pi
369  Float_t pidMax = bayePid[2] ;  // (if all equal, Pi probability get's the advantage to be the first)
370  for(Int_t iii=0; iii<5; iii++) 
371  {
372   if(bayePid[iii]>pidMax) { kkk = iii ; pidMax = bayePid[iii] ; }  // !!! Bayesian as well !!!
373  }
374  fBayesianAll[kkk]++ ; fSumAll++ ;      // goes on filling the vector of observed abundance 
375  //-
376  Int_t pdgCode = trkSign*kCode[kkk] ;
377  fFlowTrack->SetMostLikelihoodPID(pdgCode);
378  
379  return fFlowTrack ; 
380 }
381 //-----------------------------------------------------------------------
382 AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
383 {
384  // From the AliESDv0 (input) fills the AliFlowV0 (output) .
385
386  TString name = "" ; name += fV0Number ;
387  Int_t idx = fFlowEvent->V0Collection()->GetEntries() ;
388  fFlowV0 = (AliFlowV0*)(fFlowEvent->V0Collection()->New(idx)) ;
389  fFlowV0->SetName(name.Data()) ;
390  
391  // cout << " -v0- " << name.Data() << "(" << idx << ")"  << endl ;
392
393  // ESD particle label (link: KineTree-ESD)
394  Int_t label = -1 ; // TMath::Abs(fV0->GetLabel());
395  fFlowV0->SetLabel(label) ;                     
396
397  // reconstructed momentum of the V0
398  Double_t pxyz[3] ;
399  fV0->GetPxPyPz(pxyz[0],pxyz[1],pxyz[2]) ;
400
401  Float_t phi = (Float_t)Phi(pxyz) ; if(phi<0) { phi += 2*TMath::Pi() ; }
402  fFlowV0->SetPhi(phi) ;         
403  Float_t pt = (Float_t)Pt(pxyz) ; 
404  fFlowV0->SetPt(pt) ;           
405  Float_t eta = (Float_t)Eta(pxyz) ; 
406  fFlowV0->SetEta(eta) ;         
407
408  // reconstructed position of the V0 
409  Double_t xyz[3] ;              
410  fV0->GetXYZ(xyz[0],xyz[1],xyz[2]) ;            
411  fFlowV0->SetCrossPoint(xyz[0],xyz[1],xyz[2]) ;
412
413  // V0's impact parameter & error (chi2 , DCA , sigma , pointing angle)  
414  //fFlowV0->SetDca((Float_t)fV0->GetD()) ;    // GetDistNorm 
415  //fFlowV0->SetSigma((Float_t)fV0->GetDistSigma()) ;
416  //fFlowV0->SetCosPointingAngle((Float_t)fV0->GetV0CosineOfPointingAngle()) ;  
417  //fFlowV0->SetDaughtersDca(fV0->GetDcaV0Daughters()) ;
418  //fFlowV0->SetChi2((Float_t)fV0->GetChi2V0()) ;     // AliRoot v4-04-Release (December 2006)  
419  //fFlowV0->SetChi2((Float_t)fV0->GetChi2()) ;       // AliRoot v4-04-Release (old)
420  // ...when they'll stop changing the methods I'll enable the above lines. For now:
421  fFlowV0->SetDca(0.);
422  fFlowV0->SetSigma(0.1); 
423  fFlowV0->SetCosPointingAngle(1.) ;     
424  fFlowV0->SetDaughtersDca(0.) ;
425  fFlowV0->SetChi2(1.) ;
426
427  // P.id. 
428  Int_t pdgCode = fV0->GetPdgCode() ;
429  fFlowV0->SetMostLikelihoodPID(pdgCode);        
430
431  // mass 
432  fFlowV0->SetVmass((Float_t)fV0->GetEffMass()) ; 
433  
434  // daughters 
435  Int_t pN = fV0->GetPindex() ;
436  Int_t nN = fV0->GetNindex() ;
437  fFlowV0->SetDaughters(fMovedTr[pN],fMovedTr[nN]) ;
438
439  return fFlowV0 ;
440 }
441 //-----------------------------------------------------------------------
442 Bool_t AliFlowMaker::CheckTrack(AliESDtrack* fTrack) const
443 {
444  // applies track cuts (pE , nHits , label)
445
446  if(!fTrack) { return kFALSE ; }
447
448  Int_t idXt[180] ;  // used for Cluster Map ( see AliESDtrack::GetTPCclusters() )
449  Int_t   nHits = fTrack->GetTPCclusters(idXt) ;
450  Float_t pE    = fTrack->GetP() ;
451  Int_t   label = fTrack->GetLabel() ;
452  
453  if(fNHits && (nHits<=fNHits))                                           { return kFALSE ; }
454  if((fElow < fEup) && ((pE<fElow) || (pE>fEup)))                         { return kFALSE ; }
455  if((fLabel[0] < fLabel[1]) && ((label<fLabel[0]) || (label>fLabel[1]))) { return kFALSE ; }
456  //if(fPrimary && ...)                                                   { return kFALSE ; }
457
458  return kTRUE ;
459 }
460 //-----------------------------------------------------------------------
461 Bool_t AliFlowMaker::CheckV0(AliESDv0* fV0) const
462 {
463  // applies v0 cuts (mass>fElow, daughters included in the tracks)
464  
465  if(!fV0) { return kFALSE ; }
466  
467  Int_t pN = fV0->GetPindex() ;
468  Int_t nN = fV0->GetNindex() ;
469  Float_t iMass = (Float_t)fV0->GetEffMass() ;
470  
471  if(iMass < fElow)      { return kFALSE ; }
472  if(fMovedTr[pN] < 0)   { return kFALSE ; }
473  if(fMovedTr[nN] < 0)   { return kFALSE ; }
474
475  return kTRUE ;
476 }
477 //-----------------------------------------------------------------------
478 Bool_t AliFlowMaker::CheckEvent(AliESD* fESD) const
479 {
480  // applies event cuts (dummy)
481  
482  if(!fESD) { return kFALSE ; }
483
484  return kTRUE ;
485 }
486 //-----------------------------------------------------------------------
487 void AliFlowMaker::PrintCutList()
488
489  // Prints the list of Cuts 
490
491  cout << " * ESD cuts list * " << endl ; 
492  if(fLabel[0]<fLabel[1])
493  { 
494   cout << "  Track Label [ " << fLabel[0] << " , " << fLabel[1] << " ] " << endl ; 
495  }
496  if(fNHits)
497  { 
498   cout << "  TPC clusters > " << fNHits << endl ; 
499  }
500  if(fElow<fEup)
501  { 
502   cout << "  Track Energy (P_total) [ " << fElow << " , " << fEup << " ] " << endl ; 
503  }
504  if(fElow>0.)
505  { 
506   cout << "  V0 invariant mass > " << fElow << endl ; 
507  }
508  cout << " *               * " << endl ;
509 }
510 //-----------------------------------------------------------------------
511
512 //-----------------------------------------------------------------------
513 //*** USEFULL METHODS for a 3-array of double (~ TVector3) ***
514 //-----------------------------------------------------------------------
515 Double_t AliFlowMaker::Norm(Double_t nu[3])
516
517  // returns the norm of a double[3] 
518
519  Double_t norm2 = nu[0]*nu[0] + nu[1]*nu[1] + nu[2]*nu[2] ;
520  return TMath::Sqrt(norm2) ; 
521 }
522 //-----------------------------------------------------------------------
523 Double_t AliFlowMaker::Phi(Double_t nu[3])
524 {
525  // returns the azimuthal angle of a double[3] 
526
527  if(nu[0]==0 && nu[1]==0) { return 0. ; }
528  else                     { return TMath::ATan2(nu[1],nu[0]) ; }
529 }
530 //-----------------------------------------------------------------------
531 Double_t AliFlowMaker::Pt(Double_t nu[3])
532 {
533  // returns the transvers momentum of a double[3] 
534
535  Double_t trans = nu[0]*nu[0] + nu[1]*nu[1] ;
536  return TMath::Sqrt(trans) ; 
537 }
538 //-----------------------------------------------------------------------
539 Double_t AliFlowMaker::Eta(Double_t nu[3])
540 {
541  // returns the PseudoRapidity of a double[3] 
542  // if transvers momentum = 0 --> returns +/- 1.000
543
544  Double_t m = Norm(nu) ;
545  if(nu[0]!=0 || nu[1]!=0) { return 0.5*TMath::Log((m+nu[2])/(m-nu[2])) ; }
546  else                     { return TMath::Sign((Double_t)1000.,nu[2]) ; }
547 }
548 //-----------------------------------------------------------------------
549
550 #endif