[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 NSigmaTPCE() const;   
  float VTOF() const;   
  float NSigmaTOFPi() const;   
  float NSigmaTOFK() const;   
  float NSigmaTOFP() const;   
  float NSigmaTOFE() 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 SetNSigmaTPCE(const float& x);   
  void SetVTOF(const float& x);   
  void SetNSigmaTOFPi(const float& x);   
  void SetNSigmaTOFK(const float& x);   
  void SetNSigmaTOFP(const float& x);   
  void SetNSigmaTOFE(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;  
  void SetITSHitOnLayer(int i, bool val);
  bool HasPointOnITSLayer(int aIndex) const; // i: 0-5, for 6 layers

  /* 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);

 
  void SetTrueMomentum(AliFemtoThreeVector *aMom);
  void SetTrueMomentum(const AliFemtoThreeVector& aMom);
  void SetTrueMomentum(Double_t aPx, Double_t aPy, Double_t aPz);
  void SetEmissionPoint(AliFemtoLorentzVector *aPos);
  void SetEmissionPoint(const AliFemtoLorentzVector& aPos);
  void SetEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz, Double_t aT);
  void SetPDGPid(Int_t aPid);
  void SetMass(Double_t aMass);

  AliFemtoThreeVector   *GetTrueMomentum() const;
  AliFemtoLorentzVector *GetEmissionPoint() const;
  Int_t                  GetPDGPid() const;
  Double_t               GetMass() const;

  AliFemtoThreeVector   *GetGlobalEmissionPoint() const;
  void                   SetGlobalEmissionPoint(const AliFemtoThreeVector& aPos);
  void                   SetGlobalEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz);
 

  void SetPrimaryVertex(double *vertex);
  void GetPrimaryVertex(double *vertex);

  //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 fNSigmaTPCE;     // nsigma TPC for electron
  float fNSigmaTOFPi;     // nsigma TPC for pion
  float fNSigmaTOFK;     // nsigma TPC for K
  float fNSigmaTOFP;     // nsigma TPC for P
  float fNSigmaTOFE;     // nsigma TPC for electron

  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
  bool  fHasPointOnITS[6]; // if track has hit on the ITS layer (6 layers: 2 x 3 (SPD, SSD, SDD)) 

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


  AliFemtoThreeVector   *fTrueMomentum;  // True (simulated) momentum
  AliFemtoLorentzVector *fEmissionPoint; // Emission point coordinates
  Int_t                  fPDGPid;        // True PID of the particle
  Double_t               fMass;          // True particle mass
  AliFemtoThreeVector   *fGlobalEmissionPoint;

  double fVertex[3];

};

//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;
2e04885f	83	float NSigmaTPCE() const;
76ce4b5b	84	float VTOF() const;
	85	float NSigmaTOFPi() const;
	86	float NSigmaTOFK() const;
	87	float NSigmaTOFP() const;
2e04885f	88	float NSigmaTOFE() const;
76ce4b5b	89
	90
	91	float TOFpionTime() const;
	92	float TOFkaonTime() const;
	93	float TOFprotonTime() const;
	94
973a91f8	95	double XatDCA() const;
	96	double YatDCA() const;
	97	double ZatDCA() const;
	98
76ce4b5b	99	const TBits& TPCclusters() const;
	100	const TBits& TPCsharing() const;
	101
	102	void SetCharge(const short& s);
	103	void SetPidProbElectron(const float& x);
	104	void SetPidProbPion(const float& x);
	105	void SetPidProbKaon(const float& x);
	106	void SetPidProbProton(const float& x);
	107	void SetPidProbMuon(const float& x);
	108	void SetTofExpectedTimes(const float& tpi, const float& tkn, const float& tpr);
	109
	110	void SetP(const AliFemtoThreeVector& p);
	111	void SetPt(const float& x);
7eb9f5d0	112	void SetInnerMomentum(const float& x);
76ce4b5b	113	void SetHelix(const AliFmPhysicalHelixD& h);
973a91f8	114	void SetTrackId(const int& s);
76ce4b5b	115	void SetFlags(const long int& i);
	116	void SetLabel(const int& i);
	117	void SetImpactD(const float& x);
7eb9f5d0	118
	119	void SetImpactDprim(const float& x);
	120	void SetImpactDweak(const float& x);
	121	void SetImpactDmat(const float& x);
	122
76ce4b5b	123	void SetImpactZ(const float& x);
	124	void SetCdd(const float& x);
	125	void SetCdz(const float& x);
	126	void SetCzz(const float& x);
	127
	128	void SetITSchi2(const float& x);
	129	void SetITSncls(const int& i);
	130	void SetTPCchi2(const float& x);
	131	void SetTPCncls(const int& i);
	132	void SetTPCnclsF(const short& s);
	133	void SetTPCsignal(const float& s);
	134	void SetTPCsignalN(const short& s);
	135	void SetTPCsignalS(const float& x);
	136
	137	//new PID
	138	void SetNSigmaTPCPi(const float& x);
	139	void SetNSigmaTPCK(const float& x);
	140	void SetNSigmaTPCP(const float& x);
2e04885f	141	void SetNSigmaTPCE(const float& x);
76ce4b5b	142	void SetVTOF(const float& x);
	143	void SetNSigmaTOFPi(const float& x);
	144	void SetNSigmaTOFK(const float& x);
2e04885f	145	void SetNSigmaTOFP(const float& x);
2e04885f	146	void SetNSigmaTOFE(const float& x);
76ce4b5b	147
	148	void SetTPCcluster(const short& aNBit, const Bool_t& aValue);
	149	void SetTPCshared(const short& aNBit, const Bool_t& aValue);
	150
	151	void SetTPCClusterMap(const TBits& aBits);
	152	void SetTPCSharedMap(const TBits& aBits);
	153
	154	void SetKinkIndexes(int points[3]);
4eac0b05	155	int KinkIndex(int aIndex) const;
	156	void SetITSHitOnLayer(int i, bool val);
	157	bool HasPointOnITSLayer(int aIndex) const; // i: 0-5, for 6 layers
76ce4b5b	158
	159	/* Th stuff */
	160	void SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo);
	161	bool ValidHiddenInfo() const;
	162	// Fab private : (official : const AliFemtoHiddenInfo* HiddenInfo() const;
	163	AliFemtoHiddenInfo* GetHiddenInfo() const;
	164	/***/
	165
	166	const AliFemtoThreeVector& NominalTpcExitPoint() const;
ce7b3d98	167	const AliFemtoThreeVector& NominalTpcPoint(int i) const;
76ce4b5b	168	const AliFemtoThreeVector& NominalTpcEntrancePoint() const;
	169
	170	void SetNominalTPCEntrancePoint(const AliFemtoThreeVector& aXTPC);
	171	void SetNominalTPCEntrancePoint(double *aXTPC);
	172
ce7b3d98	173	void SetNominalTPCPoints(double **aXTPC);
ce7b3d98	174
76ce4b5b	175	void SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC);
	176	void SetNominalTPCExitPoint(double *aXTPC);
	177	void SetSigmaToVertex(const float& Sigma);
	178	float SigmaToVertex() const;
