]> git.uio.no Git - u/mrichter/AliRoot.git/blame - RICH/AliRICHRecon.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Stand-alone library for ESD. Possibility to use only root and lidESD.so for analysis...
[u/mrichter/AliRoot.git] / RICH / AliRICHRecon.h
CommitLineData
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
5cb4dfc3 16#include <TTask.h>
5cb4dfc3 17
998b831f 18class AliRICHHelix;
b068561d 19
20class AliRICHRecon : public TTask
21{
22public :
998b831f 23 AliRICHRecon(AliRICHHelix *pHelix,TClonesArray *pClusters,Int_t iMipId);
24 virtual ~AliRICHRecon(){;}
5cb4dfc3 25
998b831f 26 Double_t ThetaCerenkov(); // it returns reconstructed Theta Cerenkov
88dd9ad4 27 void FindThetaPhotonCerenkov(); //
28 void FindAreaAndPortionOfRing(); //
29 void FindEmissionPoint(); //
30 void FindPhotonAnglesInDRS(); //
31 void FindPhiPoint(); //
32 void FindThetaAtQuartz(Float_t ThetaCer); //
33 void HoughResponse(); //
34 void HoughFiltering(float HCS[]); //
35 void FlagPhotons(); //
36 void FindWeightThetaCerenkov(); //
88dd9ad4 37 void FindIntersectionWithDetector(); //
88dd9ad4 38 Float_t Cerenkovangle(Float_t n, Float_t b);//
88dd9ad4 39 Int_t PhotonInBand(); //
88dd9ad4 40 Int_t CheckDetectorAcceptance() const; //
41 Int_t GetFittedHoughPhotons() const{ return fFittedHoughPhotons;} //
42 Int_t GetPhotonFlag() const{ return fPhotonFlag[fPhotonIndex];} //
43 Int_t GetTrackCharge() const{ return fTrackCharge;} //
44 Int_t GetPhotonsNumber() const{ return fPhotonsNumber;} //
45 Int_t GetPhotonIndex() const{ return fPhotonIndex;} //
46 Int_t GetMipIndex() const{ return fMipIndex;} //
47 Int_t GetTrackIndex() const{ return fTrackIndex;} //
48 Int_t GetCandidatePhotonsNumber() const{ return fCandidatePhotonsNumber;} //
49 Int_t GetHoughPhotons() const{ return fHoughPhotons;} //
88dd9ad4 50 Float_t GetPhotonEnergy() const{ return fPhotonEnergy;} //
51 Float_t GetFreonRefractiveIndex() const{ return fFreonRefractiveIndex;} //
52 Float_t GetQuartzRefractiveIndex() const{ return fQuartzRefractiveIndex;} //
53 Float_t GetGasRefractiveIndex() const{ return fGasRefractiveIndex;} //
88dd9ad4 54 Float_t GetEmissionPoint() const{ return fLengthEmissionPoint;} //
55 Float_t GetMassHypotesis() const{ return fMassHypotesis;} //
56 Float_t GetBetaOfParticle() const{ return fTrackBeta;} //
57 Float_t GetEntranceX() const{ return fXtoentr;} //
58 Float_t GetEntranceY() const{ return fYtoentr;} //
59 Float_t GetThetaCerenkov() const{ return fThetaCerenkov;} //
60 Float_t GetThetaPhotonCerenkov() const{ return fThetaPhotonCerenkov;} //
88dd9ad4 61 Float_t GetTrackTheta() const{ return fTrackTheta;} //
62 Float_t GetTrackPhi() const{ return fTrackPhi;} //
88dd9ad4 63 Float_t GetXPointOnCathode() const{ return fPhotonLimitX;} //
64 Float_t GetYPointOnCathode() const{ return fPhotonLimitY;} //
65 Float_t GetThetaPhotonInDRS() const{ return fThetaPhotonInDRS;} //
66 Float_t GetPhiPhotonInDRS() const{ return fPhiPhotonInDRS;} //
67 Float_t GetThetaPhotonInTRS() const{ return fThetaPhotonInTRS;} //
68 Float_t GetPhiPhotonInTRS() const{ return fPhiPhotonInTRS;} //
69 Float_t GetThetaAtQuartz() const{ return fThetaAtQuartz;} //
70 Float_t GetPhiPoint() const{ return fPhiPoint;} //
71 Float_t GetXCoordOfEmission() const{ return fXEmiss;} //
72 Float_t GetYCoordOfEmission() const{ return fYEmiss;} //
73 Float_t GetXInnerRing() const{ return fXInner;} //
74 Float_t GetYInnerRing() const{ return fYInner;} //
75 Float_t GetRadiusInnerRing() const{ return fInnerRadius;} //
76 Float_t GetXOuterRing() const{ return fXOuter;} //
77 Float_t GetYOuterRing() const{ return fYOuter;} //
78 Float_t GetRadiusOuterRing() const{ return fOuterRadius;} //
79 Float_t GetShiftX() const{ return fShiftX;} //
80 Float_t GetShiftY() const{ return fShiftY;} //
81 Float_t GetDetectorWhereX() const{ return fXcoord;} //
82 Float_t GetDetectorWhereY() const{ return fYcoord;} //
83 Float_t GetIntersectionX() const{ return fIntersectionX;} //
84 Float_t GetIntersectionY() const{ return fIntersectionY;} //
85 Float_t GetThetaOfRing() const{ return fThetaOfRing;} //
86 Float_t GetAreaOfRing() const{ return fAreaOfRing;} //
87 Float_t GetPortionOfRing() const{ return fPortionOfRing;} //
88 Float_t GetHoughArea() const{ return fHoughArea;} //
89 Float_t GetPhotonEta() const{ return fPhotonEta[fPhotonIndex];} //
90 Float_t GetPhotonWeight() const{ return fPhotonWeight[fPhotonIndex];} //
91 Float_t GetHoughRMS() const{ return fHoughRMS;} //
88dd9ad4 92 Float_t GetFittedTrackTheta() const{ return fFittedTrackTheta;} //
93 Float_t GetFittedTrackPhi() const{ return fFittedTrackPhi;} //
94 Float_t GetFittedThetaCerenkov() const{ return fFittedThetaCerenkov;} //
88dd9ad4 95 void SetPhotonEnergy(Float_t PhotonEnergy) { fPhotonEnergy = PhotonEnergy;} //
96 void SetFreonRefractiveIndex() {fFreonRefractiveIndex = fFreonScaleFactor*(1.177+0.0172*fPhotonEnergy);}//
97 void SetQuartzRefractiveIndex() {fQuartzRefractiveIndex = sqrt(1+(46.411/(113.763556-TMath::Power(fPhotonEnergy,2)))+(228.71/(328.51563-TMath::Power(fPhotonEnergy,2))));}//
98 void SetGasRefractiveIndex() { fGasRefractiveIndex = 1.;} //
99 void SetFreonScaleFactor(Float_t FreonScaleFactor) {fFreonScaleFactor = FreonScaleFactor;} //
100 void SetEmissionPoint(Float_t LengthEmissionPoint) { fLengthEmissionPoint = LengthEmissionPoint;} //
88dd9ad4 101 void SetEntranceX(Float_t Xtoentr) { fXtoentr = Xtoentr;} //
102 void SetEntranceY(Float_t Ytoentr) { fYtoentr = Ytoentr;} //
103 void SetThetaPhotonInTRS(Float_t Theta) {fThetaPhotonInTRS = Theta;} //
104 void SetPhiPhotonInTRS(Float_t Phi) {fPhiPhotonInTRS = Phi;} //
105 void SetThetaPhotonInDRS(Float_t Theta) {fThetaPhotonInDRS = Theta;} //
106 void SetPhiPhotonInDRS(Float_t Phi) {fPhiPhotonInDRS = Phi;} //
107 void SetThetaAtQuartz(Float_t ThetaAtQuartz) {fThetaAtQuartz = ThetaAtQuartz;} //
108 void SetPhiPoint(Float_t PhiPoint){ fPhiPoint = PhiPoint;} //
109 void SetXCoordOfEmission(Float_t XEmiss) {fXEmiss = XEmiss;} //
110 void SetYCoordOfEmission(Float_t YEmiss) {fYEmiss = YEmiss;} //
111 void SetXPointOnCathode(Float_t PhotonLimitX) { fPhotonLimitX = PhotonLimitX;} //
112 void SetYPointOnCathode(Float_t PhotonLimitY) { fPhotonLimitY = PhotonLimitY;} //
113 void SetXInnerRing(Float_t XInner) {fXInner = XInner;} //
114 void SetYInnerRing(Float_t YInner) {fYInner = YInner;} //
115 void SetRadiusInnerRing(Float_t InnerRadius) {fInnerRadius = InnerRadius;} //
116 void SetXOuterRing(Float_t XOuter) {fXOuter = XOuter;} //
117 void SetYOuterRing(Float_t YOuter) {fYOuter = YOuter;} //
118 void SetRadiusOuterRing(Float_t OuterRadius) {fOuterRadius = OuterRadius;} //
119 void SetThetaCerenkov(Float_t ThetaCer) {fThetaCerenkov = ThetaCer;} //
120 void SetThetaPhotonCerenkov(Float_t ThetaPhotCer) {fThetaPhotonCerenkov = ThetaPhotCer;} //
88dd9ad4 121 void SetTrackTheta(Float_t TrackTheta) { fTrackTheta = TrackTheta;} //
122 void SetTrackPhi(Float_t TrackPhi) { fTrackPhi = TrackPhi;} //
88dd9ad4 123 void SetTrackCharge(Int_t TrackCharge) { fTrackCharge = TrackCharge;} //
88dd9ad4 124 void SetShiftX(Float_t ShiftX) { fShiftX = ShiftX;} //
125 void SetShiftY(Float_t ShiftY) { fShiftY = ShiftY;} //
126 void SetDetectorWhereX(Float_t Xcoord) { fXcoord = Xcoord;} //
127 void SetDetectorWhereY(Float_t Ycoord) { fYcoord = Ycoord;} //
128 void SetIntersectionX(Float_t IntersectionX) { fIntersectionX = IntersectionX;} //
129 void SetIntersectionY(Float_t IntersectionY) { fIntersectionY = IntersectionY;} //
130 void SetThetaOfRing(Float_t ThetaOfRing) { fThetaOfRing = ThetaOfRing;} //
131 void SetAreaOfRing(Float_t AreaOfRing) { fAreaOfRing = AreaOfRing;} //
132 void SetPortionOfRing(Float_t PortionOfRing) { fPortionOfRing = PortionOfRing;} //
133 void SetHoughArea(Float_t HoughArea) { fHoughArea = HoughArea;} //
134 void SetPhotonsNumber(Int_t PhotonsNumber) { fPhotonsNumber = PhotonsNumber;} //
135 void SetPhotonIndex(Int_t PhotonIndex) { fPhotonIndex = PhotonIndex;} //
136 void SetPhotonEta(Float_t PhotonEta) { fPhotonEta[fPhotonIndex] = PhotonEta;} //
137 void SetPhotonFlag(Int_t PhotonFlag) { fPhotonFlag[fPhotonIndex] = PhotonFlag;} //
138 void SetPhotonWeight(Float_t PhotonWeight) { fPhotonWeight[fPhotonIndex] = PhotonWeight;} //
139 void SetHoughRMS(Float_t HoughRMS) { fHoughRMS = HoughRMS;} //
140 void SetMipIndex(Int_t MipIndex) { fMipIndex = MipIndex;} //
141 void SetTrackIndex(Int_t TrackIndex) { fTrackIndex = TrackIndex;} //
88dd9ad4 142 void SetHoughPhotons(Int_t HoughPhotons) { fHoughPhotons = HoughPhotons;} //
143 void SetHoughPhotonsNorm(Float_t HoughPhotonsNorm) { fHoughPhotonsNorm = HoughPhotonsNorm;} //
144 void SetFittedTrackTheta(Float_t FittedTrackTheta) { fFittedTrackTheta = FittedTrackTheta;} //
145 void SetFittedTrackPhi(Float_t FittedTrackPhi) { fFittedTrackPhi = FittedTrackPhi;} //
146 void SetFittedThetaCerenkov(Float_t FittedThetaCerenkov) { fFittedThetaCerenkov = FittedThetaCerenkov;}//
147 void SetFittedHoughPhotons(Int_t FittedHoughPhotons) { fFittedHoughPhotons = FittedHoughPhotons;} //
88dd9ad4 148 void FindBetaFromTheta(Float_t ThetaCerenkov) {fTrackBeta = 1/(fFreonRefractiveIndex*cos(ThetaCerenkov));}//
149 Float_t SnellAngle(Float_t n1, Float_t n2, Float_t theta1); //
150 Float_t FromEmissionToCathode(); //
151
b068561d 152protected:
998b831f 153 TClonesArray *fpClusters; // poiter to clusters
88dd9ad4 154 Int_t fTrackCharge; // charge track
155 Int_t fMipIndex; // index for Mip
156 Int_t fTrackIndex; // index for track
157 Int_t fPhotonsNumber; // Number of photons candidate
158 Int_t fPhotonIndex; // index of photons
159 Int_t fPhotonFlag[3000]; // flag for photons
160 Int_t fCandidatePhotonsNumber; // number of candidate photons
161 Int_t fHoughPhotons; // n. photons after Hough
162 Int_t fFittedHoughPhotons; // n. photons after Hough and after minimization
998b831f 163
88dd9ad4 164 Float_t fTrackTheta; // Theta of track at RICH
165 Float_t fTrackPhi; // Phi of track at RICH
88dd9ad4 166 Float_t fMinDist; // min distance between extrapolated track and MIP
167 Float_t fTrackBeta; // beta of the track
168 Float_t fXtoentr; // X entrance to RICH
169 Float_t fYtoentr; // Y entrance to RICH
170 Float_t fThetaPhotonInTRS; // Theta of photon in the Track Reference System (TRS)
171 Float_t fPhiPhotonInTRS; // Phi of photon in TRS
172 Float_t fThetaPhotonInDRS; // Theta of photon in Detector Reference System (DRS)
173 Float_t fPhiPhotonInDRS; // Phi of photon in DRS
174 Float_t fThetaAtQuartz; // Theta at the quartz entrance
175 Float_t fPhiPoint; // phi of ring point
176 Float_t fXEmiss; // x emission
177 Float_t fYEmiss; // y emission
178 Float_t fXInner; // X inner ring
179 Float_t fYInner; // Y inner ring
180 Float_t fXOuter; // X outer ring
181 Float_t fYOuter; // Y outer ring
182 Float_t fInnerRadius; // inner radius
183 Float_t fOuterRadius; // outer radius
184 Float_t fPhotonEnergy; // photon energy
185 Float_t fFreonRefractiveIndex; // n freon
186 Float_t fQuartzRefractiveIndex; // n quartz
187 Float_t fGasRefractiveIndex; // n gas
188 Float_t fFreonScaleFactor; // scale factor for n freon
189 Float_t fLengthEmissionPoint; // lenght of emmission point
190 Float_t fPhotonLimitX; // X phys limit for photon
191 Float_t fPhotonLimitY; // Y phys limit for photon
192 Float_t fDistanceFromCluster; // distance from cluster
88dd9ad4 193 Float_t fCerenkovAnglePad; // cherenkov angle of pad
194 Float_t fThetaPhotonCerenkov; // theta cerenkov for photon
195 Float_t fShiftX; // x shift to entrance in radiator
196 Float_t fShiftY; // y shift to entrance in radiator
197 Float_t fXcoord; // ..
198 Float_t fYcoord; // ..
199 Float_t fIntersectionX; // ..
200 Float_t fIntersectionY; // ..
998b831f 201 Float_t fMassHypotesis; //
88dd9ad4 202 Float_t fThetaOfRing; // theta of ring
203 Float_t fAreaOfRing; // area of the ring
204 Float_t fPortionOfRing; // fraction of the accepted ring
205 Float_t fHoughArea; // area Hough
206 Float_t fPhotonEta[3000]; // theta cerenkov of photon candidates
207 Float_t fPhotonWeight[3000]; // weigth
208 Float_t fHoughRMS; // rms Hough
209 Float_t* fCandidatePhotonX; // x photon candidates
210 Float_t* fCandidatePhotonY; // y photon candidates
211 Float_t fHoughPhotonsNorm; // n. photons norm.
212 Float_t fFittedTrackTheta; // theta track after minim.
213 Float_t fFittedTrackPhi; // phi track after minim.
214 Float_t fFittedThetaCerenkov; // thetacerenkov after minim.
88dd9ad4 215 Int_t fThetaBin; // bin in theta
216 Float_t fThetaMin,fThetaMax; // min max
217 Float_t fXmin,fXmax,fYmin,fYmax; // xy min max
88dd9ad4 218 Int_t fNrings; //current number of reconstructed rings
88dd9ad4 219 Bool_t fIsWEIGHT; // flag to consider weight procedure
220 Bool_t fIsBACKGROUND; // flag to simulate bkg
88dd9ad4 221 Float_t fRadiatorWidth; // radiator width
222 Float_t fQuartzWidth; // quartz width
223 Float_t fGapWidth; // gap width
224 Float_t fDTheta; // Step for sliding window
225 Float_t fWindowWidth; // Hough width of sliding window
226
227 Int_t fNumEtaPhotons; // Number of photons
228 Int_t fEtaFlag[3000]; // flag for good photons
229 Float_t fEtaPhotons[3000]; // Cerenkov angle each photon
230 Float_t fWeightPhotons[3000]; // weight for each photon
231 Float_t fThetaCerenkov; // Theta angle for Hough
232 Float_t fWeightThetaCerenkov; // Theta Cerenkov angle weighted
233 Float_t fThetaPeakPos; // Peak position
234
235
b068561d 236 ClassDef(AliRICHRecon,0)
5cb4dfc3 237};
238
239#endif // #ifdef AliRICHRecon_cxx
240