19927357d0f41b9c565655e126b2e888683f79b9
[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 //  The numbering and coordinates should follow the official convention      //
27 //  (see David Emschermanns note on TRD convention                           //
28 //                                                                           //
29 ///////////////////////////////////////////////////////////////////////////////
30
31 #include <TMath.h>
32
33 #include "AliTRDpadPlane.h"
34
35 ClassImp(AliTRDpadPlane)
36
37 //_____________________________________________________________________________
38 AliTRDpadPlane::AliTRDpadPlane()
39   :TObject()
40   ,fLayer(0)
41   ,fStack(0)
42   ,fLength(0)
43   ,fWidth(0)
44   ,fLengthRim(0)
45   ,fWidthRim(0)
46   ,fLengthOPad(0)
47   ,fWidthOPad(0)
48   ,fLengthIPad(0)
49   ,fWidthIPad(0)
50   ,fRowSpacing(0)
51   ,fColSpacing(0)
52   ,fNrows(0)
53   ,fNcols(0)
54   ,fTiltingAngle(0)
55   ,fTiltingTan(0)
56   ,fPadRow(0)
57   ,fPadCol(0)
58   ,fPadRowSMOffset(0)
59   ,fAnodeWireOffset(0)
60 {
61   //
62   // Default constructor
63   //
64
65 }
66
67 //_____________________________________________________________________________
68 AliTRDpadPlane::AliTRDpadPlane(Int_t layer, Int_t stack)
69   :TObject()
70   ,fLayer(layer)
71   ,fStack(stack)
72   ,fLength(0)
73   ,fWidth(0)
74   ,fLengthRim(0)
75   ,fWidthRim(0)
76   ,fLengthOPad(0)
77   ,fWidthOPad(0)
78   ,fLengthIPad(0)
79   ,fWidthIPad(0)
80   ,fRowSpacing(0)
81   ,fColSpacing(0)
82   ,fNrows(0)
83   ,fNcols(0)
84   ,fTiltingAngle(0)
85   ,fTiltingTan(0)
86   ,fPadRow(0)
87   ,fPadCol(0)
88   ,fPadRowSMOffset(0)
89   ,fAnodeWireOffset(0)
90 {
91   //
92   // Constructor
93   //
94
95 }
96
97 //_____________________________________________________________________________
98 AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p)
99   :TObject(p)
100   ,fLayer(p.fLayer)
101   ,fStack(p.fStack)
102   ,fLength(p.fLength)
103   ,fWidth(p.fWidth)
104   ,fLengthRim(p.fLengthRim)
105   ,fWidthRim(p.fLengthRim)
106   ,fLengthOPad(p.fLengthOPad)
107   ,fWidthOPad(p.fWidthOPad)
108   ,fLengthIPad(p.fLengthIPad)
109   ,fWidthIPad(p.fWidthIPad)
110   ,fRowSpacing(p.fRowSpacing)
111   ,fColSpacing(p.fColSpacing)
112   ,fNrows(p.fNrows)
113   ,fNcols(p.fNcols)
114   ,fTiltingAngle(p.fTiltingAngle)
115   ,fTiltingTan(p.fTiltingTan)
116   ,fPadRow(0)
117   ,fPadCol(0)
118   ,fPadRowSMOffset(p.fPadRowSMOffset)
119   ,fAnodeWireOffset(p.fAnodeWireOffset)
120 {
121   //
122   // AliTRDpadPlane copy constructor
123   //
124
125   Int_t iBin = 0;
126
127   fPadRow = new Double_t[fNrows];
128   for (iBin = 0; iBin < fNrows; iBin++) {
129     fPadRow[iBin] = ((AliTRDpadPlane &) p).fPadRow[iBin];
130   }                                                                             
131
132   fPadCol = new Double_t[fNrows];
133   for (iBin = 0; iBin < fNrows; iBin++) {
134     fPadCol[iBin] = ((AliTRDpadPlane &) p).fPadCol[iBin];
135   }                                                                             
136
137 }
138
139 //_____________________________________________________________________________
140 AliTRDpadPlane::~AliTRDpadPlane()
141 {
142   //
143   // AliTRDpadPlane destructor
144   //
145
146   if (fPadRow) {
147     delete [] fPadRow;
148     fPadRow = 0;
149   }
150
151   if (fPadCol) {
152     delete [] fPadCol;
153     fPadCol = 0;
154   }
155
156 }
157
158 //_____________________________________________________________________________
159 AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
160 {
161   //
162   // Assignment operator
163   //
164
165   if (this == &p) {
166     return *this;
167   }
168
169   fLayer           = p.fLayer;
170   fStack           = p.fStack;
171   fLength          = p.fLength;
172   fWidth           = p.fWidth;
173   fLengthRim       = p.fLengthRim;
174   fWidthRim        = p.fLengthRim;
175   fLengthOPad      = p.fLengthOPad;
176   fWidthOPad       = p.fWidthOPad;
177   fLengthIPad      = p.fLengthIPad;
178   fWidthIPad       = p.fWidthIPad;
179   fRowSpacing      = p.fRowSpacing;
180   fColSpacing      = p.fColSpacing;
181   fNrows           = p.fNrows;
182   fNcols           = p.fNcols;
183   fTiltingAngle    = p.fTiltingAngle;
184   fTiltingTan      = p.fTiltingTan;
185   fPadRow          = 0;
186   fPadCol          = 0;
187   fPadRowSMOffset  = p.fPadRowSMOffset;
188   fAnodeWireOffset = p.fAnodeWireOffset;
189
190   Int_t iBin = 0;
191
192   fPadRow = new Double_t[fNrows];
193   for (iBin = 0; iBin < fNrows; iBin++) {
194     fPadRow[iBin] = ((AliTRDpadPlane &) p).fPadRow[iBin];
195   }                                                                             
196
197   fPadCol = new Double_t[fNrows];
198   for (iBin = 0; iBin < fNrows; iBin++) {
199     fPadCol[iBin] = ((AliTRDpadPlane &) p).fPadCol[iBin];
200   }                                                                             
201
202   return *this;
203
204 }
205
206 //_____________________________________________________________________________
207 void AliTRDpadPlane::Copy(TObject &p) const
208 {
209   //
210   // Copy function
211   //
212
213   Int_t iBin = 0;
214
215   ((AliTRDpadPlane &) p).fLayer           = fLayer;
216   ((AliTRDpadPlane &) p).fStack           = fStack;
217
218   ((AliTRDpadPlane &) p).fLength          = fLength;
219   ((AliTRDpadPlane &) p).fWidth           = fWidth;
220   ((AliTRDpadPlane &) p).fLengthRim       = fLengthRim;
221   ((AliTRDpadPlane &) p).fWidthRim        = fWidthRim;
222   ((AliTRDpadPlane &) p).fLengthOPad      = fLengthOPad;
223   ((AliTRDpadPlane &) p).fWidthOPad       = fWidthOPad;
224   ((AliTRDpadPlane &) p).fLengthIPad      = fLengthIPad;
225   ((AliTRDpadPlane &) p).fWidthIPad       = fWidthIPad;
226
227   ((AliTRDpadPlane &) p).fRowSpacing      = fRowSpacing;
228   ((AliTRDpadPlane &) p).fColSpacing      = fColSpacing;
229
230   ((AliTRDpadPlane &) p).fNrows           = fNrows;
231   ((AliTRDpadPlane &) p).fNcols           = fNcols;
232
233   ((AliTRDpadPlane &) p).fTiltingAngle    = fTiltingAngle;
234   ((AliTRDpadPlane &) p).fTiltingTan      = fTiltingTan;
235
236   ((AliTRDpadPlane &) p).fPadRowSMOffset  = fPadRowSMOffset;
237   ((AliTRDpadPlane &) p).fAnodeWireOffset = fAnodeWireOffset;
238
239   if (((AliTRDpadPlane &) p).fPadRow) {
240     delete [] ((AliTRDpadPlane &) p).fPadRow;
241   }
242   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
243   for (iBin = 0; iBin < fNrows; iBin++) {
244     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
245   }                                                                             
246
247   if (((AliTRDpadPlane &) p).fPadCol) {
248     delete [] ((AliTRDpadPlane &) p).fPadCol;
249   }
250   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
251   for (iBin = 0; iBin < fNrows; iBin++) {
252     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
253   }                                                                             
254
255   TObject::Copy(p);
256
257 }
258
259 //_____________________________________________________________________________
260 void AliTRDpadPlane::SetTiltingAngle(Double_t t)
261 {
262   //
263   // Set the tilting angle of the pads
264   //
265  
266   fTiltingAngle = t; 
267   fTiltingTan   = TMath::Tan(TMath::Pi()/180.0 * fTiltingAngle); 
268
269 }
270
271 //_____________________________________________________________________________
272 Int_t AliTRDpadPlane::GetPadRowNumber(Double_t z) const
273 {
274   //
275   // Finds the pad row number for a given z-position in local supermodule system
276   //
277
278   Int_t row    = 0;
279   Int_t nabove = 0;
280   Int_t nbelow = 0;
281   Int_t middle = 0;
282
283   if ((z > GetRow0()  ) || 
284       (z < GetRowEnd())) {
285
286     row = -1;
287
288   }
289   else {
290
291     nabove = fNrows + 1;
292     nbelow = 0;
293     while (nabove - nbelow > 1) {
294       middle = (nabove + nbelow) / 2;
295       if (z == (fPadRow[middle-1] + fPadRowSMOffset)) {
296         row    = middle;
297       }
298       if (z  > (fPadRow[middle-1] + fPadRowSMOffset)) {
299         nabove = middle;
300       }
301       else {
302         nbelow = middle;
303       }
304     }
305     row = nbelow - 1;
306
307   }
308
309   return row;
310
311 }
312
313 //_____________________________________________________________________________
314 Int_t AliTRDpadPlane::GetPadRowNumberROC(Double_t z) const
315 {
316   //
317   // Finds the pad row number for a given z-position in local ROC system
318   //
319
320   Int_t row    = 0;
321   Int_t nabove = 0;
322   Int_t nbelow = 0;
323   Int_t middle = 0;
324
325   if ((z > GetRow0ROC()  ) || 
326       (z < GetRowEndROC())) {
327
328     row = -1;
329
330   }
331   else {
332
333     nabove = fNrows + 1;
334     nbelow = 0;
335     while (nabove - nbelow > 1) {
336       middle = (nabove + nbelow) / 2;
337       if (z == fPadRow[middle-1]) {
338         row    = middle;
339       }
340       if (z  > fPadRow[middle-1]) {
341         nabove = middle;
342       }
343       else {
344         nbelow = middle;
345       }
346     }
347     row = nbelow - 1;
348
349   }
350
351   return row;
352
353 }
354
355 //_____________________________________________________________________________
356 Int_t AliTRDpadPlane::GetPadColNumber(Double_t rphi) const
357 {
358   //
359   // Finds the pad column number for a given rphi-position
360   //
361
362   Int_t col    = 0;
363   Int_t nabove = 0;
364   Int_t nbelow = 0;
365   Int_t middle = 0;
366
367   if ((rphi < GetCol0()  ) || 
368       (rphi > GetColEnd())) {
369
370     col = -1;
371
372   }
373   else {
374
375     nabove = fNcols;
376     nbelow = 0;
377     while (nabove - nbelow > 1) {
378       middle = (nabove + nbelow) / 2;
379       if (rphi == fPadCol[middle]) {
380         col    = middle;
381       }
382       if (rphi  > fPadCol[middle]) {
383         nbelow = middle;
384       }
385       else {
386         nabove = middle;
387       }
388     }
389     col = nbelow;
390
391   }
392
393   return col;
394
395 }