973a91f8	179
	180	void SetXatDCA(const double& x);
	181	void SetYatDCA(const double& x);
	182	void SetZatDCA(const double& x);
7f1f4463	183
	184
	185	void SetTrueMomentum(AliFemtoThreeVector *aMom);
	186	void SetTrueMomentum(const AliFemtoThreeVector& aMom);
	187	void SetTrueMomentum(Double_t aPx, Double_t aPy, Double_t aPz);
	188	void SetEmissionPoint(AliFemtoLorentzVector *aPos);
	189	void SetEmissionPoint(const AliFemtoLorentzVector& aPos);
	190	void SetEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz, Double_t aT);
	191	void SetPDGPid(Int_t aPid);
	192	void SetMass(Double_t aMass);
	193
	194	AliFemtoThreeVector *GetTrueMomentum() const;
	195	AliFemtoLorentzVector *GetEmissionPoint() const;
	196	Int_t GetPDGPid() const;
	197	Double_t GetMass() const;
	198
	199	AliFemtoThreeVector *GetGlobalEmissionPoint() const;
	200	void SetGlobalEmissionPoint(const AliFemtoThreeVector& aPos);
	201	void SetGlobalEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz);
76ce4b5b	202
eef80284	203
	204	void SetPrimaryVertex(double *vertex);
	205	void GetPrimaryVertex(double *vertex);
	206
76ce4b5b	207	//Alice stuff
	208	enum {
	209	kITSin=0x0001,kITSout=0x0002,kITSrefit=0x0004,kITSpid=0x0008,
	210	kTPCin=0x0010,kTPCout=0x0020,kTPCrefit=0x0040,kTPCpid=0x0080,
	211	kTRDin=0x0100,kTRDout=0x0200,kTRDrefit=0x0400,kTRDpid=0x0800,
	212	kTOFin=0x1000,kTOFout=0x2000,kTOFrefit=0x4000,kTOFpid=0x8000,
	213	kRICHpid=0x20000,
	214	kTRDbackup=0x80000,
	215	kTRDStop=0x20000000,
	216	kESDpid=0x40000000,
	217	kTIME=0x80000000
	218	};
	219
	220	private:
	221	char fCharge; // track charge
	222	float fPidProbElectron; // electron pid
	223	float fPidProbPion; // pion pid
	224	float fPidProbKaon; // kaon pid
	225	float fPidProbProton; // proton pid
	226	float fPidProbMuon; // muon pid
