]>
Commit | Line | Data |
---|---|---|
2e5f0f7b | 1 | #ifndef AliRICHChamber_H |
2 | #define AliRICHChamber_H | |
3 | ||
4 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
5 | * See cxx source for full Copyright notice */ | |
6 | ||
7 | /* $Id$ */ | |
8 | ||
9 | #include <TObjArray.h> | |
10 | #include <TRotMatrix.h> | |
11 | #include "AliRICHSegRes.h" | |
12 | ||
13 | ||
14 | class AliRICHClusterFinder; | |
15 | class AliRICHResponse; | |
16 | class AliRICHSegmentation; | |
17 | class AliRICHGeometry; | |
18 | typedef enum {mip, cerenkov} Response_t; | |
19 | ||
20 | class AliRICHChamber : public TObject | |
21 | { | |
22 | public: | |
23 | ||
24 | //Rotation matrices for each chamber | |
25 | ||
26 | TRotMatrix *fChamberMatrix; | |
27 | Float_t fChamberTrans[3]; | |
28 | ||
29 | public: | |
30 | AliRICHChamber(); | |
31 | ~AliRICHChamber(){} | |
32 | // | |
33 | // Set and get GEANT id | |
34 | Int_t GetGid() {return fGid;} | |
35 | void SetGid(Int_t id) {fGid=id;} | |
36 | // | |
37 | // Initialisation and z-Position | |
38 | void Init(); | |
39 | // Set inner radius of sensitive volume | |
40 | void SetRInner(Float_t rmin) {frMin=rmin;} | |
41 | // Set outer radius of sensitive volum | |
42 | void SetROuter(Float_t rmax) {frMax=rmax;} | |
43 | ||
44 | // Return inner radius of sensitive volume | |
45 | Float_t RInner() {return frMin;} | |
46 | // Return outer radius of sensitive volum | |
47 | Float_t ROuter() {return frMax;} | |
48 | ||
49 | void SetZPOS(Float_t p1) {fzPos=p1;} | |
50 | Float_t ZPosition() {return fzPos;} | |
51 | ||
52 | // | |
53 | //Transformation from Global to local coordinates, chamber-dependant | |
54 | void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]); | |
55 | void GlobaltoLocal(Float_t pos[3],Float_t localpos[3]); | |
56 | ||
57 | //Setting chamber specific rotation matrices | |
58 | ||
59 | void SetChamberTransform(Float_t Trans1,Float_t Trans2,Float_t Trans3,TRotMatrix *Matrix) | |
60 | ||
61 | { | |
62 | fChamberMatrix=Matrix; | |
63 | fChamberTrans[0]=Trans1; | |
64 | fChamberTrans[1]=Trans2; | |
65 | fChamberTrans[2]=Trans3; | |
66 | } | |
67 | ||
68 | TRotMatrix * GetRotMatrix() {return fChamberMatrix;} | |
69 | ||
70 | //Configure geometry model | |
71 | void GeometryModel(AliRICHGeometry* thisGeometry){ | |
72 | fGeometry=thisGeometry; | |
73 | } | |
74 | ||
75 | ||
76 | // Configure response model | |
77 | void ResponseModel(AliRICHResponse* thisResponse); | |
78 | ||
79 | // | |
80 | // Configure segmentation model | |
81 | void SegmentationModel(AliRICHSegmentation* thisSegmentation) { | |
82 | fSegmentation = thisSegmentation; | |
83 | } | |
84 | void ReconstructionModel(AliRICHClusterFinder *thisReconstruction) { | |
85 | fReconstruction = thisReconstruction; | |
86 | } | |
87 | ||
88 | // | |
89 | // Get reference to response model | |
90 | AliRICHResponse* GetResponseModel(); | |
91 | // | |
92 | // Get reference to segmentation model | |
93 | AliRICHSegmentation* GetSegmentationModel() { | |
94 | return fSegmentation; | |
95 | } | |
96 | ||
97 | // Get reference to geometry model | |
98 | AliRICHGeometry* GetGeometryModel() { | |
99 | return fGeometry; | |
100 | } | |
101 | ||
102 | ||
103 | AliRICHSegmentation* GetSegmentationModel(Int_t i) { | |
104 | return fSegmentation; | |
105 | } | |
106 | ||
107 | // | |
108 | AliRICHClusterFinder* &GetReconstructionModel() {return fReconstruction;} | |
109 | ||
110 | Int_t Nsec() {return fnsec;} | |
111 | void SetNsec(Int_t nsec) {fnsec=nsec;} | |
112 | // | |
113 | // Member function forwarding to the segmentation and response models | |
114 | // | |
115 | // Calculate pulse height from energy loss | |
116 | Float_t IntPH(Float_t eloss) {return fResponse->IntPH(eloss);} | |
117 | Float_t IntPH() {return fResponse->IntPH();} | |
118 | // | |
119 | // Ask segmentation if signal should be generated | |
120 | Int_t SigGenCond(Float_t x, Float_t y, Float_t z) | |
121 | { | |
122 | return fSegmentation->SigGenCond(x, y, z); | |
123 | } | |
124 | ||
125 | // Ask segmentation sector | |
126 | Int_t Sector(Float_t x, Float_t y) | |
127 | { | |
128 | return fSegmentation->Sector(x, y); | |
129 | } | |
130 | ||
131 | // | |
132 | // Initialisation of segmentation for hit | |
133 | void SigGenInit(Float_t x, Float_t y, Float_t z) | |
134 | { | |
135 | fSegmentation->SigGenInit(x, y, z) ; | |
136 | } | |
137 | // Configuration forwarding | |
138 | // | |
139 | void SetSigmaIntegration(Float_t p) | |
140 | { | |
141 | fResponse->SetSigmaIntegration(p); | |
142 | } | |
143 | void SetChargeSlope(Float_t p) | |
144 | { | |
145 | fResponse->SetChargeSlope(p); | |
146 | } | |
147 | void SetChargeSpread(Float_t p1, Float_t p2) | |
148 | { | |
149 | fResponse->SetChargeSpread(p1,p2); | |
150 | } | |
151 | void SetMaxAdc(Float_t p) | |
152 | { | |
153 | fResponse->SetMaxAdc(p); | |
154 | } | |
155 | void SetSqrtKx3(Float_t p) | |
156 | { | |
157 | fResponse->SetSqrtKx3(p); | |
158 | } | |
159 | void SetKx2(Float_t p) | |
160 | { | |
161 | fResponse->SetKx2(p); | |
162 | } | |
163 | void SetKx4(Float_t p) | |
164 | { | |
165 | fResponse->SetKx4(p); | |
166 | } | |
167 | void SetSqrtKy3(Float_t p) | |
168 | { | |
169 | fResponse->SetSqrtKy3(p); | |
170 | } | |
171 | void SetKy2(Float_t p) | |
172 | { | |
173 | fResponse->SetKy2(p); | |
174 | } | |
175 | void SetKy4(Float_t p) | |
176 | { | |
177 | fResponse->SetKy4(p); | |
178 | } | |
179 | ||
180 | void SetPitch(Float_t p) | |
181 | { | |
182 | fResponse->SetPitch(p); | |
183 | } | |
184 | ||
185 | void SetPadSize(Float_t p1, Float_t p2) | |
186 | { | |
187 | fSegmentation->SetPadSize(p1,p2); | |
188 | } | |
189 | void SetGapThickness(Float_t thickness) | |
190 | { | |
191 | fGeometry->SetGapThickness(thickness); | |
192 | } | |
193 | void SetProximityGapThickness(Float_t thickness) | |
194 | { | |
195 | fGeometry->SetProximityGapThickness(thickness); | |
196 | } | |
197 | void SetQuartzLength(Float_t length) | |
198 | { | |
199 | fGeometry->SetQuartzLength(length); | |
200 | } | |
201 | void SetQuartzWidth(Float_t width) | |
202 | { | |
203 | fGeometry->SetQuartzWidth(width); | |
204 | } | |
205 | void SetQuartzThickness(Float_t thickness) | |
206 | { | |
207 | fGeometry->SetQuartzThickness(thickness); | |
208 | } | |
209 | void SetOuterFreonLength(Float_t length) | |
210 | { | |
211 | fGeometry->SetOuterFreonLength(length); | |
212 | } | |
213 | void SetOuterFreonWidth(Float_t width) | |
214 | { | |
215 | fGeometry->SetOuterFreonWidth(width); | |
216 | } | |
217 | void SetInnerFreonLength(Float_t length) | |
218 | { | |
219 | fGeometry->SetInnerFreonLength(length); | |
220 | } | |
221 | void SetInnerFreonWidth(Float_t width) | |
222 | { | |
223 | fGeometry->SetInnerFreonWidth(width); | |
224 | } | |
225 | void SetFreonThickness(Float_t thickness) | |
226 | { | |
227 | fGeometry->SetFreonThickness(thickness); | |
228 | } | |
229 | ||
230 | ||
231 | // | |
232 | // Cluster formation method | |
233 | void DisIntegration(Float_t, Float_t, Float_t, Int_t&x, Float_t newclust[6][500], Response_t res); | |
234 | private: | |
235 | // GEANT volume if for sensitive volume of this | |
236 | // Maximum and Minimum Chamber size | |
237 | Float_t frMin; | |
238 | Float_t frMax; | |
239 | Int_t fGid; | |
240 | // z-position of this chamber | |
241 | Float_t fzPos; | |
242 | // The segmentation models for the cathode planes | |
243 | // fnsec=1: one plane segmented, fnsec=2: both planes are segmented. | |
244 | Int_t fnsec; | |
245 | ||
246 | AliRICHSegmentation *fSegmentation; | |
247 | AliRICHResponse *fResponse; | |
248 | AliRICHGeometry *fGeometry; | |
249 | AliRICHClusterFinder *fReconstruction; | |
250 | ClassDef(AliRICHChamber,1) | |
251 | }; | |
252 | #endif |