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

///////////////////////////////////////////////////////////////////////////
//                                                                       //
// AliFemtoParticle: main class halding all the necessary information    //
// about a particle that is required during femtoscopic analysis         //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#ifndef ALIFEMTOPARTICLE_H
#define ALIFEMTOPARTICLE_H

//#include "math.h"
#include "AliFemtoTypes.h"
#include "AliFemtoTrack.h"
#include "AliFemtoV0.h"
#include "AliFemtoKink.h"
#include "AliFemtoXi.h"
#include "AliFmPhysicalHelixD.h"
// ***
class AliFemtoHiddenInfo;
// ***
class AliFemtoParticle{
public:
  AliFemtoParticle();
  AliFemtoParticle(const AliFemtoParticle& aParticle);
  AliFemtoParticle(const AliFemtoTrack* const hbtTrack, const double& mass);
  AliFemtoParticle(const AliFemtoV0* const hbtV0, const double& mass);
  AliFemtoParticle(const AliFemtoKink* const hbtKink, const double& mass);
  AliFemtoParticle(const AliFemtoXi* const hbtXi, const double& mass);
  ~AliFemtoParticle();

  AliFemtoParticle& operator=(const AliFemtoParticle& aParticle);

  const AliFemtoLorentzVector& FourMomentum() const;

  AliFmPhysicalHelixD& Helix();

  const AliFemtoThreeVector DecayVertexPosition() const;
  unsigned long TopologyMap(const int word) const;
  int NumberOfHits() const;

  int TrackId() const;         // only for particles from tracks 
  int   NegTrackId() const;   // only for particles from v0 
  int   PosTrackId() const;   // only for particles from v0 

  AliFemtoTrack* Track() const;
  AliFemtoV0* V0() const;
  AliFemtoKink* Kink() const;

/*   const AliFemtoThreeVector& NominalTpcExitPoint() const;     // position track exits TPC assuming start at (0,0,0) */
/*   const AliFemtoThreeVector& NominalTpcEntrancePoint() const; // position track crosses IFC assuming start at (0,0,0) */
  const AliFemtoThreeVector& TpcV0PosExitPoint() const;  
  const AliFemtoThreeVector& TpcV0PosEntrancePoint() const;
  const AliFemtoThreeVector& TpcV0NegExitPoint() const;  
  const AliFemtoThreeVector& TpcV0NegEntrancePoint() const;

  // the following method is for explicit internal calculation to fill datamembers.
  // It is invoked automatically if AliFemtoParticle constructed from AliFemtoTrack
  // void CalculateNominalTpcExitAndEntrancePoints(); 
  // NOTE - this requires the fHelix, so be sure this is filled


/*   AliFemtoThreeVector fNominalPosSample[11];  // I make this public for convenience and speed of AliFemtoPair() */
/*   float fZ[45];  // Z position of cluster on padrow */
/*   float fU[45];  // U position of cluster on padrow */
/*   int fSect[45]; // Sector number of cluster on padrow */

  void ResetFourMomentum(const AliFemtoLorentzVector& fourMomentum);

  const AliFemtoHiddenInfo*  HiddenInfo() const;
  // Fab private
  AliFemtoHiddenInfo*  GetHiddenInfo() const;
  void SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo);
  void CalculatePurity();
  double GetPionPurity();
  double GetKaonPurity();
  double GetProtonPurity();
/*   void CalculateTpcExitAndEntrancePoints( AliFmPhysicalHelixD* tHelix, */
/* 					  AliFemtoThreeVector* PrimVert, */
/* 					  AliFemtoThreeVector* SecVert, */
/* 					  AliFemtoThreeVector* tmpTpcEntrancePoint, */
/* 					  AliFemtoThreeVector* tmpTpcExitPoint, */
/* 					  AliFemtoThreeVector* tmpPosSample, */
/* 					  float* tmpZ,float* tmpU,int* tmpSect); */

  // For V0 Neg Daugthers TpcEntrance/ExitPoints
/*   AliFemtoThreeVector* fTpcV0NegPosSample; // Sample of TPC V0 neg */
/*   float* fV0NegZ;                          // Array of Neg Z cluster positions */
/*   float* fV0NegU;                          // Array of Neg U cluster positions */
/*   int* fV0NegSect;                         // Array of Neg cluster sectors */
 
