[u/mrichter/AliRoot.git] / PWGCF / FLOW / Attic / AliFlowTrack.cxx

//////////////////////////////////////////////////////////////////////
//
// $Id: AliFlowTrack.cxx 18618 2007-05-16 15:38:22Z snelling $
//
// Author: Emanuele Simili
//
//////////////////////////////////////////////////////////////////////
//
//_____________________________________________________________
//
// Description: 
//         an array of AliFlowTrack is the core of the AliFlowEvent. 
// The object AliFlowTrack contains data members wich summarize the track 
// information most useful for flow study (such as Pt, eta, phi angle), some 
// detector signals (fitpoints, chi2 of the track fit, energy loss, time of 
// flight, ecc.), the p.id is stored as the detector response function, for 
// each detector (with the possibility to costomly combine them), and the 
// combined one (see bayesian P.Id. - chap.5 of the ALICE PPR). 
// This class is optimized for reaction plane calculation and sub-event 
// selection, through the appropriate methods in AliFlowEvent.  
// Two arrays of flags in the AliFlowTrack object (fSelection[][] and 
// fSubevent[][]) specify whether a track is included or not in a certain 
// Selection or Subevent. Those flags are switched on/off by the method 
// AliFlowEvent::SetSelection(), according to Eta, Pt, dca, constrainability  
// of the track, number of TPC hits, and p.id hypotesis (static member of the
// AliFlowEvent class (fEtaTpcCuts[][][], fPtTpcCuts[][][], fDcaGlobalCuts[], 
// fPid[], ecc.). 
//
// The AliFlowTrack Class is adapted from the original StFlowTrack,
// succesfully employed to study flow in the STAR experiment at RICH.
// Original Authors:                 Raimond Snellings & Art Poskanzer
//

#include "AliFlowTrack.h"
#include "AliFlowConstants.h"

#include "TMath.h"
#include <iostream>
using namespace std; //required for resolving the 'cout' symbol

ClassImp(AliFlowTrack)
//-------------------------------------------------------------
AliFlowTrack::AliFlowTrack():
fPhi(0.), fEta(0.), fPt(0.), fZFirstPoint(0.), fZLastPoint(0.), fChi2(0.), fTrackLength(0.), fMostLikelihoodPID(0), fPhiGlobal(0.), fEtaGlobal(0.), fPtGlobal(0.), fLabel(0) {
 // Default constructor
 
 for(Int_t dd=0;dd<2;dd++) 	                { fDcaSigned[dd] = 0. ; }			      
 for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fCombRespFun[ii]   = 0. ; }
 for(Int_t det=0;det<4;det++)
 {
  fFitPts[det]  = 0  ; fMaxPts[det]   = 0  ; 
  fFitChi2[det] = 0. ; fDedx[det]     = 0. ; fMom[det] = 0. ; 
  for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fRespFun[det][ii] = -1. ; }
 }
 ResetSelection() ;			      
}
//-------------------------------------------------------------
AliFlowTrack::AliFlowTrack(const Char_t* name):
fPhi(0.), fEta(0.), fPt(0.), fZFirstPoint(0.), fZLastPoint(0.), fChi2(0.), fTrackLength(0.), fMostLikelihoodPID(0), fPhiGlobal(0.), fEtaGlobal(0.), fPtGlobal(0.), fLabel(0) {
 // TNamed constructor
  
 SetName(name) ;
 AliFlowTrack() ;
}
//-------------------------------------------------------------
AliFlowTrack::~AliFlowTrack() 
{
 // default destructor (dummy)
}
//-------------------------------------------------------------

