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