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