//-------------------------------------------------------------
Float_t  AliFlowTrack::P() const 
{ 
 // Returns the total momentum of the constrained track (calculated from Pt & Eta).
 // If the track is not constrainable or eta is infinite, returns 0.
 
 if(!IsConstrainable()) { return 0. ; }		      

 Float_t momentum = 0. ; 
 Float_t conv = 1 - ( TMath::TanH(Eta()) * TMath::TanH(Eta()) ) ;
 if(conv>0) { momentum = Pt() / TMath::Sqrt(conv) ; } 

 return momentum; 
}
//-------------------------------------------------------------
Float_t  AliFlowTrack::PGlobal() const 
{ 
 // Returns the total momentum of the unconstrained track (calculated from PtGlobal & EtaGlobal). 
 // If etaGlobal is infinite, returns 0.

 Float_t momentum = 0. ; 
 Float_t conv = 1 - ( TMath::TanH(EtaGlobal()) * TMath::TanH(EtaGlobal()) ) ;
 if(conv>0) { momentum = PtGlobal() / TMath::Sqrt(conv) ; }

 return momentum; 
}
//-------------------------------------------------------------
Float_t  AliFlowTrack::Mass() const 
{ 
 // Returns the mass of the track, basing on its P.Id. hypotesis

 Float_t mass = 0.13957 ;  // pion mass 

 if(MostLikelihoodPID() == 0) 	     		      { mass = -1.    ; }
 else if(TMath::Abs(MostLikelihoodPID()) == 11)	      { mass = 0.00051; }
 else if(TMath::Abs(MostLikelihoodPID()) == 13)	      { mass = 0.10566; }
 else if(TMath::Abs(MostLikelihoodPID()) == 211)      { mass = 0.49368; }
 else if(TMath::Abs(MostLikelihoodPID()) == 321)      { mass = 0.13957; }
 else if(TMath::Abs(MostLikelihoodPID()) == 2212)     { mass = 0.93827; }
 else if(TMath::Abs(MostLikelihoodPID()) == 10010020) { mass = 1.87505; }

 return mass ;
}
//-------------------------------------------------------------
Float_t  AliFlowTrack::InvMass() const 
{ 
 // Returns the invariant mass of the track, calculated from T.O.F. and P_tot

 Float_t mass = -1 ;       	    // if no calculation possible, it returns -1
 Float_t c = TMath::Ccgs()/1e+12 ;  // = 0.02998 ;  --> speed of light in cm/psec
 Float_t tof = TofTOF() ; 	    // in pico-seconds
 Float_t lenght = TrackLength() ;   // in cm
 Float_t ptot = 0 ;   		    // constrained parameters are used if there, otherwise unconstrained
 Float_t beta, gamma ;
 if(IsConstrainable()) { ptot = P() ; }
 else                  { ptot = PGlobal() ; }
 if(tof>0 && lenght>0)
 {
  beta = lenght / (tof * c) ;
  if(beta<1) 
  {
   gamma = 1 / TMath::Sqrt( 1 - (beta * beta) ) ;
   mass = TMath::Abs( ptot / (beta * gamma) ) ;  
  }
  //cout << " (yes) Mass = " << mass << " , t/l = " << (tof/lenght) << " , beta = " << beta << " , gamma = " << gamma << endl ; 
 }   
 //else { cout << " (no)  TOF = " << tof << "	, Lenght = " << lenght << endl ; }

 return mass ;
}
//-------------------------------------------------------------
Float_t  AliFlowTrack::Y() const 
{
 // Rapidity of the constrained track.
 // If track is not constrainable, the unconstrained rapidity is returned.
 
 if(!IsConstrainable()) { return YGlobal() ; }
 if(TMath::Abs((Float_t)P()) == TMath::Abs((Float_t)Pt())) 	{ return 0. ; }
 else if(TMath::Abs((Float_t)P()) < TMath::Abs((Float_t)Pt()))	{ cout << "track: " << GetName() << "has  Pt() > P() !!!" << endl ; }
 // -
 Float_t mass = Mass() ; 
 Double_t pz = TMath::Sqrt(P()*P() - Pt()*Pt()); 
 if(Eta()<0) { pz = -pz ; }
 Double_t e = TMath::Sqrt(P()*P() + mass*mass) ;
 Float_t rapidity = 0.5*TMath::Log((e + pz)/(e - pz)) ;
 
 return rapidity ;
}
//-------------------------------------------------------------
Float_t  AliFlowTrack::YGlobal() const 
{
 // Rapidity of the unconstrained track

 if(TMath::Abs((Float_t)PGlobal()) == TMath::Abs((Float_t)PtGlobal())) 	   { return 0. ; }
 else if(TMath::Abs((Float_t)PGlobal()) < TMath::Abs((Float_t)PtGlobal())) { cout << "track: " << GetName() << "has  Pt() > P() !!!" << endl ; }
 // -
 Float_t mass = Mass() ; 
 Double_t pz = TMath::Sqrt(PGlobal()*PGlobal() - PtGlobal()*PtGlobal()); 
 if(EtaGlobal()<0) { pz = -pz ; }
 Double_t e = TMath::Sqrt(PGlobal()*PGlobal() + mass*mass) ;
 Float_t rapidity = 0.5*TMath::Log((e + pz)/(e - pz)) ;
 
 return rapidity ;
}
//-------------------------------------------------------------
const Char_t* AliFlowTrack::Pid() const
{
 // Returns the P.Id. in characters (e,mu,pi,k,p,d) basing on the stored pdg code 
 // and its sign (both stored in MostLikelihoodPID() ) .
 
 const Char_t *name[] = {"e","mu","pi","k","pr","d"} ;
 Int_t pdgCode = TMath::Abs(MostLikelihoodPID()) ;
 Int_t charge = Charge() ;

 TString pId = "" ;
 if(pdgCode == 11)            { pId = name[0] ; }
 else if(pdgCode == 13)       { pId = name[1] ; }
 else if(pdgCode == 211)      { pId = name[2] ; }
 else if(pdgCode == 321)      { pId = name[3] ; }
 else if(pdgCode == 2212)     { pId = name[4] ; }
 else if(pdgCode == 10010020) { pId = name[5] ; }
 else			      { pId = "0" ; }

 if(charge>0) 		      { pId += "+" ; } 
 else if(charge<0) 	      { pId += "-" ; }
 else		 	      { pId += "" ; }
 
 return pId.Data() ; 
}
//-------------------------------------------------------------
void AliFlowTrack::PidProbs(Float_t *pidN) const 
{ 
 // Returns the normalized probability (the "bayesian weights") for the given track to be [e,mu,pi,k,p,d] .  
 // The COMBINED detector response function is scaled by the a priori probabilities 
 // (the normalised particle abundances is stored in AliFlowConstants::fgBayesian[]) .

 Double_t sum = 0 ; 
 for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] = PidProb(n) ; sum += pidN[n] ; }
 if(sum) 
 {  
  for(Int_t n=0;n<AliFlowConstants::kPid;n++)  { pidN[n] /=  sum ; }
 }
 else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
} 
//-------------------------------------------------------------
void AliFlowTrack::PidProbsC(Float_t *pidN) const 
{ 
 // Returns the normalized probability (the "bayesian weights") for the given track to be [e,mu,pi,k,p,d] .  
 // The CUSTOM detector response function (see AliFlowTrack) is scaled by the a priori probabilities 
 // (the normalised particle abundances is stored in AliFlowConstants::fgBayesian[]) .
 
 Double_t sum = 0 ; 
 for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] = PidProbC(n) ; sum += pidN[n] ; }
 if(sum) 
 {  
  for(Int_t n=0;n<AliFlowConstants::kPid;n++)  { pidN[n] /=  sum ; }
 }
 else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
} 
//-------------------------------------------------------------
Float_t  AliFlowTrack::PidProb(Int_t nPid) const
{
 // Returns the bayesian weight of the track to be [nPid = e,mu,pi,k,pi,d].
 // The detector response function in use is the combined one (from the ESD)

 if(nPid > AliFlowConstants::kPid) { return 0. ; } 

 return (fCombRespFun[nPid] * AliFlowConstants::fgBayesian[nPid]) ;
}
//-------------------------------------------------------------
Float_t  AliFlowTrack::PidProbC(Int_t nPid) const
{
 // Returns the bayesian weight of the track to be [nPid = e,mu,pi,k,pi,d].
 // The detector response function in use is the custom one ...

 if(nPid > AliFlowConstants::kPid) { return 0. ; } 

 Float_t  customRespFun[AliFlowConstants::kPid] ;
 GetCustomRespFun(customRespFun) ;

 return (customRespFun[nPid] * AliFlowConstants::fgBayesian[nPid]) ;
}
//-------------------------------------------------------------
Float_t AliFlowTrack::MostLikelihoodRespFunc() const 
{ 
 // Returns the detector response function for the most probable P.id. hypothesis
 // (Warning: THIS IS NOT THE BAYESIAN WEIGHT !) 

 Int_t pdgCode = TMath::Abs(MostLikelihoodPID()) ;
 if(pdgCode == 11)            { return fCombRespFun[0] ; }
 else if(pdgCode == 13)       { return fCombRespFun[1] ; }
 else if(pdgCode == 211)      { return fCombRespFun[2] ; }
 else if(pdgCode == 321)      { return fCombRespFun[3] ; }
 else if(pdgCode == 2212)     { return fCombRespFun[4] ; }
 else if(pdgCode == 10010020) { return fCombRespFun[5] ; }
 else { return 0. ; }
} 
//-------------------------------------------------------------
void AliFlowTrack::SetRespFun(Int_t det, Float_t *r)
{
 // This function fills "AliFlowConstants::kPid" PID weights 
 // (detector response functions) of the track .
 // The method is private, cause it is called by the public 
 // methods: SetRespFunITS, SetRespFunTPC, ...

 for(Int_t i=0;i<AliFlowConstants::kPid;i++)
 {
  fRespFun[det][i] = r[i] ;
 }
}
//-------------------------------------------------------------
void AliFlowTrack::GetRespFun(Int_t det, Float_t *r) const
{
 // This function returns the response functions of the 
 // detector [det] for the P.Id. of the track .
 // The method is private, and it is called by the public 
 // methods: GetRespFunITS, GetRespFunTPC, ...

 for(Int_t i=0;i<AliFlowConstants::kPid;i++)
 {
  r[i] = fRespFun[det][i] ;
 }
}
//-------------------------------------------------------------
void AliFlowTrack::GetCombinedRespFun(Float_t *r) const 
{
 // This function returns the combined response functions for  
 // [e,mu,pi,k,pi,d] as it is stored in the ESD .
 
 for(Int_t i=0;i<AliFlowConstants::kPid;i++)
 {
  r[i] = fCombRespFun[i] ;
 }
}
//------------------------------------------------------------- 
void AliFlowTrack::GetCustomRespFun(Float_t *r) const
{
 // This function returns a combined response functions as setted 
 // by the user ... at the moment just the sum of single responses ...  
 // for the track to be [e,mu,pi,k,pi,d] .
 
 Int_t sum ;
 for(Int_t i=0;i<AliFlowConstants::kPid;i++)
 {
  r[i] = 0. ; sum = 0 ;
  for(Int_t det=0;det<4;det++) 
  { 
   if(fRespFun[det][i]>0) { r[i] += fRespFun[det][i] ; sum += 1 ; } 
  }
  if(sum) { r[i] /= sum ; }
 }
}
//-------------------------------------------------------------
void AliFlowTrack::SetPid(const Char_t* pid)	   	
{ 
 // Sets the P.Id. hypotesis of the track from a String imput (that should be 
 // ("e","mu","pi","k","pr","d"). Sign is allowed as well. The string itself 
 // is not stored, what is stored is the signed PDG code.
 
 if(strstr(pid,"e"))  	   { fMostLikelihoodPID = 11	; }
 else if(strstr(pid,"mu")) { fMostLikelihoodPID = 13	; }
 else if(strstr(pid,"pi")) { fMostLikelihoodPID = 211	; }
 else if(strstr(pid,"k"))  { fMostLikelihoodPID = 321	; }
 else if(strstr(pid,"pr")) { fMostLikelihoodPID = 2212  ; }
 else if(strstr(pid,"d"))  { fMostLikelihoodPID = 10010020 ; }
 else { fMostLikelihoodPID = 0 ; cout << "AliFlowTrack - !BAD IMPUT!" << endl ; }
 
 if(strchr(pid,'+'))  	   { fMostLikelihoodPID = TMath::Abs(fMostLikelihoodPID) * 1 ; }
 else if(strchr(pid,'-'))  { fMostLikelihoodPID = TMath::Abs(fMostLikelihoodPID) * -1 ; } 
}
//-------------------------------------------------------------
void AliFlowTrack::SetPid(Int_t pdgCode)	   	
{ 
 // Sets the P.Id. hypotesis of the track from the PDG code. 
 // Sign can be given as well. 
 
 fMostLikelihoodPID = pdgCode ;
}
//-------------------------------------------------------------
Bool_t AliFlowTrack::IsConstrainable()      	    const 
{ 
 // Returns kTRUE if the track is constrainable. 
 // If the track is constrainable -> the constrained parameters are stored (and the
 // unconstrained ones as well in ...Global). 
 // Otherwise (if track is not constrainable) -> just the unconstrained parameters 
 // are stored, and returned instead of the constrained ones .
 
 if(fPt==0 && fEta==0) { return kFALSE ; }
 else 	               { return kTRUE ; }
} 
//-------------------------------------------------------------
Float_t AliFlowTrack::Dca() const 
{
 // distance of closest approach (norm(dca[2]))

 Double_t mag = 0 ;
 for(Int_t ii=0;ii<2;ii++) { mag += (fDcaSigned[ii]*fDcaSigned[ii]) ; } 
 return TMath::Sqrt(mag) ; 
}     
//-------------------------------------------------------------
Float_t AliFlowTrack::DcaError() const 
{
 // error on the distance of closest approach

 Double_t err = 0 ;
 for(Int_t ii=0;ii<2;ii++) { err = (fDcaError[ii]*fDcaError[ii]) ; } 
 return TMath::Sqrt(err) ; 
}     
//-------------------------------------------------------------
void AliFlowTrack::DcaError3(Float_t err[3]) const 
{
 // Dca Error (xy, z, cov(xy,z)) ...

 for(Int_t ii=0;ii<2;ii++) { err[ii] = TMath::Abs(fDcaError[ii]) ; }		
}     
//-------------------------------------------------------------

