Coverity
[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   if (fPadRow) {
193     delete [] fPadRow;
194   }
195   fPadRow = new Double_t[fNrows];
196   for (iBin = 0; iBin < fNrows; iBin++) {
197     fPadRow[iBin] = ((AliTRDpadPlane &) p).fPadRow[iBin];
198   }                                                                             
199
200   if (fPadCol) {
201     delete [] fPadCol;
202   }
203   fPadCol = new Double_t[fNrows];
204   for (iBin = 0; iBin < fNrows; iBin++) {
205     fPadCol[iBin] = ((AliTRDpadPlane &) p).fPadCol[iBin];
206   }                                                                             
207
208   return *this;
209
210 }
211
212 //_____________________________________________________________________________
213 void AliTRDpadPlane::Copy(TObject &p) const
214 {
215   //
216   // Copy function
217   //
218
219   Int_t iBin = 0;
220
221   ((AliTRDpadPlane &) p).fLayer           = fLayer;
222   ((AliTRDpadPlane &) p).fStack           = fStack;
223
224   ((AliTRDpadPlane &) p).fLength          = fLength;
225   ((AliTRDpadPlane &) p).fWidth           = fWidth;
226   ((AliTRDpadPlane &) p).fLengthRim       = fLengthRim;
227   ((AliTRDpadPlane &) p).fWidthRim        = fWidthRim;
228   ((AliTRDpadPlane &) p).fLengthOPad      = fLengthOPad;
229   ((AliTRDpadPlane &) p).fWidthOPad       = fWidthOPad;
230   ((AliTRDpadPlane &) p).fLengthIPad      = fLengthIPad;
231   ((AliTRDpadPlane &) p).fWidthIPad       = fWidthIPad;
232
233   ((AliTRDpadPlane &) p).fRowSpacing      = fRowSpacing;
234   ((AliTRDpadPlane &) p).fColSpacing      = fColSpacing;
235
236   ((AliTRDpadPlane &) p).fNrows           = fNrows;
237   ((AliTRDpadPlane &) p).fNcols           = fNcols;
238
239   ((AliTRDpadPlane &) p).fTiltingAngle    = fTiltingAngle;
240   ((AliTRDpadPlane &) p).fTiltingTan      = fTiltingTan;
241
242   ((AliTRDpadPlane &) p).fPadRowSMOffset  = fPadRowSMOffset;
243   ((AliTRDpadPlane &) p).fAnodeWireOffset = fAnodeWireOffset;
244
245   if (((AliTRDpadPlane &) p).fPadRow) {
246     delete [] ((AliTRDpadPlane &) p).fPadRow;
247   }
248   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
249   for (iBin = 0; iBin < fNrows; iBin++) {
250     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
251   }                                                                             
252
253   if (((AliTRDpadPlane &) p).fPadCol) {
254     delete [] ((AliTRDpadPlane &) p).fPadCol;
255   }
256   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
257   for (iBin = 0; iBin < fNrows; iBin++) {
258     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
259   }                                                                             
260
261   TObject::Copy(p);
262
263 }
264
265 //_____________________________________________________________________________
266 void AliTRDpadPlane::SetTiltingAngle(Double_t t)
267 {
268   //
269   // Set the tilting angle of the pads
270   //
271  
272   fTiltingAngle = t; 
273   fTiltingTan   = TMath::Tan(TMath::Pi()/180.0 * fTiltingAngle); 
274
275 }
276
277 //_____________________________________________________________________________
278 Int_t AliTRDpadPlane::GetPadRowNumber(Double_t z) const
279 {
280   //
281   // Finds the pad row number for a given z-position in local supermodule system
282   //
283
284   Int_t row    = 0;
285   Int_t nabove = 0;
286   Int_t nbelow = 0;
287   Int_t middle = 0;
288
289   if ((z > GetRow0()  ) || 
290       (z < GetRowEnd())) {
291
292     row = -1;
293
294   }
295   else {
296
297     nabove = fNrows + 1;
298     nbelow = 0;
299     while (nabove - nbelow > 1) {
300       middle = (nabove + nbelow) / 2;
301       if (z == (fPadRow[middle-1] + fPadRowSMOffset)) {
302         row    = middle;
303       }
304       if (z  > (fPadRow[middle-1] + fPadRowSMOffset)) {
305         nabove = middle;
306       }
307       else {
308         nbelow = middle;
309       }
310     }
311     row = nbelow - 1;
312
313   }
314
315   return row;
316
317 }
318
319 //_____________________________________________________________________________
320 Int_t AliTRDpadPlane::GetPadRowNumberROC(Double_t z) const
321 {
322   //
323   // Finds the pad row number for a given z-position in local ROC system
324   //
325
326   Int_t row    = 0;
327   Int_t nabove = 0;
328   Int_t nbelow = 0;
329   Int_t middle = 0;
330
331   if ((z > GetRow0ROC()  ) || 
332       (z < GetRowEndROC())) {
333
334     row = -1;
335
336   }
337   else {
338
339     nabove = fNrows + 1;
340     nbelow = 0;
341     while (nabove - nbelow > 1) {
342       middle = (nabove + nbelow) / 2;
343       if (z == fPadRow[middle-1]) {
344         row    = middle;
345       }
346       if (z  > fPadRow[middle-1]) {
347         nabove = middle;
348       }
349       else {
350         nbelow = middle;
351       }
352     }
353     row = nbelow - 1;
354
355   }
356
357   return row;
358
359 }
360
361 //_____________________________________________________________________________
362 Int_t AliTRDpadPlane::GetPadColNumber(Double_t rphi) const
363 {
364   //
365   // Finds the pad column number for a given rphi-position
366   //
367
368   Int_t col    = 0;
369   Int_t nabove = 0;
370   Int_t nbelow = 0;
371   Int_t middle = 0;
372
373   if ((rphi < GetCol0()  ) || 
374       (rphi > GetColEnd())) {
375
376     col = -1;
377
378   }
379   else {
380
381     nabove = fNcols;
382     nbelow = 0;
383     while (nabove - nbelow > 1) {
384       middle = (nabove + nbelow) / 2;
385       if (rphi == fPadCol[middle]) {
386         col    = middle;
387       }
388       if (rphi  > fPadCol[middle]) {
389         nbelow = middle;
390       }
391       else {
392         nabove = middle;
393       }
394     }
395     col = nbelow;
396
397   }
398
399   return col;
400
401 }