Using the right AliITSRecPoint constructor for the correct initialization of the...
[u/mrichter/AliRoot.git] / ITS / AliITSInitGeometry.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Id$
18 */
19 ////////////////////////////////////////////////////////////////
20 //  This class initializes the class AliITSgeom
21 //  The initialization is done starting from 
22 //  a geometry coded by means of the ROOT geometrical modeler
23 //  This initialization can be used both for simulation and reconstruction
24 ///////////////////////////////////////////////////////////////
25
26 #include <TArrayD.h>
27 #include <TArrayF.h>
28 #include <TStopwatch.h>
29 #include <TGeoManager.h>
30 #include <TGeoVolume.h>
31 #include <TGeoShape.h>
32 #include <TGeoBBox.h>
33 #include <TGeoTrd1.h>
34 #include <TGeoTrd2.h>
35 #include <TGeoArb8.h>
36 #include <TGeoTube.h>
37 #include <TGeoCone.h>
38 #include <TGeoSphere.h>
39 #include <TGeoPara.h>
40 #include <TGeoPgon.h>
41 #include <TGeoPcon.h>
42 #include <TGeoEltu.h>
43 #include <TGeoHype.h>
44 #include <TMath.h>
45
46 #include "AliLog.h"
47 #include "AliITSgeomSPD.h"
48 #include "AliITSgeomSDD.h"
49 #include "AliITSgeomSSD.h"
50 #include "AliITSsegmentationSPD.h"
51 #include "AliITSsegmentationSDD.h"
52 #include "AliITSsegmentationSSD.h"
53 #include "AliITSgeom.h"
54 #include "AliITSInitGeometry.h"
55
56 ClassImp(AliITSInitGeometry)
57 //______________________________________________________________________
58 AliITSInitGeometry::AliITSInitGeometry():
59 TObject(),
60 fName(),
61 fMinorVersion(0),
62 fMajorVersion(0),
63 fTiming(kFALSE),
64 fSegGeom(kFALSE),
65 fDecode(kFALSE){
66     // Default Creator
67     // Inputs:
68     //   none.
69     // Outputs:
70     //   none.
71     // Return:
72     //   A default inilized AliITSInitGeometry object
73 }
74 //______________________________________________________________________
75 AliITSInitGeometry::AliITSInitGeometry(const Char_t *name,Int_t minorversion):
76 TObject(),
77 fName(name),
78 fMinorVersion(minorversion),
79 fMajorVersion(0),
80 fTiming(kFALSE),
81 fSegGeom(kFALSE),
82 fDecode(kFALSE){
83     // Default Creator
84     // Inputs:
85     //   none.
86     // Outputs:
87     //   none.
88     // Return:
89     //   A default inilized AliITSInitGeometry object
90
91     if(fName.CompareTo("AliITSvPPRasymmFMD")==0)if(fMinorVersion==1||
92                                                    fMinorVersion==2){
93         fMajorVersion=10;
94         return;
95     } // end if
96     // if not defined geometry error
97     Error("AliITSInitGeometry(name,version)"," Name must be AliITSvPPRasymmFMD"
98         " and version must be 1 or 2 for now.");
99     fMinorVersion = 0;
100     fName = "";
101     return;
102 }
103 //______________________________________________________________________
104 AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(){
105     // Creates and Initilizes the geometry transformation class AliITSgeom
106     // to values appropreate to this specific geometry. Now that
107     // the segmentation is part of AliITSgeom, the detector
108     // segmentations are also defined here.
109     // Inputs:
110     //   none.
111     // Outputs:
112     //   none.
113     // Return:
114     //   A pointer to a new properly inilized AliITSgeom class. If
115     //   pointer = 0 then failed to init.
116
117     AliITSgeom *geom = new AliITSgeom();
118     if(!InitAliITSgeom(geom)){ // Error initilization failed
119         delete geom;
120         geom = 0;
121     } // end if
122     return geom;
123 }
124 //______________________________________________________________________
125 Bool_t AliITSInitGeometry::InitAliITSgeom(AliITSgeom *geom){
126   // Initilizes the geometry transformation class AliITSgeom
127   // to values appropreate to this specific geometry. Now that
128   // the segmentation is part of AliITSgeom, the detector
129   // segmentations are also defined here.
130   // Inputs:
131   //   AliITSgeom *geom  A pointer to the AliITSgeom class
132   // Outputs:
133   //   AliITSgeom *geom  This pointer recreated and properly inilized.
134   // Return:
135   //   none.
136
137   if(!gGeoManager){
138     AliFatal("The geometry manager has not been initialized (e.g. TGeoManager::Import(\"geometry.root\")should be called in advance) - exit forced");
139     return kFALSE;
140   }
141   switch(fMajorVersion){
142   case 10:{ // only case defined so far
143     return InitAliITSgeomPPRasymmFMD(geom);
144   }break; // end case
145   default:{
146     Error("InitAliITSgeom","Undefined geomtery");
147     return kFALSE;
148   } break; // end case
149   } // end switch
150   return kFALSE;
151 }
152 //______________________________________________________________________
153 Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
154     // Initilizes the geometry transformation class AliITSgeom
155     // to values appropreate to this specific geometry. Now that
156     // the segmentation is part of AliITSgeom, the detector
157     // segmentations are also defined here.
158     // Inputs:
159     //   AliITSgeom *geom  A pointer to the AliITSgeom class
160     // Outputs:
161     //   AliITSgeom *geom  This pointer recreated and properly inilized.
162     // Return:
163     //   none.
164   //    const Double_t kcm2micron = 1.0E4;
165     const Int_t kItype=0; // Type of transormation defined 0=> Geant
166     const Int_t klayers = 6; // number of layers in the ITS
167     const Int_t kladders[klayers]   = {20,40,14,22,34,38}; // Number of ladders
168     const Int_t kdetectors[klayers] = {4,4,6,8,22,25};// number of detector/lad
169     const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
170     const TString kPathbase = "/ALIC_1/ITSV_1/ITSD_1/";
171     const TString kNames[2][klayers] = {
172         {"%sIT12_1/I12A_%d/I10A_%d/I103_%d/I101_1/ITS1_1", // lay=1
173          "%sIT12_1/I12A_%d/I20A_%d/I1D3_%d/I1D1_1/ITS2_1", // lay=2
174          "%sIT34_1/I004_%d/I302_%d/ITS3_%d/", // lay=3
175          "%sIT34_1/I005_%d/I402_%d/ITS4_%d/", // lay=4
176          "%sIT56_1/I565_%d/I562_%d/ITS5_%d/", // lay=5
177          "%sIT56_1/I569_%d/I566_%d/ITS6_%d/"},// lay=6
178         {"%sIT12_1/I12B_%d/I10B_%d/I107_%d/I101_1/ITS1_1", // lay=1
179          "%sIT12_1/I12B_%d/I20B_%d/I1D7_%d/I1D1_1/ITS2_1", // lay=2
180          "%sIT34_1/I004_%d/I302_%d/ITS3_%d", // lay=3
181          "%sIT34_1/I005_%d/I402_%d/ITS4_%d", // lay=4
182          "%sIT56_1/I565_%d/I562_%d/ITS5_%d", // lay=5
183          "%sIT56_1/I569_%d/I566_%d/ITS6_%d"}};// Lay=6
184     /*
185       Int_t itsGeomTreeCopys[knlayers][3]= {{10, 2, 4},// lay=1
186       {10, 4, 4},// lay=2
187       {14, 6, 1},// lay=3
188       {22, 8, 1},// lay=4
189       {34,22, 1},// lay=5
190       {38,25, 1}};//lay=6
191     */
192     Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2;
193     Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
194     TArrayD shapePar;
195     TString path,shapeName;
196     TGeoHMatrix materix;
197     Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
198     TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
199
200     if(fTiming) time->Start();
201     for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
202     geom->Init(kItype,klayers,kladders,kdetectors,nmods);
203     for(mod=0;mod<nmods;mod++){
204         DecodeDetectorLayers(mod,lay,lad,det); // Write
205         geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
206         RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
207         path.Form(kNames[fMinorVersion-1][lay-1].Data(),
208                   kPathbase.Data(),cpn0,cpn1,cpn2);
209         geom->GetGeomMatrix(mod)->SetPath(path);
210         GetTransformation(path.Data(),materix);
211         geom->SetTrans(mod,materix.GetTranslation());
212         geom->SetRotMatrix(mod,materix.GetRotationMatrix());
213         if(initSeg[kIdet[lay-1]]) continue;
214         GetShape(path,shapeName,shapePar);
215         if(shapeName.CompareTo("BOX")){
216             Error("InitITSgeom","Geometry changed without proper code update"
217                   "or error in reading geometry. Shape is not BOX.");
218             return kFALSE;
219         } // end if
220         InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
221     } // end for module
222     if(fTiming){
223         time->Stop();
224         time->Print();
225         delete time;
226     } // end if
227     return kTRUE;
228 }
229 //______________________________________________________________________
230 Bool_t AliITSInitGeometry::InitGeomShapePPRasymmFMD(AliITSDetector idet,
231                                                        Bool_t *initSeg,
232                                                        TArrayD &shapePar,
233                                                        AliITSgeom *geom){
234     // Initilizes the geometry segmentation class AliITSgeomS?D, or
235     // AliITSsegmentationS?D depending on the vaule of fSegGeom,
236     // to values appropreate to this specific geometry. Now that
237     // the segmentation is part of AliITSgeom, the detector
238     // segmentations are also defined here.
239     // Inputs:
240     //   Int_t      lay    The layer number/name.
241     //   AliITSgeom *geom  A pointer to the AliITSgeom class
242     // Outputs:
243     //   AliITSgeom *geom  This pointer recreated and properly inilized.
244     // Return:
245     //   none.
246   //   const Double_t kcm2micron = 1.0E4;
247     const Double_t kmicron2cm = 1.0E-4;
248     Int_t i;
249     TArrayF shapeParF;
250
251     shapeParF.Set(shapePar.GetSize());
252     for(i=0;i<shapePar.GetSize();i++) shapeParF[i]=shapePar[i];
253     switch (idet){
254     case kSPD:{
255         initSeg[idet] = kTRUE;
256         AliITSgeomSPD *geomSPD = new AliITSgeomSPD425Short();
257         Float_t bx[256],bz[280];
258         for(i=000;i<256;i++) bx[i] =  50.0*kmicron2cm; // in x all are 50 microns.
259         for(i=000;i<160;i++) bz[i] = 425.0*kmicron2cm; // most are 425 microns
260         // except below
261         for(i=160;i<280;i++) bz[i] =   0.0*kmicron2cm; // Outside of detector.
262         bz[ 31] = bz[ 32] = 625.0*kmicron2cm; // first chip boundry
263         bz[ 63] = bz[ 64] = 625.0*kmicron2cm; // first chip boundry
264         bz[ 95] = bz[ 96] = 625.0*kmicron2cm; // first chip boundry
265         bz[127] = bz[128] = 625.0*kmicron2cm; // first chip boundry
266         bz[160] = 425.0*kmicron2cm;// Set so that there is no zero pixel size for fNz.
267         geomSPD->ReSetBins(shapeParF[1],256,bx,160,bz);
268         geom->ReSetShape(idet,geomSPD);
269     }break;
270     case kSDD:{
271         initSeg[idet] = kTRUE;
272         AliITSgeomSDD *geomSDD = new AliITSgeomSDD256(shapeParF.GetSize(),
273                                                       shapeParF.GetArray());
274         geom->ReSetShape(idet,geomSDD);
275     }break;
276     case kSSD:{
277         initSeg[idet] = kTRUE;
278         AliITSgeomSSD *geomSSD = new AliITSgeomSSD275and75(
279             shapeParF.GetSize(),shapeParF.GetArray());
280         geom->ReSetShape(idet,geomSSD);
281     }break;
282     default:{// Others, Note no kSDDp or kSSDp in this geometry.
283         geom->ReSetShape(idet,0);
284         Info("InitGeomShapePPRasymmFMD",
285              "default Dx=%f Dy=%f Dz=%f default=%d",
286              shapePar[0],shapePar[1],shapePar[2],idet);
287     }break;
288     } // end switch
289     return kTRUE;
290 }
291 //______________________________________________________________________
292 Bool_t AliITSInitGeometry::InitSegmentationPPRasymmFMD(AliITSDetector idet,
293                                                        Bool_t *initSeg,
294                                                        TArrayD &shapePar,
295                                                        AliITSgeom *geom){
296     // Initilizes the geometry segmentation class AliITSgeomS?D, or
297     // AliITSsegmentationS?D depending on the vaule of fSegGeom,
298     // to values appropreate to this specific geometry. Now that
299     // the segmentation is part of AliITSgeom, the detector
300     // segmentations are also defined here.
301     // Inputs:
302     //   Int_t      lay    The layer number/name.
303     //   AliITSgeom *geom  A pointer to the AliITSgeom class
304     // Outputs:
305     //   AliITSgeom *geom  This pointer recreated and properly inilized.
306     // Return:
307     //   none.
308     const Double_t kcm2micron = 1.0E4;
309     Int_t i;
310
311     switch (idet){
312     case kSPD:{
313         initSeg[idet] = kTRUE;
314         AliITSsegmentationSPD *segSPD = new AliITSsegmentationSPD();
315         segSPD->SetDetSize(2.*shapePar[0]*kcm2micron, // X
316                            2.*shapePar[2]*kcm2micron, // Z
317                            2.*shapePar[1]*kcm2micron);// Y  Microns
318         segSPD->SetNPads(256,160);// Number of Bins in x and z
319         Float_t bx[256],bz[280];
320         for(i=000;i<256;i++) bx[i] =  50.0; // in x all are 50 microns.
321         for(i=000;i<160;i++) bz[i] = 425.0; // most are 425 microns
322         // except below
323         for(i=160;i<280;i++) bz[i] =   0.0; // Outside of detector.
324         bz[ 31] = bz[ 32] = 625.0; // first chip boundry
325         bz[ 63] = bz[ 64] = 625.0; // first chip boundry
326         bz[ 95] = bz[ 96] = 625.0; // first chip boundry
327         bz[127] = bz[128] = 625.0; // first chip boundry
328         bz[160] = 425.0;// Set so that there is no zero pixel size for fNz.
329         segSPD->SetBinSize(bx,bz); // Based on AliITSgeomSPD for now.
330         geom->ReSetShape(idet,segSPD);
331     }break;
332     case kSDD:{
333         initSeg[idet] = kTRUE;
334         AliITSsegmentationSDD *segSDD = new AliITSsegmentationSDD();
335         segSDD->SetDetSize(shapePar[0]*kcm2micron, // X
336                            2.*shapePar[2]*kcm2micron, // Z
337                            2.*shapePar[1]*kcm2micron);// Y  Microns
338         segSDD->SetNPads(256,256);// Anodes, Samples
339         geom->ReSetShape(idet,segSDD);
340     }break;
341     case kSSD:{
342         initSeg[idet] = kTRUE;
343         AliITSsegmentationSSD *segSSD = new AliITSsegmentationSSD();
344         segSSD->SetDetSize(2.*shapePar[0]*kcm2micron, // X
345                            2.*shapePar[2]*kcm2micron, // Z
346                            2.*shapePar[1]*kcm2micron);// Y  Microns.
347         segSSD->SetPadSize(95.,0.); // strip x pitch in microns
348         segSSD->SetNPads(768,2); // number of strips on each side, sides.
349         segSSD->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
350         segSSD->SetAnglesLay5(0.0075,0.0275);//strip angels rad P and N
351         segSSD->SetAnglesLay6(0.0275,0.0075);//strip angels rad P and N
352         geom->ReSetShape(idet,segSSD);
353     }break;
354     default:{// Others, Note no kSDDp or kSSDp in this geometry.
355         geom->ReSetShape(idet,0);
356         Info("InitSegmentationPPRasymmFMD",
357              "default segmentation Dx=%f Dy=%f Dz=%f default=%d",
358              shapePar[0],shapePar[1],shapePar[2],idet);
359     }break;
360     } // end switch
361     return kTRUE;
362 }
363 //______________________________________________________________________
364 Bool_t AliITSInitGeometry::GetTransformation(const TString &volumePath,
365                                              TGeoHMatrix &mat){
366     // Returns the Transformation matrix between the volume specified
367     // by the path volumePath and the Top or mater volume. The format
368     // of the path volumePath is as follows (assuming ALIC is the Top volume)
369     // "/ALIC_1/DDIP_1/S05I_2/S05H_1/S05G_3". Here ALIC is the top most
370     // or master volume which has only 1 instance of. Of all of the daughter
371     // volumes of ALICE, DDIP volume copy #1 is indicated. Similarly for
372     // the daughter volume of DDIP is S05I copy #2 and so on.
373     // Inputs:
374     //   TString& volumePath  The volume path to the specific volume
375     //                        for which you want the matrix. Volume name
376     //                        hierarchy is separated by "/" while the
377     //                        copy number is appended using a "_".
378     // Outputs:
379     //  TGeoHMatrix &mat      A matrix with its values set to those
380     //                        appropriate to the Local to Master transformation
381     // Return:
382     //   A logical value if kFALSE then an error occurred and no change to
383     //   mat was made.
384
385     // We have to preserve the modeler state
386
387     // Preserve the modeler state.
388     gGeoManager->PushPath();
389     if (!gGeoManager->cd(volumePath.Data())) {
390         gGeoManager->PopPath();
391         Error("GetTransformation","Error in cd-ing to ",volumePath.Data());
392         return kFALSE;
393     } // end if !gGeoManager
394     mat = *gGeoManager->GetCurrentMatrix();
395     // Retstore the modeler state.
396     gGeoManager->PopPath();
397     return kTRUE;
398 }
399 //______________________________________________________________________
400 Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
401                                     TString &shapeType,TArrayD &par){
402     // Returns the shape and its parameters for the volume specified
403     // by volumeName.
404     // Inputs:
405     //   TString& volumeName  The volume name
406     // Outputs:
407     //   TString &shapeType   Shape type
408     //   TArrayD &par         A TArrayD of parameters with all of the
409     //                        parameters of the specified shape.
410     // Return:
411     //   A logical indicating whether there was an error in getting this
412     //   information
413     Int_t npar;
414     gGeoManager->PushPath();
415     if (!gGeoManager->cd(volumePath.Data())) {
416         gGeoManager->PopPath();
417         return kFALSE;
418     }
419     TGeoVolume * vol = gGeoManager->GetCurrentVolume();
420     gGeoManager->PopPath();
421     if (!vol) return kFALSE;
422     TGeoShape *shape = vol->GetShape();
423     TClass *classType = shape->IsA();
424     if (classType==TGeoBBox::Class()) {
425         shapeType = "BOX";
426         npar = 3;
427         par.Set(npar);
428         TGeoBBox *box = (TGeoBBox*)shape;
429         par.AddAt(box->GetDX(),0);
430         par.AddAt(box->GetDY(),1);
431         par.AddAt(box->GetDZ(),2);
432         return kTRUE;
433     }
434     if (classType==TGeoTrd1::Class()) {
435         shapeType = "TRD1";
436         npar = 4;
437         par.Set(npar);
438         TGeoTrd1 *trd1 = (TGeoTrd1*)shape;
439         par.AddAt(trd1->GetDx1(),0);
440         par.AddAt(trd1->GetDx2(),1);
441         par.AddAt(trd1->GetDy(), 2);
442         par.AddAt(trd1->GetDz(), 3);
443         return kTRUE;
444     }
445     if (classType==TGeoTrd2::Class()) {
446         shapeType = "TRD2";
447         npar = 5;
448         par.Set(npar);
449         TGeoTrd2 *trd2 = (TGeoTrd2*)shape;
450         par.AddAt(trd2->GetDx1(),0);
451         par.AddAt(trd2->GetDx2(),1);
452         par.AddAt(trd2->GetDy1(),2);
453         par.AddAt(trd2->GetDy2(),3);
454         par.AddAt(trd2->GetDz(), 4);
455         return kTRUE;
456     }
457     if (classType==TGeoTrap::Class()) {
458         shapeType = "TRAP";
459         npar = 11;
460         par.Set(npar);
461         TGeoTrap *trap = (TGeoTrap*)shape;
462         Double_t tth = TMath::Tan(trap->GetTheta()*TMath::DegToRad());
463         par.AddAt(trap->GetDz(),0);
464         par.AddAt(tth*TMath::Cos(trap->GetPhi()*TMath::DegToRad()),1);
465         par.AddAt(tth*TMath::Sin(trap->GetPhi()*TMath::DegToRad()),2);
466         par.AddAt(trap->GetH1(),3);
467         par.AddAt(trap->GetBl1(),4);
468         par.AddAt(trap->GetTl1(),5);
469         par.AddAt(TMath::Tan(trap->GetAlpha1()*TMath::DegToRad()),6);
470         par.AddAt(trap->GetH2(),7);
471         par.AddAt(trap->GetBl2(),8);
472         par.AddAt(trap->GetTl2(),9);
473         par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
474         return kTRUE;
475     }
476     if (classType==TGeoTube::Class()) {
477         shapeType = "TUBE";
478         npar = 3;
479         par.Set(npar);
480         TGeoTube *tube = (TGeoTube*)shape;
481         par.AddAt(tube->GetRmin(),0);
482         par.AddAt(tube->GetRmax(),1);
483         par.AddAt(tube->GetDz(),2);
484         return kTRUE;
485     }
486     if (classType==TGeoTubeSeg::Class()) {
487         shapeType = "TUBS";
488         npar = 5;
489         par.Set(npar);
490         TGeoTubeSeg *tubs = (TGeoTubeSeg*)shape;
491         par.AddAt(tubs->GetRmin(),0);
492         par.AddAt(tubs->GetRmax(),1);
493         par.AddAt(tubs->GetDz(),2);
494         par.AddAt(tubs->GetPhi1(),3);
495         par.AddAt(tubs->GetPhi2(),4);
496         return kTRUE;
497     }
498     if (classType==TGeoCone::Class()) {
499         shapeType = "CONE";
500         npar = 5;
501         par.Set(npar);
502         TGeoCone *cone = (TGeoCone*)shape;
503         par.AddAt(cone->GetDz(),0);
504         par.AddAt(cone->GetRmin1(),1);
505         par.AddAt(cone->GetRmax1(),2);
506         par.AddAt(cone->GetRmin2(),3);
507         par.AddAt(cone->GetRmax2(),4);
508         return kTRUE;
509     }
510     if (classType==TGeoConeSeg::Class()) {
511         shapeType = "CONS";
512         npar = 7;
513         par.Set(npar);
514         TGeoConeSeg *cons = (TGeoConeSeg*)shape;
515         par.AddAt(cons->GetDz(),0);
516         par.AddAt(cons->GetRmin1(),1);
517         par.AddAt(cons->GetRmax1(),2);
518         par.AddAt(cons->GetRmin2(),3);
519         par.AddAt(cons->GetRmax2(),4);
520         par.AddAt(cons->GetPhi1(),5);
521         par.AddAt(cons->GetPhi2(),6);
522         return kTRUE;
523     }
524     if (classType==TGeoSphere::Class()) {
525         shapeType = "SPHE";
526         npar = 6;
527         par.Set(npar);
528         
529         TGeoSphere *sphe = (TGeoSphere*)shape;
530         par.AddAt(sphe->GetRmin(),0);
531         par.AddAt(sphe->GetRmax(),1);
532         par.AddAt(sphe->GetTheta1(),2);
533         par.AddAt(sphe->GetTheta2(),3);
534         par.AddAt(sphe->GetPhi1(),4);
535         par.AddAt(sphe->GetPhi2(),5);
536         return kTRUE;
537     }
538     if (classType==TGeoPara::Class()) {
539         shapeType = "PARA";
540         npar = 6;
541         par.Set(npar);
542         TGeoPara *para = (TGeoPara*)shape;
543         par.AddAt(para->GetX(),0);
544         par.AddAt(para->GetY(),1);
545         par.AddAt(para->GetZ(),2);
546         par.AddAt(para->GetTxy(),3);
547         par.AddAt(para->GetTxz(),4);
548         par.AddAt(para->GetTyz(),5);
549         return kTRUE;
550     }
551     if (classType==TGeoPgon::Class()) {
552         shapeType = "PGON";
553         TGeoPgon *pgon = (TGeoPgon*)shape;
554         Int_t nz = pgon->GetNz();
555         const Double_t *rmin = pgon->GetRmin();
556         const Double_t *rmax = pgon->GetRmax();
557         const Double_t *z = pgon->GetZ();
558         npar = 4 + 3*nz;
559         par.Set(npar);
560         par.AddAt(pgon->GetPhi1(),0);
561         par.AddAt(pgon->GetDphi(),1);
562         par.AddAt(pgon->GetNedges(),2);
563         par.AddAt(pgon->GetNz(),3);
564         for (Int_t i=0; i<nz; i++) {
565             par.AddAt(z[i], 4+3*i);
566             par.AddAt(rmin[i], 4+3*i+1);
567             par.AddAt(rmax[i], 4+3*i+2);
568         }
569         return kTRUE;
570     }
571     if (classType==TGeoPcon::Class()) {
572         shapeType = "PCON";
573         TGeoPcon *pcon = (TGeoPcon*)shape;
574         Int_t nz = pcon->GetNz();
575         const Double_t *rmin = pcon->GetRmin();
576         const Double_t *rmax = pcon->GetRmax();
577         const Double_t *z = pcon->GetZ();
578         npar = 3 + 3*nz;
579         par.Set(npar);
580         par.AddAt(pcon->GetPhi1(),0);
581         par.AddAt(pcon->GetDphi(),1);
582         par.AddAt(pcon->GetNz(),2);
583         for (Int_t i=0; i<nz; i++) {
584             par.AddAt(z[i], 3+3*i);
585             
586             par.AddAt(rmin[i], 3+3*i+1);
587             par.AddAt(rmax[i], 3+3*i+2);
588         }
589         return kTRUE;
590     }
591     if (classType==TGeoEltu::Class()) {
592         shapeType = "ELTU";
593         npar = 3;
594         par.Set(npar);
595         TGeoEltu *eltu = (TGeoEltu*)shape;
596         par.AddAt(eltu->GetA(),0);
597         par.AddAt(eltu->GetB(),1);
598         par.AddAt(eltu->GetDz(),2);
599         return kTRUE;
600     }
601     if (classType==TGeoHype::Class()) {
602         shapeType = "HYPE";
603         npar = 5;
604         par.Set(npar);
605         TGeoHype *hype = (TGeoHype*)shape;
606         par.AddAt(TMath::Sqrt(hype->RadiusHypeSq(0.,kTRUE)),0);
607         par.AddAt(TMath::Sqrt(hype->RadiusHypeSq(0.,kFALSE)),1);
608         par.AddAt(hype->GetDZ(),2);
609         par.AddAt(hype->GetStIn(),3);
610         par.AddAt(hype->GetStOut(),4);
611         return kTRUE;
612     }
613     if (classType==TGeoGtra::Class()) {
614         shapeType = "GTRA";
615         npar = 12;
616         par.Set(npar);
617         TGeoGtra *trap = (TGeoGtra*)shape;
618         Double_t tth = TMath::Tan(trap->GetTheta()*TMath::DegToRad());
619         par.AddAt(trap->GetDz(),0);
620         par.AddAt(tth*TMath::Cos(trap->GetPhi()*TMath::DegToRad()),1);
621         par.AddAt(tth*TMath::Sin(trap->GetPhi()*TMath::DegToRad()),2);
622         par.AddAt(trap->GetH1(),3);
623         par.AddAt(trap->GetBl1(),4);
624         par.AddAt(trap->GetTl1(),5);
625         par.AddAt(TMath::Tan(trap->GetAlpha1()*TMath::DegToRad()),6);
626         par.AddAt(trap->GetH2(),7);
627         par.AddAt(trap->GetBl2(),8);
628         par.AddAt(trap->GetTl2(),9);
629         par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
630         par.AddAt(trap->GetTwistAngle(),11);
631         return kTRUE;
632     }
633     if (classType==TGeoCtub::Class()) {
634         shapeType = "CTUB";
635         npar = 11;
636         par.Set(npar);
637         TGeoCtub *ctub = (TGeoCtub*)shape;
638         const Double_t *lx = ctub->GetNlow();
639         const Double_t *tx = ctub->GetNhigh();
640         par.AddAt(ctub->GetRmin(),0);
641         par.AddAt(ctub->GetRmax(),1);
642         par.AddAt(ctub->GetDz(),2);
643         par.AddAt(ctub->GetPhi1(),3);
644         par.AddAt(ctub->GetPhi2(),4);
645         par.AddAt(lx[0],5);
646         par.AddAt(lx[1],6);
647         par.AddAt(lx[2],7);
648         par.AddAt(tx[0],8);
649         par.AddAt(tx[1],9);
650         par.AddAt(tx[2],10);
651         return kTRUE;
652     }
653     Error("GetShape","Getting shape parameters for shape %s not implemented",
654           shape->ClassName());
655     return kFALSE;
656 }
657 //______________________________________________________________________
658 void AliITSInitGeometry::DecodeDetector(Int_t &mod,Int_t layer,Int_t cpn0,
659                                         Int_t cpn1,Int_t cpn2) const {
660     // decode geometry into detector module number. There are two decoding
661     // Scheams. Old which does not follow the ALICE coordinate system
662     // requirements, and New which dose.
663     // Inputs:
664     //    Int_t layer    The ITS layer
665     //    Int_t cpn0     The lowest copy number
666     //    Int_t cpn1     The middle copy number
667     //    Int_t cpn2     the highest copy number
668     // Output:
669     //    Int_t &mod     The module number assoicated with this set
670     //                   of copy numbers.
671     // Return:
672     //    none.
673     const Int_t kDetPerLadderSPD[2]={2,4};
674     const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
675     const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
676     Int_t lay=-1,lad=-1,det=-1,i;
677
678     if(fDecode){ // New decoding scheam
679         switch (layer){
680         case 1:{
681             lay = layer;
682             det = 5-cpn2;
683             if(cpn0==4&&cpn1==1) lad=1;
684             else if(cpn0==4&&cpn1==2) lad=20;
685             else if(cpn0<4){
686                 lad = 8-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
687             }else{ // cpn0>4
688                 lad = 28-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
689             } // end if
690         } break;
691         case 2:{
692             lay = layer;
693             det = 5-cpn2;
694             if(cpn0==4&&cpn1==1) lad=1;
695             else if(cpn0<4){
696                 lad = 14-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
697             }else{ // cpn0>4
698                 lad = 54-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
699             } // end if
700         } break;
701         case 3:{
702             lay = layer;
703             if(cpn0<5) lad = 5-cpn0;
704             else lad = 19-cpn0;
705             det = 7-cpn1;
706         } break;
707         case 4:{
708             lay = layer;
709             if(cpn0<7) lad = 7-cpn0;
710             else lad = 29-cpn0;
711             det = 9-cpn1;
712         } break;
713         case 5:{
714             lay = layer;
715             if(cpn0<10) lad = 10-cpn0;
716             else lad = 44-cpn0;
717             det = 23-cpn1;
718         } break;
719         case 6:{
720             lay = layer;
721             if(cpn0<9) lad = 9-cpn0;
722             else lad = 47-cpn0;
723             det = 26-cpn1;
724         } break;
725         } // end switch
726         mod = 0;
727         for(i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
728         mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
729         return;
730     } // end if
731     // Old decoding scheam
732     switch(layer){
733     case 1: case 2:{
734         lay = layer;
735         lad = cpn1+kDetPerLadderSPD[layer-1]*(cpn0-1);
736         det = cpn2;
737         }break;
738     case 3: case 4:{
739         lay = layer;
740         lad = cpn0;
741         det = cpn1;
742         }break;
743     case 5: case 6:{
744         lay = layer;
745         lad = cpn0;
746         det = cpn1;
747         }break;
748     default:{
749         }break;
750     } // end switch
751     mod = 0;
752     for(i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
753     mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
754     return;
755 }
756 //______________________________________________________________________
757 void AliITSInitGeometry::RecodeDetector(Int_t mod,Int_t &cpn0,
758                                         Int_t &cpn1,Int_t &cpn2){
759     // decode geometry into detector module number. There are two decoding
760     // Scheams. Old which does not follow the ALICE coordinate system
761     // requirements, and New which dose.
762     // Inputs:
763     //    Int_t mod      The module number assoicated with this set
764     //                   of copy numbers.
765     // Output:
766     //    Int_t cpn0     The lowest copy number
767     //    Int_t cpn1     The middle copy number
768     //    Int_t cpn2     the highest copy number
769     // Return:
770     //    none.
771     const Int_t kITSgeoTreeCopys[6][3]= {{10, 2, 4},// lay=1
772                                          {10, 4, 4},// lay=2
773                                          {14, 6, 1},// lay=3
774                                          {22, 8, 1},// lay=4
775                                          {34,22, 1},// lay=5
776                                          {38,25, 1}};//lay=6
777     const Int_t kDetPerLadderSPD[2]={2,4};
778     //    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
779     //    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
780     Int_t lay,lad,det;
781
782     cpn0 = cpn1 = cpn2 = 0;
783     DecodeDetectorLayers(mod,lay,lad,det);
784     if(fDecode){ // New decoding scheam
785         switch (lay){
786         case 1:{
787             cpn2 = 5-det;     // Detector 1-4
788             cpn1 = 1+(lad-1)%kDetPerLadderSPD[lay-1];
789             cpn0 = 5-(lad+kDetPerLadderSPD[lay-1])/kDetPerLadderSPD[lay-1];
790             if(mod>27) cpn0 = 15-(lad+kDetPerLadderSPD[lay-1])/
791                            kDetPerLadderSPD[lay-1];
792         } break;
793         case 2:{
794             cpn2 = 5-det;     // Detector 1-4
795             cpn1 = 4-(lad+2)%kDetPerLadderSPD[lay-1];
796             cpn0 = 1+(14-cpn1-lad)/kDetPerLadderSPD[lay-1];
797             if(mod>131) cpn0 = 1+(54-lad-cpn1)/kDetPerLadderSPD[lay-1];
798         } break;
799         case 3:{
800             cpn2 = 1;
801             if(lad<5) cpn0 = 5-lad;
802             else cpn0 = 19-lad;
803             cpn1 = 7-det;
804         } break;
805         case 4:{
806             cpn2 = 1;
807             if(lad<7) cpn0 = 7-lad;
808             else cpn0 = 29-lad;
809             cpn1 = 9-det;
810         } break;
811         case 5:{
812             cpn2 = 1;
813             if(lad<10) cpn0 = 10-lad;
814             else cpn0 = 44-lad;
815             cpn1 = 23-det;
816         } break;
817         case 6:{
818             cpn2 = 1;
819             if(lad<9) cpn0 = 9-lad;
820             else cpn0 = 47-lad;
821             cpn1 = 26-det;
822         } break;
823         default:{
824             Error("RecodeDetector","New: mod=%d lay=%d not 1-6.");
825             return;
826         } break;
827         } // end switch
828         if(cpn0<1||cpn1<1||cpn2<1||
829            cpn0>kITSgeoTreeCopys[lay-1][0]||
830            cpn1>kITSgeoTreeCopys[lay-1][1]||
831            cpn2>kITSgeoTreeCopys[lay-1][2])
832             Error("RecodeDetector",
833                   "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
834                   cpn0,cpn1,cpn2,mod,lay,lad,det);
835         return;
836     } // end if
837     // Old encoding
838     switch (lay){
839     case 1: case 2:{
840         cpn2 = det;     // Detector 1-4
841         cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
842         cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
843     } break;
844     case 3: case 4: case 5 : case 6:{
845         cpn2 = 1;
846         cpn1 = det;
847         cpn0 = lad;
848     } break;
849     default:{
850         Error("RecodeDetector","Old: mod=%d lay=%d not 1-6.");
851         return;
852     } break;
853     } // end switch
854     if(cpn0<1||cpn1<1||cpn2<1||
855        cpn0>kITSgeoTreeCopys[lay-1][0]||
856        cpn1>kITSgeoTreeCopys[lay-1][1]||
857        cpn2>kITSgeoTreeCopys[lay-1][2])
858         Error("RecodeDetector",
859               "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
860               cpn0,cpn1,cpn2,mod,lay,lad,det);
861     return;
862 }
863 //______________________________________________________________________
864 void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &lay,
865                                               Int_t &lad,Int_t &det){
866     // decode geometry into detector module number. There are two decoding
867     // Scheams. Old which does not follow the ALICE coordinate system
868     // requirements, and New which dose. Note, this use of layer ladder
869     // and detector numbers are strictly for internal use of this
870     // specific code. They do not represent the "standard" layer ladder
871     // or detector numbering except in a very old and obsoleate sence.
872     // Inputs:
873     //    Int_t mod      The module number assoicated with this set
874     //                   of copy numbers.
875     // Output:
876     //    Int_t lay     The layer number
877     //    Int_t lad     The ladder number
878     //    Int_t det     the dettector number
879     // Return:
880     //    none.
881   //    const Int_t kDetPerLadderSPD[2]={2,4};
882     const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
883     const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
884     Int_t mod2;
885
886     det  = 0;
887     lad  = 0;
888     lay  = 0;
889     mod2 = 0;
890     do{
891         mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
892         lay++;
893     }while(mod2<=mod); // end while
894     if(lay>6||lay<1) Error("DecodeDetectorLayers","0<lay=%d>6",lay);
895     mod2 -= kLadPerLayer[lay-1]*kDetPerLadder[lay-1];
896     do{
897         lad++;
898         mod2 += kDetPerLadder[lay-1];
899     }while(mod2<=mod); // end while
900     if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayera",
901             "lad=%d>kLadPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
902                                             kLadPerLayer[lay-1],mod,mod2);
903     mod2 -= kDetPerLadder[lay-1];
904     det = mod-mod2+1;
905     if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
906            "det=%d>detPerLayer[lay-1=%d]=%d mod=%d mod2=%d lad=%d",det,
907                                   lay-1,kDetPerLadder[lay-1],mod,mod2,lad);
908     return;
909 }
910