//-------------------------------------------------------------
Bool_t AliFlowTrack::Select(Int_t harmonic,Int_t selection,Int_t subevent) const 
{
 // Returns the selection flag for [harmonic] [selection] [sub-event]

 if((subevent == -1) || (subevent == fSubevent[harmonic][selection])) 
 {
  return fSelection[harmonic][selection] ; 
 } 
 return kFALSE ; 	
}
//-------------------------------------------------------------
void AliFlowTrack::PrintSelection() const
{
 // Prints a short string of 0 & 1 to visualize the selections' flags
 // [har1][sel0],[har1][sel1],[har1][sel2],...,[har2][sel0],...
 
 for(Int_t i=0;i<AliFlowConstants::kHars;i++)
 {
  for(Int_t j=0;j<AliFlowConstants::kSels;j++)
  {
   if(Select(i,j)) { cout << 1 ; }
   else    	   { cout << 0 ; }
  }
 }
 cout << endl ;
}
//-------------------------------------------------------------
void AliFlowTrack::ResetSelection() 
{
 // Re-sets all the selection/sub-event flags to 0 
 // (track won't be used in any R.P. calculation)

 for(Int_t ii=0;ii<AliFlowConstants::kHars;ii++)
 {
  for(Int_t jj=0;jj<AliFlowConstants::kSels;jj++)
  {
   fSelection[ii][jj] = kFALSE ; 
   fSubevent[ii][jj] = -1 ; 
  }
 }
}
//-------------------------------------------------------------

