]>
Commit | Line | Data |
---|---|---|
8c555625 | 1 | /////////////////////////////////////////////////////////////////////// |
2 | // Manager and of geomety classes for set: TPC // | |
3 | // // | |
4 | // Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk // | |
5 | // // | |
6 | /////////////////////////////////////////////////////////////////////// | |
7 | ||
8 | // MI change global variables for geometry | |
9 | // declaration of the global static variable | |
10 | // of AliTPCParam objects | |
11 | ||
12 | #include <iostream.h> | |
13 | #include <TMath.h> | |
14 | //#include <TObject.h> | |
15 | #include "AliTPCParam.h" | |
16 | //some old TPC parameters in AliTPCSecGeo.h | |
17 | #include "AliTPCSecGeo.h" | |
18 | ||
19 | ||
20 | ClassImp(AliTPCParam) | |
21 | ||
22 | // default values | |
23 | ||
24 | const Float_t kInnerRadiusLow = 89.45; | |
25 | const Float_t kOuterRadiusLow = 143.725; | |
26 | const Float_t kInnerRadiusUp = 134.55; | |
27 | const Float_t kOuterRadiusUp = 248.275; | |
28 | ||
29 | const Float_t kPadPitchLength = 2.05; | |
30 | const Float_t kPadPitchWidth = 0.35; | |
31 | const Float_t kPadLength = 2.05; | |
32 | const Float_t kPadWidth = 0.35; | |
33 | // Number of wires per pad and wire-wire pitch | |
34 | const Int_t knWires = 5; | |
35 | const Float_t kDiffT = 2.2e-2; | |
36 | const Float_t kDiffL = 2.2e-2; | |
37 | const Float_t kDriftV =2.85e6; | |
38 | ||
39 | const Float_t kOmegaTau = 0.145; | |
40 | const Float_t kAttCoef = 250.; | |
41 | const Float_t kOxyCont = 5.e-6; | |
42 | ||
43 | ||
44 | ||
45 | const Float_t kChipGain = 24; | |
46 | const Float_t kGasGain = 1e4; | |
47 | const Float_t kTSample = 2.e-7; //TSAMPLE | |
48 | const Float_t kTFWHM = 2.5e-7; //fwhm of charge distribution | |
49 | ||
50 | const Float_t kNoise = 500; //default noise = 1000 el | |
51 | const Int_t kZeroSup=5; | |
52 | const Float_t kPadCoupling=0.5; | |
53 | // | |
54 | const Float_t kEdgeSectorSpace = 5.26; | |
55 | ||
56 | ||
57 | ||
58 | ||
59 | //___________________________________________ | |
60 | AliTPCParam::AliTPCParam() | |
61 | { | |
62 | //constructor set the default parameters | |
63 | SetDefault(); | |
64 | } | |
65 | ||
66 | ||
67 | void AliTPCParam::CRXYZtoXYZ(Float_t *xyz, | |
68 | const Int_t §or, const Int_t & padrow, Int_t option) const | |
69 | { | |
70 | //transform relative coordinates to absolute | |
71 | Bool_t rel = ( (option&2)!=0); | |
72 | Float_t row_first; | |
73 | row_first = (sector<25) ? fPadRowLow[0] : fPadRowUp[0]; | |
74 | if (rel==kTRUE) //if we have | |
75 | { | |
76 | xyz[0]+=row_first; | |
77 | xyz[0]+=(Int_t) padrow*fPadPitchLength; | |
78 | } | |
79 | if (sector<25) | |
80 | if ( sector>12) xyz[2]*=-1.; | |
81 | else | |
82 | if (sector>48) xyz[2]*=-1; | |
83 | Float_t x1=xyz[0]; | |
84 | Float_t y1=xyz[1]; | |
85 | Float_t cos,sin; | |
86 | AdjustAngles(sector,cos,sin); | |
87 | xyz[0]=x1*cos - y1*sin; | |
88 | xyz[1]=x1*sin + y1*cos; | |
89 | } | |
90 | ||
91 | void AliTPCParam::XYZtoCRXYZ(Float_t *xyz, | |
92 | Int_t §or, Int_t & padrow, Int_t option) | |
93 | { | |
94 | //transform global position to the position relative to the sector padrow | |
95 | //if option=0 X calculate absolute calculate sector | |
96 | //if option=1 X absolute use input sector | |
97 | //if option=2 X relative to pad row calculate sector | |
98 | //if option=3 X relative use input sector | |
99 | //!!!!!!!!! WE start to calculate rows from row = 0 | |
100 | ||
101 | Bool_t rel = ( (option&2)!=0); | |
102 | //option 0 and 2 means that we don't have information about sector | |
103 | //we calculate sector | |
104 | if ((option&1)==0){ | |
105 | Float_t angle; | |
106 | Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]); | |
107 | if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0; | |
108 | else | |
109 | { | |
110 | angle =TMath::ASin(xyz[1]/r); | |
111 | if (xyz[0]<0) angle=TMath::Pi()-angle; | |
112 | if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle; | |
113 | } | |
114 | //transform global position to the position relative to the sector padrow | |
115 | //fistly calculate xyz[0] "polomer for lover sector | |
116 | sector=Int_t(angle/alpha_low)+1; | |
117 | Float_t x1; | |
118 | Float_t y1; | |
119 | //firstly we suppose that we are in inner sector | |
120 | Float_t cos,sin; | |
121 | AdjustAngles(sector,cos,sin); | |
122 | ||
123 | x1=xyz[0]*cos + xyz[1]*sin; | |
124 | y1=-xyz[0]*sin + xyz[1]*cos; | |
125 | if (x1>fOuterRadiusLow) | |
126 | { | |
127 | sector=Int_t(angle/alpha_up)+25; | |
128 | AdjustAngles(sector,cos,sin); | |
129 | x1=xyz[0]*cos + xyz[1]*sin; | |
130 | y1=-xyz[0]*sin + xyz[1]*cos; | |
131 | if (xyz[2]<0) sector+=24; | |
132 | } | |
133 | else | |
134 | if (xyz[2]<0) sector+=12; | |
135 | if (xyz[2]<0) xyz[2]=-xyz[2]; | |
136 | if (x1<fOuterRadiusLow) | |
137 | padrow =Int_t( (x1-fPadRowLow[0])/fPadPitchLength+0.5); | |
138 | else | |
139 | padrow = Int_t( (x1-fPadRowUp[0])/fPadPitchLength+0.5); | |
140 | if (rel==kTRUE) | |
141 | if (x1<fOuterRadiusLow) x1-=padrow*fPadPitchLength+fPadRowLow[0]; | |
142 | else | |
143 | x1-=padrow*fPadPitchLength+fPadRowUp[0]; | |
144 | xyz[0]=x1; | |
145 | xyz[1]=y1; | |
146 | } | |
147 | else{ | |
148 | //if we have information about sector | |
149 | Float_t cos,sin; | |
150 | AdjustAngles(sector,cos,sin); | |
151 | Float_t x1; | |
152 | Float_t y1; | |
153 | //rotate to given sector | |
154 | x1=xyz[0]*cos + xyz[1]*sin; | |
155 | y1=-xyz[0]*sin + xyz[1]*cos; | |
156 | //calculate pad row number | |
157 | if (sector<25) { | |
158 | padrow =Int_t( (x1-fPadRowLow[0])/fPadPitchLength+1.5)-1; | |
159 | if ( sector>12) xyz[2]=-xyz[2]; | |
160 | } | |
161 | else { | |
162 | padrow =Int_t( (x1-fPadRowUp[0])/fPadPitchLength+1.5)-1; | |
163 | if (sector>48) xyz[2]=-xyz[2]; | |
164 | } | |
165 | //if we store relative position calculate position relative to pad row | |
166 | if (rel==kTRUE){ | |
167 | if (sector<25) | |
168 | x1-=padrow*fPadPitchLength+fPadRowLow[0]; | |
169 | else | |
170 | x1-=padrow*fPadPitchLength+fPadRowUp[0]; | |
171 | } | |
172 | xyz[0]=x1; | |
173 | xyz[1]=y1; | |
174 | } | |
175 | } | |
176 | ||
177 | void AliTPCParam::CRYZtoTimePad(const Float_t &y, const Float_t &z, | |
178 | Float_t &time, Float_t &pad, | |
179 | Int_t sector, Int_t padrow) | |
180 | { | |
181 | //transform position in cm to position in time slices and pads | |
182 | Float_t nofpads = (sector < 25) ? fnPadsLow[padrow] : fnPadsUp[padrow]; | |
183 | Float_t padc=(nofpads+1)/2; // this is the "central" pad for a row | |
184 | pad = y/(fPadPitchWidth)+padc; | |
185 | time=(z_end-z)/(fDriftV*fTSample); | |
186 | // cout<<y<<" "<<z<<" "<<time<<" "<<pad<<" "<< | |
187 | // sector<<" "<<padrow<<"\n"; | |
188 | } | |
189 | void AliTPCParam::CRTimePadtoYZ(Float_t &y, Float_t &z, | |
190 | const Float_t &time, const Float_t &pad, | |
191 | Int_t sector, Int_t padrow) | |
192 | { | |
193 | //transform position in time slices and pads to cm | |
194 | Float_t nofpads = (sector < 25) ? fnPadsLow[padrow] : fnPadsUp[padrow]; | |
195 | Float_t padc=(nofpads+1)/2; // this is the "central" pad for a row | |
196 | y=(pad-padc)*fPadPitchWidth; | |
197 | z=z_end-time*(fDriftV*fTSample); | |
198 | // cout<<y<<" "<<z<<" "<<time<<" "<<pad<<" "<< | |
199 | // sector<<" "<<padrow<<"\n"; | |
200 | } | |
201 | ||
202 | Int_t AliTPCParam::GetWire(Float_t & x) | |
203 | { | |
204 | // | |
205 | //return wire number of pad for electron at relative position x | |
206 | //to the center of the pad | |
207 | //and adjust x to the wire position | |
208 | //we suppose that if the wire number is even the center wire | |
209 | //is at center of pad | |
210 | // | |
211 | Float_t xrel= x/fWWPitch; | |
212 | if ((fnWires>>1)==0) xrel+=1; | |
213 | else xrel+=0.5; | |
214 | Int_t nw=Int_t(xrel); | |
215 | if (xrel<0) nw-=1; | |
216 | ||
217 | x=(nw*fWWPitch); | |
218 | if ((fnWires>>1)==0) x-=fWWPitch/2.; | |
219 | return nw; | |
220 | } | |
221 | ||
222 | Int_t AliTPCParam::GetIndex(Int_t sector, Int_t row) | |
223 | { | |
224 | // | |
225 | //give index of the given sector and pad row | |
226 | //no control if the sectors and rows are reasonable !!! | |
227 | // | |
228 | if (sector<25) return (sector-1)*fnRowLow+row; | |
229 | return (24*fnRowLow)+(sector-25)*fnRowUp+row; | |
230 | } | |
231 | ||
232 | Bool_t AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) | |
233 | { | |
234 | // | |
235 | //return sector and padrow for given index | |
236 | //if index is reasonable return true else return false | |
237 | // | |
238 | if ( (index<0) || (index>fNtRows)) return kFALSE; | |
239 | Int_t outindex = 24*fnRowLow; | |
240 | if (index<outindex) { | |
241 | sector = index/fnRowLow; | |
242 | row = index - sector*fnRowLow; | |
243 | sector++; | |
244 | return kTRUE; | |
245 | } | |
246 | index-= outindex; | |
247 | sector = index/fnRowUp; | |
248 | row = index - sector*fnRowUp; | |
249 | sector++; | |
250 | return kTRUE; | |
251 | } | |
252 | ||
253 | ||
254 | ||
255 | Int_t AliTPCParam::GetPadRow(Int_t isec, Float_t &x) | |
256 | { | |
257 | // | |
258 | //return the pad row for given x (transformed) | |
259 | // | |
260 | Float_t row_first=GetPadRowRadii(isec,0); | |
261 | Int_t row = Int_t(( x-row_first+1.5*fPadPitchLength)/fPadPitchLength)-1; | |
262 | //Int_t will make from -0.5 0 but we want to make -1 so we add and after substract 1 | |
263 | x -=row* fPadPitchLength+row_first; | |
264 | if ( (row<0)||(row>=GetNRow(isec))) return -1; | |
265 | else return row; | |
266 | } | |
267 | ||
268 | void AliTPCParam::SetDefault() | |
269 | { | |
270 | //set default TPC param | |
271 | fbStatus = kFALSE; | |
272 | //set radius parameters | |
273 | fInnerRadiusLow = kInnerRadiusLow; | |
274 | fOuterRadiusLow = kOuterRadiusLow; | |
275 | fInnerRadiusUp = kInnerRadiusUp; | |
276 | fOuterRadiusUp = kOuterRadiusUp; | |
277 | // set default pad size and shape | |
278 | fPadPitchLength = kPadPitchLength; | |
279 | fPadPitchWidth = kPadPitchWidth; | |
280 | fPadLength = kPadLength; | |
281 | fPadWidth = kPadWidth; | |
282 | // | |
283 | fnWires = knWires; | |
284 | fWWPitch= kPadPitchLength/Float_t(knWires); | |
285 | fDiffT = kDiffT; | |
286 | fDiffL = kDiffL; | |
287 | fOmegaTau = kOmegaTau; | |
288 | fOxyCont = kOxyCont; | |
289 | fAttCoef = kAttCoef; | |
290 | fNoise = kNoise; | |
291 | fChipGain = kChipGain; | |
292 | fGasGain = kGasGain; | |
293 | fZeroSup= kZeroSup; | |
294 | fPadCoupling= kPadCoupling; | |
295 | fTSample =kTSample; | |
296 | fTSigma =kTFWHM/2.35; | |
297 | fDriftV=kDriftV; | |
298 | //calculate sin and cosine of rotations angle | |
299 | for (Int_t i=1; i<80; i++) | |
300 | { | |
301 | Float_t angle; | |
302 | if(i < 25){ | |
303 | angle = (i < 13) ? (i-1)*alpha_low : (i-13)*alpha_low; | |
304 | } | |
305 | else { | |
306 | angle = (i < 49) ? (i-25)*alpha_up : (i-49)*alpha_up; | |
307 | } | |
308 | fRotAngle[i]=TMath::Cos(angle); | |
309 | fRotAngle[100+i]=TMath::Sin(angle); | |
310 | } | |
311 | fbStatus = Update(); | |
312 | } | |
313 | ||
314 | void AliTPCParam::AdjustAngles(Int_t isec, Float_t &cos, Float_t &sin) const | |
315 | { | |
316 | //set cosinus and sinus of rotation angles for sector isec | |
317 | cos=fRotAngle[isec]; | |
318 | sin=fRotAngle[100+isec]; | |
319 | } | |
320 | ||
321 | Bool_t AliTPCParam::Update() | |
322 | { | |
323 | fbStatus = kFALSE; | |
324 | Int_t i; | |
325 | //recalculate and check some geometric parameters | |
326 | if (0.001>fPadPitchLength){ | |
327 | cout<<"ERROR !!! Small pad pitch length \n"<<flush; | |
328 | return kFALSE; | |
329 | } | |
330 | ||
331 | if (fPadPitchLength<fPadLength) { | |
332 | cout<<"ERROR !!! Pitch length smaller then length of pad \n"<<flush; | |
333 | return kFALSE; | |
334 | } | |
335 | ||
336 | fnRowUp = Int_t((0.01+fOuterRadiusUp-fOuterRadiusLow)/fPadPitchLength)+1; | |
337 | if ( kMaxRows<fnRowUp) fnRowUp = kMaxRows; | |
338 | if (1>fnRowUp) return kFALSE; | |
339 | ||
340 | fnRowLow = Int_t((0.01+fInnerRadiusUp-fInnerRadiusLow)/fPadPitchLength)+1; | |
341 | if ( kMaxRows<fnRowLow) fnRowUp = kMaxRows; | |
342 | if (1>fnRowLow) return kFALSE; | |
343 | // adjust upper sectors pad row positions and pad numbers | |
344 | for (i = 0;i<fnRowUp;i++) | |
345 | { | |
346 | Float_t x = fOuterRadiusLow +fPadPitchLength*(Float_t)i; | |
347 | Float_t y = (x-0.5*fPadPitchLength)*2.*tan(alpha_up/2)-kEdgeSectorSpace; | |
348 | fPadRowUp[i] = x; | |
349 | fnPadsUp[i] = (Int_t)(y/fPadPitchWidth) ; | |
350 | if ((fnPadsUp[i]%2) == 0) fnPadsUp[i]-=1; | |
351 | } | |
352 | // adjust lower sectors pad row positions and pad numbers | |
353 | for (i = 0;i<fnRowLow;i++) | |
354 | { | |
355 | Float_t x = fInnerRadiusLow +fPadPitchLength*(Float_t)i; | |
356 | Float_t y = (x-0.5*fPadPitchLength)*2.*tan(alpha_low/2)-kEdgeSectorSpace; | |
357 | fPadRowLow[i] = x; | |
358 | fnPadsLow[i] = (Int_t)(y/fPadPitchWidth) ; | |
359 | if ((fnPadsLow[i]%2) == 0) fnPadsLow[i]-=1; | |
360 | } | |
361 | ||
362 | //that variable are not writen to the file there are calculated | |
363 | // | |
364 | fWWPitch= fPadPitchLength/Float_t(fnWires); | |
365 | fZWidth = fTSample*fDriftV; | |
366 | fNtRows = 24*fnRowLow+48*fnRowUp; | |
367 | ||
368 | fbStatus = kTRUE; | |
369 | return kTRUE; | |
370 | } | |
371 | ||
372 | ||
373 | ||
374 | Bool_t AliTPCParam::GetStatus() | |
375 | { | |
376 | //get information about object consistency | |
377 | return fbStatus; | |
378 | } | |
379 | ||
380 | Int_t AliTPCParam::GetNRowLow() const | |
381 | { | |
382 | //get the number of pad rows in low sector | |
383 | return fnRowLow; | |
384 | } | |
385 | Int_t AliTPCParam::GetNRowUp() const | |
386 | { | |
387 | //get the number of pad rows in up sector | |
388 | return fnRowUp; | |
389 | } | |
390 | Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const | |
391 | { | |
392 | //get the pad row (irow) radii | |
393 | if ( !(irow<0) && (irow<fnRowLow) ) | |
394 | return fPadRowLow[irow]; | |
395 | else | |
396 | return 0; | |
397 | } | |
398 | ||
399 | Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const | |
400 | { | |
401 | //get the pad row (irow) radii | |
402 | if ( !(irow<0) && (irow<fnRowUp) ) | |
403 | return fPadRowUp[irow]; | |
404 | else | |
405 | return 0; | |
406 | } | |
407 | ||
408 | Int_t AliTPCParam::GetNPadsLow(Int_t irow) const | |
409 | { | |
410 | //get the number of pads in row irow | |
411 | if ( !(irow<0) && (irow<fnRowLow) ) | |
412 | return fnPadsLow[irow]; | |
413 | else | |
414 | return 0; | |
415 | } | |
416 | ||
417 | ||
418 | Int_t AliTPCParam::GetNPadsUp(Int_t irow) const | |
419 | { | |
420 | //get the number of pads in row irow | |
421 | if ( !(irow<0) && (irow<fnRowUp) ) | |
422 | return fnPadsUp[irow]; | |
423 | else | |
424 | return 0; | |
425 | } | |
426 | ||
427 | ||
428 | void AliTPCParam::Streamer(TBuffer &R__b) | |
429 | { | |
430 | // Stream an object of class AliTPC. | |
431 | ||
432 | if (R__b.IsReading()) { | |
433 | Version_t R__v = R__b.ReadVersion(); if (R__v) { } | |
434 | TObject::Streamer(R__b); | |
435 | if (R__v < 2) return; | |
436 | ||
437 | R__b >> fInnerRadiusLow; | |
438 | R__b >> fInnerRadiusUp; | |
439 | R__b >> fOuterRadiusLow; | |
440 | R__b >> fOuterRadiusUp; | |
441 | ||
442 | R__b >> fPadPitchLength; | |
443 | R__b >> fPadPitchWidth; | |
444 | R__b >> fPadLength; | |
445 | R__b >> fPadWidth; | |
446 | ||
447 | R__b >> fnWires; | |
448 | ||
449 | R__b >>fDiffT; | |
450 | R__b >>fDiffL; | |
451 | R__b >>fGasGain; | |
452 | R__b >>fDriftV; | |
453 | R__b >>fOmegaTau; | |
454 | R__b >>fOxyCont; | |
455 | R__b >>fAttCoef; | |
456 | ||
457 | ||
458 | R__b >>fPadCoupling; | |
459 | R__b >>fZeroSup; | |
460 | R__b >>fNoise; | |
461 | R__b >>fChipGain; | |
462 | ||
463 | R__b >>fTSample; | |
464 | R__b >>fTSigma; | |
465 | // | |
466 | fWWPitch= fPadPitchLength/Float_t(fnWires); | |
467 | fZWidth = fTSample*fDriftV; | |
468 | fNtRows = 24*fnRowLow+48*fnRowUp; | |
469 | Update(); | |
470 | } else { | |
471 | R__b.WriteVersion(AliTPCParam::IsA()); | |
472 | TObject::Streamer(R__b); | |
473 | R__b << fInnerRadiusLow; | |
474 | R__b << fInnerRadiusUp; | |
475 | R__b << fOuterRadiusLow; | |
476 | R__b << fOuterRadiusUp; | |
477 | ||
478 | R__b << fPadPitchLength; | |
479 | R__b << fPadPitchWidth; | |
480 | R__b << fPadLength; | |
481 | R__b << fPadWidth; | |
482 | ||
483 | R__b << fnWires; | |
484 | ||
485 | R__b <<fDiffT; | |
486 | R__b <<fDiffL; | |
487 | R__b <<fGasGain; | |
488 | R__b <<fDriftV; | |
489 | R__b <<fOmegaTau; | |
490 | R__b <<fOxyCont; | |
491 | R__b <<fAttCoef; | |
492 | ||
493 | ||
494 | R__b <<fPadCoupling; | |
495 | R__b <<fZeroSup; | |
496 | R__b <<fNoise; | |
497 | R__b <<fChipGain; | |
498 | ||
499 | R__b <<fTSample; | |
500 | R__b <<fTSigma; | |
501 | } | |
502 | } | |
503 |