Line data Source code
1 : #ifndef ALITPCPARAM_H
2 : #define ALITPCPARAM_H
3 : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 : * See cxx source for full Copyright notice */
5 :
6 :
7 : /// \class AliTPCParam
8 : /// \brief Manager class for TPC parameters
9 :
10 : #include "AliDetectorParam.h"
11 : #include "TMath.h"
12 :
13 : #include <TGeoMatrix.h>
14 : #include <TVectorD.h>
15 : class TString;
16 : class TGraphErrors;
17 :
18 : class AliTPCParam : public AliDetectorParam {
19 : //////////////////////////////////////////////////////
20 : //////////////////////////////////////////////////////
21 : //ALITPCParam object to be possible change
22 : //geometry and some other parameters of TPC
23 : //used by AliTPC and AliTPCSector
24 :
25 : public:
26 : AliTPCParam();
27 : virtual ~AliTPCParam();
28 : TGeoHMatrix * Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const;
29 : virtual Bool_t Transform(Float_t *xyz, Int_t *index, Int_t* oindex);
30 : //transformation from input coodination system to output coordination system
31 : Int_t Transform0to1(Float_t *xyz, Int_t *index) const;
32 : //trasforamtion from global to global - adjust index[0] sector
33 : //return value is equal to sector corresponding to global position
34 : void Transform1to2Ideal(Float_t *xyz, Int_t *index) const;
35 : //transformation to rotated coordinata - ideal frame
36 : void Transform1to2(Float_t *xyz, Int_t *index) const;
37 : //transformation to rotated coordinata
38 : void Transform2to1(Float_t *xyz, Int_t *index) const;
39 : //transformation from rotated coordinata to global coordinata
40 : void Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const;
41 : //transform rotated coordinata of one sector to rotated
42 : //coordinata relative to another sector
43 : Float_t Transform2to2NearestWire(Float_t *xyz, Int_t *index) const;
44 : //round x position to nearest wire
45 : Int_t Transform2to3(Float_t *xyz, Int_t *index) const;
46 : //calulate coresponding index[2] -pad row for straight rows
47 : //does not change xyz[]
48 : //return pad - row
49 : void Transform3to4(Float_t *xyz, Int_t *index) const;
50 : //valid only for straight rows straight rows
51 : //calculate xyz[0] position relative to given index
52 : //return pad - row
53 : void Transform4to3(Float_t *xyz, Int_t *index) const;
54 : //valid only for straight rows straight rows
55 : //transform xyz[0] position relative to given index
56 : void Transform2to5( Float_t *xyz, Int_t *index) const;
57 : //transform [x,y,z] to [r,rphi,z]
58 : void Transform5to2(Float_t *xyz, Int_t *index) const;
59 : //transform [r,rphi,z] coordinata to [x,y,z]
60 : void Transform4to8(Float_t *xyz, Int_t *index) const;
61 : //transform xyz coordinata to 'digit' coordinata
62 : void Transform8to4(Float_t *xyz, Int_t *index) const;
63 : //transform 'digit' coordinata to xyz coordinata
64 : void Transform6to8(Float_t *xyz, Int_t *index) const;
65 : //transform dr,f coordinata to 'digit' coordinata
66 : void Transform8to6(Float_t *xyz, Int_t *index) const;
67 : //transform 'digit' coordinata to dr,f coordinata
68 :
69 0 : virtual Int_t Transform2toPadRow(Float_t */*xyz*/, Int_t */*index*/) const{return 0;}
70 : //transform rotated to
71 :
72 : virtual Int_t GetPadRow(Float_t *xyz, Int_t *index) const ;
73 : //return pad row of point xyz - xyz is given in coordinate system -(given by index)
74 : //output system is 3 for straight row and 7 for cylindrical row
75 : virtual void XYZtoCRXYZ(Float_t */*xyz*/,
76 0 : Int_t &/*sector*/, Int_t &/*padrow*/, Int_t /*option*/) const {;}
77 : //transform global position to the position relative to the sector padrow
78 : //if option=0 X calculate absolute calculate sector
79 : //if option=1 X absolute use input sector
80 : //if option=2 X relative to pad row calculate sector
81 : //if option=3 X relative use input sector
82 :
83 : virtual void CRXYZtoXYZ(Float_t */*xyz*/,
84 0 : const Int_t &/*sector*/, const Int_t & /*padrow*/, Int_t /*option*/) const {;}
85 : //transform relative position to the gloabal position
86 :
87 : virtual void CRTimePadtoYZ(Float_t &/*y*/, Float_t &/*z*/,
88 : const Float_t &/*time*/, const Float_t &/*pad*/,
89 0 : Int_t /*sector*/, Int_t /*padrow*/ ){;}
90 : //transform position in digit units (time slices and pads) to "normal"
91 : //units (cm)
92 : virtual void CRYZtoTimePad(const Float_t &/*y*/, const Float_t &/*z*/,
93 : Float_t &/*time*/, Float_t &/*pad*/,
94 0 : Int_t /*sector*/, Int_t /*padrow*/){;}
95 : //transform position in cm to position in digit unit
96 0 : virtual Int_t CalcResponse(Float_t* /*x*/, Int_t * /*index*/, Int_t /*row*/){return 0;}
97 : //calculate bin response as function of the input position -x and the weight
98 : //if row -pad row is equal -1 calculate response for each pad row
99 : //otherwise it calculate only in given pad row
100 : //return number of valid response bin
101 : virtual void SetDefault(); //set defaut TPCparam
102 : virtual Bool_t Update(); //recalculate and check geometric parameters
103 : virtual Bool_t ReadGeoMatrices(); //read geo matrixes
104 : Bool_t GetStatus() const; //get information about object consistency
105 : Int_t GetIndex(Int_t sector, Int_t row) const; //give index of the given sector and pad row
106 0 : Int_t GetNSegmentsTotal() const {return fNtRows;}
107 0 : Double_t GetLowMaxY(Int_t irow) const {return irow*0.;}
108 0 : Double_t GetUpMaxY(Int_t irow) const {return irow*0;}
109 : //additional geometrical function - for Belikov
110 :
111 : Bool_t AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const; //return sector and padrow
112 : //for given index
113 :
114 : void AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const;
115 : //set cosinus and sinus of rotation angles for sector isec
116 : Float_t GetAngle(Int_t isec) const;
117 : // void GetChamberPos(Int_t isec, Float_t* xyz) const;
118 : // void GetChamberRot(Int_t isec, Float_t* angles) const;
119 : //
120 : //set sector parameters
121 : //
122 72 : void SetInnerRadiusLow(Float_t InnerRadiusLow ) { fInnerRadiusLow=InnerRadiusLow;}
123 72 : void SetOuterRadiusLow(Float_t OuterRadiusLow ) { fOuterRadiusLow=OuterRadiusLow;}
124 72 : void SetInnerRadiusUp(Float_t InnerRadiusUp) { fInnerRadiusUp= InnerRadiusUp;}
125 72 : void SetOuterRadiusUp(Float_t OuterRadiusUp) { fOuterRadiusUp= OuterRadiusUp;}
126 : void SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
127 : Float_t outershift);
128 72 : void SetInnerFrameSpace(Float_t frspace) {fInnerFrameSpace = frspace;}
129 72 : void SetOuterFrameSpace(Float_t frspace) {fOuterFrameSpace = frspace;}
130 72 : void SetInnerWireMount(Float_t fmount) {fInnerWireMount = fmount;}
131 72 : void SetOuterWireMount(Float_t fmount) {fOuterWireMount = fmount;}
132 72 : void SetZLength(Float_t zlength) {fZLength = zlength;}
133 72 : void SetGeometryType(Int_t type) {fGeometryType = type;}
134 : //
135 : // pad rows geometry
136 : //
137 72 : void SetRowNLow( Int_t NRowLow){fNRowLow = NRowLow;}
138 72 : void SetRowNUp1 (Int_t NRowUp1){fNRowUp1 = NRowUp1 ;} //upper sec short pads
139 72 : void SetRowNUp2 (Int_t NRowUp2){fNRowUp2 = NRowUp2 ;} //upper sec long pads
140 72 : void SetRowNUp (Int_t NRowUp){fNRowUp = NRowUp ;}
141 : //
142 : //set wire parameters
143 : //
144 72 : void SetInnerNWires(Int_t nWires){ fNInnerWiresPerPad=nWires;}
145 72 : void SetInnerDummyWire(Int_t dummy) {fInnerDummyWire = dummy;}
146 72 : void SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;}
147 72 : void SetOuter1NWires(Int_t nWires){ fNOuter1WiresPerPad=nWires;}
148 72 : void SetOuter2NWire(Int_t nWires){ fNOuter2WiresPerPad=nWires;}
149 72 : void SetOuterDummyWire(Int_t dummy) {fOuterDummyWire = dummy;}
150 72 : void SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;}
151 72 : void SetInnerWWPitch( Float_t wwPitch) {fInnerWWPitch = wwPitch;}
152 72 : void SetRInnerFirstWire(Float_t firstWire){fRInnerFirstWire = firstWire;}
153 72 : void SetRInnerLastWire(Float_t lastWire){fRInnerLastWire = lastWire;}
154 72 : void SetOuterWWPitch(Float_t wwPitch){fOuterWWPitch = wwPitch;}
155 0 : void SetLastWireUp1(Float_t wireUp1){fLastWireUp1 = wireUp1;}
156 72 : void SetROuterFirstWire(Float_t firstWire){fROuterFirstWire = firstWire;}
157 72 : void SetROuterLastWire(Float_t lastWire){fROuterLastWire = lastWire;}
158 : //
159 : //set pad parameter
160 : //
161 72 : void SetInnerPadPitchLength(Float_t PadPitchLength){ fInnerPadPitchLength=PadPitchLength;}
162 72 : void SetInnerPadPitchWidth(Float_t PadPitchWidth){ fInnerPadPitchWidth = PadPitchWidth;}
163 72 : void SetInnerPadLength(Float_t PadLength){ fInnerPadLength=PadLength;}
164 72 : void SetInnerPadWidth(Float_t PadWidth) { fInnerPadWidth=PadWidth;}
165 72 : void SetOuter1PadPitchLength(Float_t PadPitchLength){ fOuter1PadPitchLength=PadPitchLength;}
166 72 : void SetOuter2PadPitchLength(Float_t PadPitchLength){ fOuter2PadPitchLength=PadPitchLength;}
167 72 : void SetOuterPadPitchWidth(Float_t PadPitchWidth){ fOuterPadPitchWidth = PadPitchWidth;}
168 72 : void SetOuter1PadLength(Float_t PadLength){ fOuter1PadLength=PadLength;}
169 72 : void SetOuter2PadLength(Float_t PadLength){ fOuter2PadLength=PadLength;}
170 72 : void SetOuterPadWidth(Float_t PadWidth) { fOuterPadWidth=PadWidth;}
171 36 : void SetMWPCReadout(Bool_t type) {fBMWPCReadout = type;}
172 72 : void SetNCrossRows(Int_t rows){fNCrossRows = rows;}
173 : //
174 : //set gas paremeters
175 : //
176 72 : void SetDiffT(Float_t DiffT){ fDiffT= DiffT;}
177 72 : void SetDiffL(Float_t DiffL){ fDiffL=DiffL;}
178 72 : void SetGasGain(Float_t GasGain){ fGasGain=GasGain;}
179 0 : void SetRegionGain(UInt_t region, Float_t gain) { fRegionGain[region%3] = gain; }
180 72 : void SetDriftV(Float_t DriftV){ fDriftV= DriftV;}
181 72 : void SetOmegaTau(Float_t OmegaTau){ fOmegaTau=OmegaTau;}
182 72 : void SetAttCoef(Float_t AttCoef){ fAttCoef=AttCoef;}
183 72 : void SetOxyCont(Float_t OxyCont){ fOxyCont=OxyCont;}
184 0 : void SetGainSlopesHV(TGraphErrors * gainSlopesHV){ fGainSlopesHV=gainSlopesHV;}
185 0 : void SetGainSlopesPT(TGraphErrors * gainSlopesPT){ fGainSlopesPT=gainSlopesPT;}
186 : void SetNominalGainSlopes();
187 72 : void SetComposition(Float_t c1, Float_t c2, Float_t c3, Float_t c4, Float_t c5, Float_t c6){fComposition[0]=c1;
188 36 : fComposition[1]=c2;
189 36 : fComposition[2]=c3;
190 36 : fComposition[3]=c4;
191 36 : fComposition[4]=c5;
192 36 : fComposition[5]=c6;}
193 72 : void SetFpot(Float_t fpot){fFpot=fpot;}
194 72 : void SetNprim(Float_t prim){fNprim=prim;}
195 72 : void SetNtot(Float_t ntot){fNtot=ntot;}
196 72 : void SetWmean(Float_t wmean){fWmean=wmean;}
197 72 : void SetExp(Float_t exp){fExp=exp;}
198 72 : void SetEend(Float_t end){fEend=end;}
199 : void SetBetheBloch(TVectorD *v){
200 108 : if (fBetheBloch) delete fBetheBloch;
201 36 : fBetheBloch=0;
202 108 : if (v) fBetheBloch=new TVectorD(*v);
203 36 : }
204 : void SetBetheBlochMC(TVectorD *v){
205 108 : if (fBetheBlochMC) delete fBetheBlochMC;
206 36 : fBetheBlochMC=0;
207 108 : if (v) fBetheBlochMC=new TVectorD(*v);
208 36 : }
209 : static TVectorD * GetBetheBlochParamNa49();
210 : static TVectorD * GetBetheBlochParamAlice();
211 : static TVectorD * GetBetheBlochParamAliceMC();
212 : static void RegisterBBParam(TVectorD* param, Int_t position);
213 : //
214 : //set electronivc parameters
215 : //
216 72 : void SetPadCoupling(Float_t PadCoupling){ fPadCoupling=PadCoupling;}
217 72 : void SetZeroSup(Int_t ZeroSup) { fZeroSup=ZeroSup;}
218 72 : void SetNoise(Float_t Noise ) { fNoise= Noise;}
219 72 : void SetChipGain(Float_t ChipGain){ fChipGain= ChipGain;}
220 72 : void SetChipNorm(Float_t ChipNorm){ fChipNorm= ChipNorm;}
221 72 : void SetTSample(Float_t TSample) { fTSample=TSample;}
222 72 : void SetTFWHM(Float_t fwhm) { fTSigma=fwhm/2.35;}
223 72 : void SetMaxTBin(Int_t maxtbin) { fMaxTBin = maxtbin;}
224 72 : void SetADCSat(Int_t adcsat) { fADCSat = adcsat;}
225 72 : void SetADCDynRange(Float_t adcdynrange) {fADCDynRange = adcdynrange;}
226 0 : void SetUseGlitchFilter(Bool_t use) {fUseGlitchFilter=use;}
227 : //
228 : // High voltage parameters
229 : //
230 10368 : void SetNominalVoltage(Float_t v, UInt_t i) {if (i<72) fNominalVoltage[i]=v;}
231 0 : void SetMaxVoltageDeviation(Float_t voltage) { fMaxVoltageDeviation=voltage; }
232 0 : void SetMaxDipVoltage(Float_t voltage) { fMaxDipVoltage=voltage; }
233 0 : void SetMaxFractionHVbad(Float_t frac ) { fMaxHVfractionBad=frac; }
234 0 : void SetVoltageDipScanPeriod(Float_t period) { fVoltageDipScanPeriod=period; }
235 : //
236 : //set response parameters
237 : //
238 72 : void SetNResponseMax(Int_t max) { fNResponseMax = max;}
239 72 : void SetResponseThreshold(Int_t threshold) {fResponseThreshold = threshold;}
240 : //set L1 parameters
241 72 : void SetGateDelay(Float_t delay) {fGateDelay = delay;}
242 72 : void SetL1Delay(Float_t delay) {fL1Delay = delay;}
243 72 : void SetNTBinsBeforeL1(UShort_t nbins) {fNTBinsBeforeL1 = nbins;}
244 : //
245 : //get sector parameters
246 : //
247 1649334 : Float_t GetInnerRadiusLow() const {return fInnerRadiusLow;}
248 1615734 : Float_t GetInnerRadiusUp() const {return fInnerRadiusUp;}
249 2270058 : Float_t GetOuterRadiusLow() const {return fOuterRadiusLow;}
250 755078 : Float_t GetOuterRadiusUp() const {return fOuterRadiusUp;}
251 0 : Float_t GetInnerFrameSpace() const {return fInnerFrameSpace;}
252 0 : Float_t GetOuterFrameSpace() const {return fOuterFrameSpace;}
253 0 : Float_t GetInnerWireMount() const {return fInnerWireMount;}
254 0 : Float_t GetOuterWireMount() const {return fOuterWireMount;}
255 : Float_t GetInnerAngle() const ;
256 : Float_t GetInnerAngleShift() const ;
257 : Float_t GetOuterAngle() const ;
258 : Float_t GetOuterAngleShift() const ;
259 5291572 : Int_t GetNInnerSector() const {return fNInnerSector;}
260 902936 : Int_t GetNOuterSector() const {return fNOuterSector;}
261 212134 : Int_t GetNSector() const {return fNSector;}
262 : Float_t GetZLength(Int_t sector=0) const;
263 0 : Int_t GetGeometryType() const {return fGeometryType;}
264 :
265 : //
266 : //get wires parameter
267 : //
268 0 : Int_t GetInnerNWires() const {return fNInnerWiresPerPad;}
269 0 : Float_t GetInnerWWPitch() const {return fInnerWWPitch;}
270 0 : Int_t GetInnerDummyWire() const {return fInnerDummyWire;}
271 0 : Float_t GetInnerOffWire() const {return fInnerOffWire;}
272 0 : Float_t GetRInnerFirstWire() const {return fRInnerFirstWire;}
273 0 : Float_t GetRInnerLastWire() const {return fRInnerLastWire;}
274 0 : Int_t GetOuter1NWires() const {return fNOuter1WiresPerPad;}
275 0 : Int_t GetOuter2NWires() const {return fNOuter2WiresPerPad;}
276 0 : Float_t GetOuterWWPitch() const {return fOuterWWPitch;}
277 0 : Int_t GetOuterDummyWire() const {return fOuterDummyWire;}
278 0 : Float_t GetOuterOffWire() const {return fOuterOffWire;}
279 0 : Float_t GetLastWireUp1() const {return fLastWireUp1;}
280 0 : Float_t GetROuterFirstWire() const {return fROuterFirstWire;}
281 0 : Float_t GetROuterLastWire() const {return fROuterLastWire;}
282 : Float_t GetWWPitch(Int_t isector = 0) const {
283 530592 : return ( (isector < fNInnerSector) ? fInnerWWPitch :fOuterWWPitch);}
284 : //
285 : //get pad parameters
286 : //
287 72 : Float_t GetInnerPadPitchLength() const {return fInnerPadPitchLength;}
288 72 : Float_t GetInnerPadPitchWidth() const {return fInnerPadPitchWidth;}
289 0 : Float_t GetInnerPadLength() const {return fInnerPadLength;}
290 0 : Float_t GetInnerPadWidth() const {return fInnerPadWidth;}
291 144 : Float_t GetOuter1PadPitchLength() const {return fOuter1PadPitchLength;}
292 72 : Float_t GetOuter2PadPitchLength() const {return fOuter2PadPitchLength;}
293 72 : Float_t GetOuterPadPitchWidth() const {return fOuterPadPitchWidth;}
294 0 : Float_t GetOuter1PadLength() const {return fOuter1PadLength;}
295 0 : Float_t GetOuter2PadLength() const {return fOuter2PadLength;}
296 0 : Float_t GetOuterPadWidth() const {return fOuterPadWidth;}
297 3382744 : Bool_t GetMWPCReadout() const {return fBMWPCReadout;}
298 0 : Int_t GetNCrossRows() const {return fNCrossRows;}
299 : Float_t GetPadPitchWidth(Int_t isector = 0) const {
300 2023476 : return ( (isector < fNInnerSector) ? fInnerPadPitchWidth :fOuterPadPitchWidth);}
301 : Float_t GetPadPitchLength(Int_t isector = 0, Int_t padrow=0) const
302 764117 : { if (isector < fNInnerSector) return fInnerPadPitchLength;
303 793559 : else return ((padrow<fNRowUp1) ? fOuter1PadPitchLength:fOuter2PadPitchLength);}
304 : Int_t GetNRowLow() const; //get the number of pad rows in low sector
305 : Int_t GetNRowUp() const; //get the number of pad rows in up sector
306 : Int_t GetNRowUp1() const; // number of short rows in up sector
307 : Int_t GetNRowUp2() const; // number of long rows in up sector
308 6826484 : Int_t GetNRow(Int_t isec) const {return ((isec<fNInnerSector) ? fNRowLow:fNRowUp);}
309 8 : Int_t GetNRowsTotal() const {return fNtRows;} //get total nuber of rows
310 : Float_t GetPadRowRadiiLow(Int_t irow) const; //get the pad row (irow) radii
311 : Float_t GetPadRowRadiiUp(Int_t irow) const; //get the pad row (irow) radii
312 : Float_t GetPadRowRadii(Int_t isec,Int_t irow) const {
313 702500 : return ( (isec < fNInnerSector) ?GetPadRowRadiiLow(irow):GetPadRowRadiiUp(irow));}
314 : //retrun radii of the pad row irow in sector i
315 : Int_t GetNPadsLow(Int_t irow) const; //get the number of pads in row irow
316 : Int_t GetNPadsUp(Int_t irow) const; //get the number of pads in row irow
317 : Int_t GetNPads(Int_t isector,Int_t irow) const{
318 26957500 : return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));}
319 : Int_t GetWireSegment(Int_t sector, Int_t row) const ; // get Anode wire segment index IROC --> [0,4], OROC[0,7]
320 : Int_t GetNPadsPerSegment(Int_t segmentID) const; // get number of pads for a given Anode wire segment
321 :
322 : Float_t GetYInner(Int_t irow) const; // wire length in low sec row
323 : Float_t GetYOuter(Int_t irow) const; // wire length in up sec row
324 : Int_t GetSectorIndex(Float_t angle, Int_t row, Float_t z) const; // get sector index
325 : Float_t GetChamberCenter(Int_t isec, Float_t * center = 0) const; // get readout chamber positions
326 : TGeoHMatrix *GetTrackingMatrix(Int_t isec) const {
327 0 : return fTrackingMatrix[isec];}
328 : TGeoHMatrix *GetClusterMatrix(Int_t isec) const {
329 129896 : return fClusterMatrix[isec];}
330 : TGeoHMatrix *GetGlobalMatrix(Int_t isec) const {
331 4896 : return fGlobalMatrix[isec];}
332 4 : Bool_t IsGeoRead(){ return fGlobalMatrix!=0;}
333 : //
334 : //get GAS parameters
335 : //
336 3913336 : Float_t GetDiffT() const {return fDiffT;}
337 4167624 : Float_t GetDiffL() const {return fDiffL;}
338 10296 : Float_t GetGasGain() const {return fGasGain;}
339 0 : Float_t GetRegionGain(UInt_t region) const {return fRegionGain[region%3];}
340 3456 : Float_t GetRegionGainAbsolute(UInt_t region) const { return (fRegionGain[region%3]>1e-10) ? fRegionGain[region%3]*fGasGain : fGasGain; }
341 3217920 : Float_t GetDriftV() const {return fDriftV;}
342 3382744 : Float_t GetOmegaTau() const {return fOmegaTau;}
343 1477888 : Float_t GetAttCoef() const {return fAttCoef;}
344 1477888 : Float_t GetOxyCont() const {return fOxyCont;}
345 6 : TGraphErrors * GetGainSlopesHV() const { return fGainSlopesHV;}
346 6 : TGraphErrors * GetGainSlopesPT() const { return fGainSlopesPT;}
347 2 : Float_t* GetComposition() {return fComposition;}
348 1729274 : Float_t GetFpot()const {return fFpot;}
349 1729272 : Float_t GetNprim() const {return fNprim;}
350 9720 : Float_t GetNtot() const {return fNtot;}
351 1729272 : Float_t GetWmean()const {return fWmean;}
352 2 : Float_t GetExp()const {return fExp;}
353 2 : Float_t GetEend()const {return fEend;}
354 16 : TVectorD* GetBetheBlochParameters(){return fBetheBloch;}
355 1648468 : TVectorD* GetBetheBlochParametersMC(){return fBetheBlochMC;}
356 : static Double_t BetheBlochAleph(Double_t bb, Int_t type=0);
357 : //
358 : //get Electronic parameters
359 : //
360 0 : Float_t GetPadCoupling() const {return fPadCoupling;}
361 940738 : Int_t GetZeroSup() const {return fZeroSup;}
362 8 : Float_t GetNoise() const {return fNoise;}
363 0 : Float_t GetChipGain() const {return fChipGain;}
364 0 : Float_t GetChipNorm() const {return fChipNorm;}
365 3382746 : Float_t GetTSample() const {return fTSample;}
366 1225876 : Float_t GetZWidth() const {return fZWidth;}
367 0 : Float_t GetTFWHM() const {return fTSigma*2.35;}
368 389692 : Float_t GetZSigma() const {return fTSigma*fDriftV;}
369 2 : virtual Float_t GetZOffset() const {return 3*fTSigma*fDriftV;}
370 9937298 : Int_t GetMaxTBin() const {return fMaxTBin;}
371 4284426 : Int_t GetADCSat() const {return fADCSat;}
372 0 : Float_t GetADCDynRange() const {return fADCDynRange;}
373 9845714 : Float_t GetTotalNormFac() const {return fTotalNormFac;}
374 8 : Float_t GetNoiseNormFac() const {return fNoiseNormFac;}
375 45792 : Bool_t GetUseGlitchFilter() const {return fUseGlitchFilter;}
376 : //
377 : // High voltage parameters
378 : //
379 864 : Float_t GetNominalVoltage(UInt_t i) const {return (i<72)?fNominalVoltage[i]:0;} //0-35:IROC, 36-71:OROC
380 0 : Float_t GetMaxVoltageDeviation() const { return fMaxVoltageDeviation; }
381 16 : Float_t GetMaxDipVoltage() const { return fMaxDipVoltage; }
382 0 : Float_t GetMaxFractionHVbad() const { return fMaxHVfractionBad; }
383 16 : Float_t GetVoltageDipScanPeriod() const { return fVoltageDipScanPeriod; }
384 :
385 : //
386 : // get response data
387 : //
388 : Int_t * GetResBin(Int_t i);
389 : //return response bin i - bin given by padrow [0] pad[1] timebin[2]
390 : Float_t & GetResWeight(Int_t i);
391 : //return weight of response bin i
392 :
393 : // get L1 data
394 1480188 : Float_t GetGateDelay() const {return fGateDelay;}
395 0 : Float_t GetL1Delay() const {return fL1Delay;}
396 0 : UShort_t GetNTBinsBeforeL1() const {return fNTBinsBeforeL1;}
397 3993786 : Float_t GetNTBinsL1() const {return fNTBinsL1;}
398 : protected :
399 :
400 : Bool_t fbStatus; ///< indicates consistency of the data
401 : //---------------------------------------------------------------------
402 : // ALICE TPC sector geometry
403 : //--------------------------------------------------------------------
404 : Float_t fInnerRadiusLow; ///< lower radius of inner sector-IP
405 : Float_t fInnerRadiusUp; ///< upper radius of inner sector-IP
406 : Float_t fOuterRadiusUp; ///< upper radius of outer sector-IP
407 : Float_t fOuterRadiusLow; ///< lower radius of outer sector-IP
408 : Float_t fInnerAngle; ///< opening angle of Inner sector
409 : Float_t fInnerAngleShift; ///< shift of first inner sector center to the 0
410 : Float_t fOuterAngle; ///< opening angle of outer sector
411 : Float_t fOuterAngleShift; ///< shift of first sector center to the 0
412 : Float_t fInnerFrameSpace; ///< space for inner frame in the phi direction
413 : Float_t fOuterFrameSpace; ///< space for outer frame in the phi direction
414 : Float_t fInnerWireMount; ///< space for wire mount, inner sector
415 : Float_t fOuterWireMount; ///< space for wire mount, outer sector
416 : Int_t fNInnerSector; ///< number of inner sectors -calculated
417 : Int_t fNOuterSector; ///< number of outer sectors -calculated
418 : Int_t fNSector; ///< total number of sectors -calculated
419 : Float_t fZLength; ///< length of the drift region of the TPC
420 : /// sin and cos of rotation angles for different sectors - calculated
421 : Float_t *fRotAngle; //[fNSector]
422 : Int_t fGeometryType; ///< type of geometry -0 straight rows
423 : // Float_t *fChamberPos; //[fNSector] displacements of the readout chambers
424 : //with respect to the 'idead' geometry
425 : //in local corrdinate system
426 : // Float_t *fChamberRot; //[fNSector] rotation angles of the readout chambers
427 : //with respect to the 'idead' geometry
428 : //in local corrdinate system
429 : /// transformation matrices of the tracking coordinate system
430 : TGeoHMatrix **fTrackingMatrix; //![fNSector]
431 : /// transformation matrices of the cluster coordinate system
432 : TGeoHMatrix **fClusterMatrix; //![fNSector]
433 : /// fTrackingMatrix * fClusterMatrix
434 : TGeoHMatrix **fGlobalMatrix; //![fNSector]
435 :
436 : //1-cylindrical
437 : //---------------------------------------------------------------------
438 : // ALICE TPC wires geometry - for GEM we can consider that it is gating
439 : //--------------------------------------------------------------------
440 : Int_t fNInnerWiresPerPad; ///< Number of wires per pad
441 : Float_t fInnerWWPitch; ///< pitch between wires in inner sector - calculated
442 : Int_t fInnerDummyWire; ///< number of wires without pad readout
443 : Float_t fInnerOffWire; ///< oofset of first wire to the begining of the sector
444 : Float_t fRInnerFirstWire; ///< position of the first wire -calculated
445 : Float_t fRInnerLastWire; ///< position of the last wire -calculated
446 : Float_t fLastWireUp1; ///< position of the last wire in outer1 sector
447 : Int_t fNOuter1WiresPerPad; ///< Number of wires per pad
448 : Int_t fNOuter2WiresPerPad; ///< Number of wires per pad
449 : Float_t fOuterWWPitch; ///< pitch between wires in outer sector -calculated
450 : Int_t fOuterDummyWire; ///< number of wires without pad readout
451 : Float_t fOuterOffWire; ///< oofset of first wire to the begining of the sector
452 : Float_t fROuterFirstWire; ///< position of the first wire -calulated
453 : Float_t fROuterLastWire; ///< position of the last wire -calculated
454 : //---------------------------------------------------------------------
455 : // ALICE TPC pad parameters
456 : //--------------------------------------------------------------------
457 : Float_t fInnerPadPitchLength; ///< Inner pad pitch length
458 : Float_t fInnerPadPitchWidth; ///< Inner pad pitch width
459 : Float_t fInnerPadLength; ///< Inner pad length
460 : Float_t fInnerPadWidth; ///< Inner pad width
461 : Float_t fOuter1PadPitchLength; ///< Outer pad pitch length
462 : Float_t fOuter2PadPitchLength; ///< Outer pad pitch length
463 : Float_t fOuterPadPitchWidth; ///< Outer pad pitch width
464 : Float_t fOuter1PadLength; ///< Outer pad length
465 : Float_t fOuter2PadLength; ///< Outer pad length
466 : Float_t fOuterPadWidth; ///< Outer pad width
467 : Bool_t fBMWPCReadout; ///< indicate wire readout - kTRUE or GEM readout -kFALSE
468 : Int_t fNCrossRows; ///< number of rows to crostalk calculation
469 :
470 : Int_t fNRowLow; ///< number of pad rows per low sector -set
471 : Int_t fNRowUp1; ///< number of short pad rows per sector up -set
472 : Int_t fNRowUp2; ///< number of long pad rows per sector up -set
473 : Int_t fNRowUp; ///< number of pad rows per sector up -calculated
474 : Int_t fNtRows; ///< total number of rows in TPC -calculated
475 : Float_t fPadRowLow[600]; ///< Lower sector, pad row radii -calculated
476 : Float_t fPadRowUp[600]; ///< Upper sector, pad row radii -calculated
477 : Int_t fNPadsLow[600]; ///< Lower sector, number of pads per row -calculated
478 : Int_t fNPadsUp[600]; ///< Upper sector, number of pads per row -calculated
479 : Float_t fYInner[600]; ///< Inner sector, wire-length
480 : Float_t fYOuter[600]; ///< Outer sector, wire-length
481 : //---------------------------------------------------------------------
482 : // ALICE TPC Gas Parameters
483 : //--------------------------------------------------------------------
484 : Float_t fDiffT; ///< tangencial diffusion constant
485 : Float_t fDiffL; ///< longutudinal diffusion constant
486 : Float_t fGasGain; ///< gas gain constant
487 : Float_t fRegionGain[3]; ///< gain in pad regions relative to fGasGain
488 : Float_t fDriftV; ///< drift velocity constant
489 : Float_t fOmegaTau; ///< omega tau ExB coeficient
490 : Float_t fAttCoef; ///< attachment coefitients
491 : Float_t fOxyCont; ///< oxygen content
492 : Float_t fFpot; ///< first ionisation potential
493 : Float_t fNprim; ///< number of primary electrons/cm
494 : Float_t fNtot; ///< total number of electrons/c (MIP)
495 : Float_t fWmean; ///< mean energy for electron/ion pair
496 : Float_t fExp; ///< de = f(E) - energy loss parametrization
497 : Float_t fEend; ///< upper cutoff for de generation
498 : TVectorD* fBetheBloch; ///< Bethe-Bloch parametrization
499 : TVectorD* fBetheBlochMC; ///< Bethe-Bloch parametrization
500 : // gas mixture composition
501 : Float_t fComposition[6];
502 : TGraphErrors * fGainSlopesHV; ///< graph with the gain slope as function of HV - per chamber
503 : TGraphErrors * fGainSlopesPT; ///< graph with the gain slope as function of P/T - per chamber
504 : //---------------------------------------------------------------------
505 : // ALICE TPC Electronics Parameters
506 : //--------------------------------------------------------------------
507 : Float_t fPadCoupling; ///< coupling factor ration of anode signal
508 : //and total pads signal
509 : Int_t fZeroSup; ///< zero suppresion constant
510 : Float_t fNoise; ///< noise sigma constant
511 : Float_t fChipGain; ///< preamp shaper constant
512 : Float_t fChipNorm; ///< preamp shaper normalisation
513 : Float_t fTSample; ///< sampling time
514 : Float_t fZWidth; ///< derived value calculated using TSample and driftw -computed
515 : Float_t fTSigma; ///< width of the Preamp/Shaper function
516 : Int_t fMaxTBin; ///< maximum time bin number
517 : Int_t fADCSat; ///< saturation value of ADC (10 bits)
518 : Float_t fADCDynRange; ///< input dynamic range (mV)
519 : Float_t fTotalNormFac; ///< full normalisation factor - calculated
520 : Float_t fNoiseNormFac; ///< normalisation factor to transform noise in electron to ADC channel
521 : Bool_t fUseGlitchFilter; ///< use the glitch filter to suppress single digits above threshold
522 :
523 : //---------------------------------------------------------------------
524 : // High voltage parameters
525 : //---------------------------------------------------------------------
526 : Float_t fNominalVoltage[72]; ///< nominal voltage in [V] per chamber
527 : Float_t fMaxVoltageDeviation; ///< maximum voltage deviation from nominal voltage before a chamber is masked
528 : Float_t fMaxDipVoltage; ///< maximum voltage deviation from median before a dip event is marked
529 : Float_t fMaxHVfractionBad; ///< maximum fraction of bad HV entries (deviation from Median) before a chamber is marked bad
530 : Float_t fVoltageDipScanPeriod; ///< scanning period to detect a high volrage dip: event time stamp +- fVoltageDipScanPeriod [sec]
531 :
532 : //---------------------------------------------------------------------
533 : // ALICE TPC response data
534 : //---------------------------------------------------------------------
535 : Int_t fNResponseMax; ///< maximal dimension of response
536 : Float_t fResponseThreshold; ///< threshold for accepted response
537 : Int_t fCurrentMax; //!<! current maximal dimension -calulated
538 : Int_t *fResponseBin; //!<! array with bins -calulated
539 : Float_t *fResponseWeight; //!<! array with response -calulated
540 :
541 : //---------------------------------------------------------------------
542 : // ALICE TPC L1 Parameters
543 : //--------------------------------------------------------------------
544 : Float_t fGateDelay; ///< Delay of L1 arrival for the TPC gate signal
545 : Float_t fL1Delay; ///< Delay of L1 arrival for the TPC readout
546 : UShort_t fNTBinsBeforeL1; ///< Number of time bins before L1 arrival which are being read out
547 : Float_t fNTBinsL1; ///< Overall L1 delay in time bins
548 : protected:
549 : static TObjArray *fBBParam; ///< array of the Bethe-Bloch parameters.
550 : private:
551 : AliTPCParam(const AliTPCParam &);
552 : AliTPCParam & operator=(const AliTPCParam &);
553 :
554 : void CleanGeoMatrices();
555 :
556 : /// \cond CLASSIMP
557 36 : ClassDef(AliTPCParam,12) //parameter object for set:TPC
558 : /// \endcond
559 : };
560 :
561 :
562 : inline Int_t * AliTPCParam::GetResBin(Int_t i)
563 : {
564 : /// return response bin i - bin given by padrow [0] pad[1] timebin[2]
565 :
566 12610462 : if (i<fCurrentMax) return &fResponseBin[i*3];
567 2158109 : else return 0;
568 4922857 : }
569 :
570 : inline Float_t &AliTPCParam::GetResWeight(Int_t i)
571 : {
572 : /// return weight of response bin i
573 :
574 9845714 : if (i<fCurrentMax) return fResponseWeight[i];
575 : else return fResponseWeight[i];
576 4922857 : }
577 :
578 :
579 : inline void AliTPCParam::AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const
580 : {
581 : /// set cosinus and sinus of rotation angles for sector isec
582 :
583 1665608 : cos=fRotAngle[isec*4];
584 832804 : sin=fRotAngle[isec*4+1];
585 832804 : }
586 :
587 : inline Float_t AliTPCParam::GetAngle(Int_t isec) const
588 : {
589 : /// return rotation angle of given sector
590 :
591 0 : return fRotAngle[isec*4+2];
592 : }
593 :
594 :
595 : inline void AliTPCParam::Transform1to2Ideal(Float_t *xyz, Int_t *index) const
596 : {
597 : /// transformation to rotated coordinates
598 : /// we must have information about sector!
599 : /// rotate to given sector
600 : /// ideal frame
601 :
602 0 : Float_t cos,sin;
603 0 : AdjustCosSin(index[1],cos,sin);
604 0 : Float_t x1=xyz[0]*cos + xyz[1]*sin;
605 0 : Float_t y1=-xyz[0]*sin + xyz[1]*cos;
606 0 : xyz[0]=x1;
607 0 : xyz[1]=y1;
608 0 : xyz[2]=fZLength-TMath::Abs(xyz[2]);
609 0 : index[0]=2;
610 0 : }
611 :
612 :
613 : inline void AliTPCParam::Transform1to2(Float_t *xyz, Int_t *index) const
614 : {
615 : /// transformation to rotated coordinates
616 : /// we must have information about sector!
617 : /// rotate to given sector
618 :
619 3382752 : Double_t xyzmaster[3] = {xyz[0],xyz[1],xyz[2]};
620 1691376 : Double_t xyzlocal[3]={0,0,0};
621 3382752 : if (index[1]>=0 && index[1]<fNSector)
622 1691376 : fGlobalMatrix[index[1]]->MasterToLocal(xyzmaster,xyzlocal);
623 1691376 : xyz[0] = xyzlocal[0];
624 1691376 : xyz[1] = xyzlocal[1];
625 1691376 : xyz[2] = xyzlocal[2];
626 1691376 : index[0]=2;
627 1691376 : }
628 :
629 :
630 :
631 :
632 : inline void AliTPCParam::Transform2to1(Float_t *xyz, Int_t *index) const
633 : {
634 : /// transformation from rotated coordinates to global coordinates
635 :
636 0 : Float_t cos,sin;
637 0 : AdjustCosSin(index[1],cos,sin);
638 0 : Float_t x1=xyz[0]*cos - xyz[1]*sin;
639 0 : Float_t y1=xyz[0]*sin + xyz[1]*cos;
640 0 : xyz[0]=x1;
641 0 : xyz[1]=y1;
642 0 : xyz[2]=fZLength-xyz[2];
643 0 : if (index[1]<fNInnerSector)
644 0 : {if ( index[1]>=(fNInnerSector>>1)) xyz[2]*=-1.;}
645 : else
646 0 : {if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[2]*=-1;}
647 0 : index[0]=1;
648 0 : }
649 :
650 : inline void AliTPCParam::Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const
651 : {
652 : /// transform rotated coordinats of one sector to rotated
653 : /// coordinates relative to another sector
654 :
655 0 : Transform2to1(xyz,index);
656 0 : Transform1to2(xyz,oindex);
657 0 : index[0]=2;
658 0 : index[1]=oindex[1];
659 0 : }
660 :
661 : inline Float_t AliTPCParam::Transform2to2NearestWire(Float_t *xyz, Int_t *index) const
662 : {
663 : /// asigns the x-position of the closest wire to xyz[0], return the
664 : /// electron to closest wire distance
665 :
666 : Float_t xnew,dx;
667 3382744 : if (index[1]<fNInnerSector) {
668 984124 : xnew = fRInnerFirstWire+TMath::Nint((xyz[0]-fRInnerFirstWire)/fInnerWWPitch)*fInnerWWPitch;
669 984124 : }
670 : else {
671 707248 : xnew = fROuterFirstWire+TMath::Nint((xyz[0]-fROuterFirstWire)/fOuterWWPitch)*fOuterWWPitch;
672 : }
673 1691372 : dx = xnew-xyz[0];
674 1691372 : xyz[0]=xnew;
675 1691372 : return dx;
676 : }
677 :
678 : inline Int_t AliTPCParam::Transform2to3(Float_t *xyz, Int_t *index) const
679 : {
680 : /// calulates coresponding pad row number, sets index[2] for straight rows
681 : /// does not change xyz[] information
682 : /// valid only for straight row
683 :
684 5074116 : if (index[1]<fNInnerSector)
685 2675496 : index[2] =TMath::Nint((xyz[0]-fPadRowLow[0])/fInnerPadPitchLength);
686 : else
687 707248 : if (xyz[0] < fLastWireUp1 )
688 336340 : index[2] = TMath::Nint((xyz[0]-fPadRowUp[0])/fOuter1PadPitchLength);
689 : else
690 370908 : index[2] = TMath::Nint(fNRowUp1+(xyz[0]-fPadRowUp[64])/fOuter2PadPitchLength);
691 1691372 : index[0]=3;
692 1691372 : return index[2];
693 : }
694 :
695 : inline void AliTPCParam::Transform3to4(Float_t *xyz, Int_t *index) const
696 : {
697 : /// valid only for straight rows straight rows
698 : /// calculate xyz[0] position relative to given index
699 :
700 5074116 : if (index[1]<fNInnerSector)
701 2675496 : xyz[0] -=index[2]*fInnerPadPitchLength+fPadRowLow[0];
702 : else
703 707248 : if (index[2]<fNRowUp1)
704 336340 : xyz[0] -=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
705 : else
706 370908 : xyz[0] -=(index[2]-fNRowUp1)*fOuter2PadPitchLength+fPadRowUp[64];
707 1691372 : index[0] =4;
708 1691372 : }
709 :
710 : inline void AliTPCParam::Transform4to3(Float_t *xyz, Int_t *index) const
711 : {
712 : /// valid only for straight rows
713 : /// transforms relative xyz[0] to the global one within given sector
714 :
715 0 : if (index[1]<fNInnerSector)
716 0 : xyz[0] +=index[2]*fInnerPadPitchLength+fPadRowLow[0];
717 : else
718 0 : if(index[2]<fNRowUp1)
719 0 : xyz[0] +=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
720 : else
721 0 : xyz[0] +=index[2]*fOuter2PadPitchLength+fPadRowUp[64];
722 0 : index[0] =3;
723 0 : }
724 :
725 :
726 : inline void AliTPCParam::Transform2to5( Float_t *xyz, Int_t *index) const
727 : {
728 : /// transform [x,y,z] to [r,phi,z]
729 :
730 : Float_t angle;
731 0 : Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
732 0 : if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0;
733 : else
734 : {
735 0 : angle =TMath::ASin(xyz[1]/r);
736 0 : if (xyz[0]<0) angle=TMath::Pi()-angle;
737 0 : if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle;
738 : }
739 0 : xyz[0]=r;
740 0 : xyz[1]=angle;
741 0 : index[0]=5;
742 0 : }
743 :
744 : inline void AliTPCParam::Transform5to2( Float_t *xyz, Int_t *index) const
745 : {
746 : /// transform [r,rphi,z] to [x,y,z]
747 :
748 0 : Float_t r = xyz[0];
749 0 : Float_t angle= xyz[1];
750 0 : xyz[0]=r*TMath::Cos(angle);
751 0 : xyz[1]=r*TMath::Sin(angle);
752 0 : index[0]=2;
753 0 : }
754 :
755 : inline void AliTPCParam::Transform4to8(Float_t *xyz, Int_t *index) const
756 : {
757 : /// transform xyz coordinates to 'digit' coordinates
758 :
759 3382744 : if (index[1]<fNInnerSector) {
760 1503765 : if ( index[1]>=(fNInnerSector>>1)) xyz[1]*=-1.;
761 : }
762 : else {
763 1091092 : if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
764 : }
765 :
766 1691372 : xyz[2]/=fZWidth;
767 1691372 : if (index[1]<fNInnerSector) {
768 984124 : xyz[0]/=fInnerPadPitchLength;
769 984124 : xyz[1]/=fInnerPadPitchWidth;
770 984124 : }
771 : else{
772 707248 : xyz[1]/=fOuterPadPitchWidth;
773 1043588 : if (index[2]<fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
774 370908 : else xyz[0]/=fOuter2PadPitchLength;
775 : }
776 1691372 : xyz[1]-=0.5;
777 1691372 : index[0]=8;
778 1691372 : }
779 :
780 : inline void AliTPCParam::Transform8to4(Float_t *xyz, Int_t *index) const
781 : {
782 : /// transforms 'digit' coordinates to xyz coordinates
783 :
784 0 : if (index[1]<fNInnerSector) {
785 0 : if ( index[1]>=(fNInnerSector>>1)) xyz[1]*=-1.;
786 : }
787 : else {
788 0 : if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
789 : }
790 :
791 0 : xyz[2]*=fZWidth;
792 0 : if (index[1]<fNInnerSector) {
793 0 : xyz[0]*=fInnerPadPitchLength;
794 0 : xyz[1]*=fInnerPadPitchWidth;
795 0 : }
796 : else{
797 0 : xyz[1]*=fOuterPadPitchWidth;
798 0 : if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
799 0 : else xyz[0]*=fOuter2PadPitchLength;
800 : }
801 0 : index[0]=4;
802 0 : }
803 :
804 : inline void AliTPCParam::Transform6to8(Float_t *xyz, Int_t *index) const
805 : {
806 : /// transforms cylindrical xyz coordinates to 'digit' coordinates
807 :
808 0 : xyz[2]/=fZWidth;
809 0 : if (index[1]<fNInnerSector) {
810 0 : xyz[0]/=fInnerPadPitchLength;
811 0 : xyz[1]*=xyz[0]/fInnerPadPitchWidth;
812 0 : }
813 : else{
814 0 : xyz[1]*=xyz[0]/fOuterPadPitchWidth;
815 0 : if (index[2] < fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
816 0 : else xyz[0]/=fOuter2PadPitchLength;
817 : }
818 0 : index[0]=8;
819 0 : }
820 :
821 : inline void AliTPCParam::Transform8to6(Float_t *xyz, Int_t *index) const
822 : {
823 : /// transforms 'digit' coordinates to cylindrical xyz coordinates
824 :
825 0 : xyz[2]*=fZWidth;
826 0 : if (index[1]<fNInnerSector) {
827 0 : xyz[0]*=fInnerPadPitchLength;
828 0 : xyz[1]/=xyz[0]/fInnerPadPitchWidth;
829 0 : }
830 : else{
831 0 : xyz[1]/=xyz[0]/fOuterPadPitchWidth;
832 0 : if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
833 0 : else xyz[0]*=fOuter2PadPitchLength;
834 : }
835 0 : index[0]=6;
836 0 : }
837 : inline Float_t AliTPCParam::GetZLength(Int_t sector) const
838 6356325 : { if(sector <18 || (sector>35&§or<54)) return fZLength-0.275;
839 908586 : else return fZLength-0.302;
840 2011677 : }
841 : #endif
|
