[u/mrichter/AliRoot.git] / RICH / AliRICHRecon.h

#ifndef AliRICHRecon_h
#define AliRICHRecon_h

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// AliRICHRecon                                                         //
//                                                                      //
// RICH class to perfom pattern recognition based on Hough transfrom    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


#include <TTask.h> //base class

class AliRICHHelix;
class AliRICHParam;
class TClonesArray;
class AliRICHRecon : public TTask 
{
public : 
             AliRICHRecon();
    virtual ~AliRICHRecon()                                                          {}

  Double_t ThetaCerenkov(AliRICHHelix *pHelix,TClonesArray *pCluLst,Int_t &iMipId);                  // it returns reconstructed Theta Cerenkov
  void FindThetaPhotonCerenkov();             //
  void FindAreaAndPortionOfRing();            //
  void FindPhotonAnglesInDRS();               //
  void FindPhiPoint();                        //
  void FindThetaAtQuartz(Float_t ThetaCer);   //
  Double_t HoughResponse (              );                   //most probable track theta ckov out of all photon candidate thetas 
  Int_t    FlagPhotons   (Double_t theta);                   //n. of photon candidates which thetas are inside a window around most probable track theta ckov
  void FindThetaCerenkov(Int_t iNclus);       //
  void FindIntersectionWithDetector();        //
  Float_t Cerenkovangle(Float_t n, Float_t b);//
  Int_t   PhotonInBand();                     //
  Int_t   CheckDetectorAcceptance() const;    //
  Int_t   GetFittedHoughPhotons()                   const{ return fFittedHoughPhotons;}             //
  Int_t   GetPhotonFlag()                           const{ return fPhotonFlag[fPhotonIndex];}       //
  Int_t   GetPhotonsNumber()                        const{ return fPhotonsNumber;}                  //
  Int_t   GetPhotonIndex()                          const{ return fPhotonIndex;}                    //
  Float_t GetPhotonEnergy()                         const{ return fEphot;}                          //
  Float_t GetEmissionPoint()                        const{ return fLengthEmissionPoint;}            //
  Float_t GetMassHypotesis()                        const{ return fMassHypotesis;}                  //
  Float_t GetBetaOfParticle()                       const{ return fTrackBeta;}                      //
  Float_t GetEntranceX()                            const{ return fXtoentr;}                        //
  Float_t GetEntranceY()                            const{ return fYtoentr;}                        //
  Float_t GetThetaCerenkov()                        const{ return fThetaCerenkov;}                  //
  Float_t GetThetaPhotonCerenkov()                  const{ return fThetaPhotonCerenkov;}            //
  Float_t GetTrackTheta()                           const{ return fTrackTheta;}                     //
  Float_t GetTrackPhi()                             const{ return fTrackPhi;}                       //
  Float_t GetXPointOnCathode()                      const{ return fPhotonLimitX;}                   //
  Float_t GetYPointOnCathode()                      const{ return fPhotonLimitY;}                   //
  Float_t GetThetaPhotonInDRS()                     const{ return fThetaPhotonInDRS;}               //
  Float_t GetPhiPhotonInDRS()                       const{ return fPhiPhotonInDRS;}                 //
  Float_t GetThetaPhotonInTRS()                     const{ return fThetaPhotonInTRS;}               //
  Float_t GetPhiPhotonInTRS()                       const{ return fPhiPhotonInTRS;}                 //
  Float_t GetThetaAtQuartz()                        const{ return fThetaAtQuartz;}                  //
  Float_t GetPhiPoint()                             const{ return fPhiPoint[fPhotonIndex];}         //
  Float_t GetXCoordOfEmission()                     const{ return fXEmiss;}                         //
  Float_t GetYCoordOfEmission()                     const{ return fYEmiss;}                         //
  Float_t GetXInnerRing()                           const{ return fXInner;}                         //
  Float_t GetYInnerRing()                           const{ return fYInner;}                         //
  Float_t GetRadiusInnerRing()                      const{ return fInnerRadius;}                    //
  Float_t GetXOuterRing()                           const{ return fXOuter;}                         //
  Float_t GetYOuterRing()                           const{ return fYOuter;}                         //
  Float_t GetRadiusOuterRing()                      const{ return fOuterRadius;}                    //
  Float_t GetShiftX()                               const{ return fShiftX;}                         //
  Float_t GetShiftY()                               const{ return fShiftY;}                         //
  Float_t GetDetectorWhereX()                       const{ return fXcoord;}                         //
  Float_t GetDetectorWhereY()                       const{ return fYcoord;}                         //
  Float_t GetIntersectionX()                        const{ return fIntersectionX;}                  //
  Float_t GetIntersectionY()                        const{ return fIntersectionY;}                  //
  Float_t GetThetaOfRing()                          const{ return fThetaOfRing;}                    //
  Float_t GetAreaOfRing()                           const{ return fAreaOfRing;}                     //
  Float_t GetPortionOfRing()                        const{ return fPortionOfRing;}                  //
  Float_t GetHoughArea()                            const{ return fHoughArea;}                      //
  Float_t GetPhotonEta()                            const{ return fPhotonEta[fPhotonIndex];}        //
  Float_t GetPhotonWeight()                         const{ return fPhotonWeight[fPhotonIndex];}     //
  Float_t GetHoughRMS()                             const{ return fHoughRMS;}                       //
  Double_t GetPhotBKG()                             const{ return fnPhotBKG;}                       //
  Float_t GetFittedTrackTheta()                     const{ return fFittedTrackTheta;}               //
  Float_t GetFittedTrackPhi()                       const{ return fFittedTrackPhi;}                 //
  Float_t GetFittedThetaCerenkov()                  const{ return fFittedThetaCerenkov;}            //
  Float_t GetRingSigma2()                           const{ return fRingSigma2;}                     //
  void    SetPhotonEnergy(Float_t e)                     { fEphot = e;}                             //
  void SetEmissionPoint(Float_t LengthEmissionPoint) { fLengthEmissionPoint = LengthEmissionPoint;} //
  void SetEntranceX(Float_t Xtoentr) { fXtoentr = Xtoentr;}                                         //
  void SetEntranceY(Float_t Ytoentr) { fYtoentr = Ytoentr;}                                         //
  void SetThetaPhotonInTRS(Float_t Theta) {fThetaPhotonInTRS = Theta;}                              //
  void SetPhiPhotonInTRS(Float_t Phi) {fPhiPhotonInTRS = Phi;}                                      //
  void SetThetaPhotonInDRS(Float_t Theta) {fThetaPhotonInDRS = Theta;}                              //
  void SetPhiPhotonInDRS(Float_t Phi) {fPhiPhotonInDRS = Phi;}                                      //
  void SetThetaAtQuartz(Float_t ThetaAtQuartz) {fThetaAtQuartz = ThetaAtQuartz;}                    //
  void SetPhiPoint(Float_t PhiPoint){ fPhiPoint[fPhotonIndex] = PhiPoint;}                          //
  void SetXCoordOfEmission(Float_t XEmiss) {fXEmiss = XEmiss;}                                      //
  void SetYCoordOfEmission(Float_t YEmiss) {fYEmiss = YEmiss;}                                      //
  void SetXPointOnCathode(Float_t PhotonLimitX) { fPhotonLimitX = PhotonLimitX;}                    //
  void SetYPointOnCathode(Float_t PhotonLimitY) { fPhotonLimitY = PhotonLimitY;}                    //
  void SetXInnerRing(Float_t XInner) {fXInner = XInner;}                                            //
  void SetYInnerRing(Float_t YInner) {fYInner = YInner;}                                            //
  void SetRadiusInnerRing(Float_t InnerRadius) {fInnerRadius = InnerRadius;}                        //
  void SetXOuterRing(Float_t XOuter) {fXOuter = XOuter;}                                            //
  void SetYOuterRing(Float_t YOuter) {fYOuter = YOuter;}                                            //
  void SetRadiusOuterRing(Float_t OuterRadius) {fOuterRadius = OuterRadius;}                        //
  void SetThetaCerenkov(Float_t ThetaCer) {fThetaCerenkov = ThetaCer;}                              //
  void SetThetaPhotonCerenkov(Float_t ThetaPhotCer) {fThetaPhotonCerenkov = ThetaPhotCer;}          //
  void SetTrackTheta(Float_t TrackTheta) { fTrackTheta = TrackTheta;}                               //
  void SetTrackPhi(Float_t TrackPhi) { fTrackPhi = TrackPhi;}                                       //
  void SetShiftX(Float_t ShiftX) { fShiftX = ShiftX;}                                               //
  void SetShiftY(Float_t ShiftY) { fShiftY = ShiftY;}                                               //
  void SetDetectorWhereX(Float_t Xcoord) { fXcoord = Xcoord;}                                       //
  void SetDetectorWhereY(Float_t Ycoord) { fYcoord = Ycoord;}                                       //
  void SetIntersectionX(Float_t IntersectionX) { fIntersectionX = IntersectionX;}                   //
  void SetIntersectionY(Float_t IntersectionY) { fIntersectionY = IntersectionY;}                   //
  void SetThetaOfRing(Float_t ThetaOfRing) { fThetaOfRing = ThetaOfRing;}                           //
  void SetAreaOfRing(Float_t AreaOfRing) { fAreaOfRing = AreaOfRing;}                               //
  void SetPortionOfRing(Float_t PortionOfRing) { fPortionOfRing = PortionOfRing;}                   //
  void SetHoughArea(Float_t HoughArea) { fHoughArea = HoughArea;}                                   //
  void SetPhotonsNumber(Int_t PhotonsNumber) { fPhotonsNumber = PhotonsNumber;}                     //
  void SetPhotonIndex(Int_t PhotonIndex) { fPhotonIndex = PhotonIndex;}                             //
  void SetPhotonEta(Float_t PhotonEta) { fPhotonEta[fPhotonIndex] = PhotonEta;}                     //
  void SetPhotonFlag(Int_t PhotonFlag) { fPhotonFlag[fPhotonIndex] = PhotonFlag;}                   //
  void SetPhotonWeight(Float_t PhotonWeight) { fPhotonWeight[fPhotonIndex] = PhotonWeight;}         //
  void SetPhotBKG(Double_t nPhotBKG) {fnPhotBKG=nPhotBKG;}                                          //
  void SetHoughRMS(Float_t HoughRMS) { fHoughRMS = HoughRMS;}                                       //
  void SetFittedTrackTheta(Float_t FittedTrackTheta)    { fFittedTrackTheta = FittedTrackTheta;}    //
  void SetFittedTrackPhi(Float_t FittedTrackPhi)    { fFittedTrackPhi = FittedTrackPhi;}            //
  void SetFittedThetaCerenkov(Float_t FittedThetaCerenkov) { fFittedThetaCerenkov = FittedThetaCerenkov;}//
  void SetFittedHoughPhotons(Int_t FittedHoughPhotons) { fFittedHoughPhotons = FittedHoughPhotons;} //
  void SetRingSigma2(Float_t RingSigma2) { fRingSigma2 = RingSigma2;} //
  Float_t SnellAngle(Float_t n1, Float_t n2, Float_t theta1);                                       //
  Float_t FromEmissionToCathode();                                                                  //

protected:
  Int_t fPhotonsNumber;                       // Number of photons candidate
  Int_t fPhotonIndex;                         // index of photons
  Int_t fPhotonFlag[3000];                    // flag for photons
  Int_t   fFittedHoughPhotons;                // n. photons after Hough and after minimization
  Int_t fMinNumPhots;                         // minimum number of photons for a given ring

