TRD/AliTRDpadPlane.h

   1 #ifndef ALITRDPADPLANE_H
   2 #define ALITRDPADPLANE_H
   3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 ////////////////////////////////////////////////////////////////////////////
   9 //                                                                        //
  10 //  TRD pad plane class                                                   //
  11 //                                                                        //
  12 //  Contains the information on ideal pad positions, pad dimensions,      //
  13 //  tilting angle, etc.                                                   //
  14 //  It also provides methods to identify the current pad number from      //
  15 //  local tracking coordinates.                                           //
  16 //                                                                        //
  17 ////////////////////////////////////////////////////////////////////////////
  18
  19 #include <TObject.h>
  20
  21 //_____________________________________________________________________________
  22 class AliTRDpadPlane : public TObject {
  23
  24  public:
  25
  26   AliTRDpadPlane();
  27   AliTRDpadPlane(Int_t layer, Int_t stack);
  28   AliTRDpadPlane(const AliTRDpadPlane &p);
  29   virtual           ~AliTRDpadPlane();
  30   AliTRDpadPlane    &operator=(const AliTRDpadPlane &p);
  31   virtual void       Copy(TObject &p) const;
  32
  33   void     SetLayer(Int_t l)                   { fLayer          = l; };
  34   void     SetStack(Int_t s)                   { fStack          = s; };
  35   void     SetRowSpacing(Double_t s)           { fRowSpacing     = s; };
  36   void     SetColSpacing(Double_t s)           { fColSpacing     = s; };
  37   void     SetLengthRim(Double_t l)            { fLengthRim      = l; };
  38   void     SetWidthRim(Double_t w)             { fWidthRim       = w; };
  39   void     SetNcols(Int_t n)                   { fNcols          = n;
  40                                                  if (fPadCol) delete[] fPadCol;
  41                                                  fPadCol         = new Double_t[fNcols]; };
  42   void     SetNrows(Int_t n)                   { fNrows          = n;
  43                                                  if (fPadRow) delete[] fPadRow;
  44                                                  fPadRow         = new Double_t[fNrows]; };
  45   void     SetPadCol(Int_t ic, Double_t c)     { if (ic < fNcols) fPadCol[ic] = c;       };
  46   void     SetPadRow(Int_t ir, Double_t r)     { if (ir < fNrows) fPadRow[ir] = r;       };
  47   void     SetLength(Double_t l)               { fLength         = l; };
  48   void     SetWidth(Double_t w)                { fWidth          = w; };
  49   void     SetLengthOPad(Double_t l)           { fLengthOPad     = l; };
  50   void     SetWidthOPad(Double_t w)            { fWidthOPad      = w; };
  51   void     SetLengthIPad(Double_t l)           { fLengthIPad     = l; };
  52   void     SetWidthIPad(Double_t w)            { fWidthIPad      = w; };
  53   void     SetPadRowSMOffset(Double_t o)       { fPadRowSMOffset = o; };
  54   void     SetTiltingAngle(Double_t t);
  55
  56   Int_t    GetPadRowNumber(Double_t z) const;
  57   Int_t    GetPadRowNumberROC(Double_t z) const;
  58   Int_t    GetPadColNumber(Double_t rphi) const;
  59
  60   Double_t GetTiltOffset(Double_t rowOffset) const
  61                                              { return fTiltingTan * (rowOffset - 0.5*fLengthIPad); };
  62
  63   Double_t GetPadRowOffset(Int_t row, Double_t z) const
  64                                              { if ((row < 0) || (row >= fNrows))
  65                                                  return -1.0;
  66                                                 else
  67                                                  return fPadRow[row] + fPadRowSMOffset - z;        };
  68   Double_t GetPadRowOffsetROC(Int_t row, Double_t z) const
  69                                              { if ((row < 0) || (row >= fNrows))
  70                                                  return -1.0;
  71                                                else
  72                                                  return fPadRow[row] - z;    };
  73
  74   Double_t GetPadColOffset(Int_t col, Double_t rphi) const
  75                                              { if ((col < 0) || (col >= fNcols))
  76                                                  return -1.0;
  77                                                else
  78                                                  return rphi - fPadCol[col]; };
  79
  80   Double_t GetTiltingAngle() const           { return fTiltingAngle; };
  81
  82   Int_t    GetNrows() const                  { return fNrows;        };
  83   Int_t    GetNcols() const                  { return fNcols;        };
  84
  85   Double_t GetRow0() const                   { return fPadRow[0] + fPadRowSMOffset;    };
  86   Double_t GetRow0ROC() const                { return fPadRow[0];    };
  87   Double_t GetCol0() const                   { return fPadCol[0];    };
  88
  89   Double_t GetRowEnd() const                 { return fPadRow[fNrows-1] - fLengthOPad + fPadRowSMOffset; };
  90   Double_t GetRowEndROC() const              { return fPadRow[fNrows-1] - fLengthOPad; };
  91   Double_t GetColEnd() const                 { return fPadCol[fNcols-1] + fWidthOPad;  };
  92
  93   Double_t GetRowPos(Int_t row) const        { return fPadRow[row] + fPadRowSMOffset;  };
  94   Double_t GetRowPosROC(Int_t row) const     { return fPadRow[row];  };
  95   Double_t GetColPos(Int_t col) const        { return fPadCol[col];  };
  96
  97   Double_t GetRowSize(Int_t row) const       { if ((row == 0) || (row == fNrows-1))
  98                                                  return fLengthOPad;
  99                                                else
 100                                                  return fLengthIPad; };
 101   Double_t GetColSize(Int_t col) const       { if ((col == 0) || (col == fNcols-1))
 102                                                  return fWidthOPad;
 103                                                else
 104                                                  return fWidthIPad;  };
 105
 106   Double_t GetLengthRim() const              { return fLengthRim;    };
 107   Double_t GetWidthRim() const               { return fWidthRim;     };
 108
 109   Double_t GetRowSpacing() const             { return fRowSpacing;   };
 110   Double_t GetColSpacing() const             { return fColSpacing;   };
 111
 112   Double_t GetLengthOPad() const             { return fLengthOPad;   };
 113   Double_t GetLengthIPad() const             { return fLengthIPad;   };
 114
 115   Double_t GetWidthOPad() const              { return fWidthOPad;    };
 116   Double_t GetWidthIPad() const              { return fWidthIPad;    };
 117
 118  protected:
 119
 120   Int_t     fLayer;           //  Layer number
 121   Int_t     fStack;           //  Stack number
 122
 123   Double_t  fLength;          //  Length of pad plane in z-direction (row)
 124   Double_t  fWidth;           //  Width of pad plane in rphi-direction (col)
 125
 126   Double_t  fLengthRim;       //  Length of the rim in z-direction (row)
 127   Double_t  fWidthRim;        //  Width of the rim in rphi-direction (col)
 128
 129   Double_t  fLengthOPad;      //  Length of an outer pad in z-direction (row)
 130   Double_t  fWidthOPad;       //  Width of an outer pad in rphi-direction (col)
 131
 132   Double_t  fLengthIPad;      //  Length of an inner pad in z-direction (row)
 133   Double_t  fWidthIPad;       //  Width of an inner pad in rphi-direction (col)
 134
 135   Double_t  fRowSpacing;      //  Spacing between the pad rows
 136   Double_t  fColSpacing;      //  Spacing between the pad columns
 137
 138   Int_t     fNrows;           //  Number of rows
 139   Int_t     fNcols;           //  Number of columns
 140
 141   Double_t  fTiltingAngle;    //  Pad tilting angle
 142   Double_t  fTiltingTan;      //  Tangens of pad tilting angle
 143
 144   Double_t *fPadRow;          //  Pad border positions in row direction
 145   Double_t *fPadCol;          //  Pad border positions in column direction
 146
 147   Double_t  fPadRowSMOffset;  //  To be added to translate local ROC system to local SM system
 148
 149   ClassDef(AliTRDpadPlane,5)  //  TRD ROC pad plane
 150
 151 };
 152
 153 #endif