//-------------------------------------------------------------
void AliFlowTrack::SetConstrainable()         	   	      
{ 
 // fills the constrained parameters with the unconstrained ones,
 // making the track a constrainable track.
 //                                       !!! TRICKY METHOD !!!

 if(!IsConstrainable()) 
 { 
  fPhi = fPhiGlobal ; 
  fEta = fEtaGlobal ; 
  fPt  = fPtGlobal ; 
 } 
}
//-------------------------------------------------------------
void AliFlowTrack::SetUnConstrainable()        	   	      
{ 
 // deletes the constrained parameters making the track an 
 // unconstrainable track. 
 //                                       !!! TRICKY METHOD !!!

 if(IsConstrainable()) 
 { 
  fPhi = 0. ; 
  fEta = 0. ; 
  fPt  = 0. ; 
 } 
}
//-------------------------------------------------------------
Commit	Line	Data
30a892e3	1	//////////////////////////////////////////////////////////////////////
30a892e3	2	//
448e8856	3	// $Id: AliFlowTrack.cxx 18618 2007-05-16 15:38:22Z snelling $
30a892e3	4	//
	5	// Author: Emanuele Simili
	6	//
	7	//////////////////////////////////////////////////////////////////////
	8	//
	9	//_____________________________________________________________
	10	//
	11	// Description:
	12	// an array of AliFlowTrack is the core of the AliFlowEvent.
	13	// The object AliFlowTrack contains data members wich summarize the track
4e566f2f	14	// information most useful for flow study (such as Pt, eta, phi angle), some
	15	// detector signals (fitpoints, chi2 of the track fit, energy loss, time of
	16	// flight, ecc.), the p.id is stored as the detector response function, for
	17	// each detector (with the possibility to costomly combine them), and the
	18	// combined one (see bayesian P.Id. - chap.5 of the ALICE PPR).
30a892e3	19	// This class is optimized for reaction plane calculation and sub-event
	20	// selection, through the appropriate methods in AliFlowEvent.
	21	// Two arrays of flags in the AliFlowTrack object (fSelection[][] and
	22	// fSubevent[][]) specify whether a track is included or not in a certain
	23	// Selection or Subevent. Those flags are switched on/off by the method
	24	// AliFlowEvent::SetSelection(), according to Eta, Pt, dca, constrainability
	25	// of the track, number of TPC hits, and p.id hypotesis (static member of the
	26	// AliFlowEvent class (fEtaTpcCuts[][][], fPtTpcCuts[][][], fDcaGlobalCuts[],
	27	// fPid[], ecc.).
	28	//
	29	// The AliFlowTrack Class is adapted from the original StFlowTrack,
	30	// succesfully employed to study flow in the STAR experiment at RICH.
	31	// Original Authors: Raimond Snellings & Art Poskanzer
	32	//
	33
	34	#include "AliFlowTrack.h"
	35	#include "AliFlowConstants.h"
