ca7920c97e50f4768193132421142f21b037b923
[u/mrichter/AliRoot.git] / TRD / AliTRDgeometry.h
1 #ifndef ALITRDGEOMETRY_H
2 #define ALITRDGEOMETRY_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 geometry class                                                       //
11 //                                                                           //
12 ///////////////////////////////////////////////////////////////////////////////
13
14 #include "AliGeometry.h"
15 #include "TObjArray.h"
16 class AliRunLoader;
17 class TGeoHMatrix;
18
19 class AliTRDgeometry : public AliGeometry {
20
21  public:
22
23   enum { kNplan = 6, kNcham = 5, kNsect = 18, kNdet = 540, kNdets = 30 };
24
25   AliTRDgeometry();
26   virtual ~AliTRDgeometry();
27
28   virtual void     CreateGeometry(Int_t *idtmed);
29   virtual Int_t    IsVersion() { return 1; };
30   virtual void     Init();
31   virtual Bool_t   Impact(const TParticle* ) const { return kTRUE; };
32
33   virtual Bool_t   Local2Global(Int_t d, Double_t *local, Double_t *global) const;
34   virtual Bool_t   Local2Global(Int_t p, Int_t c, Int_t s
35                                 , Double_t *local, Double_t *global) const;
36   virtual Bool_t   Global2Local(Int_t mode, Double_t *local, Double_t *global
37                                , Int_t* index) const;
38   virtual Bool_t   Global2Detector(Double_t global[3], Int_t index[3]);
39   virtual Bool_t   Rotate(Int_t d, Double_t *pos, Double_t *rot) const;
40   virtual Bool_t   RotateBack(Int_t d, Double_t *rot, Double_t *pos) const;
41
42           void     GroupChamber(Int_t iplan, Int_t icham, Int_t *idtmed);
43           void     CreateFrame(Int_t *idtmed);
44           void     CreateServices(Int_t *idtmed);
45
46           Bool_t   ReadGeoMatrices();  
47   TGeoHMatrix *    GetGeoMatrix(Int_t det)       { return (TGeoHMatrix *) fMatrixGeo->At(det);             }
48   TGeoHMatrix *    GetMatrix(Int_t det)          { return (TGeoHMatrix *) fMatrixArray->At(det);           }
49   TGeoHMatrix *    GetCorrectionMatrix(Int_t det){ return (TGeoHMatrix *) fMatrixCorrectionArray->At(det); }
50
51   static  Int_t    Nsect()   { return fgkNsect; };
52   static  Int_t    Nplan()   { return fgkNplan; };
53   static  Int_t    Ncham()   { return fgkNcham; };
54   static  Int_t    Ndet()    { return fgkNdet;  };
55
56   static  Float_t  Rmin()    { return fgkRmin;  };
57   static  Float_t  Rmax()    { return fgkRmax;  };
58   static  Float_t  Zmax1()   { return fgkZmax1; };
59   static  Float_t  Zmax2()   { return fgkZmax2; };
60
61   static  Float_t  Cwidcha() { return (fgkSwidth2 - fgkSwidth1) 
62                              / fgkSheight * (fgkCH + fgkVspace); };
63   static  Float_t  Cheight() { return fgkCH;      };
64   static  Float_t  Cspace()  { return fgkVspace;  };
65   static  Float_t  CraHght() { return fgkCraH;    };
66   static  Float_t  CdrHght() { return fgkCdrH;    };
67   static  Float_t  CamHght() { return fgkCamH;    };
68   static  Float_t  CroHght() { return fgkCroH;    };
69   static  Float_t  CroWid()  { return fgkCroW;    };
70   static  Float_t  MyThick() { return fgkMyThick; };
71   static  Float_t  DrThick() { return fgkDrThick; };
72   static  Float_t  AmThick() { return fgkAmThick; };
73   static  Float_t  DrZpos()  { return fgkDrZpos;  };
74   static  Float_t  RpadW()   { return fgkRpadW;   };
75   static  Float_t  CpadW()   { return fgkCpadW;   };
76
77   //void     SetSMstatus(Int_t sm, Char_t status)     { sm += 5; if (sm > 17) sm -= 18;
78   //                                                          fSMstatus[sm] = status; };
79           void     SetSMstatus(Int_t sm, Char_t status)     { fSMstatus[sm] = status; };
80
81   virtual Bool_t   IsHole(Int_t /*iplan*/, Int_t /*icham*/, Int_t /*isect*/) const { return kFALSE; };
82   static  Int_t    GetDetectorSec(Int_t p, Int_t c);
83   static  Int_t    GetDetector(Int_t p, Int_t c, Int_t s);
84   virtual Int_t    GetPlane(Int_t d)   const;
85   virtual Int_t    GetChamber(Int_t d) const;
86   virtual Int_t    GetSector(Int_t d)  const;
87
88   //Char_t   GetSMstatus(Int_t sm) const              { sm += 5; if (sm > 17) sm -= 18;
89   //                                                          return fSMstatus[sm];  };
90           Char_t   GetSMstatus(Int_t sm) const              { return fSMstatus[sm];  };
91           Float_t  GetChamberWidth(Int_t p) const           { return fCwidth[p];     };
92           Float_t  GetChamberLength(Int_t p, Int_t c) const { return fClength[p][c]; }; 
93
94   virtual void     GetGlobal(const AliRecPoint* , TVector3& , TMatrixF& ) const { }; 
95   virtual void     GetGlobal(const AliRecPoint* , TVector3& ) const { };
96  
97   static  Double_t GetAlpha()  { return 2 * 3.14159265358979323846 / fgkNsect; }; 
98
99   static  AliTRDgeometry* GetGeometry(AliRunLoader* runLoader = NULL);
100   
101   static Float_t   GetTime0(Int_t p)                        { return fgkTime0[p];    };
102
103  protected:
104  
105   static const Int_t   fgkNsect;                            // Number of sectors in the full detector (18)
106   static const Int_t   fgkNplan;                            // Number of planes of the TRD (6)
107   static const Int_t   fgkNcham;                            // Number of chambers in z-direction (5)
108   static const Int_t   fgkNdet;                             // Total number of detectors (18 * 6 * 5 = 540)
109
110   static const Float_t fgkRmin;                             // Minimal radius of the TRD
111   static const Float_t fgkRmax;                             // Maximal radius of the TRD
112
113   static const Float_t fgkZmax1;                            // Half-length of the TRD at outer radius
114   static const Float_t fgkZmax2;                            // Half-length of the TRD at inner radius
115
116   static const Float_t fgkSheight;                          // Height of the TRD-volume in spaceframe (BTR1-3)
117   static const Float_t fgkSwidth1;                          // Lower width of the TRD-volume in spaceframe (BTR1-3)
118   static const Float_t fgkSwidth2;                          // Upper width of the TRD-volume in spaceframe (BTR1-3)
119   static const Float_t fgkSlenTR1;                          // Length of the TRD-volume in spaceframe (BTR1)
120   static const Float_t fgkSlenTR2;                          // Length of the TRD-volume in spaceframe (BTR2)
121   static const Float_t fgkSlenTR3;                          // Length of the TRD-volume in spaceframe (BTR3)
122
123   static const Float_t fgkSMpltT;                           // Thickness of the super module side plates
124   //static const Float_t fgkSMgapT;                           // Thickness of the gap between side plates and space frame
125
126   static const Float_t fgkCraH;                             // Height of the radiator part of the chambers
127   static const Float_t fgkCdrH;                             // Height of the drift region of the chambers
128   static const Float_t fgkCamH;                             // Height of the amplification region of the chambers
129   static const Float_t fgkCroH;                             // Height of the readout of the chambers
130   static const Float_t fgkCH;                               // Total height of the chambers
131
132   static const Float_t fgkVspace;                           // Vertical spacing of the chambers
133   static const Float_t fgkHspace;                           // Horizontal spacing of the chambers
134   static const Float_t fgkVrocsm;                           // Radial distance of the first ROC to the outer plates of the SM
135   static const Float_t fgkCalT;                             // Thickness of the lower aluminum frame
136   static const Float_t fgkCclsT;                            // Thickness of the lower G10 frame sides
137   static const Float_t fgkCclfT;                            // Thickness of the lower G10 frame front
138   static const Float_t fgkCcuT;                             // Thickness of the upper G10 frame
139   static const Float_t fgkCauT;                             // Thickness of the upper aluminum frame
140
141   static const Float_t fgkCroW;                             // Additional width of the readout chamber frames
142
143   static const Float_t fgkCpadW;                            // Difference of outer chamber width and pad plane width
144   static const Float_t fgkRpadW;                            // Difference of outer chamber width and pad plane width
145
146   static const Float_t fgkRaThick;                          // Thickness of the radiator
147   static const Float_t fgkMyThick;                          // Thickness of the mylar-layer
148   static const Float_t fgkXeThick;                          // Thickness of the gas volume
149   static const Float_t fgkDrThick;                          // Thickness of the drift region
150   static const Float_t fgkAmThick;                          // Thickness of the amplification region
151   static const Float_t fgkCuThick;                          // Thickness of the pad plane
152   static const Float_t fgkSuThick;                          // Thickness of the HEXCEL+G10 support structure
153   static const Float_t fgkFeThick;                          // Thickness of the FEE + signal lines
154   static const Float_t fgkCoThick;                          // Thickness of the PE of the cooling device
155   static const Float_t fgkWaThick;                          // Thickness of the cooling water
156   static const Float_t fgkRpThick;                          // Thickness of the PCB readout boards
157   static const Float_t fgkRcThick;                          // Thickness of the PCB copper layers
158
159   static const Float_t fgkRaZpos;                           // Position of the radiator
160   static const Float_t fgkMyZpos;                           // Position of the mylar-layer
161   static const Float_t fgkDrZpos;                           // Position of the drift region
162   static const Float_t fgkAmZpos;                           // Position of the amplification region
163   static const Float_t fgkCuZpos;                           // Position of the pad plane
164   static const Float_t fgkSuZpos;                           // Position of the HEXCEL+G10 support structure
165   static const Float_t fgkFeZpos;                           // Position of the FEE + signal lines
166   static const Float_t fgkCoZpos;                           // Position of the PE of the cooling device
167   static const Float_t fgkWaZpos;                           // Position of the cooling water
168   static const Float_t fgkRpZpos;                           // Position of the PCB readout boards
169   static const Float_t fgkRcZpos;                           // Position of the PCB copper layers
170
171   Char_t               fSMstatus[kNsect];                   // Super module status byte
172
173   Float_t              fCwidth[kNplan];                     // Outer widths of the chambers
174   Float_t              fClength[kNplan][kNcham];            // Outer lengths of the chambers
175
176   Float_t              fRotA11[kNsect];                     // Matrix elements for the rotation
177   Float_t              fRotA12[kNsect];                     // Matrix elements for the rotation
178   Float_t              fRotA21[kNsect];                     // Matrix elements for the rotation
179   Float_t              fRotA22[kNsect];                     // Matrix elements for the rotation
180
181   Float_t              fRotB11[kNsect];                     // Matrix elements for the backward rotation
182   Float_t              fRotB12[kNsect];                     // Matrix elements for the backward rotation
183   Float_t              fRotB21[kNsect];                     // Matrix elements for the backward rotation
184   Float_t              fRotB22[kNsect];                     // Matrix elements for the backward rotation
185
186   static const Double_t fgkTime0Base;                       // Base value for calculation of Time-position of pad 0
187   static const Float_t  fgkTime0[kNplan];                   // Time-position of pad 0
188   
189   Float_t              fChamberUAorig[3*kNdets][3];         // Volumes origin in
190   Float_t              fChamberUDorig[3*kNdets][3];         // the chamber
191   Float_t              fChamberUForig[3*kNdets][3];         // [3] = x, y, z
192   Float_t              fChamberUUorig[3*kNdets][3];         //
193
194   Float_t              fChamberUAboxd[3*kNdets][3];         // Volumes box
195   Float_t              fChamberUDboxd[3*kNdets][3];         // dimensions (half)
196   Float_t              fChamberUFboxd[3*kNdets][3];         // [3] = x, y, z
197   Float_t              fChamberUUboxd[3*kNdets][3];         // 
198
199   TObjArray *          fMatrixArray;                        //! array of matrix - Transformation Global to Local
200   TObjArray *          fMatrixCorrectionArray;              //! array of Matrix - Transformation Cluster to  Tracking systerm
201   TObjArray *          fMatrixGeo;                          //! geo matrices
202
203   ClassDef(AliTRDgeometry,10)                               // TRD geometry class
204
205 };
206
207 #endif