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()
  99 {
 100   //
 101   // AliTRDpadPlane destructor
 102   //
 103
 104   if (fPadRow) {
 105     delete [] fPadRow;
 106     fPadRow = 0;
 107   }
 108
 109   if (fPadCol) {
 110     delete [] fPadCol;
 111     fPadCol = 0;
 112   }
 113
 114 }
 115
 116 //_____________________________________________________________________________
 117 void AliTRDpadPlane::Copy(TObject &p) const
 118 {
 119   //
 120   // Copy function
 121   //
 122
 123   Int_t iBin = 0;
 124
 125   ((AliTRDpadPlane &) p).fLayer           = fLayer;
 126   ((AliTRDpadPlane &) p).fStack           = fStack;
 127
 128   ((AliTRDpadPlane &) p).fLength          = fLength;
 129   ((AliTRDpadPlane &) p).fWidth           = fWidth;
 130   ((AliTRDpadPlane &) p).fLengthRim       = fLengthRim;
 131   ((AliTRDpadPlane &) p).fWidthRim        = fWidthRim;
 132   ((AliTRDpadPlane &) p).fLengthOPad      = fLengthOPad;
 133   ((AliTRDpadPlane &) p).fWidthOPad       = fWidthOPad;
 134   ((AliTRDpadPlane &) p).fLengthIPad      = fLengthIPad;
 135   ((AliTRDpadPlane &) p).fWidthIPad       = fWidthIPad;
 136
 137   ((AliTRDpadPlane &) p).fRowSpacing      = fRowSpacing;
 138   ((AliTRDpadPlane &) p).fColSpacing      = fColSpacing;
 139
 140   ((AliTRDpadPlane &) p).fNrows           = fNrows;
 141   ((AliTRDpadPlane &) p).fNcols           = fNcols;
 142
 143   ((AliTRDpadPlane &) p).fTiltingAngle    = fTiltingAngle;
 144   ((AliTRDpadPlane &) p).fTiltingTan      = fTiltingTan;
 145
 146   ((AliTRDpadPlane &) p).fPadRowSMOffset  = fPadRowSMOffset;
 147   ((AliTRDpadPlane &) p).fAnodeWireOffset = fAnodeWireOffset;
 148
 149   if (((AliTRDpadPlane &) p).fPadRow) {
 150     delete [] ((AliTRDpadPlane &) p).fPadRow;
 151   }
 152   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
 153   for (iBin = 0; iBin < fNrows; iBin++) {
 154     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
 155   }
 156
 157   if (((AliTRDpadPlane &) p).fPadCol) {
 158     delete [] ((AliTRDpadPlane &) p).fPadCol;
 159   }
 160   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
 161   for (iBin = 0; iBin < fNrows; iBin++) {
 162     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
 163   }
 164
 165   TObject::Copy(p);
 166
 167 }
 168
 169 //_____________________________________________________________________________
 170 void AliTRDpadPlane::SetTiltingAngle(Double_t t)
 171 {
 172   //
 173   // Set the tilting angle of the pads
 174   //
 175
 176   fTiltingAngle = t;
 177   fTiltingTan   = TMath::Tan(TMath::Pi()/180.0 * fTiltingAngle);
 178
 179 }
 180
 181 //_____________________________________________________________________________
 182 Int_t AliTRDpadPlane::GetPadRowNumber(Double_t z) const
 183 {
 184   //
 185   // Finds the pad row number for a given z-position in local supermodule system
 186   //
 187
 188   Int_t row    = 0;
 189   Int_t nabove = 0;
 190   Int_t nbelow = 0;
 191   Int_t middle = 0;
 192
 193   if ((z > GetRow0()  ) ||
 194       (z < GetRowEnd())) {
 195
 196     row = -1;
 197
 198   }
 199   else {
 200
 201     nabove = fNrows + 1;
 202     nbelow = 0;
 203     while (nabove - nbelow > 1) {
 204       middle = (nabove + nbelow) / 2;
 205       if (z == (fPadRow[middle-1] + fPadRowSMOffset)) {
 206         row    = middle;
 207       }
 208       if (z  > (fPadRow[middle-1] + fPadRowSMOffset)) {
 209         nabove = middle;
 210       }
 211       else {
 212         nbelow = middle;
 213       }
 214     }
 215     row = nbelow - 1;
 216
 217   }
 218
 219   return row;
 220
 221 }
 222
 223 //_____________________________________________________________________________
 224 Int_t AliTRDpadPlane::GetPadRowNumberROC(Double_t z) const
 225 {
 226   //
 227   // Finds the pad row number for a given z-position in local ROC system
 228   //
 229
 230   Int_t row    = 0;
 231   Int_t nabove = 0;
 232   Int_t nbelow = 0;
 233   Int_t middle = 0;
 234
 235   if ((z > GetRow0ROC()  ) ||
 236       (z < GetRowEndROC())) {
 237
 238     row = -1;
 239
 240   }
 241   else {
 242
 243     nabove = fNrows + 1;
 244     nbelow = 0;
 245     while (nabove - nbelow > 1) {
 246       middle = (nabove + nbelow) / 2;
 247       if (z == fPadRow[middle-1]) {
 248         row    = middle;
 249       }
 250       if (z  > fPadRow[middle-1]) {
 251         nabove = middle;
 252       }
 253       else {
 254         nbelow = middle;
 255       }
 256     }
 257     row = nbelow - 1;
 258
 259   }
 260
 261   return row;
 262
 263 }
 264
 265 //_____________________________________________________________________________
 266 Int_t AliTRDpadPlane::GetPadColNumber(Double_t rphi) const
 267 {
 268   //
 269   // Finds the pad column number for a given rphi-position
 270   //
 271
 272   Int_t col    = 0;
 273   Int_t nabove = 0;
 274   Int_t nbelow = 0;
 275   Int_t middle = 0;
 276
 277   if ((rphi < GetCol0()  ) ||
 278       (rphi > GetColEnd())) {
 279
 280     col = -1;
 281
 282   }
 283   else {
 284
 285     nabove = fNcols;
 286     nbelow = 0;
 287     while (nabove - nbelow > 1) {
 288       middle = (nabove + nbelow) / 2;
 289       if (rphi == fPadCol[middle]) {
 290         col    = middle;
 291       }
 292       if (rphi  > fPadCol[middle]) {
 293         nbelow = middle;
 294       }
 295       else {
 296         nabove = middle;
 297       }
 298     }
 299     col = nbelow;
 300
 301   }
 302
 303   return col;
 304
 305 }