92016a03	36
92016a03	37	#include "TMath.h"
30a892e3	38	#include <iostream>
	39	using namespace std; //required for resolving the 'cout' symbol
	40
92016a03	41	ClassImp(AliFlowTrack)
92016a03	42	//-------------------------------------------------------------
d8b98e74	43	AliFlowTrack::AliFlowTrack():
d8b98e74	44	fPhi(0.), fEta(0.), fPt(0.), fZFirstPoint(0.), fZLastPoint(0.), fChi2(0.), fTrackLength(0.), fMostLikelihoodPID(0), fPhiGlobal(0.), fEtaGlobal(0.), fPtGlobal(0.), fLabel(0) {
30a892e3	45	// Default constructor
30a892e3	46
4e566f2f	47	for(Int_t dd=0;dd<2;dd++) { fDcaSigned[dd] = 0. ; }
	48	for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fCombRespFun[ii] = 0. ; }
	49	for(Int_t det=0;det<4;det++)
30a892e3	50	{
4e566f2f	51	fFitPts[det] = 0 ; fMaxPts[det] = 0 ;
	52	fFitChi2[det] = 0. ; fDedx[det] = 0. ; fMom[det] = 0. ;
	53	for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fRespFun[det][ii] = -1. ; }
30a892e3	54	}
	55	ResetSelection() ;
	56	}
92016a03	57	//-------------------------------------------------------------
d8b98e74	58	AliFlowTrack::AliFlowTrack(const Char_t* name):
d8b98e74	59	fPhi(0.), fEta(0.), fPt(0.), fZFirstPoint(0.), fZLastPoint(0.), fChi2(0.), fTrackLength(0.), fMostLikelihoodPID(0), fPhiGlobal(0.), fEtaGlobal(0.), fPtGlobal(0.), fLabel(0) {
30a892e3	60	// TNamed constructor
	61
	62	SetName(name) ;
	63	AliFlowTrack() ;
	64	}
92016a03	65	//-------------------------------------------------------------
30a892e3	66	AliFlowTrack::~AliFlowTrack()
	67	{
	68	// default destructor (dummy)
	69	}
92016a03	70	//-------------------------------------------------------------
30a892e3	71
92016a03	72	//-------------------------------------------------------------
30a892e3	73	Float_t AliFlowTrack::P() const
30a892e3	74	{
92016a03	75	// Returns the total momentum of the constrained track (calculated from Pt & Eta).
92016a03	76	// If the track is not constrainable or eta is infinite, returns 0.
30a892e3	77
92016a03	78	if(!IsConstrainable()) { return 0. ; }
	79
	80	Float_t momentum = 0. ;
	81	Float_t conv = 1 - ( TMath::TanH(Eta()) * TMath::TanH(Eta()) ) ;
	82	if(conv>0) { momentum = Pt() / TMath::Sqrt(conv) ; }
	83
30a892e3	84	return momentum;
30a892e3	85	}
92016a03	86	//-------------------------------------------------------------
92016a03	87	Float_t AliFlowTrack::PGlobal() const
30a892e3	88	{
92016a03	89	// Returns the total momentum of the unconstrained track (calculated from PtGlobal & EtaGlobal).
	90	// If etaGlobal is infinite, returns 0.
	91
	92	Float_t momentum = 0. ;
	93	Float_t conv = 1 - ( TMath::TanH(EtaGlobal()) * TMath::TanH(EtaGlobal()) ) ;
	94	if(conv>0) { momentum = PtGlobal() / TMath::Sqrt(conv) ; }
30a892e3	95
30a892e3	96	return momentum;
30a892e3	97	}
92016a03	98	//-------------------------------------------------------------
30a892e3	99	Float_t AliFlowTrack::Mass() const
	100	{
	101	// Returns the mass of the track, basing on its P.Id. hypotesis
	102
92016a03	103	Float_t mass = 0.13957 ; // pion mass
30a892e3	104
92016a03	105	if(MostLikelihoodPID() == 0) { mass = -1. ; }
	106	else if(TMath::Abs(MostLikelihoodPID()) == 11) { mass = 0.00051; }
	107	else if(TMath::Abs(MostLikelihoodPID()) == 13) { mass = 0.10566; }
	108	else if(TMath::Abs(MostLikelihoodPID()) == 211) { mass = 0.49368; }
	109	else if(TMath::Abs(MostLikelihoodPID()) == 321) { mass = 0.13957; }
	110	else if(TMath::Abs(MostLikelihoodPID()) == 2212) { mass = 0.93827; }
	111	else if(TMath::Abs(MostLikelihoodPID()) == 10010020) { mass = 1.87505; }
30a892e3	112
92016a03	113	return mass ;
30a892e3	114	}
92016a03	115	//-------------------------------------------------------------
30a892e3	116	Float_t AliFlowTrack::InvMass() const
	117	{
	118	// Returns the invariant mass of the track, calculated from T.O.F. and P_tot
	119
92016a03	120	Float_t mass = -1 ; // if no calculation possible, it returns -1
30a892e3	121	Float_t c = TMath::Ccgs()/1e+12 ; // = 0.02998 ; --> speed of light in cm/psec
	122	Float_t tof = TofTOF() ; // in pico-seconds
	123	Float_t lenght = TrackLength() ; // in cm
92016a03	124	Float_t ptot = 0 ; // constrained parameters are used if there, otherwise unconstrained
	125	Float_t beta, gamma ;
	126	if(IsConstrainable()) { ptot = P() ; }
	127	else { ptot = PGlobal() ; }
30a892e3	128	if(tof>0 && lenght>0)
92016a03	129	{
92016a03	130	beta = lenght / (tof * c) ;
30a892e3	131	if(beta<1)
30a892e3	132	{
92016a03	133	gamma = 1 / TMath::Sqrt( 1 - (beta * beta) ) ;
	134	mass = TMath::Abs( ptot / (beta * gamma) ) ;
	135	}
	136	//cout << " (yes) Mass = " << mass << " , t/l = " << (tof/lenght) << " , beta = " << beta << " , gamma = " << gamma << endl ;
	137	}
	138	//else { cout << " (no) TOF = " << tof << " , Lenght = " << lenght << endl ; }
30a892e3	139
92016a03	140	return mass ;
30a892e3	141	}
92016a03	142	//-------------------------------------------------------------
30a892e3	143	Float_t AliFlowTrack::Y() const
	144	{
	145	// Rapidity of the constrained track.
	146	// If track is not constrainable, the unconstrained rapidity is returned.
	147
	148	if(!IsConstrainable()) { return YGlobal() ; }
	149	if(TMath::Abs((Float_t)P()) == TMath::Abs((Float_t)Pt())) { return 0. ; }
	150	else if(TMath::Abs((Float_t)P()) < TMath::Abs((Float_t)Pt())) { cout << "track: " << GetName() << "has Pt() > P() !!!" << endl ; }
	151	// -
92016a03	152	Float_t mass = Mass() ;
	153	Double_t pz = TMath::Sqrt(P()P() - Pt()Pt());
	154	if(Eta()<0) { pz = -pz ; }
	155	Double_t e = TMath::Sqrt(P()P() + massmass) ;
	156	Float_t rapidity = 0.5*TMath::Log((e + pz)/(e - pz)) ;
30a892e3	157
	158	return rapidity ;
	159	}
