]>
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 | ||
5cb4dfc3 | 16 | #include <TTask.h> |
5cb4dfc3 | 17 | |
998b831f | 18 | class AliRICHHelix; |
b068561d | 19 | |
20 | class AliRICHRecon : public TTask | |
21 | { | |
22 | public : | |
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 | 152 | protected: |
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 |