private:
  AliFemtoTrack* fTrack;  // copy of the track the particle was formed of, else Null
  AliFemtoV0* fV0;        // copy of the v0 the particle was formed of, else Null
  AliFemtoKink* fKink;    // copy of the v0 the particle was formed of, else Null
  AliFemtoXi* fXi;        // copy of the Xi the particle was formed of, else Null  

  AliFemtoLorentzVector fFourMomentum; // Particle momentum
  AliFmPhysicalHelixD fHelix;          // Particle trajectory helix
  //unsigned long  fMap[2]; 
  //int fNhits;
/*   AliFemtoThreeVector fNominalTpcExitPoint; // Point where particle exits TPC */
/*   AliFemtoThreeVector fNominalTpcEntrancePoint; // Point where particle enters TPC */
  AliFemtoHiddenInfo* fHiddenInfo;  // Fab private

  double fPurity[6];  // Purity variables

  static double fgPrimPimPar0; // purity parameterization parameter
  static double fgPrimPimPar1; // purity parameterization parameter
  static double fgPrimPimPar2; // purity parameterization parameter
  static double fgPrimPipPar0; // purity parameterization parameter 
  static double fgPrimPipPar1; // purity parameterization parameter
  static double fgPrimPipPar2; // purity parameterization parameter
  static double fgPrimPmPar0;  // purity parameterization parameter
  static double fgPrimPmPar1;  // purity parameterization parameter
  static double fgPrimPmPar2;  // purity parameterization parameter
  static double fgPrimPpPar0;  // purity parameterization parameter
  static double fgPrimPpPar1;  // purity parameterization parameter
  static double fgPrimPpPar2;  // purity parameterization parameter

   // For V0 Daugthers TpcEntrance/ExitPoints
  AliFemtoThreeVector fPrimaryVertex;   // primary vertex of V0
  AliFemtoThreeVector fSecondaryVertex; // secondary vertex of V0

  AliFmPhysicalHelixD fHelixV0Pos;            // helix for positive V0 daughter		   
  AliFemtoThreeVector fTpcV0PosEntrancePoint; // positive V0 daughter entrance point to TPC
  AliFemtoThreeVector fTpcV0PosExitPoint;     // positive V0 daughter exit point from TPC  

  AliFmPhysicalHelixD fHelixV0Neg;            // helix for negative V0 daughter		   
  AliFemtoThreeVector fTpcV0NegEntrancePoint; // negative V0 daughter entrance point to TPC
  AliFemtoThreeVector fTpcV0NegExitPoint;     // negative V0 daughter exit point from TPC  
};

inline AliFemtoTrack* AliFemtoParticle::Track() const { return fTrack; }
inline int  AliFemtoParticle::TrackId() const { return fTrack->TrackId(); }
inline const AliFemtoLorentzVector& AliFemtoParticle::FourMomentum() const {return fFourMomentum;}
inline AliFmPhysicalHelixD& AliFemtoParticle::Helix() {return fHelix;}
//inline unsigned long AliFemtoParticle::TopologyMap(const int word) const {return fMap[word];}
//inline int AliFemtoParticle::NumberOfHits() const {return fNhits;}
//by marek chojnacki to could compile 

inline unsigned long AliFemtoParticle::TopologyMap(const int /* word */) const {return 1;}
inline int AliFemtoParticle::NumberOfHits() const {return 1;}

inline AliFemtoV0* AliFemtoParticle::V0() const { return fV0; }
inline int AliFemtoParticle::NegTrackId() const { return fV0->IdNeg(); }
inline int AliFemtoParticle::PosTrackId() const { return fV0->IdPos(); }
inline const AliFemtoThreeVector AliFemtoParticle::DecayVertexPosition() const {return fV0->DecayVertexV0(); }
// ***
inline AliFemtoHiddenInfo* AliFemtoParticle::GetHiddenInfo() const
{return fHiddenInfo;}
inline const AliFemtoHiddenInfo* AliFemtoParticle::HiddenInfo() const
{return fHiddenInfo;}
inline void AliFemtoParticle::SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo)
{ fHiddenInfo = aHiddenInfo->Clone();}
// ***

inline void AliFemtoParticle::ResetFourMomentum(const AliFemtoLorentzVector& vec){fFourMomentum = vec;}

inline AliFemtoKink* AliFemtoParticle::Kink() const { return fKink; }