92016a03	160	//-------------------------------------------------------------
30a892e3	161	Float_t AliFlowTrack::YGlobal() const
	162	{
	163	// Rapidity of the unconstrained track
	164
	165	if(TMath::Abs((Float_t)PGlobal()) == TMath::Abs((Float_t)PtGlobal())) { return 0. ; }
	166	else if(TMath::Abs((Float_t)PGlobal()) < TMath::Abs((Float_t)PtGlobal())) { cout << "track: " << GetName() << "has Pt() > P() !!!" << endl ; }
	167	// -
92016a03	168	Float_t mass = Mass() ;
	169	Double_t pz = TMath::Sqrt(PGlobal()PGlobal() - PtGlobal()PtGlobal());
	170	if(EtaGlobal()<0) { pz = -pz ; }
	171	Double_t e = TMath::Sqrt(PGlobal()PGlobal() + massmass) ;
	172	Float_t rapidity = 0.5*TMath::Log((e + pz)/(e - pz)) ;
30a892e3	173
	174	return rapidity ;
	175	}
92016a03	176	//-------------------------------------------------------------
92016a03	177	const Char_t* AliFlowTrack::Pid() const
30a892e3	178	{
	179	// Returns the P.Id. in characters (e,mu,pi,k,p,d) basing on the stored pdg code
	180	// and its sign (both stored in MostLikelihoodPID() ) .
	181
92016a03	182	const Char_t *name[] = {"e","mu","pi","k","pr","d"} ;
	183	Int_t pdgCode = TMath::Abs(MostLikelihoodPID()) ;
	184	Int_t charge = Charge() ;
30a892e3	185
92016a03	186	TString pId = "" ;
	187	if(pdgCode == 11) { pId = name[0] ; }
	188	else if(pdgCode == 13) { pId = name[1] ; }
	189	else if(pdgCode == 211) { pId = name[2] ; }
	190	else if(pdgCode == 321) { pId = name[3] ; }
	191	else if(pdgCode == 2212) { pId = name[4] ; }
	192	else if(pdgCode == 10010020) { pId = name[5] ; }
	193	else { pId = "0" ; }
30a892e3	194
92016a03	195	if(charge>0) { pId += "+" ; }
	196	else if(charge<0) { pId += "-" ; }
	197	else { pId += "" ; }
30a892e3	198
92016a03	199	return pId.Data() ;
30a892e3	200	}
92016a03	201	//-------------------------------------------------------------
4e566f2f	202	void AliFlowTrack::PidProbs(Float_t *pidN) const
30a892e3	203	{
4e566f2f	204	// Returns the normalized probability (the "bayesian weights") for the given track to be [e,mu,pi,k,p,d] .
	205	// The COMBINED detector response function is scaled by the a priori probabilities
	206	// (the normalised particle abundances is stored in AliFlowConstants::fgBayesian[]) .
30a892e3	207
30a892e3	208	Double_t sum = 0 ;
4e566f2f	209	for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] = PidProb(n) ; sum += pidN[n] ; }
	210	if(sum)
	211	{
	212	for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] /= sum ; }
30a892e3	213	}
	214	else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
	215	}
92016a03	216	//-------------------------------------------------------------
4e566f2f	217	void AliFlowTrack::PidProbsC(Float_t *pidN) const
	218	{
	219	// Returns the normalized probability (the "bayesian weights") for the given track to be [e,mu,pi,k,p,d] .
	220	// The CUSTOM detector response function (see AliFlowTrack) is scaled by the a priori probabilities
	221	// (the normalised particle abundances is stored in AliFlowConstants::fgBayesian[]) .
	222
	223	Double_t sum = 0 ;
	224	for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] = PidProbC(n) ; sum += pidN[n] ; }
	225	if(sum)
	226	{
	227	for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] /= sum ; }
	228	}
	229	else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
	230	}
	231	//-------------------------------------------------------------
	232	Float_t AliFlowTrack::PidProb(Int_t nPid) const