973a91f8	227	int fTrackId; // track unique id
76ce4b5b	228	float fTofPionTime; // TOF time - pion expected time
	229	float fTofKaonTime; // TOF time - kaon expected time
	230	float fTofProtonTime; // TOF time - proton expected time
	231
	232	AliFemtoThreeVector fP; // track momentum
	233	float fPt; // transverse momenta
7eb9f5d0	234	float fInnerMomentum; // total momentum at the inner wall of the TPC
7eb9f5d0	235
76ce4b5b	236	AliFmPhysicalHelixD fHelix; // track helix
	237	//alice stuff
	238	long int fFlags; //Reconsruction status flags
	239	int fLabel; //Track label
	240	float fImpactD; //impact parameter in xy plane
7eb9f5d0	241
	242	float fImpactDprim; //impact parameter in xy plane
	243	float fImpactDweak; //impact parameter in xy plane
	244	float fImpactDmat; //impact parameter in xy plane
	245
76ce4b5b	246	float fImpactZ;//impacct parameter in z
	247	float fCdd,fCdz,fCzz;//covariance matrix of the impact parameters
	248	// ITS related track information
	249	float fITSchi2; // chi2 in the ITS
	250	int fITSncls; // number of clusters assigned in the ITS
	251	// TPC related track information
	252	float fTPCchi2; // chi2 in the TPC
	253	int fTPCncls; // number of clusters assigned in the TPC
	254	short fTPCnclsF; // number of findable clusters in the TPC
	255	float fTPCsignal; // dEdx TPC value
	256	short fTPCsignalN; // number of points used for dEdx
	257	float fTPCsignalS; // RMS of dEdx measurement
	258
	259	float fVTOF; // v=length/TOF
	260	float fNSigmaTPCPi; // nsigma TPC for pion
	261	float fNSigmaTPCK; // nsigma TPC for K
	262	float fNSigmaTPCP; // nsigma TPC for P
2e04885f	263	float fNSigmaTPCE; // nsigma TPC for electron
76ce4b5b	264	float fNSigmaTOFPi; // nsigma TPC for pion
	265	float fNSigmaTOFK; // nsigma TPC for K
	266	float fNSigmaTOFP; // nsigma TPC for P
2e04885f	267	float fNSigmaTOFE; // nsigma TPC for electron
76ce4b5b	268
	269	float fSigmaToVertex; // Distance from track to vertex in sigmas
	270	TBits fClusters; // Cluster per padrow map
	271	TBits fShared; // Sharing per padrow map
	272	AliFemtoThreeVector fNominalTpcEntrancePoint; // Nominal track entrance point into TPC
ce7b3d98	273	AliFemtoThreeVector fNominalTpcPoints[9];
76ce4b5b	274	AliFemtoThreeVector fNominalTpcExitPoint; // Nominal track exit point from TPC
	275
	276	int fKinkIndexes[3]; // Kink Index list
4eac0b05	277	bool fHasPointOnITS[6]; // if track has hit on the ITS layer (6 layers: 2 x 3 (SPD, SSD, SDD))
973a91f8	278
	279	double fXatDCA;
	280	double fYatDCA;
	281	double fZatDCA;
76ce4b5b	282	/* Th stuff */
	283	// Fab private : add mutable
	284	// mutable
	285	AliFemtoHiddenInfo* fHiddenInfo; //! hidden info
	286	/***/
7f1f4463	287
	288
	289	AliFemtoThreeVector *fTrueMomentum; // True (simulated) momentum
	290	AliFemtoLorentzVector *fEmissionPoint; // Emission point coordinates
	291	Int_t fPDGPid; // True PID of the particle
	292	Double_t fMass; // True particle mass
	293	AliFemtoThreeVector *fGlobalEmissionPoint;
	294
eef80284	295	double fVertex[3];
eef80284	296
76ce4b5b	297	};
	298
	299	//inline const float* AliFemtoTrack::NSigma() const
	300	//{return &mNSigmaElectron;} // Fab private
	301	inline float AliFemtoTrack::PidProbElectron() const {return fPidProbElectron;}
	302	inline float AliFemtoTrack::PidProbPion() const {return fPidProbPion;}
	303	inline float AliFemtoTrack::PidProbKaon() const {return fPidProbKaon;}
	304	inline float AliFemtoTrack::PidProbProton() const {return fPidProbProton;}
	305	inline float AliFemtoTrack::PidProbMuon() const {return fPidProbMuon;}
	306
	307	#endif