#endif
Commit	Line	Data
76ce4b5b	1	///////////////////////////////////////////////////////////////////////////
	2	// //
	3	// AliFemtoParticle: main class halding all the necessary information //
	4	// about a particle that is required during femtoscopic analysis //
	5	// //
	6	///////////////////////////////////////////////////////////////////////////
	7
	8	#ifndef ALIFEMTOPARTICLE_H
	9	#define ALIFEMTOPARTICLE_H
	10
	11	//#include "math.h"
	12	#include "AliFemtoTypes.h"
	13	#include "AliFemtoTrack.h"
	14	#include "AliFemtoV0.h"
	15	#include "AliFemtoKink.h"
	16	#include "AliFemtoXi.h"
	17	#include "AliFmPhysicalHelixD.h"
	18	// ***
	19	class AliFemtoHiddenInfo;
	20	// ***
	21	class AliFemtoParticle{
	22	public:
	23	AliFemtoParticle();
	24	AliFemtoParticle(const AliFemtoParticle& aParticle);
	25	AliFemtoParticle(const AliFemtoTrack* const hbtTrack, const double& mass);
	26	AliFemtoParticle(const AliFemtoV0* const hbtV0, const double& mass);
	27	AliFemtoParticle(const AliFemtoKink* const hbtKink, const double& mass);
	28	AliFemtoParticle(const AliFemtoXi* const hbtXi, const double& mass);
	29	~AliFemtoParticle();
	30
	31	AliFemtoParticle& operator=(const AliFemtoParticle& aParticle);
	32
	33	const AliFemtoLorentzVector& FourMomentum() const;
	34
	35	AliFmPhysicalHelixD& Helix();
	36
	37	const AliFemtoThreeVector DecayVertexPosition() const;
	38	unsigned long TopologyMap(const int word) const;
	39	int NumberOfHits() const;
	40
973a91f8	41	int TrackId() const; // only for particles from tracks
	42	int NegTrackId() const; // only for particles from v0
	43	int PosTrackId() const; // only for particles from v0
76ce4b5b	44
	45	AliFemtoTrack* Track() const;
	46	AliFemtoV0* V0() const;
	47	AliFemtoKink* Kink() const;
	48
	49	/* const AliFemtoThreeVector& NominalTpcExitPoint() const; // position track exits TPC assuming start at (0,0,0) */
	50	/* const AliFemtoThreeVector& NominalTpcEntrancePoint() const; // position track crosses IFC assuming start at (0,0,0) */
	51	const AliFemtoThreeVector& TpcV0PosExitPoint() const;
	52	const AliFemtoThreeVector& TpcV0PosEntrancePoint() const;
	53	const AliFemtoThreeVector& TpcV0NegExitPoint() const;
	54	const AliFemtoThreeVector& TpcV0NegEntrancePoint() const;
	55
	56	// the following method is for explicit internal calculation to fill datamembers.
	57	// It is invoked automatically if AliFemtoParticle constructed from AliFemtoTrack
	58	// void CalculateNominalTpcExitAndEntrancePoints();
	59	// NOTE - this requires the fHelix, so be sure this is filled
	60
	61
	62	/* AliFemtoThreeVector fNominalPosSample[11]; // I make this public for convenience and speed of AliFemtoPair() */
	63	/* float fZ[45]; // Z position of cluster on padrow */
	64	/* float fU[45]; // U position of cluster on padrow */
	65	/* int fSect[45]; // Sector number of cluster on padrow */
	66
	67	void ResetFourMomentum(const AliFemtoLorentzVector& fourMomentum);
	68
	69	const AliFemtoHiddenInfo* HiddenInfo() const;
	70	// Fab private
	71	AliFemtoHiddenInfo* GetHiddenInfo() const;
	72	void SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo);
	73	void CalculatePurity();
	74	double GetPionPurity();
	75	double GetKaonPurity();
	76	double GetProtonPurity();
	77	/* void CalculateTpcExitAndEntrancePoints( AliFmPhysicalHelixD* tHelix, */
	78	/* AliFemtoThreeVector* PrimVert, */
	79	/* AliFemtoThreeVector* SecVert, */
	80	/* AliFemtoThreeVector* tmpTpcEntrancePoint, */
	81	/* AliFemtoThreeVector* tmpTpcExitPoint, */
	82	/* AliFemtoThreeVector* tmpPosSample, */
	83	/* float* tmpZ,float* tmpU,int* tmpSect); */
	84
	85	// For V0 Neg Daugthers TpcEntrance/ExitPoints
	86	/* AliFemtoThreeVector* fTpcV0NegPosSample; // Sample of TPC V0 neg */
	87	/* float* fV0NegZ; // Array of Neg Z cluster positions */
	88	/* float* fV0NegU; // Array of Neg U cluster positions */
	89	/* int* fV0NegSect; // Array of Neg cluster sectors */
	90
	91	private:
	92	AliFemtoTrack* fTrack; // copy of the track the particle was formed of, else Null
	93	AliFemtoV0* fV0; // copy of the v0 the particle was formed of, else Null
	94	AliFemtoKink* fKink; // copy of the v0 the particle was formed of, else Null
	95	AliFemtoXi* fXi; // copy of the Xi the particle was formed of, else Null
	96
	97	AliFemtoLorentzVector fFourMomentum; // Particle momentum
	98	AliFmPhysicalHelixD fHelix; // Particle trajectory helix
	99	//unsigned long fMap[2];
	100	//int fNhits;
	101	/* AliFemtoThreeVector fNominalTpcExitPoint; // Point where particle exits TPC */
	102	/* AliFemtoThreeVector fNominalTpcEntrancePoint; // Point where particle enters TPC */
	103	AliFemtoHiddenInfo* fHiddenInfo; // Fab private
	104
	105	double fPurity[6]; // Purity variables
	106
	107	static double fgPrimPimPar0; // purity parameterization parameter