30a892e3	233	{
4e566f2f	234	// Returns the bayesian weight of the track to be [nPid = e,mu,pi,k,pi,d].
	235	// The detector response function in use is the combined one (from the ESD)
	236
	237	if(nPid > AliFlowConstants::kPid) { return 0. ; }
30a892e3	238
4e566f2f	239	return (fCombRespFun[nPid] * AliFlowConstants::fgBayesian[nPid]) ;
30a892e3	240	}
92016a03	241	//-------------------------------------------------------------
4e566f2f	242	Float_t AliFlowTrack::PidProbC(Int_t nPid) const
30a892e3	243	{
4e566f2f	244	// Returns the bayesian weight of the track to be [nPid = e,mu,pi,k,pi,d].
4e566f2f	245	// The detector response function in use is the custom one ...
30a892e3	246
4e566f2f	247	if(nPid > AliFlowConstants::kPid) { return 0. ; }
30a892e3	248
4e566f2f	249	Float_t customRespFun[AliFlowConstants::kPid] ;
4e566f2f	250	GetCustomRespFun(customRespFun) ;
30a892e3	251
4e566f2f	252	return (customRespFun[nPid] * AliFlowConstants::fgBayesian[nPid]) ;
4e566f2f	253	}
92016a03	254	//-------------------------------------------------------------
4e566f2f	255	Float_t AliFlowTrack::MostLikelihoodRespFunc() const
30a892e3	256	{
4e566f2f	257	// Returns the detector response function for the most probable P.id. hypothesis
4e566f2f	258	// (Warning: THIS IS NOT THE BAYESIAN WEIGHT !)
30a892e3	259
92016a03	260	Int_t pdgCode = TMath::Abs(MostLikelihoodPID()) ;
4e566f2f	261	if(pdgCode == 11) { return fCombRespFun[0] ; }
	262	else if(pdgCode == 13) { return fCombRespFun[1] ; }
	263	else if(pdgCode == 211) { return fCombRespFun[2] ; }
	264	else if(pdgCode == 321) { return fCombRespFun[3] ; }
	265	else if(pdgCode == 2212) { return fCombRespFun[4] ; }
	266	else if(pdgCode == 10010020) { return fCombRespFun[5] ; }
30a892e3	267	else { return 0. ; }
30a892e3	268	}
92016a03	269	//-------------------------------------------------------------
4e566f2f	270	void AliFlowTrack::SetRespFun(Int_t det, Float_t *r)
	271	{
	272	// This function fills "AliFlowConstants::kPid" PID weights
	273	// (detector response functions) of the track .
	274	// The method is private, cause it is called by the public
	275	// methods: SetRespFunITS, SetRespFunTPC, ...
	276
	277	for(Int_t i=0;i<AliFlowConstants::kPid;i++)
	278	{
	279	fRespFun[det][i] = r[i] ;
	280	}
	281	}
	282	//-------------------------------------------------------------
	283	void AliFlowTrack::GetRespFun(Int_t det, Float_t *r) const
	284	{
	285	// This function returns the response functions of the
	286	// detector [det] for the P.Id. of the track .
	287	// The method is private, and it is called by the public
	288	// methods: GetRespFunITS, GetRespFunTPC, ...
	289
	290	for(Int_t i=0;i<AliFlowConstants::kPid;i++)
	291	{
	292	r[i] = fRespFun[det][i] ;
	293	}
	294	}
	295	//-------------------------------------------------------------
	296	void AliFlowTrack::GetCombinedRespFun(Float_t *r) const
	297	{
	298	// This function returns the combined response functions for
	299	// [e,mu,pi,k,pi,d] as it is stored in the ESD .
	300
	301	for(Int_t i=0;i<AliFlowConstants::kPid;i++)
	302	{
	303	r[i] = fCombRespFun[i] ;
	304	}
	305	}
	306	//-------------------------------------------------------------
	307	void AliFlowTrack::GetCustomRespFun(Float_t *r) const
	308	{
	309	// This function returns a combined response functions as setted
	310	// by the user ... at the moment just the sum of single responses ...
	311	// for the track to be [e,mu,pi,k,pi,d] .
	312
	313	Int_t sum ;
	314	for(Int_t i=0;i<AliFlowConstants::kPid;i++)
	315	{
	316	r[i] = 0. ; sum = 0 ;
	317	for(Int_t det=0;det<4;det++)
	318	{
	319	if(fRespFun[det][i]>0) { r[i] += fRespFun[det][i] ; sum += 1 ; }
	320	}
	321	if(sum) { r[i] /= sum ; }
	322	}
	323	}
	324	//-------------------------------------------------------------
30a892e3	325	void AliFlowTrack::SetPid(const Char_t* pid)
	326	{
	327	// Sets the P.Id. hypotesis of the track from a String imput (that should be
	328	// ("e","mu","pi","k","pr","d"). Sign is allowed as well. The string itself
	329	// is not stored, what is stored is the signed PDG code.
	330
	331	if(strstr(pid,"e")) { fMostLikelihoodPID = 11 ; }
	332	else if(strstr(pid,"mu")) { fMostLikelihoodPID = 13 ; }
	333	else if(strstr(pid,"pi")) { fMostLikelihoodPID = 211 ; }
	334	else if(strstr(pid,"k")) { fMostLikelihoodPID = 321 ; }
	335	else if(strstr(pid,"pr")) { fMostLikelihoodPID = 2212 ; }
	336	else if(strstr(pid,"d")) { fMostLikelihoodPID = 10010020 ; }
	337	else { fMostLikelihoodPID = 0 ; cout << "AliFlowTrack - !BAD IMPUT!" << endl ; }
	338
	339	if(strchr(pid,'+')) { fMostLikelihoodPID = TMath::Abs(fMostLikelihoodPID) * 1 ; }
	340	else if(strchr(pid,'-')) { fMostLikelihoodPID = TMath::Abs(fMostLikelihoodPID) * -1 ; }
	341	}
