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()
  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 //_____________________________________________________________________________
  64 AliTRDpadPlane::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 //_____________________________________________________________________________
 303 AliTRDpadPlane::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 //_____________________________________________________________________________
 346 AliTRDpadPlane::~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 //_____________________________________________________________________________
 370 AliTRDpadPlane &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 //_____________________________________________________________________________
 382 void 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 //_____________________________________________________________________________
 430 Int_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 //_____________________________________________________________________________
 465 Int_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 }