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