92016a03	342	//-------------------------------------------------------------
4e566f2f	343	void AliFlowTrack::SetPid(Int_t pdgCode)
	344	{
	345	// Sets the P.Id. hypotesis of the track from the PDG code.
	346	// Sign can be given as well.
	347
	348	fMostLikelihoodPID = pdgCode ;
	349	}
	350	//-------------------------------------------------------------
30a892e3	351	Bool_t AliFlowTrack::IsConstrainable() const
	352	{
	353	// Returns kTRUE if the track is constrainable.
	354	// If the track is constrainable -> the constrained parameters are stored (and the
	355	// unconstrained ones as well in ...Global).
	356	// Otherwise (if track is not constrainable) -> just the unconstrained parameters
	357	// are stored, and returned instead of the constrained ones .
	358
	359	if(fPt==0 && fEta==0) { return kFALSE ; }
	360	else { return kTRUE ; }
	361	}
92016a03	362	//-------------------------------------------------------------
92016a03	363	Float_t AliFlowTrack::Dca() const
30a892e3	364	{
92016a03	365	// distance of closest approach (norm(dca[2]))
92016a03	366
30a892e3	367	Double_t mag = 0 ;
	368	for(Int_t ii=0;ii<2;ii++) { mag += (fDcaSigned[ii]*fDcaSigned[ii]) ; }
	369	return TMath::Sqrt(mag) ;
	370	}
92016a03	371	//-------------------------------------------------------------
92016a03	372	Float_t AliFlowTrack::DcaError() const
30a892e3	373	{
92016a03	374	// error on the distance of closest approach
	375
	376	Double_t err = 0 ;
	377	for(Int_t ii=0;ii<2;ii++) { err = (fDcaError[ii]*fDcaError[ii]) ; }
	378	return TMath::Sqrt(err) ;
30a892e3	379	}
92016a03	380	//-------------------------------------------------------------
	381	void AliFlowTrack::DcaError3(Float_t err[3]) const
	382	{
	383	// Dca Error (xy, z, cov(xy,z)) ...
30a892e3	384
92016a03	385	for(Int_t ii=0;ii<2;ii++) { err[ii] = TMath::Abs(fDcaError[ii]) ; }
	386	}
	387	//-------------------------------------------------------------
30a892e3	388
92016a03	389	//-------------------------------------------------------------
	390	Bool_t AliFlowTrack::Select(Int_t harmonic,Int_t selection,Int_t subevent) const
	391	{
	392	// Returns the selection flag for [harmonic] [selection] [sub-event]
30a892e3	393
92016a03	394	if((subevent == -1) \|\| (subevent == fSubevent[harmonic][selection]))
	395	{
	396	return fSelection[harmonic][selection] ;
	397	}
	398	return kFALSE ;
	399	}
	400	//-------------------------------------------------------------
	401	void AliFlowTrack::PrintSelection() const
	402	{
	403	// Prints a short string of 0 & 1 to visualize the selections' flags
	404	// [har1][sel0],[har1][sel1],[har1][sel2],...,[har2][sel0],...
	405
	406	for(Int_t i=0;i<AliFlowConstants::kHars;i++)
	407	{
	408	for(Int_t j=0;j<AliFlowConstants::kSels;j++)
	409	{
	410	if(Select(i,j)) { cout << 1 ; }
	411	else { cout << 0 ; }
	412	}
	413	}
	414	cout << endl ;
	415	}
	416	//-------------------------------------------------------------
	417	void AliFlowTrack::ResetSelection()
	418	{
	419	// Re-sets all the selection/sub-event flags to 0
	420	// (track won't be used in any R.P. calculation)
30a892e3	421
92016a03	422	for(Int_t ii=0;ii<AliFlowConstants::kHars;ii++)
	423	{
	424	for(Int_t jj=0;jj<AliFlowConstants::kSels;jj++)
	425	{
	426	fSelection[ii][jj] = kFALSE ;
	427	fSubevent[ii][jj] = -1 ;
	428	}
	429	}
	430	}
	431	//-------------------------------------------------------------
	432
	433	//-------------------------------------------------------------
30a892e3	434	void AliFlowTrack::SetConstrainable()
30a892e3	435	{
4e566f2f	436	// fills the constrained parameters with the unconstrained ones,
	437	// making the track a constrainable track.
	438	// !!! TRICKY METHOD !!!
30a892e3	439
	440	if(!IsConstrainable())
	441	{
	442	fPhi = fPhiGlobal ;
	443	fEta = fEtaGlobal ;
	444	fPt = fPtGlobal ;
	445	}
	446	}
92016a03	447	//-------------------------------------------------------------
30a892e3	448	void AliFlowTrack::SetUnConstrainable()
30a892e3	449	{
4e566f2f	450	// deletes the constrained parameters making the track an
	451	// unconstrainable track.
	452	// !!! TRICKY METHOD !!!
30a892e3	453
	454	if(IsConstrainable())
	455	{
	456	fPhi = 0. ;
	457	fEta = 0. ;
	458	fPt = 0. ;
	459	}
	460	}
92016a03	461	//-------------------------------------------------------------