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