[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                               */

#include <TTask.h>
#include "AliRICH.h"
#include <AliRun.h>

class AliRICH;

class AliRICHRecon : public TTask {
   public :
 
   AliRICHRecon(const char*, const char*);
   ~AliRICHRecon(){EndProcessEvent();}

   AliRICH* Rich() {return fRich;}
   void StartProcessEvent();
   void EndProcessEvent();
     
   void InitRecon();

   void PatRec();

   void Minimization();

   void FillHistograms();

   void FindThetaPhotonCerenkov();
   void FindAreaAndPortionOfRing();

   void FindEmissionPoint();

   Int_t PhotonInBand();
   Float_t PhotonPositionOnCathode();

   void FindPhotonAnglesInDRS();
   void FindPhiPoint();
   void FindThetaAtQuartz(Float_t ThetaCerenkov);

   Float_t FindMassOfParticle();

   Float_t Cerenkovangle(Float_t n, Float_t beta);

   void HoughResponse();
   void HoughFiltering(float HCS[]);
   void FlagPhotons();
   void FindWeightThetaCerenkov();

   void EstimationOfTheta();
   void FindIntersectionWithDetector();
   Int_t CheckDetectorAcceptance();

   void DrawRing();
   void DrawEvent(Int_t flag);

   void waiting();

   //////////////////////////////////////
   Float_t GetEventVertexZ() { return fEventVertZ;}
   Float_t GetEventMultiplicity() { return fEventMultiplicity;}
   Float_t GetPhotonEnergy() { return fPhotonEnergy;}
   Float_t GetFreonRefractiveIndex() { return fFreonRefractiveIndex;}
   Float_t GetQuartzRefractiveIndex() { return fQuartzRefractiveIndex;}
   Float_t GetGasRefractiveIndex() { return fGasRefractiveIndex;}

   Float_t GetFreonScaleFactor() { return fFreonScaleFactor;}

   Float_t GetEmissionPoint() { return fLengthEmissionPoint;}
   Float_t GetMassHypotesis() { return fMassHypotesis;}
   Float_t GetBetaOfParticle() { return fTrackBeta;}
   Float_t GetEntranceX() { return fXtoentr;}
   Float_t GetEntranceY() { return fYtoentr;}
   Float_t GetThetaCerenkov() { return fThetaCerenkov;}
   Float_t GetThetaPhotonCerenkov() { return fThetaPhotonCerenkov;}
   Float_t GetTrackMomentum() { return fTrackMomentum;}
   Float_t GetTrackEta() { return fTrackEta;}
   Float_t GetTrackTheta() { return fTrackTheta;}
   Float_t GetTrackPhi() { return fTrackPhi;}
   Float_t GetTrackPt() { return fTrackPt;}
   Int_t   GetTrackCharge() { return fTrackCharge;}
   Float_t GetTrackTPCLastZ() { return fTrackTPCLastZ;}
   Float_t GetMinDist() { return fMinDist;}
   Float_t GetXPointOnCathode() { return fPhotonLimitX;}
   Float_t GetYPointOnCathode() { return fPhotonLimitY;}


   Float_t GetThetaPhotonInDRS() { return fThetaPhotonInDRS;}
   Float_t GetPhiPhotonInDRS() { return fPhiPhotonInDRS;}
   Float_t GetThetaPhotonInTRS() { return fThetaPhotonInTRS;}
   Float_t GetPhiPhotonInTRS() { return fPhiPhotonInTRS;}

   Float_t GetThetaAtQuartz() { return fThetaAtQuartz;}

   Float_t GetPhiPoint(){ return fPhiPoint;}
   Float_t GetXCoordOfEmission() {return fXEmiss;}
   Float_t GetYCoordOfEmission() {return fYEmiss;}

   Float_t GetXInnerRing() {return fXInner;}
   Float_t GetYInnerRing() {return fYInner;}
   Float_t GetRadiusInnerRing() {return fInnerRadius;}

   Float_t GetXOuterRing() {return fXOuter;}
   Float_t GetYOuterRing() {return fYOuter;}
   Float_t GetRadiusOuterRing() {return fOuterRadius;}
   Float_t GetShiftX() { return fShiftX;}
   Float_t GetShiftY() { return fShiftY;}
   Float_t GetDetectorWhereX() { return fXcoord;}
   Float_t GetDetectorWhereY() { return fYcoord;}
   Float_t GetIntersectionX() {return fIntersectionX;}
   Float_t GetIntersectionY() {return fIntersectionY;}

   Float_t GetThetaOfRing() { return fThetaOfRing;}
   Float_t GetAreaOfRing() {return fAreaOfRing;}
   Float_t GetPortionOfRing() {return fPortionOfRing;}
   Float_t GetHoughArea() { return fHoughArea;}

   Int_t   GetPhotonsNumber() { return fPhotonsNumber;}
   Int_t   GetPhotonIndex() { return fPhotonIndex;}
   Float_t GetPhotonEta() { return fPhotonEta[fPhotonIndex];}
   Int_t   GetPhotonFlag() { return fPhotonFlag[fPhotonIndex];}
   Float_t GetPhotonWeight() { return fPhotonWeight[fPhotonIndex];}

   Float_t GetHoughRMS() { return fHoughRMS;}

   Int_t GetMipIndex() { return fMipIndex;}
   Int_t GetTrackIndex() { return fTrackIndex;}
   Float_t* GetCandidatePhotonX() { return fCandidatePhotonX;}
   Float_t* GetCandidatePhotonY() { return fCandidatePhotonY;}
   Int_t GetCandidatePhotonsNumber() { return fCandidatePhotonsNumber;}

   Int_t GetHoughPhotons() { return fHoughPhotons;}
   Float_t GetHoughPhotonsNorm() { return fHoughPhotonsNorm;}

   Float_t GetFittedTrackTheta() { return fFittedTrackTheta;}
   Float_t GetFittedTrackPhi() { return fFittedTrackPhi;}
   Float_t GetFittedThetaCerenkov() { return fFittedThetaCerenkov;}
   Int_t   GetFittedHoughPhotons() { return fFittedHoughPhotons;}
   Float_t GetEstimationOfTheta() { return fEstimationOfTheta;}
   Float_t GetEstimationOfThetaRMS() { return fEstimationOfThetaRMS;}

   void SetEventVertexZ(Float_t EventVertZ) { fEventVertZ = EventVertZ;}
   void SetEventMultiplicity(Float_t EventMultiplicity) { fEventMultiplicity = EventMultiplicity;}
   void SetPhotonEnergy(Float_t PhotonEnergy) { fPhotonEnergy = PhotonEnergy;} 
   void SetFreonRefractiveIndex() {fFreonRefractiveIndex = fFreonScaleFactor*(1.177+0.0172*fPhotonEnergy);}
   void SetQuartzRefractiveIndex() {fQuartzRefractiveIndex = sqrt(1+(46.411/(113.763556-TMath::Power(fPhotonEnergy,2)))+(228.71/(328.51563-TMath::Power(fPhotonEnergy,2))));}
   void SetGasRefractiveIndex() { fGasRefractiveIndex = 1.;}

   void SetFreonScaleFactor(Float_t FreonScaleFactor) {fFreonScaleFactor = FreonScaleFactor;}

   void SetEmissionPoint(Float_t LengthEmissionPoint) { fLengthEmissionPoint = LengthEmissionPoint;}
   void SetMassHypotesis(Float_t mass) {fMassHypotesis = mass;}

   void SetBetaOfParticle() { fTrackBeta = fTrackMomentum/sqrt(TMath::Power(fTrackMomentum,2)+TMath::Power(fMassHypotesis,2));}

   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 = 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 SetTrackMomentum(Float_t TrackMomentum) {fTrackMomentum = TrackMomentum;}
   void SetTrackEta(Float_t TrackEta) {fTrackEta = TrackEta;}
   void SetTrackTheta(Float_t TrackTheta) { fTrackTheta = TrackTheta;}
   void SetTrackPhi(Float_t TrackPhi) { fTrackPhi = TrackPhi;}
   void SetTrackPt(Float_t TrackPt) { fTrackPt = TrackPt;}
   void SetTrackCharge(Int_t TrackCharge) { fTrackCharge = TrackCharge;}
   void SetTrackTPCLastZ(Float_t TrackTPCLastZ) { fTrackTPCLastZ = TrackTPCLastZ;}
   void SetMinDist(Float_t MinDist) { fMinDist = MinDist;}
   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 SetHoughRMS(Float_t HoughRMS) { fHoughRMS = HoughRMS;}
   void SetMipIndex(Int_t MipIndex) { fMipIndex = MipIndex;}
   void SetTrackIndex(Int_t TrackIndex) { fTrackIndex = TrackIndex;}

   void SetCandidatePhotonX(Float_t *CandidatePhotonX) { fCandidatePhotonX = CandidatePhotonX;}
   void SetCandidatePhotonY(Float_t *CandidatePhotonY) { fCandidatePhotonY = CandidatePhotonY;}
   void SetCandidatePhotonsNumber(Int_t CandidatePhotonsNumber) { fCandidatePhotonsNumber = CandidatePhotonsNumber;}
   void SetHoughPhotons(Int_t HoughPhotons) { fHoughPhotons = HoughPhotons;}
   void SetHoughPhotonsNorm(Float_t HoughPhotonsNorm) { fHoughPhotonsNorm = HoughPhotonsNorm;}

   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 SetEstimationOfTheta(Float_t EstimationOfTheta) { fEstimationOfTheta = EstimationOfTheta;}
   void SetEstimationOfThetaRMS(Float_t EstimationOfThetaRMS) { fEstimationOfThetaRMS = EstimationOfThetaRMS;}

   void FindBetaFromTheta(Float_t ThetaCerenkov) {fTrackBeta = 1/(fFreonRefractiveIndex*cos(ThetaCerenkov));}

   Float_t SnellAngle(Float_t n1, Float_t n2, Float_t theta1);

   Float_t FromEmissionToCathode();
   //////////////////////////////////////
   private:

   AliRICH* fRich;
       
   Float_t fEventVertZ;
   Float_t fEventMultiplicity;

   Float_t fTrackTheta;
   Float_t fTrackPhi;
   Float_t fTrackMomentum;
   Float_t fTrackEta;
   Float_t fTrackPt;
   Int_t   fTrackCharge;
   Float_t fTrackTPCLastZ;
   Float_t fMinDist;
   Float_t fTrackBeta;

   Float_t fXtoentr;
   Float_t fYtoentr;

   Float_t fThetaPhotonInTRS;
   Float_t fPhiPhotonInTRS;

   Float_t fThetaPhotonInDRS;
   Float_t fPhiPhotonInDRS;

   Float_t fThetaAtQuartz;
   Float_t fPhiPoint;

   Float_t fXEmiss;
   Float_t fYEmiss;

   Float_t fXInner;
   Float_t fYInner;
   Float_t fXOuter;
   Float_t fYOuter;
   Float_t fInnerRadius;
   Float_t fOuterRadius;

   Float_t fPhotonEnergy;
   Float_t fFreonRefractiveIndex;
   Float_t fQuartzRefractiveIndex;
   Float_t fGasRefractiveIndex;

   Float_t fFreonScaleFactor;

   Float_t fLengthEmissionPoint;

   Float_t fPhotonLimitX;
   Float_t fPhotonLimitY;
   Float_t fDistanceFromCluster;

   Float_t fMassHypotesis;

   Float_t fCerenkovAnglePad;

   Float_t fThetaPhotonCerenkov;

   Float_t fShiftX;
   Float_t fShiftY;

   Float_t fXcoord;
   Float_t fYcoord;

   Float_t fIntersectionX;
   Float_t fIntersectionY;

   Float_t fThetaOfRing;
   Float_t fAreaOfRing;
   Float_t fPortionOfRing;
   Float_t fHoughArea;

   Int_t fPhotonsNumber;
   Int_t fPhotonIndex;
   Float_t fPhotonEta[3000];
   Int_t fPhotonFlag[3000];
   Float_t fPhotonWeight[3000];

   Float_t fHoughRMS;

   Int_t fMipIndex;
   Int_t fTrackIndex;

   Float_t* fCandidatePhotonX;
   Float_t* fCandidatePhotonY;
   Int_t fCandidatePhotonsNumber;

   Int_t fHoughPhotons;
   Float_t fHoughPhotonsNorm;

   Float_t fFittedTrackTheta;
   Float_t fFittedTrackPhi;
   Float_t fFittedThetaCerenkov;
   Int_t   fFittedHoughPhotons;

   Float_t fEstimationOfTheta;
   Float_t fEstimationOfThetaRMS;

   public:

   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
   Float_t fThetaCerenkov;                 // Theta angle for Hough
   Float_t fWeightThetaCerenkov;           // Theta Cerenkov angle weighted
   Float_t fThetaPeakPos;                  // Peak position


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
	7	#include <TTask.h>
	8	#include "AliRICH.h"
	9	#include <AliRun.h>
	10
	11	class AliRICH;
	12
	13	class AliRICHRecon : public TTask {
	14	public :
	15
	16	AliRICHRecon(const char, const char);
9eb3dcf5	17	~AliRICHRecon(){EndProcessEvent();}
5cb4dfc3	18
	19	AliRICH* Rich() {return fRich;}
	20	void StartProcessEvent();
	21	void EndProcessEvent();
	22
	23	void InitRecon();
	24
	25	void PatRec();
	26
	27	void Minimization();
	28
	29	void FillHistograms();
	30
	31	void FindThetaPhotonCerenkov();
	32	void FindAreaAndPortionOfRing();
	33
	34	void FindEmissionPoint();
	35
	36	Int_t PhotonInBand();
	37	Float_t PhotonPositionOnCathode();
	38
	39	void FindPhotonAnglesInDRS();
	40	void FindPhiPoint();
	41	void FindThetaAtQuartz(Float_t ThetaCerenkov);
	42
	43	Float_t FindMassOfParticle();
	44
	45	Float_t Cerenkovangle(Float_t n, Float_t beta);
	46
	47	void HoughResponse();
	48	void HoughFiltering(float HCS[]);
	49	void FlagPhotons();
	50	void FindWeightThetaCerenkov();
	51
	52	void EstimationOfTheta();
	53	void FindIntersectionWithDetector();
	54	Int_t CheckDetectorAcceptance();
	55
	56	void DrawRing();
	57	void DrawEvent(Int_t flag);
	58
	59	void waiting();
	60
	61	//////////////////////////////////////
	62	Float_t GetEventVertexZ() { return fEventVertZ;}
	63	Float_t GetEventMultiplicity() { return fEventMultiplicity;}
	64	Float_t GetPhotonEnergy() { return fPhotonEnergy;}
	65	Float_t GetFreonRefractiveIndex() { return fFreonRefractiveIndex;}
	66	Float_t GetQuartzRefractiveIndex() { return fQuartzRefractiveIndex;}
	67	Float_t GetGasRefractiveIndex() { return fGasRefractiveIndex;}
	68
	69	Float_t GetFreonScaleFactor() { return fFreonScaleFactor;}
	70
	71	Float_t GetEmissionPoint() { return fLengthEmissionPoint;}
	72	Float_t GetMassHypotesis() { return fMassHypotesis;}
	73	Float_t GetBetaOfParticle() { return fTrackBeta;}
	74	Float_t GetEntranceX() { return fXtoentr;}
	75	Float_t GetEntranceY() { return fYtoentr;}
	76	Float_t GetThetaCerenkov() { return fThetaCerenkov;}
	77	Float_t GetThetaPhotonCerenkov() { return fThetaPhotonCerenkov;}
	78	Float_t GetTrackMomentum() { return fTrackMomentum;}
	79	Float_t GetTrackEta() { return fTrackEta;}
	80	Float_t GetTrackTheta() { return fTrackTheta;}
	81	Float_t GetTrackPhi() { return fTrackPhi;}
82	Float_t GetTrackPt() { return fTrackPt;}
83	Int_t GetTrackCharge() { return fTrackCharge;}
84	Float_t GetTrackTPCLastZ() { return fTrackTPCLastZ;}
85	Float_t GetMinDist() { return fMinDist;}
86	Float_t GetXPointOnCathode() { return fPhotonLimitX;}
87	Float_t GetYPointOnCathode() { return fPhotonLimitY;}
88
89
90	Float_t GetThetaPhotonInDRS() { return fThetaPhotonInDRS;}
91	Float_t GetPhiPhotonInDRS() { return fPhiPhotonInDRS;}
92	Float_t GetThetaPhotonInTRS() { return fThetaPhotonInTRS;}
93	Float_t GetPhiPhotonInTRS() { return fPhiPhotonInTRS;}
94
95	Float_t GetThetaAtQuartz() { return fThetaAtQuartz;}
96
97	Float_t GetPhiPoint(){ return fPhiPoint;}
98	Float_t GetXCoordOfEmission() {return fXEmiss;}
99	Float_t GetYCoordOfEmission() {return fYEmiss;}
100
101	Float_t GetXInnerRing() {return fXInner;}
102	Float_t GetYInnerRing() {return fYInner;}
103	Float_t GetRadiusInnerRing() {return fInnerRadius;}
104
105	Float_t GetXOuterRing() {return fXOuter;}
106	Float_t GetYOuterRing() {return fYOuter;}
107	Float_t GetRadiusOuterRing() {return fOuterRadius;}
108	Float_t GetShiftX() { return fShiftX;}
109	Float_t GetShiftY() { return fShiftY;}
110	Float_t GetDetectorWhereX() { return fXcoord;}
111	Float_t GetDetectorWhereY() { return fYcoord;}
112	Float_t GetIntersectionX() {return fIntersectionX;}
113	Float_t GetIntersectionY() {return fIntersectionY;}
114
115	Float_t GetThetaOfRing() { return fThetaOfRing;}
116	Float_t GetAreaOfRing() {return fAreaOfRing;}
117	Float_t GetPortionOfRing() {return fPortionOfRing;}
118	Float_t GetHoughArea() { return fHoughArea;}
119
120	Int_t GetPhotonsNumber() { return fPhotonsNumber;}
121	Int_t GetPhotonIndex() { return fPhotonIndex;}
122	Float_t GetPhotonEta() { return fPhotonEta[fPhotonIndex];}
123	Int_t GetPhotonFlag() { return fPhotonFlag[fPhotonIndex];}
124	Float_t GetPhotonWeight() { return fPhotonWeight[fPhotonIndex];}
125
126	Float_t GetHoughRMS() { return fHoughRMS;}
127
128	Int_t GetMipIndex() { return fMipIndex;}
129	Int_t GetTrackIndex() { return fTrackIndex;}
130	Float_t* GetCandidatePhotonX() { return fCandidatePhotonX;}
131	Float_t* GetCandidatePhotonY() { return fCandidatePhotonY;}
132	Int_t GetCandidatePhotonsNumber() { return fCandidatePhotonsNumber;}
133
134	Int_t GetHoughPhotons() { return fHoughPhotons;}
135	Float_t GetHoughPhotonsNorm() { return fHoughPhotonsNorm;}
136
137	Float_t GetFittedTrackTheta() { return fFittedTrackTheta;}
138	Float_t GetFittedTrackPhi() { return fFittedTrackPhi;}
139	Float_t GetFittedThetaCerenkov() { return fFittedThetaCerenkov;}
140	Int_t GetFittedHoughPhotons() { return fFittedHoughPhotons;}
141	Float_t GetEstimationOfTheta() { return fEstimationOfTheta;}
142	Float_t GetEstimationOfThetaRMS() { return fEstimationOfThetaRMS;}
143
144	void SetEventVertexZ(Float_t EventVertZ) { fEventVertZ = EventVertZ;}
145	void SetEventMultiplicity(Float_t EventMultiplicity) { fEventMultiplicity = EventMultiplicity;}
146	void SetPhotonEnergy(Float_t PhotonEnergy) { fPhotonEnergy = PhotonEnergy;}
147	void SetFreonRefractiveIndex() {fFreonRefractiveIndex = fFreonScaleFactor(1.177+0.0172fPhotonEnergy);}
148	void SetQuartzRefractiveIndex() {fQuartzRefractiveIndex = sqrt(1+(46.411/(113.763556-TMath::Power(fPhotonEnergy,2)))+(228.71/(328.51563-TMath::Power(fPhotonEnergy,2))));}
149	void SetGasRefractiveIndex() { fGasRefractiveIndex = 1.;}
150
151	void SetFreonScaleFactor(Float_t FreonScaleFactor) {fFreonScaleFactor = FreonScaleFactor;}
152
153	void SetEmissionPoint(Float_t LengthEmissionPoint) { fLengthEmissionPoint = LengthEmissionPoint;}
154	void SetMassHypotesis(Float_t mass) {fMassHypotesis = mass;}
155
156	void SetBetaOfParticle() { fTrackBeta = fTrackMomentum/sqrt(TMath::Power(fTrackMomentum,2)+TMath::Power(fMassHypotesis,2));}
157
158	void SetEntranceX(Float_t Xtoentr) { fXtoentr = Xtoentr;}
159	void SetEntranceY(Float_t Ytoentr) { fYtoentr = Ytoentr;}
160
161	void SetThetaPhotonInTRS(Float_t Theta) {fThetaPhotonInTRS = Theta;}
162	void SetPhiPhotonInTRS(Float_t Phi) {fPhiPhotonInTRS = Phi;}
163	void SetThetaPhotonInDRS(Float_t Theta) {fThetaPhotonInDRS = Theta;}
164	void SetPhiPhotonInDRS(Float_t Phi) {fPhiPhotonInDRS = Phi;}
165
166	void SetThetaAtQuartz(Float_t ThetaAtQuartz) {fThetaAtQuartz = ThetaAtQuartz;}
167
168	void SetPhiPoint(Float_t PhiPoint){ fPhiPoint = PhiPoint;}
169
170	void SetXCoordOfEmission(Float_t XEmiss) {fXEmiss = XEmiss;}
171	void SetYCoordOfEmission(Float_t YEmiss) {fYEmiss = YEmiss;}
172
173
174	void SetXPointOnCathode(Float_t PhotonLimitX) { fPhotonLimitX = PhotonLimitX;}
175	void SetYPointOnCathode(Float_t PhotonLimitY) { fPhotonLimitY = PhotonLimitY;}
176
177	void SetXInnerRing(Float_t XInner) {fXInner = XInner;}
178	void SetYInnerRing(Float_t YInner) {fYInner = YInner;}
179	void SetRadiusInnerRing(Float_t InnerRadius) {fInnerRadius = InnerRadius;}
180
181	void SetXOuterRing(Float_t XOuter) {fXOuter = XOuter;}
182	void SetYOuterRing(Float_t YOuter) {fYOuter = YOuter;}
183	void SetRadiusOuterRing(Float_t OuterRadius) {fOuterRadius = OuterRadius;}
184
185	void SetThetaCerenkov(Float_t ThetaCer) {fThetaCerenkov = ThetaCer;}
186	void SetThetaPhotonCerenkov(Float_t ThetaPhotCer) {fThetaPhotonCerenkov = ThetaPhotCer;}
187
188	void SetTrackMomentum(Float_t TrackMomentum) {fTrackMomentum = TrackMomentum;}
189	void SetTrackEta(Float_t TrackEta) {fTrackEta = TrackEta;}
190	void SetTrackTheta(Float_t TrackTheta) { fTrackTheta = TrackTheta;}
191	void SetTrackPhi(Float_t TrackPhi) { fTrackPhi = TrackPhi;}
192	void SetTrackPt(Float_t TrackPt) { fTrackPt = TrackPt;}
193	void SetTrackCharge(Int_t TrackCharge) { fTrackCharge = TrackCharge;}
194	void SetTrackTPCLastZ(Float_t TrackTPCLastZ) { fTrackTPCLastZ = TrackTPCLastZ;}
195	void SetMinDist(Float_t MinDist) { fMinDist = MinDist;}
196	void SetShiftX(Float_t ShiftX) { fShiftX = ShiftX;}
197	void SetShiftY(Float_t ShiftY) { fShiftY = ShiftY;}
198
199	void SetDetectorWhereX(Float_t Xcoord) { fXcoord = Xcoord;}
200	void SetDetectorWhereY(Float_t Ycoord) { fYcoord = Ycoord;}
201
202	void SetIntersectionX(Float_t IntersectionX) { fIntersectionX = IntersectionX;}
203	void SetIntersectionY(Float_t IntersectionY) { fIntersectionY = IntersectionY;}
204
205	void SetThetaOfRing(Float_t ThetaOfRing) { fThetaOfRing = ThetaOfRing;}
206	void SetAreaOfRing(Float_t AreaOfRing) { fAreaOfRing = AreaOfRing;}
207	void SetPortionOfRing(Float_t PortionOfRing) { fPortionOfRing = PortionOfRing;}
208	void SetHoughArea(Float_t HoughArea) { fHoughArea = HoughArea;}
209
210
211	void SetPhotonsNumber(Int_t PhotonsNumber) { fPhotonsNumber = PhotonsNumber;}
212	void SetPhotonIndex(Int_t PhotonIndex) { fPhotonIndex = PhotonIndex;}
213	void SetPhotonEta(Float_t PhotonEta) { fPhotonEta[fPhotonIndex] = PhotonEta;}
214	void SetPhotonFlag(Int_t PhotonFlag) { fPhotonFlag[fPhotonIndex] = PhotonFlag;}
215	void SetPhotonWeight(Float_t PhotonWeight) { fPhotonWeight[fPhotonIndex] = PhotonWeight;}
216
217	void SetHoughRMS(Float_t HoughRMS) { fHoughRMS = HoughRMS;}
218	void SetMipIndex(Int_t MipIndex) { fMipIndex = MipIndex;}
219	void SetTrackIndex(Int_t TrackIndex) { fTrackIndex = TrackIndex;}
220
221	void SetCandidatePhotonX(Float_t *CandidatePhotonX) { fCandidatePhotonX = CandidatePhotonX;}
222	void SetCandidatePhotonY(Float_t *CandidatePhotonY) { fCandidatePhotonY = CandidatePhotonY;}
223	void SetCandidatePhotonsNumber(Int_t CandidatePhotonsNumber) { fCandidatePhotonsNumber = CandidatePhotonsNumber;}
224	void SetHoughPhotons(Int_t HoughPhotons) { fHoughPhotons = HoughPhotons;}
225	void SetHoughPhotonsNorm(Float_t HoughPhotonsNorm) { fHoughPhotonsNorm = HoughPhotonsNorm;}
226
227	void SetFittedTrackTheta(Float_t FittedTrackTheta) { fFittedTrackTheta = FittedTrackTheta;}
228	void SetFittedTrackPhi(Float_t FittedTrackPhi) { fFittedTrackPhi = FittedTrackPhi;}
229	void SetFittedThetaCerenkov(Float_t FittedThetaCerenkov) { fFittedThetaCerenkov = FittedThetaCerenkov;}
230	void SetFittedHoughPhotons(Int_t FittedHoughPhotons) { fFittedHoughPhotons = FittedHoughPhotons;}
231	void SetEstimationOfTheta(Float_t EstimationOfTheta) { fEstimationOfTheta = EstimationOfTheta;}
232	void SetEstimationOfThetaRMS(Float_t EstimationOfThetaRMS) { fEstimationOfThetaRMS = EstimationOfThetaRMS;}
233
234	void FindBetaFromTheta(Float_t ThetaCerenkov) {fTrackBeta = 1/(fFreonRefractiveIndex*cos(ThetaCerenkov));}
235
236	Float_t SnellAngle(Float_t n1, Float_t n2, Float_t theta1);
237
238	Float_t FromEmissionToCathode();
239	//////////////////////////////////////
240	private:
241
242	AliRICH* fRich;
243
244	Float_t fEventVertZ;
245	Float_t fEventMultiplicity;
246
247	Float_t fTrackTheta;
248	Float_t fTrackPhi;
249	Float_t fTrackMomentum;
250	Float_t fTrackEta;
251	Float_t fTrackPt;
252	Int_t fTrackCharge;
253	Float_t fTrackTPCLastZ;
254	Float_t fMinDist;
255	Float_t fTrackBeta;
256
257	Float_t fXtoentr;
258	Float_t fYtoentr;
259
260	Float_t fThetaPhotonInTRS;
261	Float_t fPhiPhotonInTRS;
262
263	Float_t fThetaPhotonInDRS;
264	Float_t fPhiPhotonInDRS;
265
266	Float_t fThetaAtQuartz;
267	Float_t fPhiPoint;
268
269	Float_t fXEmiss;
270	Float_t fYEmiss;
271
272	Float_t fXInner;
273	Float_t fYInner;
274	Float_t fXOuter;
275	Float_t fYOuter;
276	Float_t fInnerRadius;
277	Float_t fOuterRadius;
278
279	Float_t fPhotonEnergy;
280	Float_t fFreonRefractiveIndex;
281	Float_t fQuartzRefractiveIndex;
282	Float_t fGasRefractiveIndex;
283
284	Float_t fFreonScaleFactor;
285
286	Float_t fLengthEmissionPoint;
287
288	Float_t fPhotonLimitX;
289	Float_t fPhotonLimitY;
290	Float_t fDistanceFromCluster;
291
292	Float_t fMassHypotesis;
293
294	Float_t fCerenkovAnglePad;
295
296	Float_t fThetaPhotonCerenkov;
297
298	Float_t fShiftX;
299	Float_t fShiftY;
300
301	Float_t fXcoord;
302	Float_t fYcoord;
303
304	Float_t fIntersectionX;
305	Float_t fIntersectionY;
306
307	Float_t fThetaOfRing;
308	Float_t fAreaOfRing;
309	Float_t fPortionOfRing;
310	Float_t fHoughArea;
311
312	Int_t fPhotonsNumber;
313	Int_t fPhotonIndex;
314	Float_t fPhotonEta[3000];
315	Int_t fPhotonFlag[3000];
316	Float_t fPhotonWeight[3000];
317
318	Float_t fHoughRMS;
319
320	Int_t fMipIndex;
321	Int_t fTrackIndex;
322
323	Float_t* fCandidatePhotonX;
324	Float_t* fCandidatePhotonY;
325	Int_t fCandidatePhotonsNumber;
326
327	Int_t fHoughPhotons;
328	Float_t fHoughPhotonsNorm;
329
330	Float_t fFittedTrackTheta;
331	Float_t fFittedTrackPhi;
332	Float_t fFittedThetaCerenkov;
333	Int_t fFittedHoughPhotons;
334
335	Float_t fEstimationOfTheta;
336	Float_t fEstimationOfThetaRMS;
337
338	public:
339
340	Int_t fNumEtaPhotons; // Number of photons
341	Int_t fEtaFlag[3000]; // flag for good photons
342	Float_t fEtaPhotons[3000]; // Cerenkov angle each photon
343	Float_t fWeightPhotons[3000]; // weight for each photon
344	Float_t fThetaCerenkov; // Theta angle for Hough
345	Float_t fWeightThetaCerenkov; // Theta Cerenkov angle weighted
346	Float_t fThetaPeakPos; // Peak position
347
348
349	ClassDef(AliRICHRecon,0)
350
351	};
352
353	#endif // #ifdef AliRICHRecon_cxx
354