Update on calibration classes by Raphaelle

[u/mrichter/AliRoot.git] / TRD / AliTRDpadPlane.h

diff --git a/TRD/AliTRDpadPlane.h b/TRD/AliTRDpadPlane.h
index 3c15b78d663f22b70dd435e7ed09dc05832b4a24..dd881ae2096f4655b3798222f2840d2264940f6c 100644 (file)
--- a/TRD/AliTRDpadPlane.h
+++ b/TRD/AliTRDpadPlane.h
@@ -3,7 +3,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id: AliTRDpadPlane.h,v */
+/* $Id$ */
 
 //////////////////////////////////////////////////
 //                                              //
@@ -18,7 +18,6 @@
 
 #include <TObject.h>
 
-class AliTRDgeometry;
 
 //_____________________________________________________________________________
 class AliTRDpadPlane : public TObject {
@@ -26,21 +25,98 @@ class AliTRDpadPlane : public TObject {
  public:
 
   AliTRDpadPlane();
-  AliTRDpadPlane(Int_t p, Int_t c);
+  AliTRDpadPlane(Int_t plane, Int_t chamber);
   AliTRDpadPlane(const AliTRDpadPlane &p);
   virtual           ~AliTRDpadPlane();
   AliTRDpadPlane    &operator=(const AliTRDpadPlane &p);
   virtual void       Copy(TObject &p) const;
 
-  Int_t    GetPadRowNumber(const Double_t z);
-  Int_t    GetPadColNumber(const Double_t rphi);
-
-  Double_t GetPadRowOffset(const Int_t row, const Double_t z);
-  Double_t GetPadColOffset(const Int_t col, const Double_t rphi);
+  void     SetPlane(Int_t p)                   { fPla            = p; };
+  void     SetChamber(Int_t c)                 { fCha            = c; };
+  void     SetRowSpacing(Double_t s)           { fRowSpacing     = s; };
+  void     SetColSpacing(Double_t s)           { fColSpacing     = s; };
+  void     SetLengthRim(Double_t l)            { fLengthRim      = l; };
+  void     SetWidthRim(Double_t w)             { fWidthRim       = w; };
+  void     SetNcols(Int_t n)                   { fNcols          = n;
+                                                 if (fPadCol) delete[] fPadCol;
+                                                 fPadCol         = new Double_t[fNcols]; };
+  void     SetNrows(Int_t n)                   { fNrows          = n;
+                                                 if (fPadRow) delete[] fPadRow;
+                                                 fPadRow         = new Double_t[fNrows]; };
+  void     SetPadCol(Int_t ic, Double_t c)     { if (ic < fNcols) fPadCol[ic] = c;       };
+  void     SetPadRow(Int_t ir, Double_t r)     { if (ir < fNrows) fPadRow[ir] = r;       };
+  void     SetLength(Double_t l)               { fLength         = l; };
+  void     SetWidth(Double_t w)                { fWidth          = w; };
+  void     SetLengthOPad(Double_t l)           { fLengthOPad     = l; };
+  void     SetWidthOPad(Double_t w)            { fWidthOPad      = w; };
+  void     SetLengthIPad(Double_t l)           { fLengthIPad     = l; };
+  void     SetWidthIPad(Double_t w)            { fWidthIPad      = w; };
+  void     SetPadRowSMOffset(Double_t o)       { fPadRowSMOffset = o; };
+  void     SetTiltingAngle(Double_t t);
+
+  Int_t    GetPadRowNumber(Double_t z) const;
+  Int_t    GetPadRowNumberROC(Double_t z) const;
+  Int_t    GetPadColNumber(Double_t rphi) const;
+
+  Double_t GetTiltOffset(Double_t rowOffset) const 
+                                             { return fTiltingTan * (rowOffset - 0.5*fLengthIPad); };
+
+  Double_t GetPadRowOffset(Int_t row, Double_t z) const
+                                             { if ((row < 0) || (row >= fNrows))
+                                                 return -1.0;
+                                               else 
+                                                 return fPadRow[row] + fPadRowSMOffset - z;        };
+  Double_t GetPadRowOffsetROC(Int_t row, Double_t z) const
+                                             { if ((row < 0) || (row >= fNrows))
+                                                 return -1.0;
+                                               else 
+                                                 return fPadRow[row] - z;    };
+
+  Double_t GetPadColOffset(Int_t col, Double_t rphi) const
+                                             { if ((col < 0) || (col >= fNcols))
+                                                 return -1.0;
+                                               else
+                                                 return fPadCol[col] - rphi; };
+
+  Double_t GetTiltingAngle() const           { return fTiltingAngle; };
+
+  Int_t    GetNrows() const                  { return fNrows;        };
+  Int_t    GetNcols() const                  { return fNcols;        };
+
+  Double_t GetRow0() const                   { return fPadRow[0] + fPadRowSMOffset;    };
+  Double_t GetRow0ROC() const                { return fPadRow[0];    };
+  Double_t GetCol0() const                   { return fPadCol[0];    };
+
+  Double_t GetRowEnd() const                 { return fPadRow[fNrows-1] - fLengthOPad + fPadRowSMOffset; };
+  Double_t GetRowEndROC() const              { return fPadRow[fNrows-1] - fLengthOPad; };
+  Double_t GetColEnd() const                 { return fPadCol[fNcols-1] - fWidthOPad;  };
+
+  Double_t GetRowPos(Int_t row) const        { return fPadRow[row] + fPadRowSMOffset;  };
+  Double_t GetRowPosROC(Int_t row) const     { return fPadRow[row];  };
+  Double_t GetColPos(Int_t col) const        { return fPadCol[col];  };
   
- protected:
+  Double_t GetRowSize(Int_t row) const       { if ((row == 0) || (row == fNrows-1))
+                                                 return fLengthOPad;
+                                               else
+                                                 return fLengthIPad; };
+  Double_t GetColSize(Int_t col) const       { if ((col == 0) || (col == fNcols-1))
+                                                 return fWidthOPad;
+                                               else
+                                                  return fWidthIPad; };
+
+  Double_t GetLengthRim() const              { return fLengthRim;    };
+  Double_t GetWidthRim() const               { return fWidthRim;     };
+
+  Double_t GetRowSpacing() const             { return fRowSpacing;   };
+  Double_t GetColSpacing() const             { return fColSpacing;   };
 
-  AliTRDgeometry *fGeo;       //! TRD geometry       
+  Double_t GetLengthOPad() const             { return fLengthOPad;   };
+  Double_t GetLengthIPad() const             { return fLengthIPad;   };
+
+  Double_t GetWidthOPad() const              { return fWidthOPad;    };
+  Double_t GetWidthIPad() const              { return fWidthIPad;    };
+
+ protected:
 
   Int_t     fPla;             //  Plane number
   Int_t     fCha;             //  Chamber number
@@ -64,11 +140,14 @@ class AliTRDpadPlane : public TObject {
   Int_t     fNcols;           //  Number of columns
 
   Double_t  fTiltingAngle;    //  Pad tilting angle  
+  Double_t  fTiltingTan;      //  Tangens of pad tilting angle
+
+  Double_t *fPadRow;          //  Pad border positions in row direction
+  Double_t *fPadCol;          //  Pad border positions in column direction
 
-  Double_t *fPadRow;          //! Pad border positions in row direction
-  Double_t *fPadCol;          //! Pad border positions in column direction
+  Double_t  fPadRowSMOffset;  //  To be added to translate local ROC system to local SM system
 
-  ClassDef(AliTRDpadPlane,1)  //  TRD ROC pad plane
+  ClassDef(AliTRDpadPlane,4)  //  TRD ROC pad plane
 
 };