Fixed bug with HP and no unget in iostream.h. Now using putback instead.
[u/mrichter/AliRoot.git] / ITS / AliITSgeom.h
1 #ifndef ALIITSGEOM_H
2 #define ALIITSGEOM_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 //  ITS geometry manipulation routines.
10 //  Created April 15 1999.
11 //  version: 0.0.0
12 //  By: Bjorn S. Nilsen
13 //
14 //     A package of geometry routines to do transformations between
15 // local, detector active area, and ALICE global coordinate system in such
16 // a way as to allow for detector alignment studies and the like. All of
17 // the information needed to do the coordinate transformation are kept in
18 // a specialized structure for ease of implementation.
19 /////////////////////////////////////////////////////////////////////////
20 #include <iostream.h>
21 #include <TObjArray.h>
22 #include <TVector.h>
23
24 #include "AliITSgeomMatrix.h"
25
26 class ifstream;
27 class ofstream;
28
29
30 typedef enum {kSPD=0, kSDD=1, kSSD=2, kSSDp=3,kSDDp=4} AliITSDetector;
31
32 //_______________________________________________________________________
33
34 class AliITSgeom : public TObject {
35
36  public:
37     AliITSgeom();                      // Default constructor
38     AliITSgeom(const char *filename);  // Constructor
39     AliITSgeom(Int_t itype,Int_t nlayers,Int_t *nlads,Int_t *ndets,
40                Int_t nmods); // Constructor
41     //     this function allocates a AliITSgeomMatrix for a particular
42     // module.
43     void CreatMatrix(Int_t mod,Int_t lay,Int_t lad,Int_t det,
44                      AliITSDetector idet,Double_t tran[3],Double_t rot[10]);
45     void ReadNewFile(const char *filename);  // Constructor for new format.
46     void WriteNewFile(const char *filename); // Output for new format.
47     AliITSgeom(AliITSgeom &source);    // Copy constructor
48     void operator=(AliITSgeom &source);// = operator
49     virtual ~AliITSgeom();             // Default destructor
50 // Getters
51     Int_t GetTransformationType() const {return fTrans;}
52 //
53     // returns kTRUE if the tranformation defined by this class is
54     // for Global Geant coordiante system to the local Geant coordinate system
55     // of the detector. These are the transformation used by GEANT.
56     Bool_t IsGeantToGeant()     const {return (fTrans == 0);}
57     // returns kTRUE if the tranformation defined by this class is
58     // for Global Geant coordiante system to the local "Tracking" coordinate
59     // system of the detector. These are the transformation used by the
60     // Tracking code.
61     Bool_t IsGeantToTracking()  const {return ((fTrans&&0xfffe)!= 0);}
62     // returns kTRUE if the tranformation defined by this class is
63     // for Global Geant coordiante system to the local Geant coordinate system
64     // of the detector but may have been displaced by some typicaly small
65     // abount. These are modified transformation simular to that used by GEANT.
66     Bool_t IsGeantToDisplaced() const {return ((fTrans&&0xfffd)!= 0);}
67     // returns kTRUE if the shape defined by ishape has been defined in this
68     // set of transformations. Typical values of ishape are kSPD, kSDD, kSSD,
69     // SSD2.
70     Bool_t IsShapeDefined(Int_t ishape){
71         if(fShape!=0){return ((fShape->At(ishape))!=0);}else return kFALSE;}
72 //
73     //     This function returns a pointer to the particular AliITSgeomMatrix
74     // class for a specific module index.
75     AliITSgeomMatrix *GetGeomMatrix(Int_t index){
76         return (AliITSgeomMatrix*)(fGm->At(index));}
77     //     This function returns the number of detectors/ladder for a give 
78     // layer. In particular it returns fNdet[layer-1].
79     Int_t GetNdetectors(const Int_t lay) const {return fNdet[lay-1];}
80     //     This function returns the number of ladders for a give layer. In
81     // particular it returns fNlad[layer-1].
82     Int_t GetNladders(const Int_t lay)   const {return fNlad[lay-1];}
83     //     This function returns the number of layers defined in the ITS
84     // geometry. In particular it returns fNlayers.
85     Int_t GetNlayers()                   const {return fNlayers;}
86     Int_t GetModuleIndex(const Int_t lay,const Int_t lad,const Int_t det);
87     //     This function returns the module index number given the layer,
88     // ladder and detector numbers put into the array id[3].
89     Int_t GetModuleIndex(const Int_t *id){
90         return GetModuleIndex(id[0],id[1],id[2]);}
91     void  GetModuleId(const Int_t index,Int_t &lay,Int_t &lad,Int_t &det);
92 //
93     Int_t GetStartDet(const Int_t dtype );
94     Int_t GetLastDet(const Int_t dtype);
95     //     Returns the starting module index number for SPD detector,
96     // assuming the modules are placed in the "standard" cylindrical
97     // ITS structure.
98     Int_t GetStartSPD() {return GetModuleIndex(1,1,1);}
99     //     Returns the ending module index number for SPD detector,
100     // assuming the modules are placed in the "standard" cylindrical
101     // ITS structure.
102     Int_t GetLastSPD()  {return GetModuleIndex(2,fNlad[1],fNdet[1]);}
103     //     Returns the starting module index number for SDD detector,
104     // assuming the modules are placed in the "standard" cylindrical
105     // ITS structure.
106     Int_t GetStartSDD() {return GetModuleIndex(3,1,1);}
107     //     Returns the ending module index number for SDD detector,
108     // assuming the modules are placed in the "standard" cylindrical
109     // ITS structure.
110     Int_t GetLastSDD()  {return GetModuleIndex(4,fNlad[3],fNdet[3]);}
111     //     Returns the starting module index number for SSD detector,
112     // assuming the modules are placed in the "standard" cylindrical
113     // ITS structure.
114     Int_t GetStartSSD() {return GetModuleIndex(5,1,1);}
115     //     Returns the ending module index number for SSD detector,
116     // assuming the modules are placed in the "standard" cylindrical
117     // ITS structure.
118     Int_t GetLastSSD()  {return GetModuleIndex(6,fNlad[5],fNdet[5]);}
119     //     Returns the last module index number.
120     Int_t GetIndexMax() {return fNmodules;}
121 //
122     //     This function returns the rotation angles for a give module 
123     // in the Double point array ang[3]. The angles are in radians
124     void  GetAngles(const Int_t index,Double_t *ang) {
125                     GetGeomMatrix(index)->GetAngles(ang);}
126     //     This function returns the rotation angles for a give module
127     // in the three floating point variables provided. rx = frx,
128     // fy = fry, rz = frz. The angles are in radians
129     void  GetAngles(const Int_t index,Float_t &rx,Float_t &ry,Float_t &rz) {
130                     Double_t a[3];GetAngles(index,a);
131                     rx = a[0];ry = a[1];rz = a[2];}
132     //     This function returns the rotation angles for a give detector on
133     // a give ladder in a give layer in the three floating point variables
134     // provided. rx = frx, fy = fry, rz = frz. The angles are in radians
135     void  GetAngles(const Int_t lay,const Int_t lad,const Int_t det,
136                     Float_t &rx,Float_t &ry,Float_t &rz) {
137                     GetAngles(GetModuleIndex(lay,lad,det),rx,ry,rz);}
138 //
139     //     This function returns the 6 GEANT rotation angles for a give 
140     // module in the double point array ang[3]. The angles are in degrees
141     void  GetGeantAngles(const Int_t index,Double_t *ang){
142         GetGeomMatrix(index)->SixAnglesFromMatrix(ang);}
143 //
144     //     This function returns the Cartesian translation for a give
145     // module in the Double array t[3]. The units are
146     // those of the Monte Carlo, generally cm.
147     void  GetTrans(const Int_t index,Double_t *t) {
148                    GetGeomMatrix(index)->GetTranslation(t);}
149     //     This function returns the Cartesian translation for a give
150     // module index in the three floating point variables provided.
151     // x = fx0, y = fy0, z = fz0. The units are those of the Mont
152     // Carlo, generally cm.
153     void  GetTrans(const Int_t index,Float_t &x,Float_t &y,Float_t &z) {
154                    Double_t t[3];GetTrans(index,t);
155                    x = t[0];y = t[1];z = t[2];}
156     //     This function returns the Cartesian translation for a give
157     // detector on a give ladder in a give layer in the three floating
158     // point variables provided. x = fx0, y = fy0, z = fz0. The units are
159     // those of the Monte Carlo, generally cm.
160     void  GetTrans(const Int_t lay,const Int_t lad,const Int_t det,
161                    Float_t &x,Float_t &y,Float_t &z) {
162                    GetTrans(GetModuleIndex(lay,lad,det),x,y,z);}
163 //
164     //      This function returns the Cartesian translation [cm] and the
165     // 6 GEANT rotation angles [degrees]for a given layer ladder and
166     // detector number, in the TVector x (at least 9 elements large).
167     void  GetCenterThetaPhi(const Int_t lay,const Int_t lad,const Int_t det,
168                             TVector &x){Double_t t[3],ang[6];
169                             Int_t index=GetModuleIndex(lay,lad,det);
170                             GetTrans(index,t);GetGeantAngles(index,ang);
171                             x(0) =   t[0];x(1) =   t[1];x(2) =   t[2];
172                             x(3) = ang[0];x(4) = ang[1];x(5) = ang[2];
173                             x(6) = ang[3];x(7) = ang[4];x(8) = ang[5];}
174 //
175     //     This function returns the rotation matrix in Double
176     // precision for a given module.
177     void  GetRotMatrix(const Int_t index,Double_t mat[3][3]){
178           GetGeomMatrix(index)->GetMatrix(mat);}
179     //     This function returns the rotation matrix in a Double
180     // precision pointer for a given module. mat[i][j] => mat[3*i+j].
181     void  GetRotMatrix(const Int_t index,Double_t *mat){
182           Double_t rot[3][3];GetRotMatrix(index,rot);
183           for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++) mat[3*i+j] = rot[i][j];}
184     //     This function returns the rotation matrix in a floating 
185     // precision pointer for a given layer ladder and detector module.
186     // mat[i][j] => mat[3*i+j].
187     void  GetRotMatrix(const Int_t lay,const Int_t lad,const Int_t det,
188                  Float_t *mat){GetRotMatrix(GetModuleIndex(lay,lad,det),mat);}
189     //     This function returns the rotation matrix in a Double
190     // precision pointer for a given layer ladder and detector module.
191     // mat[i][j] => mat[3*i+j].
192     void  GetRotMatrix(const Int_t lay,const Int_t lad,const Int_t det,
193                 Double_t *mat){GetRotMatrix(GetModuleIndex(lay,lad,det),mat);}
194     //     This function returns the rotation matrix in a floating
195     // precision pointer for a given module. mat[i][j] => mat[3*i+j].
196     void  GetRotMatrix(const Int_t index,Float_t *mat){
197           Double_t rot[3][3];
198           GetGeomMatrix(index)->GetMatrix(rot);
199           for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++) mat[3*i+j] = rot[i][j];}
200 //
201     //     Will define fShape if it isn't already defined.
202     void DefineShapes(const Int_t size=4)
203         {if(fShape==0) fShape = new TObjArray(size);else fShape->Expand(size);}
204     //     this function returns a pointer to the class decribing a particluar
205     // detectory type based on AliITSDetector value. This will return a pointer
206     // to one of the classes AliITSgeomSPD, AliITSgeomSDD, or AliITSgeomSSD,
207     // for example.
208     virtual TObject *GetShape(const AliITSDetector idet)
209         {return fShape->At((Int_t)idet);};
210     //     This function returns a pointer to the class describing the
211     // detector for a particular module index. This will return a pointer
212     // to one of the classes AliITSgeomSPD, AliITSgeomSDD, or AliITSgeomSSD,
213     // for example.
214     virtual TObject *GetShape(const Int_t index){
215         return fShape->At(GetGeomMatrix(index)->
216                           GetDetectorIndex());}
217     //     This function returns a pointer to the class describing the
218     // detector for a particular layer ladder and detector numbers. This
219     // will return a pointer to one of the classes AliITSgeomSPD,
220     // AliITSgeomSDD, or AliITSgeomSSD, for example.
221     virtual TObject *GetShape(const Int_t lay,const Int_t lad,const Int_t det)
222                              {return GetShape(GetModuleIndex(lay,lad,det));}
223 //
224 //  Setters
225     //     Sets the rotation angles and matrix for a give module index
226     // via the double precision array a[3] [radians].
227     void SetByAngles(const Int_t index,const Double_t a[]){
228         GetGeomMatrix(index)->SetAngles(a);}
229     //     Sets the rotation angles and matrix for a give module index
230     // via the 3 floating precision variables rx, ry, and rz [radians].
231     void SetByAngles(const Int_t index,
232                      const Float_t rx,const Float_t ry,const Float_t rz) {
233                      Double_t a[3];a[0] = rx;a[1] = ry;a[2] = rz;
234                      GetGeomMatrix(index)->SetAngles(a);}
235     //     Sets the rotation angles and matrix for a give layer, ladder,
236     // and detector numbers via the 3 floating precision variables rx,
237     // ry, and rz [radians].
238     void SetByAngles(const Int_t lay,const Int_t lad,const Int_t det,
239                      const Float_t rx,const Float_t ry,const Float_t rz) {
240                      SetByAngles(GetModuleIndex(lay,lad,det),rx,ry,rz);}
241 //
242     //     Sets the rotation angles and matrix for a give module index
243     // via the Double precision array a[6] [degree]. The angles are those
244     // defined by GEANT 3.12.
245     void SetByGeantAngles(const Int_t index,const Double_t *ang){
246         GetGeomMatrix(index)->MatrixFromSixAngles(ang);}
247     //     Sets the rotation angles and matrix for a give layer, ladder
248     // and detector, in the array id[3] via the Double precision array
249     // a[6] [degree]. The angles are those defined by GEANT 3.12.
250     void SetByGeantAngles(const Int_t *id,const Double_t *ang){
251         SetByGeantAngles(GetModuleIndex(id),ang);}
252     //     Sets the rotation angles and matrix for a give layer, ladder
253     // and detector, via the Double precision array a[6] [degree]. The
254     // angles are those defined by GEANT 3.12.
255     void SetByGeantAngles(const Int_t lay,const Int_t lad,const Int_t det,
256                           const Double_t *ang){
257         SetByGeantAngles(GetModuleIndex(lay,lad,det),ang);}
258 //
259     //     This function sets a new translation vector, given by the
260     // array x[3], for the Cartesian coordinate transformation
261     // for a give module index.
262     void SetTrans(const Int_t index,Double_t x[]){
263         GetGeomMatrix(index)->SetTranslation(x);}
264     //     This function sets a new translation vector, given by the three
265     // variables x, y, and z, for the Cartesian coordinate transformation
266     // for the detector defined by layer, ladder and detector.
267     void SetTrans(const Int_t lay,const Int_t lad,const Int_t det,
268                   Float_t x,Float_t y,Float_t z){Double_t t[3];
269                   t[0] = x;t[1] = y;t[2] = z;
270                   SetTrans(GetModuleIndex(lay,lad,det),t);}
271 //
272     //     This function adds one more shape element to the TObjArray
273     // fShape. It is primarily used in the constructor functions of the
274     // AliITSgeom class. The pointer *shape can be the pointer to any
275     // class that is derived from TObject (this is true for nearly every
276     // ROOT class). This does not appear to be working properly at this time.
277     void AddShape(TObject *shp){fShape->AddLast(shp);}
278     //     This function deletes an existing shape element, of type TObject,
279     // and replaces it with the one specified. This is primarily used to
280     // changes the parameters to the segmentation class for a particular
281     // type of detector.
282     void ReSetShape(const Int_t dtype,TObject *shp){
283          fShape->RemoveAt(dtype);fShape->AddAt(shp,dtype);}
284 //
285 //  transformations
286     //     Transforms from the ALICE Global coordinate system
287     // to the detector local coordinate system for the detector
288     // defined by the layer, ladder, and detector numbers. The
289     // global and local coordinate are given in two floating point
290     // arrays g[3], and l[3].
291     void GtoL(const Int_t lay,const Int_t lad,const Int_t det,
292               const Float_t *g,Float_t *l){
293          GtoL(GetModuleIndex(lay,lad,det),g,l);}
294     //     Transforms from the ALICE Global coordinate system
295     // to the detector local coordinate system for the detector
296     // defined by the id[0], id[1], and id[2] numbers. The
297     // global and local coordinate are given in two floating point
298     // arrays g[3], and l[3].
299     void GtoL(const Int_t *id,const Float_t *g,Float_t *l){
300          GtoL(GetModuleIndex(id),g,l);}
301     //     Transforms from the ALICE Global coordinate system
302     // to the detector local coordinate system for the detector
303     // module index number. The global and local coordinate are
304     // given in two floating point arrays g[3], and l[3].
305     void GtoL(const Int_t index,const Float_t *g,Float_t *l){
306          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
307          GetGeomMatrix(index)->GtoLPosition(dg,dl);
308          for(i=0;i<3;i++) l[i] =dl[i];}
309     //     Transforms from the ALICE Global coordinate system
310     // to the detector local coordinate system for the detector
311     // defined by the layer, ladder, and detector numbers. The
312     // global and local coordinate are given in two Double point
313     // arrays g[3], and l[3].
314     void GtoL(const Int_t lay,const Int_t lad,const Int_t det,
315               const Double_t *g,Double_t *l){
316          GtoL(GetModuleIndex(lay,lad,det),g,l);}
317     //     Transforms from the ALICE Global coordinate system
318     // to the detector local coordinate system for the detector
319     // defined by the id[0], id[1], and id[2] numbers. The
320     // global and local coordinate are given in two Double point
321     // arrays g[3], and l[3].
322     void GtoL(const Int_t *id,const Double_t *g,Double_t *l){
323          GtoL(GetModuleIndex(id),g,l);}
324     //     Transforms from the ALICE Global coordinate system
325     // to the detector local coordinate system for the detector
326     // module index number. The global and local coordinate are
327     // given in two Double point arrays g[3], and l[3].
328     void GtoL(const Int_t index,const Double_t *g,Double_t *l){
329          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
330          GetGeomMatrix(index)->GtoLPosition(dg,dl);
331          for(i=0;i<3;i++) l[i] =dl[i];}
332 //
333     //     Transforms from the ALICE Global coordinate system
334     // to the detector local coordinate system (used for ITS tracking)
335     // for the detector module index number. The global and local
336     // coordinate are given in two Double point arrays g[3], and l[3].
337     void GtoLtracking(const Int_t index,const Double_t *g,Double_t *l){
338          if(IsGeantToTracking()) GtoL(index,g,l);
339          else GetGeomMatrix(index)->GtoLPositionTracking(g,l);}
340     //     Transforms from the ALICE Global coordinate system
341     // to the detector local coordinate system (used for ITS tracking)
342     // for the detector id[3]. The global and local
343     // coordinate are given in two Double point arrays g[3], and l[3].
344     void GtoLtracking(const Int_t *id,const Double_t *g,Double_t *l){
345          GtoLtracking(GetModuleIndex(id),g,l);}
346     //     Transforms from the ALICE Global coordinate system
347     // to the detector local coordinate system (used for ITS tracking)
348     // for the detector layer ladder and detector numbers. The global
349     // and local coordinate are given in two Double point arrays g[3],
350     // and l[3].
351     void GtoLtracking(const Int_t lay,const Int_t lad,const Int_t det,
352                       const Double_t *g,Double_t *l){
353          GtoLtracking(GetModuleIndex(lay,lad,det),g,l);}
354 //
355     //     Transforms of momentum types of quantities from the ALICE
356     // Global coordinate system to the detector local coordinate system
357     // for the detector layer ladder and detector numbers. The global
358     // and local coordinate are given in two float point arrays g[3],
359     // and l[3].
360     void GtoLMomentum(const Int_t lay,const Int_t lad,const Int_t det,
361                       const Float_t *g,Float_t *l){
362                          GtoLMomentum(GetModuleIndex(lay,lad,det),g,l);}
363     //     Transforms of momentum types of quantities from the ALICE
364     // Global coordinate system to the detector local coordinate system
365     // for the detector module index number. The global and local
366     // coordinate are given in two float point arrays g[3], and l[3].
367     void GtoLMomentum(const Int_t index,const Float_t *g,Float_t *l){
368          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
369          GetGeomMatrix(index)->GtoLMomentum(dg,dl);
370          for(i=0;i<3;i++) l[i] =dl[i];}
371     //     Transforms of momentum types of quantities from the ALICE
372     // Global coordinate system to the detector local coordinate system
373     // for the detector layer ladder and detector numbers. The global
374     // and local coordinate are given in two Double point arrays g[3],
375     // and l[3].
376     void GtoLMomentum(const Int_t lay,const Int_t lad,const Int_t det,
377                       const Double_t *g,Double_t *l){
378          GtoLMomentum(GetModuleIndex(lay,lad,det),g,l);}
379     //     Transforms of momentum types of quantities from the ALICE
380     // Global coordinate system to the detector local coordinate system
381     // for the detector module index number. The global and local
382     // coordinate are given in two Double point arrays g[3], and l[3].
383     void GtoLMomentum(const Int_t index,const Double_t *g,Double_t *l){
384          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dg[i] = g[i];
385          GetGeomMatrix(index)->GtoLMomentum(dg,dl);
386          for(i=0;i<3;i++) l[i] =dl[i];}
387 //
388     //     Transforms of momentum types of quantities from the ALICE
389     // Global coordinate system to the detector local coordinate system
390     // (used for ITS tracking) for the detector module index number.
391     // The global and local coordinate are given in two Double point
392     // arrays g[3], and l[3].
393     void GtoLMomentumTracking(const Int_t index,const Double_t *g,Double_t *l){
394          if(IsGeantToTracking()) GtoLMomentum(index,g,l);
395          else GetGeomMatrix(index)->GtoLMomentumTracking(g,l);}
396     //     Transforms of momentum types of quantities from the ALICE
397     // Global coordinate system to the detector local coordinate system
398     // (used for ITS tracking) for the detector id[3].
399     // The global and local coordinate are given in two Double point
400     // arrays g[3], and l[3].
401     void GtoLMomentumTracking(const Int_t *id,const Double_t *g,Double_t *l){
402                  GtoLMomentumTracking(GetModuleIndex(id),g,l);}
403     //     Transforms of momentum types of quantities from the ALICE
404     // Global coordinate system to the detector local coordinate system
405     // (used for ITS tracking) for the detector layer ladder and detector
406     // numbers. The global and local coordinate are given in two Double point
407     // arrays g[3], and l[3].
408     void GtoLMomentumTracking(const Int_t lay,const Int_t lad,const Int_t det,
409                               const Double_t *g,Double_t *l){
410                         GtoLMomentumTracking(GetModuleIndex(lay,lad,det),g,l);}
411 //
412     //     Transforms from the detector local coordinate system
413     // to the ALICE Global coordinate  system for the detector
414     // defined by the layer, ladder, and detector numbers. The
415     // global and local coordinate are given in two floating point
416     // arrays g[3], and l[3].
417     void LtoG(const Int_t lay,const Int_t lad,const Int_t det,
418               const Float_t *l,Float_t *g){
419                      LtoG(GetModuleIndex(lay,lad,det),l,g);}
420     //     Transforms from the detector local coordinate system
421     // to the ALICE Global coordinate system for the detector
422     // defined by the id[0], id[1], and id[2] numbers. The
423     // global and local coordinate are given in two floating point
424     // arrays g[3], and l[3].
425     void LtoG(const Int_t *id,const Float_t *l,Float_t *g){
426                      LtoG(GetModuleIndex(id),l,g);}
427     //     Transforms from the detector local coordinate system
428     // to the ALICE Global coordinate system for the detector
429     // module index number. The global and local coordinate are
430     // given in two floating point arrays g[3], and l[3].
431     void LtoG(const Int_t index,const Float_t *l,Float_t *g){
432          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
433          GetGeomMatrix(index)->LtoGPosition(dl,dg);
434          for(i=0;i<3;i++) g[i] =dg[i];}
435     //     Transforms from the detector local coordinate system
436     // to the ALICE Global coordinate system for the detector
437     // defined by the layer, ladder, and detector numbers. The
438     // global and local coordinate are given in two Double point
439     // arrays g[3], and l[3].
440     void LtoG(const Int_t lay,const Int_t lad,const Int_t det,
441               const Double_t *l,Double_t *g){
442                       LtoG(GetModuleIndex(lay,lad,det),l,g);}
443     //     Transforms from the detector local coordinate system
444     // to the ALICE Global coordinate system for the detector
445     // defined by the id[0], id[1], and id[2] numbers. The
446     // global and local coordinate are given in two Double point
447     // arrays g[3], and l[3].
448     void LtoG(const Int_t *id,const Double_t *l,Double_t *g){
449                        LtoG(GetModuleIndex(id),l,g);}
450     //     Transforms from the detector local coordinate system
451     // to the ALICE Global coordinate system for the detector
452     // module index number. The global and local coordinate are
453     // given in two Double point arrays g[3], and l[3].
454     void LtoG(const Int_t index,const Double_t *l,Double_t *g){
455          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
456          GetGeomMatrix(index)->LtoGPosition(dl,dg);
457          for(i=0;i<3;i++) g[i] =dg[i];}
458 //
459     //     Transforms from the detector local coordinate system (used
460     // for ITS tracking) to the ALICE Global coordinate system 
461     // for the detector module index number. The global and local
462     // coordinate are given in two Double point arrays g[3], and l[3].
463     void LtoGtracking(const Int_t index,const Double_t *l,Double_t *g){
464          if(IsGeantToTracking()) LtoG(index,l,g);
465          else GetGeomMatrix(index)->LtoGPositionTracking(l,g);}
466     //     Transforms from the detector local coordinate system (used
467     // for ITS tracking) to the ALICE Global coordinate system 
468     // for the detector id[3]. The global and local
469     // coordinate are given in two Double point arrays g[3], and l[3].
470     void LtoGtracking(const Int_t *id,const Double_t *l,Double_t *g){
471          LtoGtracking(GetModuleIndex(id),l,g);}
472     //     Transforms from the detector local coordinate system (used
473     // for ITS tracking) to the detector local coordinate system
474     // for the detector layer ladder and detector numbers. The global
475     // and local coordinate are given in two Double point arrays g[3],
476     // and l[3].
477     void LtoGtracking(const Int_t lay,const Int_t lad,const Int_t det,
478                       const Double_t *l,Double_t *g){
479          LtoGtracking(GetModuleIndex(lay,lad,det),l,g);}
480 //
481     //     Transforms of momentum types of quantities from the detector
482     // local coordinate system to the ALICE Global coordinate system
483     // for the detector layer ladder and detector numbers. The global
484     // and local coordinate are given in two float point arrays g[3],
485     // and l[3].
486     void LtoGMomentum(const Int_t lay,const Int_t lad,const Int_t det,
487                       const Float_t *l,Float_t *g){
488          LtoGMomentum(GetModuleIndex(lay,lad,det),l,g);}
489     //     Transforms of momentum types of quantities from the detector
490     // local coordinate system to the ALICE Global coordinate system
491     // for the detector module index number. The global and local
492     // coordinate are given in two float point arrays g[3], and l[3].
493     void LtoGMomentum(const Int_t index,const Float_t *l,Float_t *g){
494          Double_t dg[3],dl[3];Int_t i;for(i=0;i<3;i++) dl[i] = l[i];
495          GetGeomMatrix(index)->LtoGMomentum(dl,dg);
496          for(i=0;i<3;i++) g[i] =dg[i];}
497     //     Transforms of momentum types of quantities from the detector
498     // local coordinate system to the ALICE Global coordinate system
499     // for the detector layer ladder and detector numbers. The global
500     // and local coordinate are given in two Double point arrays g[3],
501     // and l[3].
502     void LtoGMomentum(const Int_t lay,const Int_t lad,const Int_t det,
503                            const Double_t *l,Double_t *g){
504                         LtoGMomentum(GetModuleIndex(lay,lad,det),l,g);}
505     //     Transforms of momentum types of quantities from the detector
506     // local coordinate system to the ALICE Global coordinate system
507     // for the detector module index number. The global and local
508     // coordinate are given in two Double point arrays g[3], and l[3].
509     void LtoGMomentum(const Int_t index,const Double_t *l,Double_t *g){
510          GetGeomMatrix(index)->LtoGMomentum(l,g);}
511 //
512     //     Transforms of momentum types of quantities from the detector 
513     // local coordinate system (used for ITS tracking) to the detector
514     // system ALICE Global for the detector module index number.
515     // The global and local coordinate are given in two Double point
516     // arrays g[3], and l[3].
517     void LtoGMomentumTracking(const Int_t index,const Double_t *l,Double_t *g){
518          if(IsGeantToTracking()) LtoGMomentum(index,l,g);
519          else GetGeomMatrix(index)->LtoGMomentumTracking(l,g);}
520     //     Transforms of momentum types of quantities from the detector
521     // local coordinate system (used for ITS tracking) to the ALICE
522     // Global coordinate system for the detector id[3].
523     // The global and local coordinate are given in two Double point
524     // arrays g[3], and l[3].
525     void LtoGMomentumTracking(const Int_t *id,const Double_t *l,Double_t *g){
526                  LtoGMomentumTracking(GetModuleIndex(id),l,g);}
527     //     Transforms of momentum types of quantities from the detector
528     // local coordinate system (used for ITS tracking) to the ALICE
529     // Global coordinate system for the detector layer ladder and detector
530     // numbers. The global and local coordinate are given in two Double point
531     // arrays g[3], and l[3].
532     void LtoGMomentumTracking(const Int_t lay,const Int_t lad,const Int_t det,
533                               const Double_t *l,Double_t *g){
534                         LtoGMomentumTracking(GetModuleIndex(lay,lad,det),l,g);}
535 //
536     //     Transforms from one detector local coordinate system
537     // to another detector local coordinate system for the detector
538     // module index1 number to the detector module index2 number. The
539     //  local coordinates are given in two Double point arrays l1[3],
540     // and l2[3].
541     void LtoL(const Int_t index1,const Int_t index2,Double_t *l1,Double_t *l2){
542          Double_t g[3]; LtoG(index1,l1,g);GtoL(index2,g,l2);}
543     //     Transforms from one detector local coordinate system
544     // to another detector local coordinate system for the detector
545     // id1[3] to the detector id2[3]. The local coordinates are given
546     // in two Double point arrays l1[3], and l2[3].
547     void LtoL(const Int_t *id1,const Int_t *id2,Double_t *l1,Double_t *l2){
548          LtoL(GetModuleIndex(id1[0],id1[1],id1[2]),
549               GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
550 //
551     //     Transforms from one detector local coordinate system (used for
552     // ITS tracking) to another detector local coordinate system (used
553     // for ITS tracking) for the detector module index1 number to the
554     // detector module index2 number. The local coordinates are given
555     // in two Double point arrays l1[3], and l2[3].
556     void LtoLtracking(const Int_t index1,const Int_t index2,
557                            Double_t *l1,Double_t *l2){
558          Double_t g[3]; LtoGtracking(index1,l1,g);GtoLtracking(index2,g,l2);}
559     //     Transforms from one detector local coordinate system (used for
560     // ITS tracking) to another detector local coordinate system (used
561     // for ITS tracking) for the detector id1[3] to the detector id2[3].
562     // The local coordinates are given in two Double point arrays l1[3],
563     // and l2[3].
564     void LtoLtracking(const Int_t *id1,const Int_t *id2,
565                            Double_t *l1,Double_t *l2){
566          LtoLtracking(GetModuleIndex(id1[0],id1[1],id1[2]),
567               GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
568 //
569     //     Transforms of momentum types of quantities from one detector
570     // local coordinate system to another detector local coordinate
571     // system for the detector module index1 number to the detector
572     // module index2 number. The local coordinates are given in two
573     // Double point arrays l1[3], and l2[3].
574     void LtoLMomentum(const Int_t index1,const Int_t index2,
575                       const Double_t *l1,Double_t *l2){
576          Double_t g[3]; LtoGMomentum(index1,l1,g);GtoLMomentum(index2,g,l2);}
577     //     Transforms of momentum types of quantities from one detector
578     // local coordinate system to another detector local coordinate
579     // system for the detector id1[3] to the detector id2[3]. The local
580     // coordinates are given in two Double point arrays l1[3], and l2[3].
581     void LtoLMomentum(const Int_t *id1,const Int_t *id2,
582                       const Double_t *l1,Double_t *l2){
583          LtoLMomentum(GetModuleIndex(id1[0],id1[1],id1[2]),
584                       GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
585 //
586     //     Transforms of momentum types of quantities from one detector
587     // local coordinate system (used by ITS tracking) to another detector
588     // local coordinate system (used by ITS tracking) for the detector
589     // module index1 number to the detector module index2 number. The
590     // local coordinates are given in two Double point arrays l1[3],
591     // and l2[3].
592     void LtoLMomentumTracking(const Int_t index1,const Int_t index2,
593                            Double_t *l1,Double_t *l2){
594          Double_t g[3]; LtoGMomentumTracking(index1,l1,g);
595                         GtoLMomentumTracking(index2,g,l2);}
596     //     Transforms of momentum types of quantities from one detector
597     // local coordinate system (used by ITS tracking) to another detector
598     // local coordinate system (used by ITS tracking) for the detector
599     // id1[3] to the detector id2[3]. The local coordinates are given in
600     // two Double point arrays l1[3], and l2[3].
601     void LtoLMomentumTracking(const Int_t *id1,const Int_t *id2,
602                            Double_t *l1,Double_t *l2){
603          LtoLMomentumTracking(GetModuleIndex(id1[0],id1[1],id1[2]),
604                               GetModuleIndex(id2[0],id2[1],id2[2]),l1,l2);}
605 //
606     //     Transforms a matrix, like an Uncertainty or Error matrix from
607     // the ALICE Global coordinate system to a detector local coordinate
608     // system. The specific detector is determined by the module index
609     // number.
610     void GtoLErrorMatrix(const Int_t index,const Double_t **g,Double_t **l){
611          GetGeomMatrix(index)->GtoLPositionError((Double_t (*)[3])g,(Double_t (*)[3])l);}
612 //
613     //     Transforms a matrix, like an Uncertainty or Error matrix from
614     // the ALICE Global coordinate system to a detector local coordinate
615     // system (used by ITS tracking). The specific detector is determined
616     // by the module index number.
617     void GtoLErrorMatrixTracking(const Int_t index,const Double_t **g,
618                                  Double_t **l){
619         if(IsGeantToTracking()) GetGeomMatrix(index)->GtoLPositionError((
620             Double_t (*)[3])g,(Double_t (*)[3])l);
621         else GetGeomMatrix(index)->GtoLPositionErrorTracking(
622              (Double_t (*)[3])g,(Double_t (*)[3])l);}
623 //
624     //     Transforms a matrix, like an Uncertainty or Error matrix from
625     // the detector local coordinate system to a ALICE Global coordinate
626     // system. The specific detector is determined by the module index
627     // number.
628     void LtoGErrorMatrix(const Int_t index,const Double_t **l,Double_t **g){
629          GetGeomMatrix(index)->LtoGPositionError((Double_t (*)[3])l,(Double_t (*)[3])g);}
630 //
631     //     Transforms a matrix, like an Uncertainty or Error matrix from
632     // the detector local coordinate system (used by ITS tracking) to a
633     // ALICE Global coordinate system. The specific detector is determined
634     // by the module index number.
635     void LtoGErrorMatrixTracking(const Int_t index,const Double_t **l,
636                                  Double_t **g){
637          if(IsGeantToTracking()) GetGeomMatrix(index)->LtoGPositionError((
638             Double_t (*)[3])g,(Double_t (*)[3])l);
639         else GetGeomMatrix(index)->LtoGPositionErrorTracking((Double_t (*)[3])l,
640                                                (Double_t (*)[3])g);}
641 //
642     //     Transforms a matrix, like an Uncertainty or Error matrix from
643     // one detector local coordinate system to another detector local
644     // coordinate system. The specific detector is determined by the
645     // two module index number index1 and index2.
646     void LtoLErrorMatrix(const Int_t index1,const Int_t index2,
647                          const Double_t **l1,Double_t **l2){
648         Double_t g[3][3];
649                   LtoGErrorMatrix(index1,l1,(Double_t **)g);
650                   GtoLErrorMatrix(index2,(const Double_t **)g,l2);}
651 //
652     //     Transforms a matrix, like an Uncertainty or Error matrix from
653     // one detector local coordinate system (used by ITS tracking) to
654     // another detector local coordinate system (used by ITS tracking).
655     // The specific detector is determined by the two module index number
656     // index1 and index2.
657     void LtoLErrorMatrixTraking(const Int_t index1,const Int_t index2,
658                          const Double_t **l1,Double_t **l2){Double_t g[3][3];
659                   LtoGErrorMatrixTracking(index1,l1,(Double_t **)g);
660                   GtoLErrorMatrixTracking(index2,(const Double_t **)g,l2);}
661 //  Find Specific Modules
662     Int_t    GetNearest(const Double_t g[3],const Int_t lay=0);
663     void     GetNearest27(const Double_t g[3],Int_t n[27],const Int_t lay=0);
664     // Returns the distance [cm] between the point g[3] and the center of
665     // the detector/module specified by the the module index number.
666     Double_t Distance(const Int_t index,const Double_t g[3]){
667          return  TMath::Sqrt(GetGeomMatrix(index)->Distance2(g));}
668 //  Geometry manipulation
669     void GlobalChange(const Float_t  *tran,const Float_t  *rot);
670     void GlobalCylindericalChange(const Float_t *tran,const Float_t *rot);
671     void RandomChange(const Float_t *stran,const Float_t *srot);
672     void RandomCylindericalChange(const Float_t *stran,const Float_t *srot);
673     void GeantToTracking(AliITSgeom &source); // This converts the geometry
674 //  Other routines.
675     void PrintComparison(FILE *fp,AliITSgeom *other);
676     void PrintData(FILE *fp,const Int_t lay,const Int_t lad,const Int_t det);
677     ofstream &PrintGeom(ofstream &out);
678     ifstream &ReadGeom(ifstream &in);
679
680  private:
681     char       fVersion[20];// Transformation version.
682     Int_t      fTrans;   // Flag to keep track of which transformation 
683     Int_t      fNmodules;// The total number of modules
684     Int_t      fNlayers; // The number of layers.
685     Int_t     *fNlad;    //[fNlayers] Array of the number of ladders/layer(layer)
686     Int_t     *fNdet;    //[fNlayers] Array of the number of detectors/ladder(layer)
687     TObjArray *fGm;      // Structure of trans. and rotation.
688     TObjArray *fShape;   // Array of shapes and detector information.
689
690     ClassDef(AliITSgeom,2) // ITS geometry class
691 };
692
693 #endif