Changes in initialization of the pad planes
[u/mrichter/AliRoot.git] / TRD / AliTRDpadPlane.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 //  Describes a pad plane of a TRD ROC                                       //
21 //                                                                           //
22 //  Contains the information on pad postions, pad dimensions,                //
23 //  tilting angle, etc.                                                      //
24 //  It also provides methods to identify the current pad number from         //
25 //  global coordinates.                                                      //
26 //                                                                           //
27 ///////////////////////////////////////////////////////////////////////////////
28
29 #include "AliTRDpadPlane.h"
30 #include "AliTRDgeometryFull.h"
31
32 ClassImp(AliTRDpadPlane)
33
34 //_____________________________________________________________________________
35 AliTRDpadPlane::AliTRDpadPlane():TObject()
36 {
37   //
38   // Default constructor
39   //
40
41   fGeo          = 0;
42
43   fPla          = 0;
44   fCha          = 0;
45
46   fLength       = 0.0;
47   fWidth        = 0.0;
48   fLengthRim    = 0.0;
49   fWidthRim     = 0.0;
50   fLengthOPad   = 0.0;
51   fWidthOPad    = 0.0;
52   fLengthIPad   = 0.0;
53   fWidthIPad    = 0.0;
54
55   fRowSpacing   = 0.0;
56   fColSpacing   = 0.0;
57
58   fNrows        = 0;
59   fNcols        = 0;
60
61   fPadRow       = 0;
62   fPadCol       = 0;
63
64   fTiltingAngle = 0.0;
65
66 }
67
68 //_____________________________________________________________________________
69 AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c):TObject()
70 {
71   //
72   // Constructor that initializes a given pad plane type
73   //
74
75   fGeo = new AliTRDgeometryFull();
76
77   fPla = p;
78   fCha = c;
79
80   fRowSpacing = 0.0;
81   fColSpacing = 0.0;
82
83   fLengthRim  = 1.0;
84   fWidthRim   = 0.5;
85
86   fNcols      = 144;
87
88   //
89   // The pad plane parameter
90   //
91   switch (p) {
92   case 0:
93     if (c == 2) {
94       // L0C0 type
95       fNrows        =  12;
96       fLength       = 108.0;
97       fWidth        =  92.2;
98       fLengthOPad   =   8.0;
99       fWidthOPad    =   0.515;
100       fLengthIPad   =   9.0;
101       fWidthIPad    =   0.635;
102       fTiltingAngle =  -2.0;
103     }
104     else {
105       // L0C1 type
106       fNrows        =  16;
107       fLength       = 122.0;
108       fWidth        =  92.2;
109       fLengthOPad   =   7.5;
110       fWidthOPad    =   0.515;
111       fLengthIPad   =   7.5;
112       fWidthIPad    =   0.635;
113       fTiltingAngle =  -2.0;
114     }
115     break;
116   case 1:
117     if (c == 2) {
118       // L1C0 type
119       fNrows        =  12;
120       fLength       = 108.0;
121       fWidth        =  96.6;
122       fLengthOPad   =   8.0;
123       fWidthOPad    =   0.585;
124       fLengthIPad   =   9.0;
125       fWidthIPad    =   0.665;
126       fTiltingAngle =   2.0;
127     }
128     else {
129       // L1C1 type
130       fNrows        =  16;
131       fLength       = 122.0;
132       fWidth        =  96.6;
133       fLengthOPad   =   7.5;
134       fWidthOPad    =   0.585;
135       fLengthIPad   =   7.5;
136       fWidthIPad    =   0.665;
137       fTiltingAngle =   2.0;
138     }
139     break;
140   case 2:
141     if (c == 2) {
142       // L2C0 type
143       fNrows        =  12;
144       fLength       = 108.0;
145       fWidth        = 101.1;
146       fLengthOPad   =   8.0;
147       fWidthOPad    =   0.705;
148       fLengthIPad   =   9.0;
149       fWidthIPad    =   0.695;
150       fTiltingAngle =  -2.0;
151     }
152     else {
153       // L2C1 type
154       fNrows        =  16;
155       fLength       = 129.0;
156       fWidth        = 101.1;
157       fLengthOPad   =   7.5;
158       fWidthOPad    =   0.705;
159       fLengthIPad   =   8.0;
160       fWidthIPad    =   0.695;
161       fTiltingAngle =  -2.0;
162     }
163     break;
164   case 3:
165     if (c == 2) {
166       // L3C0 type
167       fNrows        =  12;
168       fLength       = 108.0;
169       fWidth        = 105.5;
170       fLengthOPad   =   8.0;
171       fWidthOPad    =   0.775;
172       fLengthIPad   =   9.0;
173       fWidthIPad    =   0.725;
174       fTiltingAngle =   2.0;
175     }
176     else {
177       // L3C1 type
178       fNrows        =  16;
179       fLength       = 136.0;
180       fWidth        = 105.5;
181       fLengthOPad   =   7.5;
182       fWidthOPad    =   0.775;
183       fLengthIPad   =   8.5;
184       fWidthIPad    =   0.725;
185       fTiltingAngle =   2.0;
186     }
187     break;
188   case 4:
189     if (c == 2) {
190       // L4C0 type
191       fNrows        =  12;
192       fLength       = 108.0;
193       fWidth        = 109.9;
194       fLengthOPad   =   8.0;
195       fWidthOPad    =   0.845;
196       fLengthIPad   =   9.0;
197       fWidthIPad    =   0.755;
198       fTiltingAngle =  -2.0;
199     }
200     else {
201       // L4C1 type
202       fNrows        =  16;
203       fLength       = 143.0;
204       fWidth        = 109.9;
205       fLengthOPad   =   7.5;
206       fWidthOPad    =   0.845;
207       fLengthIPad   =   9.0;
208       fWidthIPad    =   0.755;
209       fTiltingAngle =  -2.0;
210     }
211     break;
212   case 5:
213     if (c == 2) {
214       // L5C0 type
215       fNrows        =  12;
216       fLength       = 108.0;
217       fWidth        = 114.4;
218       fLengthOPad   =   8.0;
219       fWidthOPad    =   0.965;
220       fLengthIPad   =   9.0;
221       fWidthIPad    =   0.785;
222       fTiltingAngle =   2.0;
223     }
224     else {
225       // L5C1 type
226       fNrows        =  16;
227       fLength       = 145.0;
228       fWidth        = 114.4;
229       fLengthOPad   =   8.5;
230       fWidthOPad    =   0.965;
231       fLengthIPad   =   9.0;
232       fWidthIPad    =   0.785;
233       fTiltingAngle =   2.0;
234     }
235     break;
236   };
237
238   //
239   // Store tilting angle as tangens (opposite direction!)
240   //
241   fTiltingAngle = TMath::Tan(TMath::Pi()/180.0 * -fTiltingAngle);
242
243   //
244   // The positions of the borders of the pads
245   //
246   // Row direction
247   //
248   fPadRow = new Double_t[fNrows];
249   Double_t row = fGeo->GetChamberLength(p,0)
250                + fGeo->GetChamberLength(p,1)
251                + fGeo->GetChamberLength(p,2) / 2.
252                - fGeo->RpadW()
253                - fLengthRim;
254   for (Int_t ic = 0; ic < c; ic++) {
255     row -= fGeo->GetChamberLength(p,ic);
256   }
257   for (Int_t ir = 0; ir < fNrows; ir++) {
258     fPadRow[ir] = row;
259     row -= fRowSpacing;
260     if (ir == 0) {
261       row -= fLengthOPad;
262     }
263     else {
264       row -= fLengthIPad;
265     }
266   }
267   //
268   // Column direction
269   //
270   fPadCol = new Double_t[fNcols];
271   Double_t col = fGeo->GetChamberWidth(p) / 2. 
272                + fGeo->CroWid()
273                - fWidthRim;
274   for (Int_t ic = 0; ic < fNcols; ic++) {
275     fPadCol[ic] = col;
276     col -= fColSpacing;
277     if (ic == 0) {
278       col -= fWidthOPad;
279     }
280     else {
281       col -= fWidthIPad;
282     }
283   }
284
285 }
286
287 //_____________________________________________________________________________
288 AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p):TObject(p)
289 {
290   //
291   // AliTRDpadPlane copy constructor
292   //
293
294   ((AliTRDpadPlane &) p).Copy(*this);
295
296 }
297
298 //_____________________________________________________________________________
299 AliTRDpadPlane::~AliTRDpadPlane()
300 {
301   //
302   // AliTRDpadPlane destructor
303   //
304
305   if (fGeo) {
306     delete fGeo;
307     fGeo    = 0;
308   }
309
310   if (fPadRow) {
311     delete [] fPadRow;
312     fPadRow = 0;
313   }
314
315   if (fPadCol) {
316     delete [] fPadCol;
317     fPadCol = 0;
318   }
319
320 }
321
322 //_____________________________________________________________________________
323 AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
324 {
325   //
326   // Assignment operator
327   //
328
329   if (this != &p) ((AliTRDpadPlane &) p).Copy(*this);
330   return *this;
331
332 }
333
334 //_____________________________________________________________________________
335 void AliTRDpadPlane::Copy(TObject &p) const
336 {
337   //
338   // Copy function
339   //
340
341   Int_t iBin = 0;
342
343   ((AliTRDpadPlane &) p).fGeo          = 0;
344
345   ((AliTRDpadPlane &) p).fPla          = fPla;
346   ((AliTRDpadPlane &) p).fCha          = fCha;
347
348   ((AliTRDpadPlane &) p).fLength       = fLength;
349   ((AliTRDpadPlane &) p).fWidth        = fWidth;
350   ((AliTRDpadPlane &) p).fLengthRim    = fLengthRim;
351   ((AliTRDpadPlane &) p).fWidthRim     = fWidthRim;
352   ((AliTRDpadPlane &) p).fLengthOPad   = fLengthOPad;
353   ((AliTRDpadPlane &) p).fWidthOPad    = fWidthOPad;
354   ((AliTRDpadPlane &) p).fLengthIPad   = fLengthIPad;
355   ((AliTRDpadPlane &) p).fWidthIPad    = fWidthIPad;
356
357   ((AliTRDpadPlane &) p).fRowSpacing   = fRowSpacing;
358   ((AliTRDpadPlane &) p).fColSpacing   = fColSpacing;
359
360   ((AliTRDpadPlane &) p).fNrows        = fNrows;
361   ((AliTRDpadPlane &) p).fNcols        = fNcols;
362
363   ((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;
364
365   if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
366   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
367   for (iBin = 0; iBin < fNrows; iBin++) {
368     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
369   }                                                                             
370
371   if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
372   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
373   for (iBin = 0; iBin < fNrows; iBin++) {
374     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
375   }                                                                             
376
377   TObject::Copy(p);
378
379 }
380
381 //_____________________________________________________________________________
382 Int_t AliTRDpadPlane::GetPadRowNumber(const Double_t z) const
383 {
384   //
385   // Finds the pad row number for a given global z-position
386   //
387
388   Int_t row    = 0;
389   Int_t nabove = 0;
390   Int_t nbelow = 0;
391   Int_t middle = 0;
392
393   if ((z > GetRow0()) || (z < GetRowEnd())) {
394
395     row = -1;
396
397   }
398   else {
399
400     nabove = fNrows+1;
401     nbelow = 0;
402     while (nabove - nbelow > 1) {
403       middle = (nabove + nbelow) / 2;
404       if (z == fPadRow[middle-1]) row    = middle;
405       if (z  > fPadRow[middle-1]) nabove = middle;
406       else                        nbelow = middle;
407     }
408     row = nbelow - 1;
409
410   }
411
412   return row;
413
414 }
415
416 //_____________________________________________________________________________
417 Int_t AliTRDpadPlane::GetPadColNumber(const Double_t rphi
418                                     , const Double_t rowOffset) const
419 {
420   //
421   // Finds the pad column number for a given global rphi-position
422   //
423
424   Int_t    col       = 0;
425   Int_t    nabove    = 0;
426   Int_t    nbelow    = 0;
427   Int_t    middle    = 0;
428   Double_t rphiShift = 0;
429
430   if ((rphi > GetCol0()) || (rphi < GetColEnd())) {
431
432     col = -1;
433
434   }
435   else {
436
437     //
438     // Take the tilting angle into account by shifting the hit position
439     // into the opposite direction
440     //
441
442     rphiShift = rphi + fTiltingAngle * rowOffset;
443
444     nabove = fNcols+1;
445     nbelow = 0;
446     while (nabove - nbelow > 1) {
447       middle = (nabove + nbelow) / 2;
448       if (rphi == fPadCol[middle-1]) col    = middle;
449       if (rphi  > fPadCol[middle-1]) nabove = middle;
450       else                           nbelow = middle;
451     }
452     col = nbelow - 1;
453
454     //printf("rphi=%f, rphiShift=%f, col=%d, colH=%f\n"
455     //   ,rphi,rphiShift,col,fPadCol[col]);
456
457   }
458
459   return col;
460
461 }