  Float_t fTrackTheta;                        // Theta of track at RICH
  Float_t fTrackPhi;                          // Phi of track at RICH
  Float_t fMinDist;                           // min distance between extrapolated track and MIP
  Float_t fTrackBeta;                         // beta of the track
  Float_t fXtoentr;                           // X entrance to RICH
  Float_t fYtoentr;                           // Y entrance to RICH
  Float_t fThetaPhotonInTRS;                  // Theta of photon in the Track Reference System (TRS)
  Float_t fPhiPhotonInTRS;                    // Phi of photon in TRS
  Float_t fThetaPhotonInDRS;                  // Theta of photon in Detector Reference System (DRS)
  Float_t fPhiPhotonInDRS;                    // Phi of photon in DRS
  Float_t fThetaAtQuartz;                     // Theta at the quartz entrance
  Float_t fPhiPoint[3000];                    // array of phi of ring photons
  Float_t fXEmiss;                            //  x emission
  Float_t fYEmiss;                            //  y emission
  Float_t fXInner;                            // X inner ring
  Float_t fYInner;                            // Y inner ring
  Float_t fXOuter;                            // X outer ring
  Float_t fYOuter;                            // Y outer ring
  Float_t fInnerRadius;                       // inner radius
  Float_t fOuterRadius;                       // outer radius
  Float_t fEphot;                             // photon energy
  Float_t fLengthEmissionPoint;               // lenght of emmission point
  Float_t fPhotonLimitX;                      // X phys limit for photon
  Float_t fPhotonLimitY;                      // Y phys limit for photon 
  Float_t fDistanceFromCluster;               // distance from cluster
  Float_t fCerenkovAnglePad;                  // cherenkov angle of pad
  Float_t fThetaPhotonCerenkov;               // theta cerenkov for photon
  Float_t fShiftX;                            // x shift to entrance in radiator
  Float_t fShiftY;                            // y shift to entrance in radiator
  Float_t fXcoord;                            // ..
  Float_t fYcoord;                            // ..
  Float_t fIntersectionX;                     // ..
  Float_t fIntersectionY;                     // ..
  Float_t fMassHypotesis;                     //
  Float_t fThetaOfRing;                       // theta of ring
  Float_t fAreaOfRing;                        // area of the ring
  Float_t fPortionOfRing;                     // fraction of the accepted ring
  Float_t fHoughArea;                         // area Hough
  Float_t fPhotonEta[3000];                   // theta cerenkov of photon candidates
  Float_t fPhotonWeight[3000];                // weigth
  Float_t fHoughRMS;                          // rms Hough
  Float_t fFittedTrackTheta;                  // theta track after minim.
  Float_t fFittedTrackPhi;                    // phi track after minim.
  Float_t fFittedThetaCerenkov;               // thetacerenkov after minim.
  Float_t fThetaMin,fThetaMax;                // min max
  Bool_t  fIsWEIGHT;                          // flag to consider weight procedure
  Bool_t  fIsBACKGROUND;                      // flag to simulate bkg
  Float_t fDTheta;                            // Step for sliding window
  Float_t fWindowWidth;                       // Hough width of sliding window
  
