[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / AliFemto / AliFemtoTrack.h

///////////////////////////////////////////////////////////////////////////
//                                                                       //
// AliFemtoTrack: main class holding all the necessary information       //
// about a track (before the identification) that is required during     //
// femtoscopic analysis. This class is filled with information from the  //
// input stream by the reader. A particle has a link back to the Track   //
// it was created from, so we do not copy the information.               //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#ifndef ALIFEMTOTRACK_H
#define ALIFEMTOTRACK_H

#include "AliFemtoTypes.h"
#include "AliFmPhysicalHelixD.h"
#include "TBits.h"
/* Th stuff */
#include "AliFemtoHiddenInfo.h"
/***/

#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
class StEvent;
class StTrack;
class StMuDst;
class StMuTrack;
#endif

class AliFemtoTrack{
public:
  AliFemtoTrack();
  AliFemtoTrack(const AliFemtoTrack& aTrack);// copy constructor
  AliFemtoTrack& operator=(const AliFemtoTrack& aTrack);
#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
#ifdef __ROOT__
 //AliFemtoTrack(const StTrack*, AliFemtoThreeVector);   // c-tor from StTrack of STAR DSTs
  //AliFemtoTrack(const StMuDst* dst, const StMuTrack* t);
#endif
  //AliFemtoTrack(const StEvent*, const StTrack*);
#endif

  ~AliFemtoTrack();
//    ~AliFemtoTrack(){/* no-op*/};

  short Charge() const;
  float PidProbElectron() const;
  float PidProbPion() const;
  float PidProbKaon() const;
  float PidProbProton() const;
  float PidProbMuon() const;
  
  AliFemtoThreeVector P() const;
  float Pt() const;
  float InnerMomentum() const;

  const AliFmPhysicalHelixD& Helix() const;
  int TrackId() const;
  long int Flags() const;
  int Label()const;
  float ImpactD()const;

  float ImpactDprim()const;
  float ImpactDweak()const;
  float ImpactDmat()const;

  float ImpactZ()const;
  float Cdd() const;
  float Cdz() const;
  float Czz() const; 
  
  float ITSchi2() const;    
  int   ITSncls() const;     
  float TPCchi2() const;       
  int   TPCncls() const;       
  short TPCnclsF() const;      
  float TPCsignal() const;
  short TPCsignalN() const;    
  float TPCsignalS() const;   
 
  //new PID
  float NSigmaTPCPi() const;   
  float NSigmaTPCK() const;   
  float NSigmaTPCP() const;   
  float VTOF() const;   
  float NSigmaTOFPi() const;   
  float NSigmaTOFK() const;   
  float NSigmaTOFP() const;   


  float TOFpionTime() const;
  float TOFkaonTime() const;
  float TOFprotonTime() const;

  double XatDCA() const;
  double YatDCA() const;
  double ZatDCA() const;

  const TBits& TPCclusters() const;
  const TBits& TPCsharing()  const;
  
  void SetCharge(const short& s);
  void SetPidProbElectron(const float& x);
  void SetPidProbPion(const float& x);
  void SetPidProbKaon(const float& x);
  void SetPidProbProton(const float& x);
  void SetPidProbMuon(const float& x);
  void SetTofExpectedTimes(const float& tpi, const float& tkn, const float& tpr);
   
  void SetP(const AliFemtoThreeVector& p);
  void SetPt(const float& x);
  void SetInnerMomentum(const float& x);
  void SetHelix(const AliFmPhysicalHelixD& h);
  void SetTrackId(const int& s);
  void SetFlags(const long int& i);
  void SetLabel(const int& i);
  void SetImpactD(const float& x);

  void SetImpactDprim(const float& x);
  void SetImpactDweak(const float& x);
  void SetImpactDmat(const float& x);

  void SetImpactZ(const float& x);
  void SetCdd(const float& x);
  void SetCdz(const float& x);
  void SetCzz(const float& x);
  
  void SetITSchi2(const float& x);    
  void SetITSncls(const int& i);     
  void SetTPCchi2(const float& x);       
  void SetTPCncls(const int& i);       
  void SetTPCnclsF(const short& s);      
  void SetTPCsignal(const float& s);
  void SetTPCsignalN(const short& s);    
  void SetTPCsignalS(const float& x);   

  //new PID
  void SetNSigmaTPCPi(const float& x);   
  void SetNSigmaTPCK(const float& x);   
  void SetNSigmaTPCP(const float& x);   
  void SetVTOF(const float& x);   
  void SetNSigmaTOFPi(const float& x);   
  void SetNSigmaTOFK(const float& x);   
  void SetNSigmaTOFP(const float& x);  

  void SetTPCcluster(const short& aNBit, const Bool_t& aValue);
  void SetTPCshared(const short& aNBit, const Bool_t& aValue);

  void SetTPCClusterMap(const TBits& aBits);
  void SetTPCSharedMap(const TBits& aBits);

  void SetKinkIndexes(int points[3]);
  int  KinkIndex(int aIndex) const;

  /* Th stuff */
  void SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo);
  bool ValidHiddenInfo() const;
  // Fab private : (official : const AliFemtoHiddenInfo* HiddenInfo() const;
  AliFemtoHiddenInfo* GetHiddenInfo() const;
  /***/
  
  const AliFemtoThreeVector& NominalTpcExitPoint() const;
  const AliFemtoThreeVector& NominalTpcPoint(int i) const;
  const AliFemtoThreeVector& NominalTpcEntrancePoint() const;
    
  void SetNominalTPCEntrancePoint(const AliFemtoThreeVector& aXTPC);
  void SetNominalTPCEntrancePoint(double *aXTPC);

  void SetNominalTPCPoints(double **aXTPC);

  void SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC);
  void SetNominalTPCExitPoint(double *aXTPC);
  void SetSigmaToVertex(const float& Sigma);
  float SigmaToVertex() const;

  void SetXatDCA(const double& x);
  void SetYatDCA(const double& x);
  void SetZatDCA(const double& x);
 
  //Alice stuff
  enum {
    kITSin=0x0001,kITSout=0x0002,kITSrefit=0x0004,kITSpid=0x0008,
    kTPCin=0x0010,kTPCout=0x0020,kTPCrefit=0x0040,kTPCpid=0x0080,
    kTRDin=0x0100,kTRDout=0x0200,kTRDrefit=0x0400,kTRDpid=0x0800,
    kTOFin=0x1000,kTOFout=0x2000,kTOFrefit=0x4000,kTOFpid=0x8000,
    kRICHpid=0x20000,
    kTRDbackup=0x80000,
    kTRDStop=0x20000000,
    kESDpid=0x40000000,
    kTIME=0x80000000
  };
  
 private:
  char fCharge;           // track charge
  float fPidProbElectron; // electron pid
  float fPidProbPion;     // pion pid 
  float fPidProbKaon;     // kaon pid 
  float fPidProbProton;   // proton pid
  float fPidProbMuon;     // muon pid
  int fTrackId;  // track unique id
  float fTofPionTime;     // TOF time - pion expected time
  float fTofKaonTime;     // TOF time - kaon expected time
  float fTofProtonTime;   // TOF time - proton expected time

  AliFemtoThreeVector fP; // track momentum
  float fPt;              // transverse momenta
  float fInnerMomentum;    // *total* momentum at the *inner* wall of the TPC

  AliFmPhysicalHelixD fHelix; // track helix
  //alice stuff
  long int fFlags; //Reconsruction status flags
  int fLabel; //Track label  
  float fImpactD; //impact parameter in xy plane

  float fImpactDprim; //impact parameter in xy plane
  float fImpactDweak; //impact parameter in xy plane
  float fImpactDmat; //impact parameter in xy plane

  float fImpactZ;//impacct parameter in z
  float fCdd,fCdz,fCzz;//covariance matrix of the impact parameters
  // ITS related track information
  float fITSchi2;        // chi2 in the ITS
  int   fITSncls;        // number of clusters assigned in the ITS
  // TPC related track information
  float  fTPCchi2;       // chi2 in the TPC
  int    fTPCncls;       // number of clusters assigned in the TPC
  short fTPCnclsF;       // number of findable clusters in the TPC
  float fTPCsignal;      // dEdx TPC value
  short fTPCsignalN;     // number of points used for dEdx
  float fTPCsignalS;     // RMS of dEdx measurement

  float fVTOF;     // v=length/TOF
  float fNSigmaTPCPi;     // nsigma TPC for pion
  float fNSigmaTPCK;     // nsigma TPC for K
  float fNSigmaTPCP;     // nsigma TPC for P
  float fNSigmaTOFPi;     // nsigma TPC for pion
  float fNSigmaTOFK;     // nsigma TPC for K
  float fNSigmaTOFP;     // nsigma TPC for P

  float fSigmaToVertex;  // Distance from track to vertex in sigmas
  TBits fClusters;       // Cluster per padrow map
  TBits fShared;         // Sharing per padrow map
  AliFemtoThreeVector fNominalTpcEntrancePoint; // Nominal track entrance point into TPC
  AliFemtoThreeVector fNominalTpcPoints[9];
  AliFemtoThreeVector fNominalTpcExitPoint;     // Nominal track exit point from TPC

  int   fKinkIndexes[3]; // Kink Index list

  double fXatDCA;
  double fYatDCA;
  double fZatDCA;
  /* Th stuff */
  // Fab private : add mutable
  //  mutable 
  AliFemtoHiddenInfo* fHiddenInfo; //! hidden info
  /***/
};

