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 }