c59046a30f4f82209d76acdb17070f35a3db99ee
[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 "AliTRDgeometry.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   fTiltingTan   = 0.0;
66
67 }
68
69 //_____________________________________________________________________________
70 AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c):TObject(),fPadRow(0),fPadCol(0)
71 {
72   //
73   // Constructor that initializes a given pad plane type
74   //
75
76   fGeo = new AliTRDgeometry();
77
78   fPla = p;
79   fCha = c;
80
81   fRowSpacing = 0.0;
82   fColSpacing = 0.0;
83
84   fLengthRim  = 1.0;
85   fWidthRim   = 0.5;
86
87   fNcols      = 144;
88
89   //
90   // The pad plane parameter
91   //
92   switch (p) {
93   case 0:
94     if (c == 2) {
95       // L0C0 type
96       fNrows        =  12;
97       fLength       = 108.0;
98       fWidth        =  92.2;
99       fLengthOPad   =   8.0;
100       fWidthOPad    =   0.515;
101       fLengthIPad   =   9.0;
102       fWidthIPad    =   0.635;
103       fTiltingAngle =  -2.0;
104     }
105     else {
106       // L0C1 type
107       fNrows        =  16;
108       fLength       = 122.0;
109       fWidth        =  92.2;
110       fLengthOPad   =   7.5;
111       fWidthOPad    =   0.515;
112       fLengthIPad   =   7.5;
113       fWidthIPad    =   0.635;
114       fTiltingAngle =  -2.0;
115     }
116     break;
117   case 1:
118     if (c == 2) {
119       // L1C0 type
120       fNrows        =  12;
121       fLength       = 108.0;
122       fWidth        =  96.6;
123       fLengthOPad   =   8.0;
124       fWidthOPad    =   0.585;
125       fLengthIPad   =   9.0;
126       fWidthIPad    =   0.665;
127       fTiltingAngle =   2.0;
128     }
129     else {
130       // L1C1 type
131       fNrows        =  16;
132       fLength       = 122.0;
133       fWidth        =  96.6;
134       fLengthOPad   =   7.5;
135       fWidthOPad    =   0.585;
136       fLengthIPad   =   7.5;
137       fWidthIPad    =   0.665;
138       fTiltingAngle =   2.0;
139     }
140     break;
141   case 2:
142     if (c == 2) {
143       // L2C0 type
144       fNrows        =  12;
145       fLength       = 108.0;
146       fWidth        = 101.1;
147       fLengthOPad   =   8.0;
148       fWidthOPad    =   0.705;
149       fLengthIPad   =   9.0;
150       fWidthIPad    =   0.695;
151       fTiltingAngle =  -2.0;
152     }
153     else {
154       // L2C1 type
155       fNrows        =  16;
156       fLength       = 129.0;
157       fWidth        = 101.1;
158       fLengthOPad   =   7.5;
159       fWidthOPad    =   0.705;
160       fLengthIPad   =   8.0;
161       fWidthIPad    =   0.695;
162       fTiltingAngle =  -2.0;
163     }
164     break;
165   case 3:
166     if (c == 2) {
167       // L3C0 type
168       fNrows        =  12;
169       fLength       = 108.0;
170       fWidth        = 105.5;
171       fLengthOPad   =   8.0;
172       fWidthOPad    =   0.775;
173       fLengthIPad   =   9.0;
174       fWidthIPad    =   0.725;
175       fTiltingAngle =   2.0;
176     }
177     else {
178       // L3C1 type
179       fNrows        =  16;
180       fLength       = 136.0;
181       fWidth        = 105.5;
182       fLengthOPad   =   7.5;
183       fWidthOPad    =   0.775;
184       fLengthIPad   =   8.5;
185       fWidthIPad    =   0.725;
186       fTiltingAngle =   2.0;
187     }
188     break;
189   case 4:
190     if (c == 2) {
191       // L4C0 type
192       fNrows        =  12;
193       fLength       = 108.0;
194       fWidth        = 109.9;
195       fLengthOPad   =   8.0;
196       fWidthOPad    =   0.845;
197       fLengthIPad   =   9.0;
198       fWidthIPad    =   0.755;
199       fTiltingAngle =  -2.0;
200     }
201     else {
202       // L4C1 type
203       fNrows        =  16;
204       fLength       = 143.0;
205       fWidth        = 109.9;
206       fLengthOPad   =   7.5;
207       fWidthOPad    =   0.845;
208       fLengthIPad   =   9.0;
209       fWidthIPad    =   0.755;
210       fTiltingAngle =  -2.0;
211     }
212     break;
213   case 5:
214     if (c == 2) {
215       // L5C0 type
216       fNrows        =  12;
217       fLength       = 108.0;
218       fWidth        = 114.4;
219       fLengthOPad   =   8.0;
220       fWidthOPad    =   0.965;
221       fLengthIPad   =   9.0;
222       fWidthIPad    =   0.785;
223       fTiltingAngle =   2.0;
224     }
225     else {
226       // L5C1 type
227       fNrows        =  16;
228       fLength       = 145.0;
229       fWidth        = 114.4;
230       fLengthOPad   =   8.5;
231       fWidthOPad    =   0.965;
232       fLengthIPad   =   9.0;
233       fWidthIPad    =   0.785;
234       fTiltingAngle =   2.0;
235     }
236     break;
237   };
238
239   //
240   // Store tilting angle as tangens
241   //
242   fTiltingTan = TMath::Tan(TMath::Pi()/180.0 * fTiltingAngle);
243
244   //
245   // The positions of the borders of the pads
246   //
247   // Row direction
248   //
249   fPadRow = new Double_t[fNrows];
250   Double_t row = fGeo->GetChamberLength(p,0)
251                + fGeo->GetChamberLength(p,1)
252                + fGeo->GetChamberLength(p,2) / 2.
253                - fGeo->RpadW()
254                - fLengthRim;
255   for (Int_t ic = 0; ic < c; ic++) {
256     row -= fGeo->GetChamberLength(p,ic);
257   }
258   for (Int_t ir = 0; ir < fNrows; ir++) {
259     fPadRow[ir] = row;
260     row -= fRowSpacing;
261     if (ir == 0) {
262       row -= fLengthOPad;
263     }
264     else {
265       row -= fLengthIPad;
266     }
267   }
268   //
269   // Column direction
270   //
271   fPadCol = new Double_t[fNcols];
272   Double_t col = fGeo->GetChamberWidth(p) / 2. 
273                + fGeo->CroWid()
274                - fWidthRim;
275   for (Int_t ic = 0; ic < fNcols; ic++) {
276     fPadCol[ic] = col;
277     col -= fColSpacing;
278     if (ic == 0) {
279       col -= fWidthOPad;
280     }
281     else {
282       col -= fWidthIPad;
283     }
284   }
285
286 }
287
288 //_____________________________________________________________________________
289 AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p):TObject(p)
290 {
291   //
292   // AliTRDpadPlane copy constructor
293   //
294
295   ((AliTRDpadPlane &) p).Copy(*this);
296
297 }
298
299 //_____________________________________________________________________________
300 AliTRDpadPlane::~AliTRDpadPlane()
301 {
302   //
303   // AliTRDpadPlane destructor
304   //
305
306   if (fGeo) {
307     delete fGeo;
308     fGeo    = 0;
309   }
310
311   if (fPadRow) {
312     delete [] fPadRow;
313     fPadRow = 0;
314   }
315
316   if (fPadCol) {
317     delete [] fPadCol;
318     fPadCol = 0;
319   }
320
321 }
322
323 //_____________________________________________________________________________
324 AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
325 {
326   //
327   // Assignment operator
328   //
329
330   if (this != &p) ((AliTRDpadPlane &) p).Copy(*this);
331   return *this;
332
333 }
334
335 //_____________________________________________________________________________
336 void AliTRDpadPlane::Copy(TObject &p) const
337 {
338   //
339   // Copy function
340   //
341
342   Int_t iBin = 0;
343
344   ((AliTRDpadPlane &) p).fGeo          = 0;
345
346   ((AliTRDpadPlane &) p).fPla          = fPla;
347   ((AliTRDpadPlane &) p).fCha          = fCha;
348
349   ((AliTRDpadPlane &) p).fLength       = fLength;
350   ((AliTRDpadPlane &) p).fWidth        = fWidth;
351   ((AliTRDpadPlane &) p).fLengthRim    = fLengthRim;
352   ((AliTRDpadPlane &) p).fWidthRim     = fWidthRim;
353   ((AliTRDpadPlane &) p).fLengthOPad   = fLengthOPad;
354   ((AliTRDpadPlane &) p).fWidthOPad    = fWidthOPad;
355   ((AliTRDpadPlane &) p).fLengthIPad   = fLengthIPad;
356   ((AliTRDpadPlane &) p).fWidthIPad    = fWidthIPad;
357
358   ((AliTRDpadPlane &) p).fRowSpacing   = fRowSpacing;
359   ((AliTRDpadPlane &) p).fColSpacing   = fColSpacing;
360
361   ((AliTRDpadPlane &) p).fNrows        = fNrows;
362   ((AliTRDpadPlane &) p).fNcols        = fNcols;
363
364   ((AliTRDpadPlane &) p).fTiltingAngle = fTiltingAngle;
365   ((AliTRDpadPlane &) p).fTiltingTan   = fTiltingTan;
366
367   if (((AliTRDpadPlane &) p).fPadRow) delete [] ((AliTRDpadPlane &) p).fPadRow;
368   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
369   for (iBin = 0; iBin < fNrows; iBin++) {
370     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
371   }                                                                             
372
373   if (((AliTRDpadPlane &) p).fPadCol) delete [] ((AliTRDpadPlane &) p).fPadCol;
374   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
375   for (iBin = 0; iBin < fNrows; iBin++) {
376     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
377   }                                                                             
378
379   TObject::Copy(p);
380
381 }
382
383 //_____________________________________________________________________________
384 Int_t AliTRDpadPlane::GetPadRowNumber(Double_t z) const
385 {
386   //
387   // Finds the pad row number for a given global z-position
388   //
389
390   Int_t row    = 0;
391   Int_t nabove = 0;
392   Int_t nbelow = 0;
393   Int_t middle = 0;
394
395   if ((z > GetRow0()) || (z < GetRowEnd())) {
396
397     row = -1;
398
399   }
400   else {
401
402     nabove = fNrows+1;
403     nbelow = 0;
404     while (nabove - nbelow > 1) {
405       middle = (nabove + nbelow) / 2;
406       if (z == fPadRow[middle-1]) row    = middle;
407       if (z  > fPadRow[middle-1]) nabove = middle;
408       else                        nbelow = middle;
409     }
410     row = nbelow - 1;
411
412   }
413
414   return row;
415
416 }
417
418 //_____________________________________________________________________________
419 Int_t AliTRDpadPlane::GetPadColNumber(Double_t rphi
420                                       , Double_t /*rowOffset*/) const
421 {
422   //
423   // Finds the pad column number for a given global rphi-position
424   //
425
426   Int_t    col       = 0;
427   Int_t    nabove    = 0;
428   Int_t    nbelow    = 0;
429   Int_t    middle    = 0;
430   Double_t rphiShift = 0;
431
432   // MI change don't apply tilting angle here - better to do it directly on hit level
433   // Take the tilting angle into account by shifting the hit position
434   // into the opposite direction
435   // 
436
437
438   rphiShift = rphi ;
439
440   if ((rphiShift > GetCol0()) || (rphiShift < GetColEnd())) {
441
442     col = -1;
443
444   }
445   else {
446
447     nabove = fNcols+1;
448     nbelow = 0;
449     while (nabove - nbelow > 1) {
450       middle = (nabove + nbelow) / 2;
451       if (rphiShift == fPadCol[middle-1]) col    = middle;
452       if (rphiShift  > fPadCol[middle-1]) nabove = middle;
453       else                                nbelow = middle;
454     }
455     col = nbelow - 1;
456
457   }
458
459   return col;
460
461 }