//inline const float* AliFemtoTrack::NSigma() const 
//{return &mNSigmaElectron;} // Fab private 
inline float AliFemtoTrack::PidProbElectron() const {return fPidProbElectron;}
inline float AliFemtoTrack::PidProbPion() const {return fPidProbPion;}
inline float AliFemtoTrack::PidProbKaon() const {return fPidProbKaon;}
inline float AliFemtoTrack::PidProbProton() const {return fPidProbProton;}
inline float AliFemtoTrack::PidProbMuon() const {return fPidProbMuon;}

#endif
Commit	Line	Data
76ce4b5b	1	///////////////////////////////////////////////////////////////////////////
	2	// //
	3	// AliFemtoTrack: main class holding all the necessary information //
	4	// about a track (before the identification) that is required during //
	5	// femtoscopic analysis. This class is filled with information from the //
	6	// input stream by the reader. A particle has a link back to the Track //
	7	// it was created from, so we do not copy the information. //
	8	// //
	9	///////////////////////////////////////////////////////////////////////////
	10
	11	#ifndef ALIFEMTOTRACK_H
	12	#define ALIFEMTOTRACK_H
	13
	14	#include "AliFemtoTypes.h"
	15	#include "AliFmPhysicalHelixD.h"
	16	#include "TBits.h"
	17	/* Th stuff */
	18	#include "AliFemtoHiddenInfo.h"
	19	/***/
	20
	21	#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
	22	class StEvent;
	23	class StTrack;
	24	class StMuDst;
	25	class StMuTrack;
	26	#endif
	27
	28	class AliFemtoTrack{
	29	public:
	30	AliFemtoTrack();
	31	AliFemtoTrack(const AliFemtoTrack& aTrack);// copy constructor
	32	AliFemtoTrack& operator=(const AliFemtoTrack& aTrack);
	33	#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
	34	#ifdef __ROOT__
	35	//AliFemtoTrack(const StTrack*, AliFemtoThreeVector); // c-tor from StTrack of STAR DSTs
	36	//AliFemtoTrack(const StMuDst* dst, const StMuTrack* t);
	37	#endif
	38	//AliFemtoTrack(const StEvent, const StTrack);
	39	#endif
	40
	41	~AliFemtoTrack();
	42	// ~AliFemtoTrack(){/* no-op*/};
	43
	44	short Charge() const;
	45	float PidProbElectron() const;
	46	float PidProbPion() const;
	47	float PidProbKaon() const;
	48	float PidProbProton() const;
	49	float PidProbMuon() const;
	50
	51	AliFemtoThreeVector P() const;
	52	float Pt() const;
7eb9f5d0	53	float InnerMomentum() const;
7eb9f5d0	54
76ce4b5b	55	const AliFmPhysicalHelixD& Helix() const;
973a91f8	56	int TrackId() const;
76ce4b5b	57	long int Flags() const;
	58	int Label()const;
	59	float ImpactD()const;
7eb9f5d0	60
	61	float ImpactDprim()const;
	62	float ImpactDweak()const;
	63	float ImpactDmat()const;
	64
76ce4b5b	65	float ImpactZ()const;
	66	float Cdd() const;
	67	float Cdz() const;
	68	float Czz() const;
	69
	70	float ITSchi2() const;
	71	int ITSncls() const;
	72	float TPCchi2() const;
	73	int TPCncls() const;
	74	short TPCnclsF() const;
	75	float TPCsignal() const;
	76	short TPCsignalN() const;
	77	float TPCsignalS() const;
	78
	79	//new PID
	80	float NSigmaTPCPi() const;
	81	float NSigmaTPCK() const;
	82	float NSigmaTPCP() const;
	83	float VTOF() const;
	84	float NSigmaTOFPi() const;
	85	float NSigmaTOFK() const;
	86	float NSigmaTOFP() const;
	87
	88
	89	float TOFpionTime() const;
	90	float TOFkaonTime() const;
	91	float TOFprotonTime() const;
	92
973a91f8	93	double XatDCA() const;
	94	double YatDCA() const;
	95	double ZatDCA() const;
	96
76ce4b5b	97	const TBits& TPCclusters() const;
	98	const TBits& TPCsharing() const;
	99
	100	void SetCharge(const short& s);
	101	void SetPidProbElectron(const float& x);
	102	void SetPidProbPion(const float& x);
	103	void SetPidProbKaon(const float& x);
	104	void SetPidProbProton(const float& x);
	105	void SetPidProbMuon(const float& x);
	106	void SetTofExpectedTimes(const float& tpi, const float& tkn, const float& tpr);
	107
	108	void SetP(const AliFemtoThreeVector& p);
	109	void SetPt(const float& x);
7eb9f5d0	110	void SetInnerMomentum(const float& x);
76ce4b5b	111	void SetHelix(const AliFmPhysicalHelixD& h);
973a91f8	112	void SetTrackId(const int& s);
76ce4b5b	113	void SetFlags(const long int& i);
	114	void SetLabel(const int& i);
	115	void SetImpactD(const float& x);
7eb9f5d0	116
	117	void SetImpactDprim(const float& x);
	118	void SetImpactDweak(const float& x);
	119	void SetImpactDmat(const float& x);
	120
76ce4b5b	121	void SetImpactZ(const float& x);
	122	void SetCdd(const float& x);
	123	void SetCdz(const float& x);
	124	void SetCzz(const float& x);
	125
	126	void SetITSchi2(const float& x);
	127	void SetITSncls(const int& i);
	128	void SetTPCchi2(const float& x);
	129	void SetTPCncls(const int& i);
	130	void SetTPCnclsF(const short& s);
	131	void SetTPCsignal(const float& s);
	132	void SetTPCsignalN(const short& s);
	133	void SetTPCsignalS(const float& x);
	134
	135	//new PID
	136	void SetNSigmaTPCPi(const float& x);
	137	void SetNSigmaTPCK(const float& x);
	138	void SetNSigmaTPCP(const float& x);
	139	void SetVTOF(const float& x);
	140	void SetNSigmaTOFPi(const float& x);
	141	void SetNSigmaTOFK(const float& x);
	142	void SetNSigmaTOFP(const float& x);
	143
	144	void SetTPCcluster(const short& aNBit, const Bool_t& aValue);
	145	void SetTPCshared(const short& aNBit, const Bool_t& aValue);
	146
	147	void SetTPCClusterMap(const TBits& aBits);
	148	void SetTPCSharedMap(const TBits& aBits);
	149
	150	void SetKinkIndexes(int points[3]);
	151	int KinkIndex(int aIndex) const;
	152
	153	/* Th stuff */
	154	void SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo);
	155	bool ValidHiddenInfo() const;
	156	// Fab private : (official : const AliFemtoHiddenInfo* HiddenInfo() const;
	157	AliFemtoHiddenInfo* GetHiddenInfo() const;
	158	/***/
	159
	160	const AliFemtoThreeVector& NominalTpcExitPoint() const;
