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