  Int_t   fNumEtaPhotons;                     // Number of photons
  Int_t   fEtaFlag[3000];                     // flag for good photons
  Float_t fEtaPhotons[3000];                  // Cerenkov angle each photon
  Float_t fWeightPhotons[3000];               // weight for each photon
  Double_t fnPhotBKG;                         // # estimated BKG photons in the ring
  Float_t fThetaCerenkov;                     // Theta angle for Hough
  Float_t fWeightThetaCerenkov;               // Theta Cerenkov angle weighted
  Float_t fThetaPeakPos;                      // Peak position
  Float_t fRingSigma2;                        // sigma2 of the reconstructed ring
  ClassDef(AliRICHRecon,0)
};
    
#endif // #ifdef AliRICHRecon_cxx
Commit	Line	Data
5cb4dfc3	1	#ifndef AliRICHRecon_h
	2	#define AliRICHRecon_h
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
88dd9ad4	7	//////////////////////////////////////////////////////////////////////////
	8	// //
	9	// AliRICHRecon //
	10	// //
	11	// RICH class to perfom pattern recognition based on Hough transfrom //
	12	// //
	13	//////////////////////////////////////////////////////////////////////////
	14
	15
db910db9	16	#include <TTask.h> //base class
5cb4dfc3	17
998b831f	18	class AliRICHHelix;
db910db9	19	class AliRICHParam;
db910db9	20	class TClonesArray;
b068561d	21	class AliRICHRecon : public TTask
	22	{
	23	public :
db910db9	24	AliRICHRecon();
db910db9	25	virtual ~AliRICHRecon() {}
5cb4dfc3	26
db910db9	27	Double_t ThetaCerenkov(AliRICHHelix pHelix,TClonesArray pCluLst,Int_t &iMipId); // it returns reconstructed Theta Cerenkov
88dd9ad4	28	void FindThetaPhotonCerenkov(); //
88dd9ad4	29	void FindAreaAndPortionOfRing(); //
88dd9ad4	30	void FindPhotonAnglesInDRS(); //
	31	void FindPhiPoint(); //
	32	void FindThetaAtQuartz(Float_t ThetaCer); //
db910db9	33	Double_t HoughResponse ( ); //most probable track theta ckov out of all photon candidate thetas
db910db9	34	Int_t FlagPhotons (Double_t theta); //n. of photon candidates which thetas are inside a window around most probable track theta ckov
4c3a1f92	35	void FindThetaCerenkov(Int_t iNclus); //
88dd9ad4	36	void FindIntersectionWithDetector(); //
88dd9ad4	37	Float_t Cerenkovangle(Float_t n, Float_t b);//
88dd9ad4	38	Int_t PhotonInBand(); //
88dd9ad4	39	Int_t CheckDetectorAcceptance() const; //
	40	Int_t GetFittedHoughPhotons() const{ return fFittedHoughPhotons;} //
	41	Int_t GetPhotonFlag() const{ return fPhotonFlag[fPhotonIndex];} //
88dd9ad4	42	Int_t GetPhotonsNumber() const{ return fPhotonsNumber;} //
88dd9ad4	43	Int_t GetPhotonIndex() const{ return fPhotonIndex;} //
db910db9	44	Float_t GetPhotonEnergy() const{ return fEphot;} //
88dd9ad4	45	Float_t GetEmissionPoint() const{ return fLengthEmissionPoint;} //
	46	Float_t GetMassHypotesis() const{ return fMassHypotesis;} //
	47	Float_t GetBetaOfParticle() const{ return fTrackBeta;} //
	48	Float_t GetEntranceX() const{ return fXtoentr;} //
	49	Float_t GetEntranceY() const{ return fYtoentr;} //
	50	Float_t GetThetaCerenkov() const{ return fThetaCerenkov;} //
	51	Float_t GetThetaPhotonCerenkov() const{ return fThetaPhotonCerenkov;} //
88dd9ad4	52	Float_t GetTrackTheta() const{ return fTrackTheta;} //
88dd9ad4	53	Float_t GetTrackPhi() const{ return fTrackPhi;} //
88dd9ad4	54	Float_t GetXPointOnCathode() const{ return fPhotonLimitX;} //
	55	Float_t GetYPointOnCathode() const{ return fPhotonLimitY;} //
	56	Float_t GetThetaPhotonInDRS() const{ return fThetaPhotonInDRS;} //
	57	Float_t GetPhiPhotonInDRS() const{ return fPhiPhotonInDRS;} //
	58	Float_t GetThetaPhotonInTRS() const{ return fThetaPhotonInTRS;} //
	59	Float_t GetPhiPhotonInTRS() const{ return fPhiPhotonInTRS;} //
	60	Float_t GetThetaAtQuartz() const{ return fThetaAtQuartz;} //
101624cd	61	Float_t GetPhiPoint() const{ return fPhiPoint[fPhotonIndex];} //
88dd9ad4	62	Float_t GetXCoordOfEmission() const{ return fXEmiss;} //
	63	Float_t GetYCoordOfEmission() const{ return fYEmiss;} //
	64	Float_t GetXInnerRing() const{ return fXInner;} //
	65	Float_t GetYInnerRing() const{ return fYInner;} //
	66	Float_t GetRadiusInnerRing() const{ return fInnerRadius;} //
	67	Float_t GetXOuterRing() const{ return fXOuter;} //
	68	Float_t GetYOuterRing() const{ return fYOuter;} //
	69	Float_t GetRadiusOuterRing() const{ return fOuterRadius;} //
	70	Float_t GetShiftX() const{ return fShiftX;} //
	71	Float_t GetShiftY() const{ return fShiftY;} //
	72	Float_t GetDetectorWhereX() const{ return fXcoord;} //
	73	Float_t GetDetectorWhereY() const{ return fYcoord;} //
	74	Float_t GetIntersectionX() const{ return fIntersectionX;} //
	75	Float_t GetIntersectionY() const{ return fIntersectionY;} //
	76	Float_t GetThetaOfRing() const{ return fThetaOfRing;} //
	77	Float_t GetAreaOfRing() const{ return fAreaOfRing;} //
	78	Float_t GetPortionOfRing() const{ return fPortionOfRing;} //
	79	Float_t GetHoughArea() const{ return fHoughArea;} //
	80	Float_t GetPhotonEta() const{ return fPhotonEta[fPhotonIndex];} //
	81	Float_t GetPhotonWeight() const{ return fPhotonWeight[fPhotonIndex];} //
	82	Float_t GetHoughRMS() const{ return fHoughRMS;} //
fab9e039	83	Double_t GetPhotBKG() const{ return fnPhotBKG;} //
88dd9ad4	84	Float_t GetFittedTrackTheta() const{ return fFittedTrackTheta;} //
	85	Float_t GetFittedTrackPhi() const{ return fFittedTrackPhi;} //
	86	Float_t GetFittedThetaCerenkov() const{ return fFittedThetaCerenkov;} //
84093f6f	87	Float_t GetRingSigma2() const{ return fRingSigma2;} //
84093f6f	88	void SetPhotonEnergy(Float_t e) { fEphot = e;} //
88dd9ad4	89	void SetEmissionPoint(Float_t LengthEmissionPoint) { fLengthEmissionPoint = LengthEmissionPoint;} //
88dd9ad4	90	void SetEntranceX(Float_t Xtoentr) { fXtoentr = Xtoentr;} //
	91	void SetEntranceY(Float_t Ytoentr) { fYtoentr = Ytoentr;} //
	92	void SetThetaPhotonInTRS(Float_t Theta) {fThetaPhotonInTRS = Theta;} //
	93	void SetPhiPhotonInTRS(Float_t Phi) {fPhiPhotonInTRS = Phi;} //
	94	void SetThetaPhotonInDRS(Float_t Theta) {fThetaPhotonInDRS = Theta;} //
	95	void SetPhiPhotonInDRS(Float_t Phi) {fPhiPhotonInDRS = Phi;} //
	96	void SetThetaAtQuartz(Float_t ThetaAtQuartz) {fThetaAtQuartz = ThetaAtQuartz;} //
101624cd	97	void SetPhiPoint(Float_t PhiPoint){ fPhiPoint[fPhotonIndex] = PhiPoint;} //
88dd9ad4	98	void SetXCoordOfEmission(Float_t XEmiss) {fXEmiss = XEmiss;} //
	99	void SetYCoordOfEmission(Float_t YEmiss) {fYEmiss = YEmiss;} //
	100	void SetXPointOnCathode(Float_t PhotonLimitX) { fPhotonLimitX = PhotonLimitX;} //
	101	void SetYPointOnCathode(Float_t PhotonLimitY) { fPhotonLimitY = PhotonLimitY;} //
	102	void SetXInnerRing(Float_t XInner) {fXInner = XInner;} //
	103	void SetYInnerRing(Float_t YInner) {fYInner = YInner;} //
	104	void SetRadiusInnerRing(Float_t InnerRadius) {fInnerRadius = InnerRadius;} //
	105	void SetXOuterRing(Float_t XOuter) {fXOuter = XOuter;} //
	106	void SetYOuterRing(Float_t YOuter) {fYOuter = YOuter;} //
	107	void SetRadiusOuterRing(Float_t OuterRadius) {fOuterRadius = OuterRadius;} //
	108	void SetThetaCerenkov(Float_t ThetaCer) {fThetaCerenkov = ThetaCer;} //
	109	void SetThetaPhotonCerenkov(Float_t ThetaPhotCer) {fThetaPhotonCerenkov = ThetaPhotCer;} //
88dd9ad4	110	void SetTrackTheta(Float_t TrackTheta) { fTrackTheta = TrackTheta;} //
88dd9ad4	111	void SetTrackPhi(Float_t TrackPhi) { fTrackPhi = TrackPhi;} //
88dd9ad4	112	void SetShiftX(Float_t ShiftX) { fShiftX = ShiftX;} //
	113	void SetShiftY(Float_t ShiftY) { fShiftY = ShiftY;} //
	114	void SetDetectorWhereX(Float_t Xcoord) { fXcoord = Xcoord;} //
	115	void SetDetectorWhereY(Float_t Ycoord) { fYcoord = Ycoord;} //
	116	void SetIntersectionX(Float_t IntersectionX) { fIntersectionX = IntersectionX;} //
	117	void SetIntersectionY(Float_t IntersectionY) { fIntersectionY = IntersectionY;} //
	118	void SetThetaOfRing(Float_t ThetaOfRing) { fThetaOfRing = ThetaOfRing;} //
	119	void SetAreaOfRing(Float_t AreaOfRing) { fAreaOfRing = AreaOfRing;} //
	120	void SetPortionOfRing(Float_t PortionOfRing) { fPortionOfRing = PortionOfRing;} //
	121	void SetHoughArea(Float_t HoughArea) { fHoughArea = HoughArea;} //
	122	void SetPhotonsNumber(Int_t PhotonsNumber) { fPhotonsNumber = PhotonsNumber;} //
	123	void SetPhotonIndex(Int_t PhotonIndex) { fPhotonIndex = PhotonIndex;} //
	124	void SetPhotonEta(Float_t PhotonEta) { fPhotonEta[fPhotonIndex] = PhotonEta;} //
	125	void SetPhotonFlag(Int_t PhotonFlag) { fPhotonFlag[fPhotonIndex] = PhotonFlag;} //
	126	void SetPhotonWeight(Float_t PhotonWeight) { fPhotonWeight[fPhotonIndex] = PhotonWeight;} //
fab9e039	127	void SetPhotBKG(Double_t nPhotBKG) {fnPhotBKG=nPhotBKG;} //
88dd9ad4	128	void SetHoughRMS(Float_t HoughRMS) { fHoughRMS = HoughRMS;} //
88dd9ad4	129	void SetFittedTrackTheta(Float_t FittedTrackTheta) { fFittedTrackTheta = FittedTrackTheta;} //
	130	void SetFittedTrackPhi(Float_t FittedTrackPhi) { fFittedTrackPhi = FittedTrackPhi;} //
	131	void SetFittedThetaCerenkov(Float_t FittedThetaCerenkov) { fFittedThetaCerenkov = FittedThetaCerenkov;}//
	132	void SetFittedHoughPhotons(Int_t FittedHoughPhotons) { fFittedHoughPhotons = FittedHoughPhotons;} //
84093f6f	133	void SetRingSigma2(Float_t RingSigma2) { fRingSigma2 = RingSigma2;} //
88dd9ad4	134	Float_t SnellAngle(Float_t n1, Float_t n2, Float_t theta1); //
	135	Float_t FromEmissionToCathode(); //
	136
b068561d	137	protected:
88dd9ad4	138	Int_t fPhotonsNumber; // Number of photons candidate
	139	Int_t fPhotonIndex; // index of photons
	140	Int_t fPhotonFlag[3000]; // flag for photons
88dd9ad4	141	Int_t fFittedHoughPhotons; // n. photons after Hough and after minimization
910735ae	142	Int_t fMinNumPhots; // minimum number of photons for a given ring
998b831f	143
88dd9ad4	144	Float_t fTrackTheta; // Theta of track at RICH
88dd9ad4	145	Float_t fTrackPhi; // Phi of track at RICH
88dd9ad4	146	Float_t fMinDist; // min distance between extrapolated track and MIP
	147	Float_t fTrackBeta; // beta of the track
	148	Float_t fXtoentr; // X entrance to RICH
	149	Float_t fYtoentr; // Y entrance to RICH
	150	Float_t fThetaPhotonInTRS; // Theta of photon in the Track Reference System (TRS)
	151	Float_t fPhiPhotonInTRS; // Phi of photon in TRS
	152	Float_t fThetaPhotonInDRS; // Theta of photon in Detector Reference System (DRS)
	153	Float_t fPhiPhotonInDRS; // Phi of photon in DRS
	154	Float_t fThetaAtQuartz; // Theta at the quartz entrance
101624cd	155	Float_t fPhiPoint[3000]; // array of phi of ring photons
88dd9ad4	156	Float_t fXEmiss; // x emission
	157	Float_t fYEmiss; // y emission
	158	Float_t fXInner; // X inner ring
	159	Float_t fYInner; // Y inner ring
	160	Float_t fXOuter; // X outer ring
	161	Float_t fYOuter; // Y outer ring
	162	Float_t fInnerRadius; // inner radius
	163	Float_t fOuterRadius; // outer radius
db910db9	164	Float_t fEphot; // photon energy
88dd9ad4	165	Float_t fLengthEmissionPoint; // lenght of emmission point
	166	Float_t fPhotonLimitX; // X phys limit for photon
	167	Float_t fPhotonLimitY; // Y phys limit for photon
	168	Float_t fDistanceFromCluster; // distance from cluster
88dd9ad4	169	Float_t fCerenkovAnglePad; // cherenkov angle of pad
	170	Float_t fThetaPhotonCerenkov; // theta cerenkov for photon
	171	Float_t fShiftX; // x shift to entrance in radiator
	172	Float_t fShiftY; // y shift to entrance in radiator
	173	Float_t fXcoord; // ..
	174	Float_t fYcoord; // ..
	175	Float_t fIntersectionX; // ..
	176	Float_t fIntersectionY; // ..
998b831f	177	Float_t fMassHypotesis; //
88dd9ad4	178	Float_t fThetaOfRing; // theta of ring
	179	Float_t fAreaOfRing; // area of the ring
	180	Float_t fPortionOfRing; // fraction of the accepted ring
	181	Float_t fHoughArea; // area Hough
	182	Float_t fPhotonEta[3000]; // theta cerenkov of photon candidates
	183	Float_t fPhotonWeight[3000]; // weigth
	184	Float_t fHoughRMS; // rms Hough
88dd9ad4	185	Float_t fFittedTrackTheta; // theta track after minim.
	186	Float_t fFittedTrackPhi; // phi track after minim.
	187	Float_t fFittedThetaCerenkov; // thetacerenkov after minim.
88dd9ad4	188	Float_t fThetaMin,fThetaMax; // min max
88dd9ad4	189	Bool_t fIsWEIGHT; // flag to consider weight procedure
88dd9ad4	190	Bool_t fIsBACKGROUND; // flag to simulate bkg
88dd9ad4	191	Float_t fDTheta; // Step for sliding window
	192	Float_t fWindowWidth; // Hough width of sliding window
	193
	194	Int_t fNumEtaPhotons; // Number of photons
	195	Int_t fEtaFlag[3000]; // flag for good photons
	196	Float_t fEtaPhotons[3000]; // Cerenkov angle each photon
	197	Float_t fWeightPhotons[3000]; // weight for each photon
fab9e039	198	Double_t fnPhotBKG; // # estimated BKG photons in the ring
88dd9ad4	199	Float_t fThetaCerenkov; // Theta angle for Hough
	200	Float_t fWeightThetaCerenkov; // Theta Cerenkov angle weighted
	201	Float_t fThetaPeakPos; // Peak position
84093f6f	202	Float_t fRingSigma2; // sigma2 of the reconstructed ring
b068561d	203	ClassDef(AliRICHRecon,0)
5cb4dfc3	204	};
	205
	206	#endif // #ifdef AliRICHRecon_cxx
	207