ce7b3d98	161	const AliFemtoThreeVector& NominalTpcPoint(int i) const;
76ce4b5b	162	const AliFemtoThreeVector& NominalTpcEntrancePoint() const;
	163
	164	void SetNominalTPCEntrancePoint(const AliFemtoThreeVector& aXTPC);
	165	void SetNominalTPCEntrancePoint(double *aXTPC);
	166
ce7b3d98	167	void SetNominalTPCPoints(double **aXTPC);
ce7b3d98	168
76ce4b5b	169	void SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC);
	170	void SetNominalTPCExitPoint(double *aXTPC);
	171	void SetSigmaToVertex(const float& Sigma);
	172	float SigmaToVertex() const;
973a91f8	173
	174	void SetXatDCA(const double& x);
	175	void SetYatDCA(const double& x);
	176	void SetZatDCA(const double& x);
76ce4b5b	177
	178	//Alice stuff
	179	enum {
	180	kITSin=0x0001,kITSout=0x0002,kITSrefit=0x0004,kITSpid=0x0008,
	181	kTPCin=0x0010,kTPCout=0x0020,kTPCrefit=0x0040,kTPCpid=0x0080,
	182	kTRDin=0x0100,kTRDout=0x0200,kTRDrefit=0x0400,kTRDpid=0x0800,
	183	kTOFin=0x1000,kTOFout=0x2000,kTOFrefit=0x4000,kTOFpid=0x8000,
	184	kRICHpid=0x20000,
	185	kTRDbackup=0x80000,
	186	kTRDStop=0x20000000,
	187	kESDpid=0x40000000,
	188	kTIME=0x80000000
	189	};
	190
	191	private:
	192	char fCharge; // track charge
	193	float fPidProbElectron; // electron pid
	194	float fPidProbPion; // pion pid
	195	float fPidProbKaon; // kaon pid
	196	float fPidProbProton; // proton pid
	197	float fPidProbMuon; // muon pid
