New macro "MUONreco.C" for using the event reconstruction package in C++
[u/mrichter/AliRoot.git] / TPC / AliTPCParam.h
CommitLineData
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 16const Float_t z_end = 250.;
17const Float_t alpha_low=0.34906585; // 20 degrees
18const Float_t alpha_up=0.34906585; // 20 degrees
19const Float_t q_el = 1.602e-19; // elementary charge
20const Float_t adc_sat = 1023; // dynamic range (10 bits)
21const Float_t dyn_range = 2000.; // output dynamic range (mV)
22//
1283eee5 23
8c555625 24
cc80f89e 25class 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 32public:
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 &sector, 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 &sector, 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
290protected :
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
381protected:
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
395inline 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
402inline 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 418const Float_t a_rphi=0.41818e-2;
1283eee5 419const Float_t b_rphi=0.17460e-4;
420const Float_t c_rphi=0.30993e-2;
421const Float_t d_rphi=0.41061e-3;
422// Sigma z
423const Float_t a_z=0.39614e-2;
424const Float_t b_z=0.22443e-4;
425const Float_t c_z=0.51504e-1;
426// Cluster width in rphi
427const Float_t ac_rphi=0.18322;
428const Float_t bc_rphi=0.59551e-3;
429const Float_t cc_rphi=0.60952e-1;
430// Cluster width in z
431const Float_t ac_z=0.19081;
432const Float_t bc_z=0.55938e-3;
433const Float_t cc_z=0.30428;
cc80f89e 434
435
436
437void 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
446Float_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
455inline 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
471inline 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
490inline 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
500inline 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
518inline 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
533inline 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
546inline 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
560inline 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
579inline 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
591inline 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
609inline 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
627inline 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
646inline 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