]>
Commit | Line | Data |
---|---|---|
8c555625 | 1 | #ifndef TPCParam_H |
2 | #define TPCParam_H | |
3da30618 | 3 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
4 | * See cxx source for full Copyright notice */ | |
5 | ||
6 | /* $Id$ */ | |
7 | ||
8c555625 | 8 | //////////////////////////////////////////////// |
9 | // Manager class for TPC parameters // | |
10 | //////////////////////////////////////////////// | |
8c555625 | 11 | |
cc80f89e | 12 | #include "AliDetectorParam.h" |
13 | #include "TMath.h" | |
1283eee5 | 14 | |
15 | // the last things from AliTPCSecGeo | |
cc80f89e | 16 | const Float_t z_end = 250.; |
17 | const Float_t alpha_low=0.34906585; // 20 degrees | |
18 | const Float_t alpha_up=0.34906585; // 20 degrees | |
19 | const Float_t q_el = 1.602e-19; // elementary charge | |
20 | const Float_t adc_sat = 1023; // dynamic range (10 bits) | |
21 | const Float_t dyn_range = 2000.; // output dynamic range (mV) | |
22 | // | |
1283eee5 | 23 | |
8c555625 | 24 | |
cc80f89e | 25 | class AliTPCParam : public AliDetectorParam { |
8c555625 | 26 | ////////////////////////////////////////////////////// |
27 | ////////////////////////////////////////////////////// | |
28 | //ALITPCParam object to be possible change | |
29 | //geometry and some other parameters of TPC | |
cc80f89e | 30 | //used by AliTPC and AliTPCSector |
31 | ||
8c555625 | 32 | public: |
33 | AliTPCParam(); | |
cc80f89e | 34 | virtual ~AliTPCParam(); |
8c555625 | 35 | |
cc80f89e | 36 | virtual Bool_t Transform(Float_t *xyz, Int_t *index, Int_t* oindex); |
37 | //transformation from input coodination system to output coordination system | |
38 | Int_t Transform0to1(Float_t *xyz, Int_t *index) const; | |
39 | //trasforamtion from global to global - adjust index[0] sector | |
40 | //return value is equal to sector corresponding to global position | |
41 | inline void Transform1to2(Float_t *xyz, Int_t *index) const; | |
42 | //transformation to rotated coordinata | |
43 | inline void Transform2to1(Float_t *xyz, Int_t *index) const; | |
44 | //transformation from rotated coordinata to global coordinata | |
45 | inline void Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const; | |
46 | //transform rotated coordinata of one sector to rotated | |
47 | //coordinata relative to another sector | |
48 | inline Float_t Transform2to2NearestWire(Float_t *xyz, Int_t *index) const; | |
49 | //round x position to nearest wire | |
50 | inline Int_t Transform2to3(Float_t *xyz, Int_t *index) const; | |
51 | //calulate coresponding index[2] -pad row for straight rows | |
52 | //does not change xyz[] | |
53 | //return pad - row | |
54 | inline void Transform3to4(Float_t *xyz, Int_t *index) const; | |
55 | //valid only for straight rows straight rows | |
56 | //calculate xyz[0] position relative to given index | |
57 | //return pad - row | |
58 | inline void Transform4to3(Float_t *xyz, Int_t *index) const; | |
59 | //valid only for straight rows straight rows | |
60 | //transform xyz[0] position relative to given index | |
61 | inline void Transform2to5( Float_t *xyz, Int_t *index) const; | |
62 | //transform [x,y,z] to [r,rphi,z] | |
63 | inline void Transform5to2(Float_t *xyz, Int_t *index) const; | |
64 | //transform [r,rphi,z] coordinata to [x,y,z] | |
65 | inline void Transform4to8(Float_t *xyz, Int_t *index) const; | |
66 | //transform xyz coordinata to 'digit' coordinata | |
67 | inline void Transform8to4(Float_t *xyz, Int_t *index) const; | |
68 | //transform 'digit' coordinata to xyz coordinata | |
69 | inline void Transform6to8(Float_t *xyz, Int_t *index) const; | |
70 | //transform dr,f coordinata to 'digit' coordinata | |
71 | inline void Transform8to6(Float_t *xyz, Int_t *index) const; | |
72 | //transform 'digit' coordinata to dr,f coordinata | |
73 | ||
74 | virtual Int_t Transform2toPadRow(Float_t *xyz, Int_t *index) const{return 0;} | |
75 | //transform rotated to | |
76 | ||
77 | virtual Int_t GetPadRow(Float_t *xyz, Int_t *index) const ; | |
78 | //return pad row of point xyz - xyz is given in coordinate system -(given by index) | |
79 | //output system is 3 for straight row and 7 for cylindrical row | |
80 | virtual void XYZtoCRXYZ(Float_t *xyz, | |
81 | Int_t §or, Int_t &padrow, Int_t option=3){;} | |
8c555625 | 82 | //transform global position to the position relative to the sector padrow |
83 | //if option=0 X calculate absolute calculate sector | |
84 | //if option=1 X absolute use input sector | |
85 | //if option=2 X relative to pad row calculate sector | |
86 | //if option=3 X relative use input sector | |
87 | ||
cc80f89e | 88 | virtual void CRXYZtoXYZ(Float_t *xyz, |
89 | const Int_t §or, const Int_t & padrow, Int_t option=3) const {;} | |
8c555625 | 90 | //transform relative position to the gloabal position |
91 | ||
cc80f89e | 92 | virtual void CRTimePadtoYZ(Float_t &y, Float_t &z, |
93 | const Float_t &time, const Float_t &pad, | |
94 | Int_t sector, Int_t padrow ){;} | |
8c555625 | 95 | //transform position in digit units (time slices and pads) to "normal" |
96 | //units (cm) | |
cc80f89e | 97 | virtual void CRYZtoTimePad(const Float_t &y, const Float_t &z, |
98 | Float_t &time, Float_t &pad, | |
99 | Int_t sector, Int_t padrow){;} | |
100 | //transform position in cm to position in digit unit | |
101 | virtual Int_t CalcResponse(Float_t* x, Int_t * index, Int_t row){return 0;} | |
102 | //calculate bin response as function of the input position -x and the weight | |
103 | //if row -pad row is equal -1 calculate response for each pad row | |
104 | //otherwise it calculate only in given pad row | |
105 | //return number of valid response bin | |
106 | virtual void SetDefault(); //set defaut TPCparam | |
107 | virtual Bool_t Update(); //recalculate and check geometric parameters | |
108 | Bool_t GetStatus(); //get information about object consistency | |
109 | Int_t GetIndex(Int_t sector, Int_t row); //give index of the given sector and pad row | |
110 | Int_t GetNSegmentsTotal() const {return fNtRows;} | |
8c555625 | 111 | Double_t GetLowMaxY(Int_t irow) const {return irow*0.;} |
112 | Double_t GetUpMaxY(Int_t irow) const {return irow*0;} | |
cc80f89e | 113 | //additional geometrical function - for Belikov |
114 | ||
115 | Bool_t AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const; //return sector and padrow | |
8c555625 | 116 | //for given index |
8c555625 | 117 | |
cc80f89e | 118 | inline void AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const; |
119 | //set cosinus and sinus of rotation angles for sector isec | |
120 | inline Float_t GetAngle(Int_t isec) const; | |
121 | // | |
122 | //set sector parameters | |
123 | // | |
124 | void SetInnerRadiusLow(Float_t InnerRadiusLow ) { fInnerRadiusLow=InnerRadiusLow;} | |
125 | void SetOuterRadiusLow(Float_t OuterRadiusLow ) { fOuterRadiusLow=OuterRadiusLow;} | |
126 | void SetInnerRadiusUp(Float_t InnerRadiusUp) { fInnerRadiusUp= InnerRadiusUp;} | |
127 | void SetOuterRadiusUp(Float_t OuterRadiusUp) { fOuterRadiusUp= OuterRadiusUp;} | |
128 | void SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle, | |
129 | Float_t outershift); | |
130 | void SetInnerFrameSpace(Float_t frspace) {fInnerFrameSpace = frspace;} | |
131 | void SetOuterFrameSpace(Float_t frspace) {fOuterFrameSpace = frspace;} | |
132 | void SetInnerWireMount(Float_t fmount) {fInnerWireMount = fmount;} | |
133 | void SetOuterWireMount(Float_t fmount) {fOuterWireMount = fmount;} | |
134 | void SetZLength(Float_t zlength) {fZLength = zlength;} | |
135 | void SetGeometryType(Int_t type) {fGeometryType = type;} | |
136 | // | |
137 | //set wire parameters | |
138 | // | |
139 | void SetInnerNWires(Int_t nWires){ fNInnerWiresPerPad=nWires;} | |
140 | void SetInnerDummyWire(Int_t dummy) {fInnerDummyWire = dummy;} | |
141 | void SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;} | |
142 | void SetOuterNWires(Int_t nWires){ fNOuterWiresPerPad=nWires;} | |
143 | void SetOuterDummyWire(Int_t dummy) {fOuterDummyWire = dummy;} | |
144 | void SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;} | |
145 | // | |
146 | //set pad parameter | |
147 | // | |
148 | void SetInnerPadPitchLength(Float_t PadPitchLength){ fInnerPadPitchLength=PadPitchLength;} | |
149 | void SetInnerPadPitchWidth(Float_t PadPitchWidth){ fInnerPadPitchWidth = PadPitchWidth;} | |
150 | void SetInnerPadLength(Float_t PadLength){ fInnerPadLength=PadLength;} | |
151 | void SetInnerPadWidth(Float_t PadWidth) { fInnerPadWidth=PadWidth;} | |
152 | void SetOuterPadPitchLength(Float_t PadPitchLength){ fOuterPadPitchLength=PadPitchLength;} | |
153 | void SetOuterPadPitchWidth(Float_t PadPitchWidth){ fOuterPadPitchWidth = PadPitchWidth;} | |
154 | void SetOuterPadLength(Float_t PadLength){ fOuterPadLength=PadLength;} | |
155 | void SetOuterPadWidth(Float_t PadWidth) { fOuterPadWidth=PadWidth;} | |
156 | void SetMWPCReadout(Bool_t type) {fBMWPCReadout = type;} | |
157 | void SetNCrossRows(Int_t rows){fNCrossRows = rows;} | |
158 | // | |
159 | //set gas paremeters | |
160 | // | |
161 | void SetDiffT(Float_t DiffT){ fDiffT= DiffT;} | |
162 | void SetDiffL(Float_t DiffL){ fDiffL=DiffL;} | |
163 | void SetGasGain(Float_t GasGain){ fGasGain=GasGain;} | |
164 | void SetDriftV(Float_t DriftV){ fDriftV= DriftV;} | |
165 | void SetOmegaTau(Float_t OmegaTau){ fOmegaTau=OmegaTau;} | |
166 | void SetAttCoef(Float_t AttCoef){ fAttCoef=AttCoef;} | |
167 | void SetOxyCont(Float_t OxyCont){ fOxyCont=OxyCont;} | |
168 | // | |
169 | //set electronivc parameters | |
170 | // | |
171 | void SetPadCoupling(Float_t PadCoupling){ fPadCoupling=PadCoupling;} | |
172 | void SetZeroSup(Int_t ZeroSup) { fZeroSup=ZeroSup;} | |
173 | void SetNoise(Float_t Noise ) { fNoise= Noise;} | |
174 | void SetChipGain(Float_t ChipGain){ fChipGain= ChipGain;} | |
175 | void SetChipNorm(Float_t ChipNorm){ fChipNorm= ChipNorm;} | |
176 | void SetTSample(Float_t TSample) { fTSample=TSample;} | |
177 | void SetTFWHM(Float_t fwhm) { fTSigma=fwhm/2.35;} | |
178 | void SetMaxTBin(Int_t maxtbin) { fMaxTBin = maxtbin;} | |
179 | void SetADCSat(Int_t adcsat) { fADCSat = adcsat;} | |
180 | void SetADCDynRange(Float_t adcdynrange) {fADCDynRange = adcdynrange;} | |
181 | // | |
182 | //set response parameters | |
183 | // | |
184 | void SetNResponseMax(Int_t max) { fNResponseMax = max;} | |
185 | void SetResponseThreshold(Int_t threshold) {fResponseThreshold = threshold;} | |
186 | // | |
187 | //get sector parameters | |
188 | // | |
189 | Float_t GetInnerRadiusLow() const {return fInnerRadiusLow;} | |
190 | Float_t GetInnerRadiusUp() const {return fInnerRadiusUp;} | |
191 | Float_t GetOuterRadiusLow() const {return fOuterRadiusLow;} | |
192 | Float_t GetOuterRadiusUp() const {return fOuterRadiusUp;} | |
193 | Float_t GetInnerFrameSpace() const {return fInnerFrameSpace;} | |
194 | Float_t GetOuterFrameSpace() const {return fOuterFrameSpace;} | |
195 | Float_t GetInnerWireMount() const {return fInnerWireMount;} | |
196 | Float_t GetOuterWireMount() const {return fOuterWireMount;} | |
197 | Float_t GetInnerAngle() const ; | |
198 | Float_t GetInnerAngleShift() const ; | |
199 | Float_t GetOuterAngle() const ; | |
200 | Float_t GetOuterAngleShift() const ; | |
201 | Int_t GetNInnerSector() const {return fNInnerSector;} | |
202 | Int_t GetNOuterSector() const {return fNOuterSector;} | |
203 | Int_t GetNSector() const {return fNSector;} | |
204 | Float_t GetZLength() const {return fZLength;} | |
205 | Int_t GetGeometryType() const {return fGeometryType;} | |
206 | ||
207 | // | |
208 | //get wires parameter | |
209 | // | |
210 | Int_t GetInnerNWires() const {return fNInnerWiresPerPad;} | |
211 | Float_t GetInnerWWPitch() const {return fInnerWWPitch;} | |
212 | Int_t GetInnerDummyWire() const {return fInnerDummyWire;} | |
213 | Float_t GetInnerOffWire() const {return fInnerOffWire;} | |
214 | Float_t GetRInnerFirstWire() const {return fRInnerFirstWire;} | |
215 | Float_t GetRInnerLastWire() const {return fRInnerLastWire;} | |
216 | Int_t GetOuterNWires() const {return fNOuterWiresPerPad;} | |
217 | Float_t GetOuterWWPitch() const {return fOuterWWPitch;} | |
218 | Int_t GetOuterDummyWire() const {return fOuterDummyWire;} | |
219 | Float_t GetOuterOffWire() const {return fOuterOffWire;} | |
220 | Float_t GetROuterFirstWire() const {return fROuterFirstWire;} | |
221 | Float_t GetROuterLastWire() const {return fROuterLastWire;} | |
222 | Float_t GetWWPitch(Int_t isector = 0) const { | |
223 | return ( (isector < fNInnerSector) ? fInnerWWPitch :fOuterWWPitch);} | |
224 | // | |
225 | //get pad parameters | |
226 | // | |
227 | Float_t GetInnerPadPitchLength() const {return fInnerPadPitchLength;} | |
228 | Float_t GetInnerPadPitchWidth() const {return fInnerPadPitchWidth;} | |
229 | Float_t GetInnerPadLength() const {return fInnerPadLength;} | |
230 | Float_t GetInnerPadWidth() const {return fInnerPadWidth;} | |
231 | Float_t GetOuterPadPitchLength() const {return fOuterPadPitchLength;} | |
232 | Float_t GetOuterPadPitchWidth() const {return fOuterPadPitchWidth;} | |
233 | Float_t GetOuterPadLength() const {return fOuterPadLength;} | |
234 | Float_t GetOuterPadWidth() const {return fOuterPadWidth;} | |
235 | Bool_t GetMWPCReadout() const {return fBMWPCReadout;} | |
236 | Int_t GetNCrossRows() const {return fNCrossRows;} | |
237 | Float_t GetPadPitchWidth(Int_t isector = 0) const { | |
238 | return ( (isector < fNInnerSector) ? fInnerPadPitchWidth :fOuterPadPitchWidth);} | |
239 | Float_t GetPadPitchLength(Int_t isector = 0) const { | |
240 | return ( (isector < fNInnerSector) ? fInnerPadPitchLength :fOuterPadPitchLength);} | |
8c555625 | 241 | |
8c555625 | 242 | Int_t GetNRowLow() const; //get the number of pad rows in low sector |
243 | Int_t GetNRowUp() const; //get the number of pad rows in up sector | |
cc80f89e | 244 | Int_t GetNRow(Int_t isec) const {return ((isec<fNInnerSector) ? fNRowLow:fNRowUp);} |
245 | Int_t GetNRowsTotal(){return fNtRows;} //get total nuber of rows | |
8c555625 | 246 | Float_t GetPadRowRadiiLow(Int_t irow) const; //get the pad row (irow) radii |
247 | Float_t GetPadRowRadiiUp(Int_t irow) const; //get the pad row (irow) radii | |
248 | Float_t GetPadRowRadii(Int_t isec,Int_t irow) const { | |
1283eee5 | 249 | return ( (isec < fNInnerSector) ?GetPadRowRadiiLow(irow):GetPadRowRadiiUp(irow));} |
cc80f89e | 250 | //retrun radii of the pad row irow in sector i |
8c555625 | 251 | Int_t GetNPadsLow(Int_t irow) const; //get the number of pads in row irow |
252 | Int_t GetNPadsUp(Int_t irow) const; //get the number of pads in row irow | |
cc80f89e | 253 | Int_t GetNPads(Int_t isector,Int_t irow) const{ |
254 | return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));} | |
255 | // | |
256 | //get GAS parameters | |
257 | // | |
258 | Float_t GetDiffT() const {return fDiffT;} | |
259 | Float_t GetDiffL() const {return fDiffL;} | |
260 | Float_t GetGasGain() const {return fGasGain;} | |
261 | Float_t GetDriftV() const {return fDriftV;} | |
262 | Float_t GetOmegaTau() const {return fOmegaTau;} | |
263 | Float_t GetAttCoef() const {return fAttCoef;} | |
264 | Float_t GetOxyCont() const {return fOxyCont;} | |
265 | // | |
266 | //get Electronic parameters | |
267 | // | |
268 | Float_t GetPadCoupling() const {return fPadCoupling;} | |
269 | Int_t GetZeroSup() const {return fZeroSup;} | |
270 | Float_t GetNoise() const {return fNoise;} | |
271 | Float_t GetChipGain() const {return fChipGain;} | |
272 | Float_t GetChipNorm() const {return fChipNorm;} | |
273 | Float_t GetTSample() const {return fTSample;} | |
274 | Float_t GetZWidth() const {return fZWidth;} | |
275 | Float_t GetTFWHM() const {return fTSigma*2.35;} | |
276 | Float_t GetZSigma() const {return fTSigma*fDriftV;} | |
277 | virtual Float_t GetZOffset() {return 3*fTSigma*fDriftV;} | |
278 | Int_t GetMaxTBin() const {return fMaxTBin;} | |
279 | Int_t GetADCSat() const {return fADCSat;} | |
280 | Float_t GetADCDynRange() const {return fADCDynRange;} | |
281 | Float_t GetTotalNormFac() const {return fTotalNormFac;} | |
282 | Float_t GetNoiseNormFac() const {return fNoiseNormFac;} | |
283 | // | |
284 | // get response data | |
285 | // | |
286 | inline Int_t * GetResBin(Int_t i); | |
287 | //return response bin i - bin given by padrow [0] pad[1] timebin[2] | |
288 | inline Float_t GetResWeight(Int_t i); | |
289 | //return weight of response bin i | |
290 | protected : | |
8c555625 | 291 | |
8c555625 | 292 | Bool_t fbStatus; //indicates consistency of the data |
293 | //--------------------------------------------------------------------- | |
294 | // ALICE TPC sector geometry | |
cc80f89e | 295 | //-------------------------------------------------------------------- |
296 | Float_t fInnerRadiusLow; // lower radius of inner sector-IP | |
297 | Float_t fInnerRadiusUp; // upper radius of inner sector-IP | |
298 | Float_t fOuterRadiusUp; // upper radius of outer sector-IP | |
299 | Float_t fOuterRadiusLow; // lower radius of outer sector-IP | |
300 | Float_t fInnerAngle; //opening angle of Inner sector | |
301 | Float_t fInnerAngleShift; //shift of first inner sector center to the 0 | |
302 | Float_t fOuterAngle; //opening angle of outer sector | |
303 | Float_t fOuterAngleShift; //shift of first sector center to the 0 | |
304 | Float_t fInnerFrameSpace; //space for inner frame in the phi direction | |
305 | Float_t fOuterFrameSpace; //space for outer frame in the phi direction | |
306 | Float_t fInnerWireMount; //space for wire mount, inner sector | |
307 | Float_t fOuterWireMount; //space for wire mount, outer sector | |
308 | Int_t fNInnerSector; //!number of inner sectors -calculated | |
309 | Int_t fNOuterSector; //!number of outer sectors -calculated | |
310 | Int_t fNSector; //! total number of sectors -calculated | |
311 | Float_t fZLength; //length of the drift region of the TPC | |
312 | Float_t *fRotAngle; // sin and cos of rotation angles for | |
313 | // diferent sectors -calculated | |
314 | Int_t fGeometryType; //type of geometry -0 straight rows | |
315 | //1-cylindrical | |
316 | //--------------------------------------------------------------------- | |
317 | // ALICE TPC wires geometry - for GEM we can consider that it is gating | |
8c555625 | 318 | //-------------------------------------------------------------------- |
cc80f89e | 319 | Int_t fNInnerWiresPerPad; // Number of wires per pad |
320 | Float_t fInnerWWPitch; // pitch between wires in inner sector - calculated | |
321 | Int_t fInnerDummyWire; //number of wires without pad readout | |
322 | Float_t fInnerOffWire; //oofset of first wire to the begining of the sector | |
323 | Float_t fRInnerFirstWire; //position of the first wire -calculated | |
324 | Float_t fRInnerLastWire; //position of the last wire -calculated | |
325 | Int_t fNOuterWiresPerPad; // Number of wires per pad | |
326 | Float_t fOuterWWPitch; // pitch between wires in outer sector -calculated | |
327 | Int_t fOuterDummyWire; //number of wires without pad readout | |
328 | Float_t fOuterOffWire; //oofset of first wire to the begining of the sector | |
329 | Float_t fROuterFirstWire; //position of the first wire -calulated | |
330 | Float_t fROuterLastWire; //position of the last wire -calculated | |
1283eee5 | 331 | //--------------------------------------------------------------------- |
332 | // ALICE TPC pad parameters | |
333 | //-------------------------------------------------------------------- | |
cc80f89e | 334 | Float_t fInnerPadPitchLength; //Inner pad pitch length |
335 | Float_t fInnerPadPitchWidth; //Inner pad pitch width | |
336 | Float_t fInnerPadLength; //Inner pad length | |
337 | Float_t fInnerPadWidth; //Inner pad width | |
338 | Float_t fOuterPadPitchLength; //Outer pad pitch length | |
339 | Float_t fOuterPadPitchWidth; //Outer pad pitch width | |
340 | Float_t fOuterPadLength; //Outer pad length | |
341 | Float_t fOuterPadWidth; //Outer pad width | |
342 | Bool_t fBMWPCReadout; //indicate wire readout - kTRUE or GEM readout -kFALSE | |
343 | Int_t fNCrossRows; //number of rows to crostalk calculation | |
344 | ||
345 | Int_t fNRowLow; //number of pad rows per low sector -calculated | |
346 | Int_t fNRowUp; //number of pad rows per sector up -calculated | |
347 | Int_t fNtRows; //total number of rows in TPC -calculated | |
348 | Float_t fPadRowLow[600]; //Lower sector, pad row radii -calculated | |
349 | Float_t fPadRowUp[600]; //Upper sector, pad row radii -calculated | |
350 | Int_t fNPadsLow[600]; //Lower sector, number of pads per row -calculated | |
351 | Int_t fNPadsUp[600]; //Upper sector, number of pads per row -calculated | |
8c555625 | 352 | //--------------------------------------------------------------------- |
353 | // ALICE TPC Gas Parameters | |
354 | //-------------------------------------------------------------------- | |
355 | Float_t fDiffT; //tangencial diffusion constant | |
356 | Float_t fDiffL; //longutudinal diffusion constant | |
357 | Float_t fGasGain; //gas gain constant | |
cc80f89e | 358 | Float_t fDriftV; //drift velocity constant |
8c555625 | 359 | Float_t fOmegaTau; //omega tau ExB coeficient |
360 | Float_t fAttCoef; //attachment coefitients | |
361 | Float_t fOxyCont; //oxygen content | |
362 | //--------------------------------------------------------------------- | |
363 | // ALICE TPC Electronics Parameters | |
364 | //-------------------------------------------------------------------- | |
365 | Float_t fPadCoupling; //coupling factor ration of anode signal | |
366 | //and total pads signal | |
cc80f89e | 367 | Int_t fZeroSup; //zero suppresion constant |
368 | Float_t fNoise; //noise sigma constant | |
369 | Float_t fChipGain; //preamp shaper constant | |
370 | Float_t fChipNorm; //preamp shaper normalisation | |
371 | Float_t fTSample; //sampling time | |
372 | Float_t fZWidth; //derived value calculated using TSample and driftw -computed | |
373 | Float_t fTSigma; //width of the Preamp/Shaper function | |
374 | Int_t fMaxTBin; //maximum time bin number | |
375 | Int_t fADCSat; //saturation value of ADC (10 bits) | |
376 | Float_t fADCDynRange; //input dynamic range (mV) | |
377 | Float_t fTotalNormFac; //full normalisation factor - calculated | |
378 | Float_t fNoiseNormFac; //normalisation factor to transform noise in electron to ADC channel | |
379 | ||
380 | ||
381 | protected: | |
382 | //--------------------------------------------------------------------- | |
383 | // ALICE TPC response data | |
384 | //--------------------------------------------------------------------- | |
385 | Int_t fNResponseMax; //maximal dimension of response | |
386 | Float_t fResponseThreshold; //threshold for accepted response | |
387 | Int_t fCurrentMax; //current maximal dimension -calulated | |
388 | Int_t *fResponseBin; //array with bins -calulated | |
389 | Float_t *fResponseWeight; //array with response -calulated | |
390 | ||
8c555625 | 391 | ClassDef(AliTPCParam,2) //parameter object for set:TPC |
392 | }; | |
393 | ||
cc80f89e | 394 | |
395 | inline Int_t * AliTPCParam::GetResBin(Int_t i) | |
396 | { | |
397 | //return response bin i - bin given by padrow [0] pad[1] timebin[2] | |
398 | if (i<fCurrentMax) return &fResponseBin[i*3]; | |
399 | else return 0; | |
400 | }; | |
401 | ||
402 | inline Float_t AliTPCParam::GetResWeight(Int_t i) | |
403 | { | |
404 | //return weight of response bin i | |
405 | if (i<fCurrentMax) return fResponseWeight[i]; | |
406 | else return 0; | |
407 | } | |
8c555625 | 408 | |
cc80f89e | 409 | |
1283eee5 | 410 | ///////////////////////////////////////////////////////////////////////////// |
411 | // | |
412 | //--------------------------------------------------------------------- | |
413 | // ALICE TPC Cluster Parameters | |
414 | //-------------------------------------------------------------------- | |
415 | // | |
416 | // | |
417 | // Sigma rphi | |
cc80f89e | 418 | const Float_t a_rphi=0.41818e-2; |
1283eee5 | 419 | const Float_t b_rphi=0.17460e-4; |
420 | const Float_t c_rphi=0.30993e-2; | |
421 | const Float_t d_rphi=0.41061e-3; | |
422 | // Sigma z | |
423 | const Float_t a_z=0.39614e-2; | |
424 | const Float_t b_z=0.22443e-4; | |
425 | const Float_t c_z=0.51504e-1; | |
426 | // Cluster width in rphi | |
427 | const Float_t ac_rphi=0.18322; | |
428 | const Float_t bc_rphi=0.59551e-3; | |
429 | const Float_t cc_rphi=0.60952e-1; | |
430 | // Cluster width in z | |
431 | const Float_t ac_z=0.19081; | |
432 | const Float_t bc_z=0.55938e-3; | |
433 | const Float_t cc_z=0.30428; | |
cc80f89e | 434 | |
435 | ||
436 | ||
437 | void AliTPCParam::AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const | |
438 | { | |
439 | // | |
440 | //set cosinus and sinus of rotation angles for sector isec | |
441 | // | |
442 | cos=fRotAngle[isec*4]; | |
443 | sin=fRotAngle[isec*4+1]; | |
444 | } | |
445 | ||
446 | Float_t AliTPCParam::GetAngle(Int_t isec) const | |
447 | { | |
448 | // | |
449 | //return rotation angle of given sector | |
450 | // | |
451 | return fRotAngle[isec*4+2]; | |
452 | } | |
453 | ||
454 | ||
455 | inline void AliTPCParam::Transform1to2(Float_t *xyz, Int_t *index) const | |
456 | { | |
457 | //transformation to rotated coordinates | |
458 | //we must have information about sector! | |
459 | ||
460 | //rotate to given sector | |
461 | Float_t cos,sin; | |
462 | AdjustCosSin(index[1],cos,sin); | |
463 | Float_t x1=xyz[0]*cos + xyz[1]*sin; | |
464 | Float_t y1=-xyz[0]*sin + xyz[1]*cos; | |
465 | xyz[0]=x1; | |
466 | xyz[1]=y1; | |
467 | xyz[2]=fZLength-TMath::Abs(xyz[2]); | |
468 | index[0]=2; | |
469 | } | |
470 | ||
471 | inline void AliTPCParam::Transform2to1(Float_t *xyz, Int_t *index) const | |
472 | { | |
473 | // | |
474 | //transformation from rotated coordinates to global coordinates | |
475 | // | |
476 | Float_t cos,sin; | |
477 | AdjustCosSin(index[1],cos,sin); | |
478 | Float_t x1=xyz[0]*cos - xyz[1]*sin; | |
479 | Float_t y1=xyz[0]*sin + xyz[1]*cos; | |
480 | xyz[0]=x1; | |
481 | xyz[1]=y1; | |
482 | xyz[2]=fZLength-xyz[2]; | |
483 | if (index[1]<fNInnerSector) | |
484 | if ( index[1]>=(fNInnerSector>>1)) xyz[2]*=-1.; | |
485 | else | |
486 | if ( (index[1]-fNInnerSector) > (fNOuterSector>>1) ) xyz[2]*=-1; | |
487 | index[0]=1; | |
488 | } | |
489 | ||
490 | inline void AliTPCParam::Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const | |
491 | { | |
492 | //transform rotated coordinats of one sector to rotated | |
493 | //coordinates relative to another sector | |
494 | Transform2to1(xyz,index); | |
495 | Transform1to2(xyz,oindex); | |
496 | index[0]=2; | |
497 | index[1]=oindex[1]; | |
498 | } | |
499 | ||
500 | inline Float_t AliTPCParam::Transform2to2NearestWire(Float_t *xyz, Int_t *index) const | |
501 | { | |
502 | // | |
503 | // asigns the x-position of the closest wire to xyz[0], return the | |
504 | // electron to closest wire distance | |
505 | // | |
506 | Float_t xnew,dx; | |
507 | if (index[1]<fNInnerSector) { | |
508 | xnew = fRInnerFirstWire+TMath::Nint((xyz[0]-fRInnerFirstWire)/fInnerWWPitch)*fInnerWWPitch; | |
509 | } | |
510 | else { | |
511 | xnew = fROuterFirstWire+TMath::Nint((xyz[0]-fROuterFirstWire)/fOuterWWPitch)*fOuterWWPitch; | |
512 | } | |
513 | dx = xnew-xyz[0]; | |
514 | xyz[0]=xnew; | |
515 | return dx; | |
516 | } | |
517 | ||
518 | inline Int_t AliTPCParam::Transform2to3(Float_t *xyz, Int_t *index) const | |
519 | { | |
520 | // | |
521 | //calulates coresponding pad row number, sets index[2] for straight rows | |
522 | //does not change xyz[] information | |
523 | //valid only for straight row | |
524 | // | |
525 | if (index[1]<fNInnerSector) | |
526 | index[2] =TMath::Nint((xyz[0]-fPadRowLow[0])/fInnerPadPitchLength); | |
527 | else | |
528 | index[2] = TMath::Nint((xyz[0]-fPadRowUp[0])/fOuterPadPitchLength); | |
529 | index[0]=3; | |
530 | return index[2]; | |
531 | } | |
532 | ||
533 | inline void AliTPCParam::Transform3to4(Float_t *xyz, Int_t *index) const | |
534 | { | |
535 | // | |
536 | //valid only for straight rows straight rows | |
537 | //calculate xyz[0] position relative to given index | |
538 | // | |
539 | if (index[1]<fNInnerSector) | |
540 | xyz[0] -=index[2]*fInnerPadPitchLength+fPadRowLow[0]; | |
541 | else | |
542 | xyz[0] -=index[2]*fOuterPadPitchLength+fPadRowUp[0]; | |
543 | index[0] =4; | |
544 | } | |
545 | ||
546 | inline void AliTPCParam::Transform4to3(Float_t *xyz, Int_t *index) const | |
547 | { | |
548 | // | |
549 | //valid only for straight rows | |
550 | //transforms relative xyz[0] to the global one within given sector | |
551 | // | |
552 | if (index[1]<fNInnerSector) | |
553 | xyz[0] +=index[2]*fInnerPadPitchLength+fPadRowLow[0]; | |
554 | else | |
555 | xyz[0] +=index[2]*fOuterPadPitchLength+fPadRowUp[0]; | |
556 | index[0] =3; | |
557 | } | |
558 | ||
559 | ||
560 | inline void AliTPCParam::Transform2to5( Float_t *xyz, Int_t *index) const | |
561 | { | |
562 | // | |
563 | //transform [x,y,z] to [r,phi,z] | |
564 | // | |
565 | Float_t angle; | |
566 | Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]); | |
567 | if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0; | |
568 | else | |
569 | { | |
570 | angle =TMath::ASin(xyz[1]/r); | |
571 | if (xyz[0]<0) angle=TMath::Pi()-angle; | |
572 | if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle; | |
573 | } | |
574 | xyz[0]=r; | |
575 | xyz[1]=angle; | |
576 | index[0]=5; | |
577 | } | |
578 | ||
579 | inline void AliTPCParam::Transform5to2( Float_t *xyz, Int_t *index) const | |
580 | { | |
581 | // | |
582 | //transform [r,rphi,z] to [x,y,z] | |
583 | // | |
584 | Float_t r = xyz[0]; | |
585 | Float_t angle= xyz[1]; | |
586 | xyz[0]=r*TMath::Cos(angle); | |
587 | xyz[1]=r*TMath::Sin(angle); | |
588 | index[0]=2; | |
589 | } | |
590 | ||
591 | inline void AliTPCParam::Transform4to8(Float_t *xyz, Int_t *index) const | |
592 | { | |
593 | // | |
594 | //transform xyz coordinates to 'digit' coordinates | |
595 | // | |
596 | if (index[1]<fNInnerSector) { | |
597 | xyz[0]/=fInnerPadPitchLength; | |
598 | xyz[1]/=fInnerPadPitchWidth; | |
599 | xyz[2]/=fZWidth; | |
600 | } | |
601 | else{ | |
602 | xyz[0]/=fOuterPadPitchLength; | |
603 | xyz[1]/=fOuterPadPitchWidth; | |
604 | xyz[2]/=fZWidth; | |
605 | } | |
606 | index[0]=8; | |
607 | } | |
608 | ||
609 | inline void AliTPCParam::Transform8to4(Float_t *xyz, Int_t *index) const | |
610 | { | |
611 | // | |
612 | //transforms 'digit' coordinates to xyz coordinates | |
613 | // | |
614 | if (index[1]<fNInnerSector) { | |
615 | xyz[0]*=fInnerPadPitchLength; | |
616 | xyz[1]*=fInnerPadPitchWidth; | |
617 | xyz[2]*=fZWidth; | |
618 | } | |
619 | else{ | |
620 | xyz[0]*=fOuterPadPitchLength; | |
621 | xyz[1]*=fOuterPadPitchWidth; | |
622 | xyz[2]*=fZWidth; | |
623 | } | |
624 | index[0]=4; | |
625 | } | |
626 | ||
627 | inline void AliTPCParam::Transform6to8(Float_t *xyz, Int_t *index) const | |
628 | { | |
629 | // | |
630 | //transforms cylindrical xyz coordinates to 'digit' coordinates | |
631 | // | |
632 | ||
633 | if (index[1]<fNInnerSector) { | |
634 | xyz[0]/=fInnerPadPitchLength; | |
635 | xyz[1]*=xyz[0]/fInnerPadPitchWidth; | |
636 | xyz[2]/=fZWidth; | |
637 | } | |
638 | else{ | |
639 | xyz[0]/=fOuterPadPitchLength; | |
640 | xyz[1]*=xyz[0]/fOuterPadPitchWidth; | |
641 | xyz[2]/=fZWidth; | |
642 | } | |
643 | index[0]=8; | |
644 | } | |
645 | ||
646 | inline void AliTPCParam::Transform8to6(Float_t *xyz, Int_t *index) const | |
647 | { | |
648 | // | |
649 | //transforms 'digit' coordinates to cylindrical xyz coordinates | |
650 | // | |
651 | ||
652 | if (index[1]<fNInnerSector) { | |
653 | xyz[0]*=fInnerPadPitchLength; | |
654 | xyz[1]/=xyz[0]/fInnerPadPitchWidth; | |
655 | xyz[2]*=fZWidth; | |
656 | } | |
657 | else{ | |
658 | xyz[0]*=fOuterPadPitchLength; | |
659 | xyz[1]/=xyz[0]/fOuterPadPitchWidth; | |
660 | xyz[2]*=fZWidth; | |
661 | } | |
662 | index[0]=6; | |
663 | } | |
8c555625 | 664 | |
665 | ||
666 | ||
667 | #endif |