]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - TRD/AliTRDgeometry.h
Removing MC position of the primary vertex (Jouri)
[u/mrichter/AliRoot.git] / TRD / AliTRDgeometry.h
index 0852850276f7ddc5fd90d05f7c7e28c125629b09..2b98b1862f73d0b08dc23544aba06826784d52ac 100644 (file)
@@ -22,11 +22,11 @@ class AliTRDgeometry : public AliGeometry {
 
  public:
 
-          enum { kNplan =   6
-               , kNcham =   5
-               , kNsect =  18
-               , kNdet  = 540 
-               , kNdets =  30 };
+  enum { kNplan =   6
+       , kNcham =   5
+       , kNsect =  18
+       , kNdet  = 540 
+       , kNdets =  30 };
 
   AliTRDgeometry();
   AliTRDgeometry(const AliTRDgeometry &g);
@@ -39,14 +39,7 @@ class AliTRDgeometry : public AliGeometry {
   virtual Bool_t   Impact(const TParticle* ) const                     { return kTRUE;           }
   virtual Bool_t   IsHole(Int_t /*p*/, Int_t /*c*/, Int_t /*s*/) const { return kFALSE;          }
 
-  virtual Bool_t   Local2Global(Int_t d, Double_t *local, Double_t *global) const;
-  virtual Bool_t   Local2Global(Int_t p, Int_t c, Int_t s
-                              , Double_t *local, Double_t *global) const;
-  virtual Bool_t   Global2Local(Int_t mode, Double_t *local, Double_t *global
-                              , Int_t *index) const;
-  virtual Bool_t   Global2Detector(Double_t global[3], Int_t index[3]);
-  virtual Bool_t   Rotate(Int_t d, Double_t *pos, Double_t *rot) const;
-  virtual Bool_t   RotateBack(Int_t d, Double_t *rot, Double_t *pos) const;
+  virtual Bool_t   RotateBack(Int_t det, Double_t *loc, Double_t *glb) const;
 
           void     GroupChamber(Int_t iplan, Int_t icham, Int_t *idtmed);
           void     CreateFrame(Int_t *idtmed);
@@ -60,9 +53,17 @@ class AliTRDgeometry : public AliGeometry {
   
   static  Int_t    GetDetectorSec(Int_t p, Int_t c);
   static  Int_t    GetDetector(Int_t p, Int_t c, Int_t s);
-  virtual Int_t    GetPlane(Int_t d)   const;
+  virtual Int_t    GetPlane(Int_t d) const;
   virtual Int_t    GetChamber(Int_t d) const;
-  virtual Int_t    GetSector(Int_t d)  const;
+  virtual Int_t    GetSector(Int_t d) const;
+
+  // Translation from MCM to Pad and vice versa
+  virtual Int_t    GetPadRowFromMCM(Int_t irob, Int_t imcm) const;
+  virtual Int_t    GetPadColFromADC(Int_t irob, Int_t imcm, Int_t iadc) const;
+  virtual Int_t    GetMCMfromPad(Int_t irow, Int_t icol) const;
+  virtual Int_t    GetROBfromPad(Int_t irow, Int_t icol) const;
+  virtual Int_t    GetRobSide(Int_t irob) const;
+  virtual Int_t    GetColSide(Int_t icol) const;
 
   static Float_t   GetTime0(Int_t p)                                   { return fgkTime0[p];     }
 
@@ -82,11 +83,6 @@ class AliTRDgeometry : public AliGeometry {
   static  Int_t    Ncham()                                             { return fgkNcham;        }
   static  Int_t    Ndet()                                              { return fgkNdet;         }
 
-  static  Float_t  Rmin()                                              { return fgkRmin;         }
-  static  Float_t  Rmax()                                              { return fgkRmax;         }
-  static  Float_t  Zmax1()                                             { return fgkZmax1;        }
-  static  Float_t  Zmax2()                                             { return fgkZmax2;        }
-
   static  Float_t  Cheight()                                           { return fgkCH;           }
   static  Float_t  Cspace()                                            { return fgkVspace;       }
   static  Float_t  CraHght()                                           { return fgkCraH;         }
@@ -105,6 +101,17 @@ class AliTRDgeometry : public AliGeometry {
                                                                                 / fgkSheight 
                                                                                 * (fgkCH + fgkVspace);      }
 
+  static  Int_t    MCMmax()                                            { return fgkMCMmax;       }
+  static  Int_t    MCMrow()                                            { return fgkMCMrow;       }
+  static  Int_t    ROBmaxC0()                                          { return fgkROBmaxC0;     }
+  static  Int_t    ROBmaxC1()                                          { return fgkROBmaxC1;     }
+  static  Int_t    ADCmax()                                            { return fgkADCmax;       }
+  static  Int_t    TBmax()                                             { return fgkTBmax;        }            
+  static  Int_t    Padmax()                                            { return fgkPadmax;       }
+  static  Int_t    Colmax()                                            { return fgkColmax;       }
+  static  Int_t    RowmaxC0()                                          { return fgkRowmaxC0;     }
+  static  Int_t    RowmaxC1()                                          { return fgkRowmaxC1;     }
+
   TGeoHMatrix     *GetGeoMatrix(Int_t det)                             { return (TGeoHMatrix *) 
                                                                            fMatrixGeo->At(det);             }
   TGeoHMatrix     *GetMatrix(Int_t det)                                { return (TGeoHMatrix *) 
@@ -113,24 +120,16 @@ class AliTRDgeometry : public AliGeometry {
                                                                            fMatrixCorrectionArray->At(det); }
 
  protected:
+
   static const Int_t    fgkNsect;                            //  Number of sectors in the full detector (18)
   static const Int_t    fgkNplan;                            //  Number of planes of the TRD (6)
   static const Int_t    fgkNcham;                            //  Number of chambers in z-direction (5)
   static const Int_t    fgkNdet;                             //  Total number of detectors (18 * 6 * 5 = 540)
 
-  static const Float_t  fgkRmin;                             //  Minimal radius of the TRD
-  static const Float_t  fgkRmax;                             //  Maximal radius of the TRD
-
-  static const Float_t  fgkZmax1;                            //  Half-length of the TRD at outer radius
-  static const Float_t  fgkZmax2;                            //  Half-length of the TRD at inner radius
-
-  static const Float_t  fgkSheight;                          //  Height of the TRD-volume in spaceframe (BTR1-3)
-  static const Float_t  fgkSwidth1;                          //  Lower width of the TRD-volume in spaceframe (BTR1-3)
-  static const Float_t  fgkSwidth2;                          //  Upper width of the TRD-volume in spaceframe (BTR1-3)
-  static const Float_t  fgkSlenTR1;                          //  Length of the TRD-volume in spaceframe (BTR1)
-  static const Float_t  fgkSlenTR2;                          //  Length of the TRD-volume in spaceframe (BTR2)
-  static const Float_t  fgkSlenTR3;                          //  Length of the TRD-volume in spaceframe (BTR3)
+  static const Float_t  fgkSheight;                          //  Height of the TRD-volume in spaceframe (BTRD)
+  static const Float_t  fgkSwidth1;                          //  Lower width of the TRD-volume in spaceframe (BTRD)
+  static const Float_t  fgkSwidth2;                          //  Upper width of the TRD-volume in spaceframe (BTRD)
+  static const Float_t  fgkSlength;                          //  Length of the TRD-volume in spaceframe (BTRD)
 
   static const Float_t  fgkSMpltT;                           //  Thickness of the super module side plates
 
@@ -144,51 +143,58 @@ class AliTRDgeometry : public AliGeometry {
   static const Float_t  fgkHspace;                           //  Horizontal spacing of the chambers
   static const Float_t  fgkVrocsm;                           //  Radial distance of the first ROC to the outer SM plates
   static const Float_t  fgkCalT;                             //  Thickness of the lower aluminum frame
-  static const Float_t  fgkCclsT;                            //  Thickness of the lower G10 frame sides
-  static const Float_t  fgkCclfT;                            //  Thickness of the lower G10 frame front
-  static const Float_t  fgkCcuT;                             //  Thickness of the upper G10 frame
-  static const Float_t  fgkCauT;                             //  Thickness of the upper aluminum frame
+  static const Float_t  fgkCalW;                             //  Width of additional aluminum on lower frame
+  static const Float_t  fgkCclsT;                            //  Thickness of the lower Wacosit frame sides
+  static const Float_t  fgkCclfT;                            //  Thickness of the lower Wacosit frame front
+  static const Float_t  fgkCglT;                             //  Thichness of the glue around the radiator
+  static const Float_t  fgkCcuT;                             //  Thickness of the upper Wacosit frame
+  static const Float_t  fgkCauT;                             //  Thickness of the aluminum frame of the back panel
 
   static const Float_t  fgkCroW;                             //  Additional width of the readout chamber frames
 
   static const Float_t  fgkCpadW;                            //  Difference of outer chamber width and pad plane width
   static const Float_t  fgkRpadW;                            //  Difference of outer chamber width and pad plane width
 
-  static const Float_t  fgkRaThick;                          //  Thickness of the radiator
   static const Float_t  fgkMyThick;                          //  Thickness of the mylar-layer
+  static const Float_t  fgkRaThick;                          //  Thickness of the radiator
   static const Float_t  fgkXeThick;                          //  Thickness of the gas volume
   static const Float_t  fgkDrThick;                          //  Thickness of the drift region
   static const Float_t  fgkAmThick;                          //  Thickness of the amplification region
+  static const Float_t  fgkWrThick;                          //  Thickness of the wire planes
   static const Float_t  fgkCuThick;                          //  Thickness of the pad plane
-  static const Float_t  fgkSuThick;                          //  Thickness of the HEXCEL+G10 support structure
-  static const Float_t  fgkFeThick;                          //  Thickness of the FEE + signal lines
-  static const Float_t  fgkCoThick;                          //  Thickness of the PE of the cooling device
-  static const Float_t  fgkWaThick;                          //  Thickness of the cooling water
+  static const Float_t  fgkGlThick;                          //  Thickness of the glue layer
+  static const Float_t  fgkSuThick;                          //  Thickness of the NOMEX support structure
   static const Float_t  fgkRpThick;                          //  Thickness of the PCB readout boards
   static const Float_t  fgkRcThick;                          //  Thickness of the PCB copper layers
+  static const Float_t  fgkRoThick;                          //  Thickness of all other ROB componentes (caps, etc.)
 
   static const Float_t  fgkRaZpos;                           //  Position of the radiator
-  static const Float_t  fgkMyZpos;                           //  Position of the mylar-layer
   static const Float_t  fgkDrZpos;                           //  Position of the drift region
   static const Float_t  fgkAmZpos;                           //  Position of the amplification region
+  static const Float_t  fgkWrZpos;                           //  Position of the wire planes
   static const Float_t  fgkCuZpos;                           //  Position of the pad plane
+  static const Float_t  fgkGlZpos;                           //  Position of the glue layer
   static const Float_t  fgkSuZpos;                           //  Position of the HEXCEL+G10 support structure
-  static const Float_t  fgkFeZpos;                           //  Position of the FEE + signal lines
-  static const Float_t  fgkCoZpos;                           //  Position of the PE of the cooling device
-  static const Float_t  fgkWaZpos;                           //  Position of the cooling water
   static const Float_t  fgkRpZpos;                           //  Position of the PCB readout boards
   static const Float_t  fgkRcZpos;                           //  Position of the PCB copper layers
+  static const Float_t  fgkRoZpos;                           //  Position of all other ROB componentes (caps, etc.)
+
+  static const Int_t    fgkMCMmax;                           //  Maximum number of MCMs per ROB
+  static const Int_t    fgkMCMrow;                           //  Maximum number of MCMs per ROB Row
+  static const Int_t    fgkROBmaxC0;                         //  Maximum number of ROBs per C0 chamber
+  static const Int_t    fgkROBmaxC1;                         //  Maximum number of ROBs per C1 chamber
+  static const Int_t    fgkADCmax;                           //  Maximum number of ADC channels per MCM
+  static const Int_t    fgkTBmax;                            //  Maximum number of Time bins
+  static const Int_t    fgkPadmax;                           //  Maximum number of pads per MCM
+  static const Int_t    fgkColmax;                           //  Maximum number of pads per padplane row
+  static const Int_t    fgkRowmaxC0;                         //  Maximum number of Rows per C0 chamber
+  static const Int_t    fgkRowmaxC1;                         //  Maximum number of Rows per C1 chamber
 
   Char_t                fSMstatus[kNsect];                   //  Super module status byte
 
   Float_t               fCwidth[kNplan];                     //  Outer widths of the chambers
   Float_t               fClength[kNplan][kNcham];            //  Outer lengths of the chambers
 
-  Float_t               fRotA11[kNsect];                     //  Matrix elements for the rotation
-  Float_t               fRotA12[kNsect];                     //  Matrix elements for the rotation
-  Float_t               fRotA21[kNsect];                     //  Matrix elements for the rotation
-  Float_t               fRotA22[kNsect];                     //  Matrix elements for the rotation
-
   Float_t               fRotB11[kNsect];                     //  Matrix elements for the backward rotation
   Float_t               fRotB12[kNsect];                     //  Matrix elements for the backward rotation
   Float_t               fRotB21[kNsect];                     //  Matrix elements for the backward rotation
@@ -207,11 +213,11 @@ class AliTRDgeometry : public AliGeometry {
   Float_t               fChamberUFboxd[3*kNdets][3];         //  [3] = x, y, z
   Float_t               fChamberUUboxd[3*kNdets][3];         // 
 
-  TObjArray *           fMatrixArray;                        //! Transformation Global to Local
-  TObjArray *           fMatrixCorrectionArray;              //! Transformation Cluster to  Tracking systerm
-  TObjArray *           fMatrixGeo;                          //! Geo matrices
+  TObjArray            *fMatrixArray;                        //! Transformation Global to Local
+  TObjArray            *fMatrixCorrectionArray;              //! Transformation Cluster to  Tracking systerm
+  TObjArray            *fMatrixGeo;                          //! Geo matrices
 
-  ClassDef(AliTRDgeometry,10)                                //  TRD geometry class
+  ClassDef(AliTRDgeometry,13)                                //  TRD geometry class
 
 };