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

class AliRICH;
class TFile;
class TNtuple;
class TCanvas;

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