108	static double fgPrimPimPar1; // purity parameterization parameter
109	static double fgPrimPimPar2; // purity parameterization parameter
110	static double fgPrimPipPar0; // purity parameterization parameter
111	static double fgPrimPipPar1; // purity parameterization parameter
112	static double fgPrimPipPar2; // purity parameterization parameter
113	static double fgPrimPmPar0; // purity parameterization parameter
114	static double fgPrimPmPar1; // purity parameterization parameter
115	static double fgPrimPmPar2; // purity parameterization parameter
116	static double fgPrimPpPar0; // purity parameterization parameter
117	static double fgPrimPpPar1; // purity parameterization parameter
118	static double fgPrimPpPar2; // purity parameterization parameter
119
120	// For V0 Daugthers TpcEntrance/ExitPoints
121	AliFemtoThreeVector fPrimaryVertex; // primary vertex of V0
122	AliFemtoThreeVector fSecondaryVertex; // secondary vertex of V0
123
124	AliFmPhysicalHelixD fHelixV0Pos; // helix for positive V0 daughter
125	AliFemtoThreeVector fTpcV0PosEntrancePoint; // positive V0 daughter entrance point to TPC
126	AliFemtoThreeVector fTpcV0PosExitPoint; // positive V0 daughter exit point from TPC
127
128	AliFmPhysicalHelixD fHelixV0Neg; // helix for negative V0 daughter
129	AliFemtoThreeVector fTpcV0NegEntrancePoint; // negative V0 daughter entrance point to TPC
130	AliFemtoThreeVector fTpcV0NegExitPoint; // negative V0 daughter exit point from TPC
131	};
132
133	inline AliFemtoTrack* AliFemtoParticle::Track() const { return fTrack; }
973a91f8	134	inline int AliFemtoParticle::TrackId() const { return fTrack->TrackId(); }
76ce4b5b	135	inline const AliFemtoLorentzVector& AliFemtoParticle::FourMomentum() const {return fFourMomentum;}
	136	inline AliFmPhysicalHelixD& AliFemtoParticle::Helix() {return fHelix;}
	137	//inline unsigned long AliFemtoParticle::TopologyMap(const int word) const {return fMap[word];}
	138	//inline int AliFemtoParticle::NumberOfHits() const {return fNhits;}
	139	//by marek chojnacki to could compile
	140
	141	inline unsigned long AliFemtoParticle::TopologyMap(const int /* word */) const {return 1;}
	142	inline int AliFemtoParticle::NumberOfHits() const {return 1;}
	143
	144	inline AliFemtoV0* AliFemtoParticle::V0() const { return fV0; }
973a91f8	145	inline int AliFemtoParticle::NegTrackId() const { return fV0->IdNeg(); }
973a91f8	146	inline int AliFemtoParticle::PosTrackId() const { return fV0->IdPos(); }
76ce4b5b	147	inline const AliFemtoThreeVector AliFemtoParticle::DecayVertexPosition() const {return fV0->DecayVertexV0(); }
	148	// ***
	149	inline AliFemtoHiddenInfo* AliFemtoParticle::GetHiddenInfo() const
	150	{return fHiddenInfo;}
	151	inline const AliFemtoHiddenInfo* AliFemtoParticle::HiddenInfo() const
	152	{return fHiddenInfo;}
	153	inline void AliFemtoParticle::SetHiddenInfo(AliFemtoHiddenInfo* aHiddenInfo)
	154	{ fHiddenInfo = aHiddenInfo->Clone();}
	155	// ***
	156
	157	inline void AliFemtoParticle::ResetFourMomentum(const AliFemtoLorentzVector& vec){fFourMomentum = vec;}
	158
	159	inline AliFemtoKink* AliFemtoParticle::Kink() const { return fKink; }
	160
	161	#endif