973a91f8	198	int fTrackId; // track unique id
76ce4b5b	199	float fTofPionTime; // TOF time - pion expected time
	200	float fTofKaonTime; // TOF time - kaon expected time
	201	float fTofProtonTime; // TOF time - proton expected time
	202
	203	AliFemtoThreeVector fP; // track momentum
	204	float fPt; // transverse momenta
7eb9f5d0	205	float fInnerMomentum; // total momentum at the inner wall of the TPC
7eb9f5d0	206
76ce4b5b	207	AliFmPhysicalHelixD fHelix; // track helix
	208	//alice stuff
	209	long int fFlags; //Reconsruction status flags
	210	int fLabel; //Track label
	211	float fImpactD; //impact parameter in xy plane
7eb9f5d0	212
	213	float fImpactDprim; //impact parameter in xy plane
	214	float fImpactDweak; //impact parameter in xy plane
	215	float fImpactDmat; //impact parameter in xy plane
	216
76ce4b5b	217	float fImpactZ;//impacct parameter in z
	218	float fCdd,fCdz,fCzz;//covariance matrix of the impact parameters
	219	// ITS related track information
	220	float fITSchi2; // chi2 in the ITS
	221	int fITSncls; // number of clusters assigned in the ITS
	222	// TPC related track information
	223	float fTPCchi2; // chi2 in the TPC
	224	int fTPCncls; // number of clusters assigned in the TPC
	225	short fTPCnclsF; // number of findable clusters in the TPC
	226	float fTPCsignal; // dEdx TPC value
	227	short fTPCsignalN; // number of points used for dEdx
	228	float fTPCsignalS; // RMS of dEdx measurement
	229
	230	float fVTOF; // v=length/TOF
	231	float fNSigmaTPCPi; // nsigma TPC for pion
	232	float fNSigmaTPCK; // nsigma TPC for K
	233	float fNSigmaTPCP; // nsigma TPC for P
	234	float fNSigmaTOFPi; // nsigma TPC for pion
	235	float fNSigmaTOFK; // nsigma TPC for K
	236	float fNSigmaTOFP; // nsigma TPC for P
	237
	238	float fSigmaToVertex; // Distance from track to vertex in sigmas
	239	TBits fClusters; // Cluster per padrow map
	240	TBits fShared; // Sharing per padrow map
	241	AliFemtoThreeVector fNominalTpcEntrancePoint; // Nominal track entrance point into TPC
ce7b3d98	242	AliFemtoThreeVector fNominalTpcPoints[9];
76ce4b5b	243	AliFemtoThreeVector fNominalTpcExitPoint; // Nominal track exit point from TPC
	244
	245	int fKinkIndexes[3]; // Kink Index list
973a91f8	246
	247	double fXatDCA;
	248	double fYatDCA;
	249	double fZatDCA;
76ce4b5b	250	/* Th stuff */
	251	// Fab private : add mutable
	252	// mutable
	253	AliFemtoHiddenInfo* fHiddenInfo; //! hidden info
	254	/***/
	255	};
	256
	257	//inline const float* AliFemtoTrack::NSigma() const
	258	//{return &mNSigmaElectron;} // Fab private
	259	inline float AliFemtoTrack::PidProbElectron() const {return fPidProbElectron;}
	260	inline float AliFemtoTrack::PidProbPion() const {return fPidProbPion;}
	261	inline float AliFemtoTrack::PidProbKaon() const {return fPidProbKaon;}
	262	inline float AliFemtoTrack::PidProbProton() const {return fPidProbProton;}
	263	inline float AliFemtoTrack::PidProbMuon() const {return fPidProbMuon;}
	264
	265	#endif