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 "AliITSInitGeometry.h"
  54 #include <TDatime.h>
  55
  56 ClassImp(AliITSInitGeometry)
  57
  58 const Bool_t AliITSInitGeometry::fgkOldSPDbarrel = kFALSE;
  59 const Bool_t AliITSInitGeometry::fgkOldSDDbarrel = kFALSE;
  60 const Bool_t AliITSInitGeometry::fgkOldSSDbarrel = kFALSE;
  61 const Bool_t AliITSInitGeometry::fgkOldSDDcone   = kTRUE;
  62 const Bool_t AliITSInitGeometry::fgkOldSSDcone   = kTRUE;
  63 const Bool_t AliITSInitGeometry::fgkOldSPDshield = kTRUE;
  64 const Bool_t AliITSInitGeometry::fgkOldSDDshield = kTRUE;
  65 const Bool_t AliITSInitGeometry::fgkOldSSDshield = kTRUE;
  66 const Bool_t AliITSInitGeometry::fgkOldServices  = kTRUE;
  67 const Bool_t AliITSInitGeometry::fgkOldSupports  = kTRUE;
  68 //______________________________________________________________________
  69 AliITSInitGeometry::AliITSInitGeometry():
  70 TObject(),                   // Base Class
  71 fName(0),                    // Geometry name
  72 fMinorVersion(-1),           // Minor version number/type
  73 fMajorVersion(kvDefault),    // Major versin number
  74 fTiming(kFALSE),             // Flag to start inilization timing
  75 fSegGeom(kFALSE),            // Flag to switch between the old use of
  76                              // AliITSgeomS?D class, or AliITSsegmentation
  77                              // class in fShape of AliITSgeom class.
  78 fDecode(kFALSE),             // Flag for new/old decoding
  79 fDebug(0){                   // Debug flag
  80     // Default Creator
  81     // Inputs:
  82     //   none.
  83     // Outputs:
  84     //   none.
  85     // Return:
  86     //   A default inilized AliITSInitGeometry object
  87
  88     fName = "Undefined";
  89 }
  90 //______________________________________________________________________
  91 AliITSInitGeometry::AliITSInitGeometry(AliITSVersion_t version,
  92                                        Int_t minorversion):
  93 TObject(),                   // Base Class
  94 fName(0),                    // Geometry name
  95 fMinorVersion(minorversion), // Minor version number/type
  96 fMajorVersion(version),      // Major versin number
  97 fTiming(kFALSE),             // Flag to start inilization timing
  98 fSegGeom(kFALSE),            // Flag to switch between the old use of
  99                              // AliITSgeomS?D class, or AliITSsegmentation
 100                              // class in fShape of AliITSgeom class.
 101 fDecode(kFALSE),             // Flag for new/old decoding
 102 fDebug(0){                   // Debug flag
 103     // Default Creator
 104     // Inputs:
 105     //   none.
 106     // Outputs:
 107     //   none.
 108     // Return:
 109     //   A default inilized AliITSInitGeometry object
 110
 111     if(version == kvPPRasymmFMD && (fMinorVersion==1|| fMinorVersion==2)){
 112         fName="AliITSvPPRasymmFMD";
 113     }else if(version == kv11Hybrid){
 114         fName="AliITSv11Hybrid";
 115     }else {
 116         AliFatal(Form("Undefined geometry: fMajorVersion=%d, "
 117                       "fMinorVersion= %d",(Int_t)fMajorVersion,fMinorVersion));
 118         fName = "Undefined";
 119     } // end if
 120     return;
 121 }
 122 //______________________________________________________________________
 123 AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(){
 124     // Creates and Initilizes the geometry transformation class AliITSgeom
 125     // to values appropreate to this specific geometry. Now that
 126     // the segmentation is part of AliITSgeom, the detector
 127     // segmentations are also defined here.
 128     // Inputs:
 129     //   none.
 130     // Outputs:
 131     //   none.
 132     // Return:
 133     //   A pointer to a new properly inilized AliITSgeom class. If
 134     //   pointer = 0 then failed to init.
 135
 136
 137   AliITSVersion_t version = kvDefault;
 138   Int_t minor = 0;
 139   TDatime datetime;
 140   TGeoVolume *itsV = gGeoManager->GetVolume("ITSV");
 141   if(!itsV){
 142     Error("CreateAliITSgeom","Can't find ITS volume ITSV, aborting");
 143     return 0;
 144   }// end if
 145   const Char_t *title = itsV->GetTitle();
 146   if(!ReadVersionString(title,(Int_t)strlen(title),version,minor,
 147                         datetime))
 148     Warning("UpdateInternalGeometry","Can't read title=%s\n",title);
 149   SetTiming(kFALSE);
 150   SetSegGeom(kFALSE);
 151   SetDecoding(kFALSE);
 152   AliITSgeom *geom = CreateAliITSgeom(version,minor);
 153   AliDebug(1,"AliITSgeom object has been initialized from TGeo\n");
 154   return geom;
 155 }
 156 //______________________________________________________________________
 157 AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(Int_t major,Int_t minor){
 158     // Creates and Initilizes the geometry transformation class AliITSgeom
 159     // to values appropreate to this specific geometry. Now that
 160     // the segmentation is part of AliITSgeom, the detector
 161     // segmentations are also defined here.
 162     // Inputs:
 163     //   Int_t major   major version, see AliITSVersion_t
 164     //   Int_t minor   minor version
 165     // Outputs:
 166     //   none.
 167     // Return:
 168     //   A pointer to a new properly inilized AliITSgeom class. If
 169     //   pointer = 0 then failed to init.
 170
 171     switch(major){
 172     case kvtest:
 173         SetGeometryName("AliITSvtest");
 174         SetVersion(kvtest,minor);
 175         break;
 176     case kvSPD02:
 177         SetGeometryName("AliITSvSPD02");
 178         SetVersion(kvSPD02,minor);
 179         break;
 180     case kvSDD03:
 181         SetGeometryName("AliITSvSDD03");
 182         SetVersion(kvSDD03,minor);
 183         break;
 184     case kvSSD03:
 185         SetGeometryName("AliITSvSSD03");
 186         SetVersion(kvSSD03,minor);
 187         break;
 188     case kvITS04:
 189         SetGeometryName("AliITSvBeamTest03");
 190         SetVersion(kvITS04,minor);
 191         break;
 192     case kvPPRcourseasymm:
 193         SetGeometryName("AliITSvPPRcourseasymm");
 194         SetVersion(kvPPRcourseasymm,minor);
 195         break;
 196     case kvPPRasymmFMD:
 197         SetGeometryName("AliITSvPPRasymmFMD");
 198         SetVersion(kvPPRasymmFMD,minor);
 199         break;
 200     case kv11:
 201         SetGeometryName("AliITSv11");
 202         SetVersion(kv11,minor);
 203         break;
 204     case kv11Hybrid:
 205         SetGeometryName("AliITSv11Hybrid");
 206         SetVersion(kv11Hybrid,minor);
 207         break;
 208     case kvDefault:
 209     default:
 210         SetGeometryName("Undefined");
 211         SetVersion(kvDefault,minor);
 212         break;
 213     } // end switch
 214     AliITSgeom *geom = new AliITSgeom();
 215     if(!InitAliITSgeom(geom)){ // Error initilization failed
 216         delete geom;
 217         geom = 0;
 218     } // end if
 219     return geom;
 220 }
 221 //______________________________________________________________________
 222 Bool_t AliITSInitGeometry::InitAliITSgeom(AliITSgeom *geom){
 223   // Initilizes the geometry transformation class AliITSgeom
 224   // to values appropreate to this specific geometry. Now that
 225   // the segmentation is part of AliITSgeom, the detector
 226   // segmentations are also defined here.
 227   // Inputs:
 228   //   AliITSgeom *geom  A pointer to the AliITSgeom class
 229   // Outputs:
 230   //   AliITSgeom *geom  This pointer recreated and properly inilized.
 231   // Return:
 232   //   none.
 233
 234     if(!gGeoManager){
 235         AliFatal("The geometry manager has not been initialized (e.g. "
 236                  "TGeoManager::Import(\"geometry.root\")should be "
 237                  "called in advance) - exit forced");
 238         return kFALSE;
 239     } // end if
 240     switch(fMajorVersion) {
 241     case kvtest: {
 242         if(GetMinorVersion()==1) return InitAliITSgeomPPRasymmFMD(geom);
 243         else if(GetMinorVersion()==2) return InitAliITSgeomtest2(geom);
 244     } break; // end case
 245     case kvSPD02: {
 246         return InitAliITSgeomSPD02(geom);
 247     } break; // end case
 248     case kvSDD03: {
 249         return InitAliITSgeomSDD03(geom);
 250     } break; // end case
 251     case kvSSD03: {
 252         return InitAliITSgeomSSD03(geom);
 253     } break; // end case
 254     case kvITS04: {
 255         return InitAliITSgeomITS04(geom);
 256     } break; // end case
 257     case kvPPRasymmFMD: {
 258         return InitAliITSgeomPPRasymmFMD(geom);
 259     } break; // end case
 260     case kvPPRcourseasymm: {
 261         return kTRUE; // No sensitive detectors in course geometry
 262     } break; // end case
 263     case kv11Hybrid: {
 264         return InitAliITSgeomV11Hybrid(geom);
 265     } break; // end case
 266     case kv11: {
 267         return InitAliITSgeomV11(geom);
 268     } break; // end case
 269     case kvDefault: default: {
 270         AliFatal("Undefined geometry");
 271         return kFALSE;
 272     } break; // end case
 273     } // end switch
 274     return kFALSE;
 275 }
 276 //______________________________________________________________________
 277 void AliITSInitGeometry::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
 278     // Transpose the rotation matrix part of a TGeoHMatrix. This
 279     // is needed because TGeo stores the transpose of the rotation
 280     // matrix as compared to what AliITSgeomMatrix uses (and Geant3).
 281     // Inputs:
 282     //    TGeoHMatrix *m  The matrix to be transposed
 283     // Outputs:
 284     //    TGEoHMatrix *m  The transposed matrix
 285     // Return:
 286     //    none.
 287     Int_t i;
 288     Double_t r[9];
 289
 290     if(m==0) return; // no matrix to transpose.
 291     for(i=0;i<9;i += 4) r[i] = m->GetRotationMatrix()[i]; // diagonals
 292     r[1] = m->GetRotationMatrix()[3];
 293     r[2] = m->GetRotationMatrix()[6];
 294     r[3] = m->GetRotationMatrix()[1];
 295     r[5] = m->GetRotationMatrix()[7];
 296     r[6] = m->GetRotationMatrix()[2];
 297     r[7] = m->GetRotationMatrix()[5];
 298     m->SetRotation(r);
 299     return;
 300 }
 301 //______________________________________________________________________
 302 Bool_t AliITSInitGeometry::InitAliITSgeomtest2(AliITSgeom *geom){
 303     // Initilizes the geometry transformation class AliITSgeom
 304     // to values appropreate to this specific geometry. Now that
 305     // the segmentation is part of AliITSgeom, the detector
 306     // segmentations are also defined here.
 307     // Inputs:
 308     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 309     // Outputs:
 310     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 311     // Return:
 312     //   none.
 313     //  const Double_t kcm2micron = 1.0E4;
 314     const Int_t kItype=0; // Type of transormation defined 0=> Geant
 315     const Int_t klayers = 6; // number of layers in the ITS
 316     const Int_t kladders[klayers]   = {1,1,1,1,1,1}; // Number of ladders
 317     const Int_t kdetectors[klayers] = {1,1,1,1,1,1};// number of detector/lad
 318     const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
 319     const TString kNames[klayers] = {
 320          "/ALIC_1/ITSV_1/ITSspd1_1/ITS1_1", // lay=1
 321          "/ALIC_1/ITSV_1/ITSspd2_1/ITS2_1", // lay=2
 322          "/ALIC_1/ITSV_1/ITSsdd1_1/ITS3_1", // lay=3
 323          "/ALIC_1/ITSV_1/ITSsdd2_1/ITS4_1", // lay=4
 324          "/ALIC_1/ITSV_1/ITSssd1_1/ITS5_1", // lay=5
 325          "/ALIC_1/ITSV_1/ITSssd2_1/ITS6_1"};// Lay=6
 326     Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2;
 327     Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
 328     TArrayD shapePar;
 329     TString shapeName;
 330     TGeoHMatrix matrix;
 331     Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
 332     TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
 333
 334     if(fTiming) time->Start();
 335     for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
 336     geom->Init(kItype,klayers,kladders,kdetectors,nmods);
 337     for(mod=0;mod<nmods;mod++){
 338         DecodeDetectorLayers(mod,lay,lad,det); // Write
 339         geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
 340         RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
 341         geom->GetGeomMatrix(mod)->SetPath(kNames[lay-1]);
 342         GetTransformation(kNames[lay-1].Data(),matrix);
 343         geom->SetTrans(mod,matrix.GetTranslation());
 344         TransposeTGeoHMatrix(&matrix); // Transpose TGeo's rotation matrixes
 345         geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 346         if(initSeg[kIdet[lay-1]]) continue;
 347         GetShape(kNames[lay-1],shapeName,shapePar);
 348         if(shapeName.CompareTo("BOX")){
 349             Error("InitITSgeom2","Geometry changed without proper code update"
 350                   "or error in reading geometry. Shape is not BOX shape is %s",
 351                   shapeName.Data());
 352             return kFALSE;
 353         } // end if
 354         InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
 355     } // end for module
 356     if(fTiming){
 357         time->Stop();
 358         time->Print();
 359         delete time;
 360     } // end if
 361     return kTRUE;
 362 }
 363 //______________________________________________________________________
 364 Bool_t AliITSInitGeometry::InitAliITSgeomSPD02(AliITSgeom *geom){
 365     // Initilizes the geometry transformation class AliITSgeom
 366     // to values appropreate to this specific geometry. Now that
 367     // the segmentation is part of AliITSgeom, the detector
 368     // segmentations are also defined here.
 369     // Inputs:
 370     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 371     // Outputs:
 372     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 373     // Return:
 374     //   none.
 375     const Int_t kltypess=2;
 376     const Int_t knlayers=5;
 377     const TString knames[kltypess]=
 378         {"ALIC_1/ITSV_1/ITEL_%d/IMB0_1/IMBS_1",//lay=1,2,4,5
 379          "ALIC_1/ITSV_1/IDET_%d/ITS0_1/ITST_1"};// lay=3
 380     const Int_t kitsGeomTreeCopys[2]={4,1};
 381     const Int_t knlad[knlayers]={knlayers*1},kndet[knlayers]={knlayers*1};
 382     TString path,shapeName;
 383     TGeoHMatrix matrix;
 384     TArrayD shapePar;
 385     TArrayF shapeParF;
 386     Double_t trans[3]={3*0.0},rot[10]={10*0.0};
 387     Int_t npar=3,mod,i,j,lay,lad,det,cpy;
 388     Float_t par[20];
 389     TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
 390
 391     par[0]=0.64;par[1]=0.5*300.0E-4;par[2]=3.48;
 392     mod=5;;
 393     geom->Init(0,knlayers,knlad,kndet,mod);
 394
 395     if(fTiming) time->Start();
 396     for(i=0;i<kltypess;i++)for(cpy=1;cpy<=kitsGeomTreeCopys[i];cpy++){
 397         path.Form(knames[i].Data(),cpy);
 398         GetTransformation(path.Data(),matrix);
 399         GetShape(path.Data(),shapeName,shapePar);
 400         shapeParF.Set(shapePar.GetSize());
 401         for(j=0;j<shapePar.GetSize();j++) shapeParF[j]=shapePar[j];
 402         lay = cpy;
 403         if(i==0&&cpy>2) lay=cpy+1;
 404         if(i==1) lay=3;
 405         DecodeDetector(mod,kitsGeomTreeCopys[i],1,cpy,0);
 406         DecodeDetectorLayers(mod,lay,lad,det);
 407         geom->CreateMatrix(mod,lay,lad,det,kSPD,trans,rot);
 408         geom->SetTrans(mod,matrix.GetTranslation());
 409         geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 410         geom->GetGeomMatrix(mod)->SetPath(path.Data());
 411         if(!(geom->IsShapeDefined((Int_t)kSPD)))
 412             geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(npar,par));
 413     } // end for i,cpy/
 414     if(fTiming){
 415         time->Stop();
 416         time->Print();
 417         delete time;
 418     } // end if
 419     return kTRUE;
 420 }
 421 //______________________________________________________________________
 422 Bool_t AliITSInitGeometry::InitAliITSgeomSDD03(AliITSgeom *geom){
 423     // Initilizes the geometry transformation class AliITSgeom
 424     // to values appropreate to this specific geometry. Now that
 425     // the segmentation is part of AliITSgeom, the detector
 426     // segmentations are also defined here.
 427     // Inputs:
 428     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 429     // Outputs:
 430     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 431     // Return:
 432     //   none
 433     const Int_t knlayers=12;
 434     //   const Int_t kndeep=6;
 435     const Int_t kltypess=2;
 436     const AliITSDetector kidet[knlayers]={kSSD,kSDD};
 437     const TString knames[kltypess]={
 438         "/ALIC_1/ITSV_1/ITEL_%d/ITAI_1/IMB0_1/IMBS_1",
 439         "/ALIC_1/ITSV_1/IDET_%d/IDAI_1/ITS0_1/ITST_1"};
 440     const Int_t kitsGeomTreeCopys[kltypess]={10,2};
 441     const Int_t knp=384;
 442     const Float_t kpitch=50.E-4;/*cm*/
 443     Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
 444     Int_t nlad[knlayers]={knlayers*1};
 445     Int_t ndet[knlayers]={knlayers*1};
 446     Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
 447     TString path,shapeName;
 448     TGeoHMatrix matrix;
 449     Double_t trans[3]={3*0.0},rot[10]={10*0.0};
 450     TArrayD shapePar;
 451     TArrayF shapeParF;
 452     Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
 453
 454     geom->Init(0,knlayers,nlad,ndet,mod);
 455     p[0]=-box[0];
 456     n[0]=box[0];
 457     // Fill in anode and cathode strip locations (lower edge)
 458     for(i=1;i<knp;i++){
 459         p[i] =p[i-1]+kpitch;
 460         n[i] =n[i-1]-kpitch;
 461     } // end for i
 462     p[knp]=box[0];
 463     n[knp]=-box[0];
 464     for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
 465         DecodeDetector(mod,kitsGeomTreeCopys[i],cp0,1,2);
 466         DecodeDetectorLayers(mod,lay,lad,det);
 467         path.Form(knames[i].Data(),cp0);
 468         GetTransformation(path.Data(),matrix);
 469         GetShape(path.Data(),shapeName,shapePar);
 470         shapeParF.Set(shapePar.GetSize());
 471         for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
 472         geom->CreateMatrix(mod,lay,lad,det,kidet[i],trans,rot);
 473         geom->SetTrans(mod,matrix.GetTranslation());
 474         geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 475         geom->GetGeomMatrix(mod)->SetPath(path.Data());
 476         switch (kidet[i]){
 477         case kSDD: if(!(geom->IsShapeDefined((Int_t)kSDD))){
 478             geom->ReSetShape(kSDD,new AliITSgeomSDD256(shapeParF.GetSize(),
 479                                                        shapeParF.GetArray()));
 480             isShapeDefined[i]=kTRUE;
 481         } break;
 482         case kSSD:if(!(geom->IsShapeDefined((Int_t)kSSD))){
 483             geom->ReSetShape(kSSD,new AliITSgeomSSD(box,0.0,0.0,
 484                                                     knp+1,p,knp+1,n));
 485             isShapeDefined[i]=kTRUE;
 486         } break;
 487         default:{} break;
 488         } // end switch
 489     } // end for i,cp0
 490
 491     return kTRUE;
 492 }
 493 //______________________________________________________________________
 494 Bool_t AliITSInitGeometry::InitAliITSgeomSSD03(AliITSgeom *geom){
 495     // Initilizes the geometry transformation class AliITSgeom
 496     // to values appropreate to this specific geometry. Now that
 497     // the segmentation is part of AliITSgeom, the detector
 498     // segmentations are also defined here.
 499     // Inputs:
 500     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 501     // Outputs:
 502     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 503     // Return:
 504     //   none.
 505     const Int_t knlayers=5;
 506     //   const Int_t kndeep=6;
 507     const Int_t kltypess=3;
 508     const AliITSDetector kIdet[knlayers]={kND,kSSD,kND};
 509     const TString knames[kltypess]={
 510         "/ALIC_1/ITSV_1/ITSA_%d/ITSS_1",
 511         "/ALIC_1/ITSV_1/IGAR_%d/IAIR_1/ITST_1",
 512         "/ALIC_1/ITSV_1/IFRA_%d/IFRS_1"};
 513     const Int_t kitsGeomTreeCopys[kltypess]={3,1,1};
 514     const Int_t kitsGeomDetTypes[kltypess]={1,2,3};
 515     const Int_t knp=384;
 516     const Float_t kpitch=50.E-4;//cm
 517     Bool_t initSeg[3]={kFALSE, kFALSE, kFALSE};
 518     Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
 519     Int_t nlad[knlayers]={knlayers*1};
 520     Int_t ndet[knlayers]={knlayers*1};
 521     Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
 522     TString path,shapeName;
 523     TGeoHMatrix matrix;
 524     Double_t trans[3]={3*0.0},rot[10]={10*0.0};
 525     TArrayD shapePar;
 526     TArrayF shapeParF;
 527     Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
 528
 529     geom->Init(0,knlayers,nlad,ndet,mod);
 530     p[0]=-box[0];
 531     n[0]=box[0];
 532     // Fill in anode and cathode strip locations (lower edge)
 533     for(i=1;i<knp;i++){
 534         p[i] =p[i-1]+kpitch;
 535         n[i] =n[i-1]-kpitch;
 536     } // end for i
 537     p[knp]=box[0];
 538     n[knp]=-box[0];
 539     for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
 540         DecodeDetector(mod,kitsGeomDetTypes[i],cp0,1,0);
 541         DecodeDetectorLayers(mod,lay,lad,det);
 542         path.Form(knames[i].Data(),cp0);
 543         GetTransformation(path.Data(),matrix);
 544         GetShape(path.Data(),shapeName,shapePar);
 545         shapeParF.Set(shapePar.GetSize());
 546         for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
 547         geom->CreateMatrix(mod,lay,lad,det,kIdet[i],trans,rot);
 548         geom->SetTrans(mod,matrix.GetTranslation());
 549         geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 550         geom->GetGeomMatrix(mod)->SetPath(path.Data());
 551         switch (kIdet[i]){
 552         case kSSD:if(!(geom->IsShapeDefined((Int_t)kSSD))){
 553             InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
 554             isShapeDefined[i]=kTRUE;
 555         } break;
 556         default:{} break;
 557         } // end switch
 558     } // end for i,cp0
 559
 560     return kTRUE;
 561 }
 562 //______________________________________________________________________
 563 Bool_t AliITSInitGeometry::InitAliITSgeomITS04(AliITSgeom *geom) const{
 564     // Initilizes the geometry transformation class AliITSgeom
 565     // to values appropreate to this specific geometry. Now that
 566     // the segmentation is part of AliITSgeom, the detector
 567     // segmentations are also defined here.
 568     // Inputs:
 569     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 570     // Outputs:
 571     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 572     // Return:
 573     //   none.
 574
 575   // We can not use AliITSvBeamTestITS04::fgk... data members because
 576   // AliITSInitGeometry is part of the base library while AliITSvBeamTestITS04
 577   // is part of the simulation library. This would introduce a dependance
 578   // between the 2 libraries
 579
 580
 581     const Int_t knlayers = 6;
 582     Int_t nlad[knlayers], ndet[knlayers];
 583
 584     nlad[0] = 1; ndet[0] = 2;
 585     nlad[1] = 1; ndet[1] = 2;
 586     nlad[2] = 1; ndet[2] = 1;
 587     nlad[3] = 1; ndet[3] = 1;
 588     nlad[4] = 1; ndet[4] = 2;
 589     nlad[5] = 1; ndet[5] = 2;
 590
 591     Int_t nModTot = 10;
 592     geom->Init(0,knlayers,nlad,ndet,nModTot);
 593
 594     /*
 595     //=== Set default shapes
 596     const Float_t kDxyzSPD[] = {AliITSvBeamTestITS04::fgkSPDwidthSens/2,
 597                                 AliITSvBeamTestITS04::fgkSPDthickSens/2,
 598                                 AliITSvBeamTestITS04::fgkSPDlengthSens/2};
 599     if(!(geom->IsShapeDefined(kSPD)))
 600        geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
 601
 602     const Float_t kDxyzSDD[] = {AliITSvBeamTestITS04::fgkSDDwidthSens/2.,
 603                                 AliITSvBeamTestITS04::fgkSDDthickSens/2.,
 604                                 AliITSvBeamTestITS04::fgkSDDlengthSens/2.};
 605     if(!(geom->IsShapeDefined(kSDD)))
 606         geom->ReSetShape(kSDD, new AliITSgeomSDD256(3,(Float_t *)kDxyzSDD));
 607
 608     const Float_t kDxyzSSD[] = {AliITSvBeamTestITS04::fgkSSDlengthSens/2,
 609                                 AliITSvBeamTestITS04::fgkSSDthickSens/2,
 610                                 AliITSvBeamTestITS04::fgkSSDwidthSens/2};
 611     if(!(geom->IsShapeDefined(kSSD)))
 612        geom->ReSetShape(kSSD,new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
 613
 614     // Creating the matrices in AliITSgeom for each sensitive volume
 615     // (like in AliITSv11GeometrySDD) mln
 616     // Here, each layer is one detector
 617
 618     char layerName[30];
 619     Int_t startMod = 0,mod;
 620     TGeoVolume *itsmotherVolume = gGeoManager->GetVolume("ITSV");
 621     // SPD
 622     for (Int_t i=0; i<4;i++) {
 623         sprintf(layerName, "ITSspdWafer_%i",i+1);
 624         TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
 625         if (layNode) {
 626             TGeoHMatrix layMatrix(*layNode->GetMatrix());
 627             Double_t *trans  = layMatrix.GetTranslation();
 628             Double_t *r      = layMatrix.GetRotationMatrix();
 629             Double_t rot[10] = {r[0],r[1],r[2],
 630                                 r[3],r[4],r[5],
 631                                 r[6],r[7],r[8], 1.0};
 632             Int_t iDet = 1;
 633             Int_t iLad = 1;
 634             Int_t iLay = 1;
 635             DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
 636             DecodeDetectorLayers(mod,iLay,iLad,iDet);
 637             geom->CreateMatrix(startMod,iLay,iLad,iDet,kSPD,trans,rot);
 638             startMod++;
 639         };
 640     };
 641
 642     // SDD
 643     for (Int_t i=0; i<2;i++) {
 644         sprintf(layerName, "ITSsddWafer_%i",i+4+1);
 645         TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
 646         if (layNode) {
 647             TGeoHMatrix layMatrix(*layNode->GetMatrix());
 648             Double_t *trans  = layMatrix.GetTranslation();
 649             Double_t *r      = layMatrix.GetRotationMatrix();
 650             Double_t rot[10] = {r[0],r[1],r[2],
 651                                 r[3],r[4],r[5],
 652                                 r[6],r[7],r[8], 1.0};
 653             Int_t iDet = 1;
 654             Int_t iLad = 1;
 655             Int_t iLay = 1;
 656             DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
 657             DecodeDetectorLayers(mod,iLay,iLad,iDet);
 658             geom->CreateMatrix(startMod,iLay,iLad,iDet,kSDD,trans,rot);
 659             startMod++;
 660         };
 661     };
 662
 663     // SSD
 664     for (Int_t i=0; i<4;i++) {
 665         sprintf(layerName, "ITSssdWafer_%i",i+4+2+1);
 666         TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
 667         if (layNode) {
 668             TGeoHMatrix layMatrix(*layNode->GetMatrix());
 669             Double_t *trans  = layMatrix.GetTranslation();
 670             Double_t *r      = layMatrix.GetRotationMatrix();
 671             Double_t rot[10] = {r[0],r[1],r[2],
 672                                 r[3],r[4],r[5],
 673                                 r[6],r[7],r[8], 1.0};
 674             Int_t iDet = 1;
 675             Int_t iLad = 1;
 676             Int_t iLay = 5;
 677             DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
 678             DecodeDetectorLayers(mod,iLay,iLad,iDet);
 679             geom->CreateMatrix(startMod,iLay,iLad,iDet,kSSD,trans,rot);
 680             startMod++;
 681         };
 682     };
 683
 684     return kTRUE;
 685   */
 686     return kFALSE;
 687 }
 688 //______________________________________________________________________
 689 Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
 690     // Initilizes the geometry transformation class AliITSgeom
 691     // to values appropreate to this specific geometry. Now that
 692     // the segmentation is part of AliITSgeom, the detector
 693     // segmentations are also defined here.
 694     // Inputs:
 695     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 696     // Outputs:
 697     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 698     // Return:
 699     //   none.
 700   //    const Double_t kcm2micron = 1.0E4;
 701     const Int_t kItype=0; // Type of transormation defined 0=> Geant
 702     const Int_t klayers = 6; // number of layers in the ITS
 703     const Int_t kladders[klayers]   = {20,40,14,22,34,38}; // Number of ladders
 704     const Int_t kdetectors[klayers] = {4,4,6,8,22,25};// number of detector/lad
 705     const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
 706     const TString kPathbase = "/ALIC_1/ITSV_1/ITSD_1/";
 707     const TString kNames[2][klayers] = {
 708         {"%sIT12_1/I12A_%d/I10A_%d/I103_%d/I101_1/ITS1_1", // lay=1
 709          "%sIT12_1/I12A_%d/I20A_%d/I1D3_%d/I1D1_1/ITS2_1", // lay=2
 710          "%sIT34_1/I004_%d/I302_%d/ITS3_%d/", // lay=3
 711          "%sIT34_1/I005_%d/I402_%d/ITS4_%d/", // lay=4
 712          "%sIT56_1/I565_%d/I562_%d/ITS5_%d/", // lay=5
 713          "%sIT56_1/I569_%d/I566_%d/ITS6_%d/"},// lay=6
 714 //      {"%sIT12_1/I12B_%d/I10B_%d/I107_%d/I101_1/ITS1_1", // lay=1
 715 //       "%sIT12_1/I12B_%d/I20B_%d/I1D7_%d/I1D1_1/ITS2_1", // lay=2
 716         {"%sIT12_1/I12B_%d/I10B_%d/L1H-STAVE%d_1/I107_%d/I101_1/ITS1_1", // lay=1
 717          "%sIT12_1/I12B_%d/I20B_%d/L2H-STAVE%d_1/I1D7_%d/I1D1_1/ITS2_1", // lay=2
 718          "%sIT34_1/I004_%d/I302_%d/ITS3_%d", // lay=3
 719          "%sIT34_1/I005_%d/I402_%d/ITS4_%d", // lay=4
 720          "%sIT56_1/I565_%d/I562_%d/ITS5_%d", // lay=5
 721          "%sIT56_1/I569_%d/I566_%d/ITS6_%d"}};// Lay=6
 722     /*
 723       Int_t itsGeomTreeCopys[knlayers][3]= {{10, 2, 4},// lay=1
 724       {10, 4, 4},// lay=2
 725       {14, 6, 1},// lay=3
 726       {22, 8, 1},// lay=4
 727       {34,22, 1},// lay=5
 728       {38,25, 1}};//lay=6
 729     */
 730     Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2, cpnHS;
 731     Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
 732     TArrayD shapePar;
 733     TString path,shapeName;
 734     TGeoHMatrix matrix;
 735     Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
 736     TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
 737
 738     if(fTiming) time->Start();
 739     for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
 740     geom->Init(kItype,klayers,kladders,kdetectors,nmods);
 741     for(mod=0;mod<nmods;mod++){
 742         DecodeDetectorLayers(mod,lay,lad,det); // Write
 743         geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
 744         RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
 745
 746         if (kIdet[lay-1]==kSPD) { // we need 1 more copy number because of the half-stave
 747           if (det<3) cpnHS = 0; else cpnHS = 1;
 748           path.Form(kNames[fMinorVersion-1][lay-1].Data(),kPathbase.Data(),
 749                     cpn0,cpn1,cpnHS,cpn2);
 750         } else {
 751           path.Form(kNames[fMinorVersion-1][lay-1].Data(),kPathbase.Data(),
 752                     cpn0,cpn1,cpn2);
 753         };
 754 //         path.Form(kNames[fMinorVersion-1][lay-1].Data(),
 755 //                   kPathbase.Data(),cpn0,cpn1,cpn2);
 756
 757         geom->GetGeomMatrix(mod)->SetPath(path);
 758         GetTransformation(path.Data(),matrix);
 759         geom->SetTrans(mod,matrix.GetTranslation());
 760         TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
 761         geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 762         if(initSeg[kIdet[lay-1]]) continue;
 763         GetShape(path,shapeName,shapePar);
 764         if(shapeName.CompareTo("BOX")){
 765           Error("InitITSgeomPPRasymmFMD",
 766                 "Geometry changed without proper code update or error "
 767                 "in reading geometry. Shape is not BOX. Shape is %s",
 768                 shapeName.Data());
 769           return kFALSE;
 770         } // end if
 771         InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
 772     } // end for module
 773     if(fTiming){
 774         time->Stop();
 775         time->Print();
 776         delete time;
 777     } // end if
 778     return kTRUE;
 779 }
 780 //______________________________________________________________________
 781 Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){
 782     // Initilizes the geometry transformation class AliITSgeom
 783     // to values appropreate to this specific geometry. Now that
 784     // the segmentation is part of AliITSgeom, the detector
 785     // segmentations are also defined here.
 786     // Inputs:
 787     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 788     // Outputs:
 789     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 790     // Return:
 791     //   none.
 792
 793   const Int_t kItype  = 0; // Type of transformation defined 0=> Geant
 794   const Int_t klayers = 6; // number of layers in the ITS
 795   const Int_t kladders[klayers]   = {20,40,14,22,34,38}; // Number of ladders
 796   const Int_t kdetectors[klayers] = {4,4,6,8,22,25};// number of detector/lad
 797   const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
 798   const TString kPathbase = "/ALIC_1/ITSV_1/";
 799
 800   char *pathSPDsens1, *pathSPDsens2;
 801   if (SPDIsTGeoNative()) {
 802     pathSPDsens1="%sITSSPDCarbonFiberSectorV_%d/ITSSPDSensitiveVirtualvolumeM0_1/LAY1_STAVE_%d/HALF-STAVE%d_1/LAY1_LADDER_%d/LAY1_SENSOR_1";
 803     pathSPDsens2="%sITSSPDCarbonFiberSectorV_%d/ITSSPDSensitiveVirtualvolumeM0_1/LAY2_STAVE_%d/HALF-STAVE%d_1/LAY2_LADDER_%d/LAY2_SENSOR_1";
 804   } else{
 805     pathSPDsens1 = "%sITSD_1/IT12_1/I12B_%d/I10B_%d/L1H-STAVE%d_1/I107_%d/I101_1/ITS1_1";
 806     pathSPDsens2 = "%sITSD_1/IT12_1/I12B_%d/I20B_%d/L2H-STAVE%d_1/I1D7_%d/I1D1_1/ITS2_1";
 807   }
 808
 809   char *pathSDDsens1, *pathSDDsens2;
 810   if (SDDIsTGeoNative()) {
 811     pathSDDsens1 = "%sITSsddLayer3_1/ITSsddLadd_%d/ITSsddSensor3_%d/ITSsddWafer3_%d/ITSsddSensitivL3_1";
 812     pathSDDsens2 = "%sITSsddLayer4_1/ITSsddLadd_%d/ITSsddSensor4_%d/ITSsddWafer4_%d/ITSsddSensitivL4_1";
 813   } else{
 814     pathSDDsens1 = "%sITSD_1/IT34_1/I004_%d/I302_%d/ITS3_%d";
 815     pathSDDsens2 = "%sITSD_1/IT34_1/I005_%d/I402_%d/ITS4_%d";
 816   }
 817
 818   char *pathSSDsens1, *pathSSDsens2;
 819   if (SSDIsTGeoNative()) {
 820     pathSSDsens1 = "%sITSssdLayer5_1/ITSssdLay5Ladd_%d/ITSsddSensor5_%d/ITSsddSensitivL5_1";
 821     pathSSDsens2 = "%sITSssdLayer6_1/ITSssdLay6Ladd_%d/ITSsddSensor6_%d/ITSsddSensitivL6_1";
 822   } else{
 823     pathSSDsens1 = "%sITSD_1/IT56_1/I565_%d/I562_%d/ITS5_%d";
 824     pathSSDsens2 = "%sITSD_1/IT56_1/I569_%d/I566_%d/ITS6_%d";
 825   }
 826
 827   const TString kNames[klayers] = {
 828     pathSPDsens1, // lay=1
 829     pathSPDsens2, // lay=2
 830     pathSDDsens1, // lay=3
 831     pathSDDsens2, // lay=4
 832     pathSSDsens1, // lay=5
 833     pathSSDsens2};// Lay=6
 834
 835   Int_t mod,nmods=0, lay, lad, det, cpn0, cpn1, cpn2, cpnHS=1;
 836   Double_t tran[3]={0.,0.,0.}, rot[10]={9*0.0,1.0};
 837   TArrayD shapePar;
 838   TString path, shapeName;
 839   TGeoHMatrix matrix;
 840   Bool_t initSeg[3]={kFALSE, kFALSE, kFALSE};
 841   TStopwatch *time = 0x0;
 842   if(fTiming) time = new TStopwatch();
 843
 844   if(fTiming) time->Start();
 845   for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
 846   geom->Init(kItype,klayers,kladders,kdetectors,nmods);
 847
 848   for(mod=0; mod<nmods; mod++) {
 849
 850     DecodeDetectorLayers(mod,lay,lad,det);
 851     geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
 852     RecodeDetectorv11Hybrid(mod,cpn0,cpn1,cpn2);
 853
 854 //     if (SPDIsTGeoNative())
 855 //       if (kIdet[lay-1]==kSPD) {
 856 //      cpn0 = lad-1;
 857 //      cpn1 = det-1;
 858 //      cpn2 = 1;
 859 //       }
 860 //     if (SDDIsTGeoNative())
 861 //       if (kIdet[lay-1]==kSDD) {
 862 //      cpn0 = lad-1;
 863 //      cpn1 = det-1;
 864 //      cpn2 = 1;
 865 //       }
 866 //     if (SSDIsTGeoNative())
 867 //       if (kIdet[lay-1]==kSSD) {
 868 //      cpn0 = lad-1;
 869 //      cpn1 = det-1;
 870 //      cpn2 = 1;
 871 //       }
 872
 873     if (kIdet[lay-1]==kSPD) { // we need 1 more copy number because of the half-stave
 874       if (det<3) cpnHS = 0; else cpnHS = 1;
 875       path.Form(kNames[lay-1].Data(),kPathbase.Data(),cpn0,cpn1,cpnHS,cpn2);
 876     } else {
 877       path.Form(kNames[lay-1].Data(),kPathbase.Data(),cpn0,cpn1,cpn2);
 878     };
 879
 880     geom->GetGeomMatrix(mod)->SetPath(path);
 881     GetTransformation(path.Data(),matrix);
 882     geom->SetTrans(mod,matrix.GetTranslation());
 883     TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
 884     geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 885     if(initSeg[kIdet[lay-1]]) continue;
 886     GetShape(path,shapeName,shapePar);
 887     if(shapeName.CompareTo("BOX")){
 888       Error("InitITSgeom","Geometry changed without proper code update"
 889             "or error in reading geometry. Shape is not BOX.");
 890       return kFALSE;
 891     } // end if
 892     InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
 893   } // end for module
 894
 895   if(fTiming){
 896     time->Stop();
 897     time->Print();
 898     delete time;
 899   } // end if
 900   return kTRUE;
 901 }
 902 //______________________________________________________________________
 903 Bool_t AliITSInitGeometry::InitAliITSgeomV11(AliITSgeom *geom){
 904   // Initilizes the geometry transformation class AliITSgeom
 905   // Now that the segmentation is part of AliITSgeom, the detector
 906   // segmentations are also defined here.
 907   //
 908   // Inputs:
 909   //   AliITSgeom *geom  A pointer to the AliITSgeom class
 910   // Outputs:
 911   //   AliITSgeom *geom  This pointer recreated and properly inilized.
 912   // LG
 913
 914
 915   const Int_t kItype=0; // Type of transormation defined 0=> Geant
 916   const Int_t klayers = 6; // number of layers in the ITS
 917   const Int_t kladders[klayers]   = {20,40,14,22,34,38}; // Number of ladders
 918   const Int_t kdetectors[klayers] = {4,4,6,8,22,25};// number of detector/lad
 919   const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
 920
 921   const TString kPathbase = "/ALIC_1/ITSV_1/";
 922   const TString kNames[klayers] =
 923     {"AliITSInitGeometry:spd missing", // lay=1
 924      "AliITSInitGeometry:spd missing", // lay=2
 925      "%sITSsddLayer3_1/ITSsddLadd_%d/ITSsddSensor_%d/ITSsddWafer_1/ITSsddSensitiv_1", // lay=3
 926      "%sITSsddLayer4_1/ITSsddLadd_%d/ITSsddSensor_%d/ITSsddWafer_1/ITSsddSensitiv_1", // lay=4
 927      "AliITSInitGeometry:ssd missing", // lay=5
 928      "AliITSInitGeometry:ssd missing"};// lay=6
 929
 930   Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2;
 931   Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
 932   TArrayD shapePar;
 933   TString path,shapeName;
 934   TGeoHMatrix matrix;
 935   Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
 936   TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
 937
 938   if(fTiming) time->Start();
 939   for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
 940
 941   geom->Init(kItype,klayers,kladders,kdetectors,nmods);
 942   for(mod=0;mod<nmods;mod++) {
 943
 944     DecodeDetectorLayers(mod,lay,lad,det); // Write
 945     geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
 946     RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
 947     path.Form(kNames[lay-1].Data(),
 948               kPathbase.Data(),cpn0,cpn1,cpn2);
 949     geom->GetGeomMatrix(mod)->SetPath(path);
 950     if (GetTransformation(path.Data(),matrix)) {
 951       geom->SetTrans(mod,matrix.GetTranslation());
 952       TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
 953       geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
 954     }
 955
 956     if(initSeg[kIdet[lay-1]]) continue;
 957     GetShape(path,shapeName,shapePar);
 958     if(shapeName.CompareTo("BOX")){
 959       Error("InitAliITSgeomV11","Geometry changed without proper code update"
 960             "or error in reading geometry. Shape is not BOX.");
 961       return kFALSE;
 962     } // end if
 963     InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
 964
 965   } // end for module
 966
 967   if(fTiming){
 968     time->Stop();
 969     time->Print();
 970     delete time;
 971   } // end if
 972   return kTRUE;
 973 }
 974
 975 //______________________________________________________________________
 976 Bool_t AliITSInitGeometry::InitGeomShapePPRasymmFMD(AliITSDetector idet,
 977                                                        Bool_t *initSeg,
 978                                                        TArrayD &shapePar,
 979                                                        AliITSgeom *geom){
 980     // Initilizes the geometry segmentation class AliITSgeomS?D, or
 981     // AliITSsegmentationS?D depending on the vaule of fSegGeom,
 982     // to values appropreate to this specific geometry. Now that
 983     // the segmentation is part of AliITSgeom, the detector
 984     // segmentations are also defined here.
 985     // Inputs:
 986     //   Int_t      lay    The layer number/name.
 987     //   AliITSgeom *geom  A pointer to the AliITSgeom class
 988     // Outputs:
 989     //   AliITSgeom *geom  This pointer recreated and properly inilized.
 990     // Return:
 991     //   none.
 992   //   const Double_t kcm2micron = 1.0E4;
 993     const Double_t kmicron2cm = 1.0E-4;
 994     Int_t i;
 995     TArrayF shapeParF;
 996
 997     shapeParF.Set(shapePar.GetSize());
 998     for(i=0;i<shapePar.GetSize();i++) shapeParF[i]=shapePar[i];
 999     switch (idet){
1000     case kSPD:{
1001         initSeg[idet] = kTRUE;
1002         AliITSgeomSPD *geomSPD = new AliITSgeomSPD425Short();
1003         Float_t bx[256],bz[280];
1004         for(i=000;i<256;i++) bx[i] =  50.0*kmicron2cm; // in x all are 50 microns.
1005         for(i=000;i<160;i++) bz[i] = 425.0*kmicron2cm; // most are 425 microns
1006         // except below
1007         for(i=160;i<280;i++) bz[i] =   0.0*kmicron2cm; // Outside of detector.
1008         bz[ 31] = bz[ 32] = 625.0*kmicron2cm; // first chip boundry
1009         bz[ 63] = bz[ 64] = 625.0*kmicron2cm; // first chip boundry
1010         bz[ 95] = bz[ 96] = 625.0*kmicron2cm; // first chip boundry
1011         bz[127] = bz[128] = 625.0*kmicron2cm; // first chip boundry
1012         bz[160] = 425.0*kmicron2cm;// Set so that there is no zero pixel size for fNz.
1013         geomSPD->ReSetBins(shapeParF[1],256,bx,160,bz);
1014         geom->ReSetShape(idet,geomSPD);
1015     }break;
1016     case kSDD:{
1017         initSeg[idet] = kTRUE;
1018         AliITSgeomSDD *geomSDD = new AliITSgeomSDD256(shapeParF.GetSize(),
1019                                                       shapeParF.GetArray());
1020         geom->ReSetShape(idet,geomSDD);
1021     }break;
1022     case kSSD:{
1023         initSeg[idet] = kTRUE;
1024         AliITSgeomSSD *geomSSD = new AliITSgeomSSD275and75(
1025             shapeParF.GetSize(),shapeParF.GetArray());
1026         geom->ReSetShape(idet,geomSSD);
1027     }break;
1028     default:{// Others, Note no kSDDp or kSSDp in this geometry.
1029         geom->ReSetShape(idet,0);
1030         Info("InitGeomShapePPRasymmFMD",
1031              "default Dx=%f Dy=%f Dz=%f default=%d",
1032              shapePar[0],shapePar[1],shapePar[2],idet);
1033     }break;
1034     } // end switch
1035     return kTRUE;
1036 }
1037 //______________________________________________________________________
1038 Bool_t AliITSInitGeometry::InitSegmentationPPRasymmFMD(AliITSDetector idet,
1039                                                        Bool_t *initSeg,
1040                                                        TArrayD &shapePar,
1041                                                        AliITSgeom *geom){
1042     // Initilizes the geometry segmentation class AliITSgeomS?D, or
1043     // AliITSsegmentationS?D depending on the vaule of fSegGeom,
1044     // to values appropreate to this specific geometry. Now that
1045     // the segmentation is part of AliITSgeom, the detector
1046     // segmentations are also defined here.
1047     // Inputs:
1048     //   Int_t      lay    The layer number/name.
1049     //   AliITSgeom *geom  A pointer to the AliITSgeom class
1050     // Outputs:
1051     //   AliITSgeom *geom  This pointer recreated and properly inilized.
1052     // Return:
1053     //   none.
1054     const Double_t kcm2micron = 1.0E4;
1055     Int_t i;
1056
1057     switch (idet){
1058     case kSPD:{
1059         initSeg[idet] = kTRUE;
1060         AliITSsegmentationSPD *segSPD = new AliITSsegmentationSPD();
1061         segSPD->SetDetSize(2.*shapePar[0]*kcm2micron, // X
1062                            2.*shapePar[2]*kcm2micron, // Z
1063                            2.*shapePar[1]*kcm2micron);// Y  Microns
1064         segSPD->SetNPads(256,160);// Number of Bins in x and z
1065         Float_t bx[256],bz[280];
1066         for(i=000;i<256;i++) bx[i] =  50.0; // in x all are 50 microns.
1067         for(i=000;i<160;i++) bz[i] = 425.0; // most are 425 microns
1068         // except below
1069         for(i=160;i<280;i++) bz[i] =   0.0; // Outside of detector.
1070         bz[ 31] = bz[ 32] = 625.0; // first chip boundry
1071         bz[ 63] = bz[ 64] = 625.0; // first chip boundry
1072         bz[ 95] = bz[ 96] = 625.0; // first chip boundry
1073         bz[127] = bz[128] = 625.0; // first chip boundry
1074         bz[160] = 425.0;// Set so that there is no zero pixel size for fNz.
1075         segSPD->SetBinSize(bx,bz); // Based on AliITSgeomSPD for now.
1076         geom->ReSetShape(idet,segSPD);
1077     }break;
1078     case kSDD:{
1079         initSeg[idet] = kTRUE;
1080         AliITSsegmentationSDD *segSDD = new AliITSsegmentationSDD();
1081         segSDD->SetDetSize(shapePar[0]*kcm2micron, // X
1082                            2.*shapePar[2]*kcm2micron, // Z
1083                            2.*shapePar[1]*kcm2micron);// Y  Microns
1084         segSDD->SetNPads(256,256);// Anodes, Samples
1085         geom->ReSetShape(idet,segSDD);
1086     }break;
1087     case kSSD:{
1088         initSeg[idet] = kTRUE;
1089         AliITSsegmentationSSD *segSSD = new AliITSsegmentationSSD();
1090         segSSD->SetDetSize(2.*shapePar[0]*kcm2micron, // X
1091                            2.*shapePar[2]*kcm2micron, // Z
1092                            2.*shapePar[1]*kcm2micron);// Y  Microns.
1093         segSSD->SetPadSize(95.,0.); // strip x pitch in microns
1094         segSSD->SetNPads(768,2); // number of strips on each side, sides.
1095         segSSD->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
1096         segSSD->SetAnglesLay5(0.0075,0.0275);//strip angels rad P and N
1097         segSSD->SetAnglesLay6(0.0275,0.0075);//strip angels rad P and N
1098         geom->ReSetShape(idet,segSSD);
1099     }break;
1100     default:{// Others, Note no kSDDp or kSSDp in this geometry.
1101         geom->ReSetShape(idet,0);
1102         Info("InitSegmentationPPRasymmFMD",
1103              "default segmentation Dx=%f Dy=%f Dz=%f default=%d",
1104              shapePar[0],shapePar[1],shapePar[2],idet);
1105     }break;
1106     } // end switch
1107     return kTRUE;
1108 }
1109 //______________________________________________________________________
1110 Bool_t AliITSInitGeometry::GetTransformation(const TString &volumePath,
1111                                              TGeoHMatrix &mat){
1112     // Returns the Transformation matrix between the volume specified
1113     // by the path volumePath and the Top or mater volume. The format
1114     // of the path volumePath is as follows (assuming ALIC is the Top volume)
1115     // "/ALIC_1/DDIP_1/S05I_2/S05H_1/S05G_3". Here ALIC is the top most
1116     // or master volume which has only 1 instance of. Of all of the daughter
1117     // volumes of ALICE, DDIP volume copy #1 is indicated. Similarly for
1118     // the daughter volume of DDIP is S05I copy #2 and so on.
1119     // Inputs:
1120     //   TString& volumePath  The volume path to the specific volume
1121     //                        for which you want the matrix. Volume name
1122     //                        hierarchy is separated by "/" while the
1123     //                        copy number is appended using a "_".
1124     // Outputs:
1125     //  TGeoHMatrix &mat      A matrix with its values set to those
1126     //                        appropriate to the Local to Master transformation
1127     // Return:
1128     //   A logical value if kFALSE then an error occurred and no change to
1129     //   mat was made.
1130
1131     // We have to preserve the modeler state
1132
1133     // Preserve the modeler state.
1134     gGeoManager->PushPath();
1135     if (!gGeoManager->cd(volumePath.Data())) {
1136       gGeoManager->PopPath();
1137       Error("GetTransformation","Error in cd-ing to ",volumePath.Data());
1138       return kFALSE;
1139     } // end if !gGeoManager
1140     mat = *gGeoManager->GetCurrentMatrix();
1141     // Retstore the modeler state.
1142     gGeoManager->PopPath();
1143     return kTRUE;
1144 }
1145 //______________________________________________________________________
1146 Bool_t AliITSInitGeometry::GetShape(const TString &volumePath,
1147                                     TString &shapeType,TArrayD &par){
1148     // Returns the shape and its parameters for the volume specified
1149     // by volumeName.
1150     // Inputs:
1151     //   TString& volumeName  The volume name
1152     // Outputs:
1153     //   TString &shapeType   Shape type
1154     //   TArrayD &par         A TArrayD of parameters with all of the
1155     //                        parameters of the specified shape.
1156     // Return:
1157     //   A logical indicating whether there was an error in getting this
1158     //   information
1159     Int_t npar;
1160     gGeoManager->PushPath();
1161     if (!gGeoManager->cd(volumePath.Data())) {
1162         gGeoManager->PopPath();
1163         return kFALSE;
1164     }
1165     TGeoVolume * vol = gGeoManager->GetCurrentVolume();
1166     gGeoManager->PopPath();
1167     if (!vol) return kFALSE;
1168     TGeoShape *shape = vol->GetShape();
1169     TClass *classType = shape->IsA();
1170     if (classType==TGeoBBox::Class()) {
1171         shapeType = "BOX";
1172         npar = 3;
1173         par.Set(npar);
1174         TGeoBBox *box = (TGeoBBox*)shape;
1175         par.AddAt(box->GetDX(),0);
1176         par.AddAt(box->GetDY(),1);
1177         par.AddAt(box->GetDZ(),2);
1178         return kTRUE;
1179     } // end if
1180     if (classType==TGeoTrd1::Class()) {
1181         shapeType = "TRD1";
1182         npar = 4;
1183         par.Set(npar);
1184         TGeoTrd1 *trd1 = (TGeoTrd1*)shape;
1185         par.AddAt(trd1->GetDx1(),0);
1186         par.AddAt(trd1->GetDx2(),1);
1187         par.AddAt(trd1->GetDy(), 2);
1188         par.AddAt(trd1->GetDz(), 3);
1189         return kTRUE;
1190     } // end if
1191     if (classType==TGeoTrd2::Class()) {
1192         shapeType = "TRD2";
1193         npar = 5;
1194         par.Set(npar);
1195         TGeoTrd2 *trd2 = (TGeoTrd2*)shape;
1196         par.AddAt(trd2->GetDx1(),0);
1197         par.AddAt(trd2->GetDx2(),1);
1198         par.AddAt(trd2->GetDy1(),2);
1199         par.AddAt(trd2->GetDy2(),3);
1200         par.AddAt(trd2->GetDz(), 4);
1201         return kTRUE;
1202     } // end if
1203     if (classType==TGeoTrap::Class()) {
1204         shapeType = "TRAP";
1205         npar = 11;
1206         par.Set(npar);
1207         TGeoTrap *trap = (TGeoTrap*)shape;
1208         Double_t tth = TMath::Tan(trap->GetTheta()*TMath::DegToRad());
1209         par.AddAt(trap->GetDz(),0);
1210         par.AddAt(tth*TMath::Cos(trap->GetPhi()*TMath::DegToRad()),1);
1211         par.AddAt(tth*TMath::Sin(trap->GetPhi()*TMath::DegToRad()),2);
1212         par.AddAt(trap->GetH1(),3);
1213         par.AddAt(trap->GetBl1(),4);
1214         par.AddAt(trap->GetTl1(),5);
1215         par.AddAt(TMath::Tan(trap->GetAlpha1()*TMath::DegToRad()),6);
1216         par.AddAt(trap->GetH2(),7);
1217         par.AddAt(trap->GetBl2(),8);
1218         par.AddAt(trap->GetTl2(),9);
1219         par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
1220         return kTRUE;
1221     } // end if
1222     if (classType==TGeoTube::Class()) {
1223         shapeType = "TUBE";
1224         npar = 3;
1225         par.Set(npar);
1226         TGeoTube *tube = (TGeoTube*)shape;
1227         par.AddAt(tube->GetRmin(),0);
1228         par.AddAt(tube->GetRmax(),1);
1229         par.AddAt(tube->GetDz(),2);
1230         return kTRUE;
1231     } // end if
1232     if (classType==TGeoTubeSeg::Class()) {
1233         shapeType = "TUBS";
1234         npar = 5;
1235         par.Set(npar);
1236         TGeoTubeSeg *tubs = (TGeoTubeSeg*)shape;
1237         par.AddAt(tubs->GetRmin(),0);
1238         par.AddAt(tubs->GetRmax(),1);
1239         par.AddAt(tubs->GetDz(),2);
1240         par.AddAt(tubs->GetPhi1(),3);
1241         par.AddAt(tubs->GetPhi2(),4);
1242         return kTRUE;
1243     } // end if
1244     if (classType==TGeoCone::Class()) {
1245         shapeType = "CONE";
1246         npar = 5;
1247         par.Set(npar);
1248         TGeoCone *cone = (TGeoCone*)shape;
1249         par.AddAt(cone->GetDz(),0);
1250         par.AddAt(cone->GetRmin1(),1);
1251         par.AddAt(cone->GetRmax1(),2);
1252         par.AddAt(cone->GetRmin2(),3);
1253         par.AddAt(cone->GetRmax2(),4);
1254         return kTRUE;
1255     } // end if
1256     if (classType==TGeoConeSeg::Class()) {
1257         shapeType = "CONS";
1258         npar = 7;
1259         par.Set(npar);
1260         TGeoConeSeg *cons = (TGeoConeSeg*)shape;
1261         par.AddAt(cons->GetDz(),0);
1262         par.AddAt(cons->GetRmin1(),1);
1263         par.AddAt(cons->GetRmax1(),2);
1264         par.AddAt(cons->GetRmin2(),3);
1265         par.AddAt(cons->GetRmax2(),4);
1266         par.AddAt(cons->GetPhi1(),5);
1267         par.AddAt(cons->GetPhi2(),6);
1268         return kTRUE;
1269     } // end if
1270     if (classType==TGeoSphere::Class()) {
1271         shapeType = "SPHE";
1272         npar = 6;
1273         par.Set(npar);
1274
1275         TGeoSphere *sphe = (TGeoSphere*)shape;
1276         par.AddAt(sphe->GetRmin(),0);
1277         par.AddAt(sphe->GetRmax(),1);
1278         par.AddAt(sphe->GetTheta1(),2);
1279         par.AddAt(sphe->GetTheta2(),3);
1280         par.AddAt(sphe->GetPhi1(),4);
1281         par.AddAt(sphe->GetPhi2(),5);
1282         return kTRUE;
1283     } // end if
1284     if (classType==TGeoPara::Class()) {
1285         shapeType = "PARA";
1286         npar = 6;
1287         par.Set(npar);
1288         TGeoPara *para = (TGeoPara*)shape;
1289         par.AddAt(para->GetX(),0);
1290         par.AddAt(para->GetY(),1);
1291         par.AddAt(para->GetZ(),2);
1292         par.AddAt(para->GetTxy(),3);
1293         par.AddAt(para->GetTxz(),4);
1294         par.AddAt(para->GetTyz(),5);
1295         return kTRUE;
1296     } // end if
1297     if (classType==TGeoPgon::Class()) {
1298         shapeType = "PGON";
1299         TGeoPgon *pgon = (TGeoPgon*)shape;
1300         Int_t nz = pgon->GetNz();
1301         const Double_t *rmin = pgon->GetRmin();
1302         const Double_t *rmax = pgon->GetRmax();
1303         const Double_t *z = pgon->GetZ();
1304         npar = 4 + 3*nz;
1305         par.Set(npar);
1306         par.AddAt(pgon->GetPhi1(),0);
1307         par.AddAt(pgon->GetDphi(),1);
1308         par.AddAt(pgon->GetNedges(),2);
1309         par.AddAt(pgon->GetNz(),3);
1310         for (Int_t i=0; i<nz; i++) {
1311             par.AddAt(z[i], 4+3*i);
1312             par.AddAt(rmin[i], 4+3*i+1);
1313             par.AddAt(rmax[i], 4+3*i+2);
1314         }
1315         return kTRUE;
1316     } // end if
1317     if (classType==TGeoPcon::Class()) {
1318         shapeType = "PCON";
1319         TGeoPcon *pcon = (TGeoPcon*)shape;
1320         Int_t nz = pcon->GetNz();
1321         const Double_t *rmin = pcon->GetRmin();
1322         const Double_t *rmax = pcon->GetRmax();
1323         const Double_t *z = pcon->GetZ();
1324         npar = 3 + 3*nz;
1325         par.Set(npar);
1326         par.AddAt(pcon->GetPhi1(),0);
1327         par.AddAt(pcon->GetDphi(),1);
1328         par.AddAt(pcon->GetNz(),2);
1329         for (Int_t i=0; i<nz; i++) {
1330             par.AddAt(z[i], 3+3*i);
1331
1332             par.AddAt(rmin[i], 3+3*i+1);
1333             par.AddAt(rmax[i], 3+3*i+2);
1334         }
1335         return kTRUE;
1336     } // end if
1337     if (classType==TGeoEltu::Class()) {
1338         shapeType = "ELTU";
1339         npar = 3;
1340         par.Set(npar);
1341         TGeoEltu *eltu = (TGeoEltu*)shape;
1342         par.AddAt(eltu->GetA(),0);
1343         par.AddAt(eltu->GetB(),1);
1344         par.AddAt(eltu->GetDz(),2);
1345         return kTRUE;
1346     } // end if
1347     if (classType==TGeoHype::Class()) {
1348         shapeType = "HYPE";
1349         npar = 5;
1350         par.Set(npar);
1351         TGeoHype *hype = (TGeoHype*)shape;
1352         par.AddAt(TMath::Sqrt(hype->RadiusHypeSq(0.,kTRUE)),0);
1353         par.AddAt(TMath::Sqrt(hype->RadiusHypeSq(0.,kFALSE)),1);
1354         par.AddAt(hype->GetDZ(),2);
1355         par.AddAt(hype->GetStIn(),3);
1356         par.AddAt(hype->GetStOut(),4);
1357         return kTRUE;
1358     } // end if
1359     if (classType==TGeoGtra::Class()) {
1360         shapeType = "GTRA";
1361         npar = 12;
1362         par.Set(npar);
1363         TGeoGtra *trap = (TGeoGtra*)shape;
1364         Double_t tth = TMath::Tan(trap->GetTheta()*TMath::DegToRad());
1365         par.AddAt(trap->GetDz(),0);
1366         par.AddAt(tth*TMath::Cos(trap->GetPhi()*TMath::DegToRad()),1);
1367         par.AddAt(tth*TMath::Sin(trap->GetPhi()*TMath::DegToRad()),2);
1368         par.AddAt(trap->GetH1(),3);
1369         par.AddAt(trap->GetBl1(),4);
1370         par.AddAt(trap->GetTl1(),5);
1371         par.AddAt(TMath::Tan(trap->GetAlpha1()*TMath::DegToRad()),6);
1372         par.AddAt(trap->GetH2(),7);
1373         par.AddAt(trap->GetBl2(),8);
1374         par.AddAt(trap->GetTl2(),9);
1375         par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
1376         par.AddAt(trap->GetTwistAngle(),11);
1377         return kTRUE;
1378     } // end if
1379     if (classType==TGeoCtub::Class()) {
1380         shapeType = "CTUB";
1381         npar = 11;
1382         par.Set(npar);
1383         TGeoCtub *ctub = (TGeoCtub*)shape;
1384         const Double_t *lx = ctub->GetNlow();
1385         const Double_t *tx = ctub->GetNhigh();
1386         par.AddAt(ctub->GetRmin(),0);
1387         par.AddAt(ctub->GetRmax(),1);
1388         par.AddAt(ctub->GetDz(),2);
1389         par.AddAt(ctub->GetPhi1(),3);
1390         par.AddAt(ctub->GetPhi2(),4);
1391         par.AddAt(lx[0],5);
1392         par.AddAt(lx[1],6);
1393         par.AddAt(lx[2],7);
1394         par.AddAt(tx[0],8);
1395         par.AddAt(tx[1],9);
1396         par.AddAt(tx[2],10);
1397         return kTRUE;
1398     } // end if
1399     Error("GetShape","Getting shape parameters for shape %s not implemented",
1400           shape->ClassName());
1401     shapeType = "Unknown";
1402     return kFALSE;
1403 }
1404 //______________________________________________________________________
1405 void AliITSInitGeometry::DecodeDetector(
1406     Int_t &mod,Int_t layer,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
1407     // decode geometry into detector module number. There are two decoding
1408     // Scheams. Old which does not follow the ALICE coordinate system
1409     // requirements, and New which dose.
1410     // Inputs:
1411     //    Int_t layer    The ITS layer
1412     //    Int_t cpn0     The lowest copy number
1413     //    Int_t cpn1     The middle copy number
1414     //    Int_t cpn2     the highest copy number
1415     // Output:
1416     //    Int_t &mod     The module number assoicated with this set
1417     //                   of copy numbers.
1418     // Return:
1419     //    none.
1420
1421     // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't
1422     // like them but I see not better way for the moment.
1423     switch (fMajorVersion){
1424     case kvtest:{
1425         if(GetMinorVersion()==1)
1426             return DecodeDetectorvPPRasymmFMD(mod,layer,cpn0,cpn1,cpn2);
1427         else if(GetMinorVersion()==2)
1428             return DecodeDetectorvtest2(mod,layer,cpn0,cpn1,cpn2);
1429         Warning("DecodeDetector",
1430                 "Geometry is kvtest minor version=%d is not defined",
1431                 GetMinorVersion());
1432     }break;
1433     case kvDefault:{
1434         Error("DecodeDetector","Major version = kvDefault, not supported");
1435     }break;
1436     case kvSPD02:{
1437         return DecodeDetectorvSPD02(mod,layer,cpn0,cpn1,cpn2);
1438     }break;
1439     case kvSDD03:{
1440         return DecodeDetectorvSDD03(mod,layer,cpn0,cpn1,cpn2);
1441     }break;
1442     case kvSSD03:{
1443         return DecodeDetectorvSSD03(mod,layer,cpn0,cpn1,cpn2);
1444     }break;
1445     case kvITS04:{
1446         return DecodeDetectorvITS04(mod,layer,cpn0,cpn1,cpn2);
1447     }break;
1448     case kvPPRcourseasymm:{
1449         return DecodeDetectorvPPRcourseasymm(mod,layer,cpn0,cpn1,cpn2);
1450     }break;
1451     case kvPPRasymmFMD:{
1452         return DecodeDetectorvPPRasymmFMD(mod,layer,cpn0,cpn1,cpn2);
1453     }break;
1454     case kv11:{
1455         return DecodeDetectorv11(mod,layer,cpn0,cpn1,cpn2);
1456     }break;
1457     case kv11Hybrid:{
1458         return DecodeDetectorv11Hybrid(mod,layer,cpn0,cpn1,cpn2);
1459     }break;
1460     default:{
1461         Error("DecodeDetector","Major version = %d, not supported",
1462               (Int_t)fMajorVersion);
1463         return;
1464     }break;
1465     } // end switch
1466     return;
1467 }
1468 //______________________________________________________________________
1469 void AliITSInitGeometry::RecodeDetector(Int_t mod,Int_t &cpn0,
1470                                         Int_t &cpn1,Int_t &cpn2){
1471     // decode geometry into detector module number. There are two decoding
1472     // Scheams. Old which does not follow the ALICE coordinate system
1473     // requirements, and New which dose.
1474     // Inputs:
1475     //    Int_t mod      The module number assoicated with this set
1476     //                   of copy numbers.
1477     // Output:
1478     //    Int_t cpn0     The lowest copy number
1479     //    Int_t cpn1     The middle copy number
1480     //    Int_t cpn2     the highest copy number
1481     // Return:
1482     //    none.
1483
1484     // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't
1485     // like them but I see not better way for the moment.
1486     switch (fMajorVersion){
1487     case kvtest:{
1488         if(GetMinorVersion()==1)
1489             return RecodeDetectorvPPRasymmFMD(mod,cpn0,cpn1,cpn2);
1490         else if(GetMinorVersion()==2)
1491             return RecodeDetectorvtest2(mod,cpn0,cpn1,cpn2);
1492         Warning("RecodeDetector",
1493                 "Geometry is kvtest minor version=%d is not defined",
1494                 GetMinorVersion());
1495         return;
1496     }break;
1497     case kvDefault:{
1498         Error("RecodeDetector","Major version = kvDefault, not supported");
1499         return;
1500     }break;
1501     case kvSPD02:{
1502         return RecodeDetectorvSPD02(mod,cpn0,cpn1,cpn2);
1503     }break;
1504     case kvSDD03:{
1505         return RecodeDetectorvSDD03(mod,cpn0,cpn1,cpn2);
1506     }break;
1507     case kvSSD03:{
1508         return RecodeDetectorvSSD03(mod,cpn0,cpn1,cpn2);
1509     }break;
1510     case kvITS04:{
1511         return RecodeDetectorvITS04(mod,cpn0,cpn1,cpn2);
1512     }break;
1513     case kvPPRcourseasymm:{
1514         return RecodeDetectorvPPRcourseasymm(mod,cpn0,cpn1,cpn2);
1515     }break;
1516     case kvPPRasymmFMD:{
1517         return RecodeDetectorvPPRasymmFMD(mod,cpn0,cpn1,cpn2);
1518     }break;
1519     case kv11:{
1520         return RecodeDetectorv11(mod,cpn0,cpn1,cpn2);
1521     }break;
1522     case kv11Hybrid:{
1523         return RecodeDetectorv11Hybrid(mod,cpn0,cpn1,cpn2);
1524     }break;
1525     default:{
1526         Error("RecodeDetector","Major version = %d, not supported",
1527               (Int_t)fMajorVersion);
1528         return;
1529     }break;
1530     } // end switch
1531     return;
1532 }
1533 //______________________________________________________________________
1534 void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &layer,
1535                                               Int_t &lad,Int_t &det){
1536     // decode geometry into detector module number. There are two decoding
1537     // Scheams. Old which does not follow the ALICE coordinate system
1538     // requirements, and New which dose. Note, this use of layer ladder
1539     // and detector numbers are strictly for internal use of this
1540     // specific code. They do not represent the "standard" layer ladder
1541     // or detector numbering except in a very old and obsoleate sence.
1542     // Inputs:
1543     //    Int_t mod      The module number assoicated with this set
1544     //                   of copy numbers.
1545     // Output:
1546     //    Int_t lay     The layer number
1547     //    Int_t lad     The ladder number
1548     //    Int_t det     the dettector number
1549     // Return:
1550     //    none.
1551
1552     // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't
1553     // like them but I see not better way for the moment.
1554     switch (fMajorVersion) {
1555     case kvtest:{
1556         if(GetMinorVersion()==1)
1557             return DecodeDetectorLayersvPPRasymmFMD(mod,layer,lad,det);
1558         else if(GetMinorVersion()==2)
1559             return DecodeDetectorLayersvtest2(mod,layer,lad,det);
1560         Warning("DecodeDetectorLayers",
1561                 "Geometry is kvtest minor version=%d is not defined",
1562                 GetMinorVersion());
1563         return;
1564     } break;
1565     case kvDefault:{
1566         Error("DecodeDetectorLayers",
1567               "Major version = kvDefault, not supported");
1568         return;
1569     }break;
1570     case kvSPD02:{
1571         return DecodeDetectorLayersvSPD02(mod,layer,lad,det);
1572     }break;
1573     case kvSDD03:{
1574         return DecodeDetectorLayersvSDD03(mod,layer,lad,det);
1575     }break;
1576     case kvSSD03:{
1577         return DecodeDetectorLayersvSSD03(mod,layer,lad,det);
1578     }break;
1579     case kvITS04:{
1580         return DecodeDetectorLayersvITS04(mod,layer,lad,det);
1581     }break;
1582     case kvPPRcourseasymm:{
1583         return DecodeDetectorLayersvPPRcourseasymm(mod,layer,lad,det);
1584     }break;
1585     case kvPPRasymmFMD:{
1586         return DecodeDetectorLayersvPPRasymmFMD(mod,layer,lad,det);
1587     }break;
1588     case kv11:{
1589         return DecodeDetectorLayersv11(mod,layer,lad,det);
1590     }break;
1591     case kv11Hybrid:{
1592         return DecodeDetectorLayersv11Hybrid(mod,layer,lad,det);
1593     }break;
1594     default:{
1595         Error("DecodeDetectorLayers","Major version = %d, not supported",
1596               (Int_t)fMajorVersion);
1597         return;
1598     }break;
1599     } // end switch
1600     return;
1601 }
1602 //______________________________________________________________________
1603 void AliITSInitGeometry::DecodeDetectorvSPD02(
1604     Int_t &mod,Int_t ncpn,Int_t cpy0,Int_t cpy1,Int_t cpy2) const {
1605     // decode geometry into detector module number
1606     // Inputs:
1607     //    Int_t ncpn     The Number of copies of this volume
1608     //    Int_t cpy0     The lowest copy number
1609     //    Int_t cpy1     The middle copy number
1610     //    Int_t cpy2     the highest copy number
1611     // Output:
1612     //    Int_t &mod     The module number assoicated with this set
1613     //                   of copy numbers.
1614     // Return:
1615     //    none.
1616
1617     // detector = ladder = 1
1618     if(ncpn==4 && cpy1>2) mod = cpy1; // layer = 1,2
1619     else mod = cpy1-1; // layer = 4,5
1620     if(ncpn==1) mod = 2; // layer=3
1621     cpy0 = cpy2;
1622     return;
1623 }
1624 //______________________________________________________________________
1625 void AliITSInitGeometry::RecodeDetectorvSPD02(Int_t mod,Int_t &cpn0,
1626                                         Int_t &cpn1,Int_t &cpn2) const {
1627     // decode geometry into detector module number. There are two decoding
1628     // Scheams. Old which does not follow the ALICE coordinate system
1629     // requirements, and New which dose.
1630     // Inputs:
1631     //    Int_t mod      The module number assoicated with this set
1632     //                   of copy numbers.
1633     // Output:
1634     //    Int_t cpn0     The lowest copy number
1635     //    Int_t cpn1     The middle copy number
1636     //    Int_t cpn2     the highest copy number
1637     // Return:
1638     //    none.
1639
1640     cpn2 = 0;
1641     if(mod==2){
1642         cpn0 = 1;
1643         cpn1 = 1;
1644         return;
1645     } else if(mod<2){
1646         cpn0 = 1;
1647         cpn1 = mod+1;
1648     }else{
1649         cpn0 = 1;
1650         cpn1 = mod;
1651     } // end if
1652     return;
1653 }
1654 //______________________________________________________________________
1655 void AliITSInitGeometry::DecodeDetectorLayersvSPD02(Int_t mod,Int_t &lay,
1656                                             Int_t &lad,Int_t &det) const{
1657     // decode geometry into detector module number. There are two decoding
1658     // Scheams. Old which does not follow the ALICE coordinate system
1659     // requirements, and New which dose. Note, this use of layer ladder
1660     // and detector numbers are strictly for internal use of this
1661     // specific code. They do not represent the "standard" layer ladder
1662     // or detector numbering except in a very old and obsoleate sence.
1663     // Inputs:
1664     //    Int_t mod      The module number assoicated with this set
1665     //                   of copy numbers.
1666     // Output:
1667     //    Int_t lay     The layer number
1668     //    Int_t lad     The ladder number
1669     //    Int_t det     the dettector number
1670     // Return:
1671     //    none.
1672
1673     lay = mod+1;
1674     lad = det = 1;
1675     return;
1676 }
1677 //______________________________________________________________________
1678 void AliITSInitGeometry::DecodeDetectorvSDD03(
1679     Int_t &mod,Int_t ncpys,Int_t cpy0,Int_t cpy1,Int_t cpy2) const {
1680     // decode geometry into detector module number. There are two decoding
1681     // Scheams. Old which does not follow the ALICE coordinate system
1682     // requirements, and New which dose.
1683     // Inputs:
1684     //    Int_t ncpys    The number of posible copies cpn1
1685     //    Int_t cpy0     The lowest copy number
1686     //    Int_t cpy1     The middle copy number
1687     //    Int_t cpy2     the highest copy number
1688     // Output:
1689     //    Int_t &mod     The module number assoicated with this set
1690     //                   of copy numbers.
1691     // Return:
1692     //    none.
1693
1694     if(ncpys==10){ // ITEL detectors
1695         if(cpy1>4) mod = cpy1+1;
1696         else mod = cpy1-1;
1697     }else{ // IDET detectors
1698         if(cpy1==1) mod = 4;
1699         else mod = 5;
1700     } // end if
1701     cpy0=cpy2;
1702     return;
1703 }
1704 //______________________________________________________________________
1705 void AliITSInitGeometry::RecodeDetectorvSDD03(Int_t mod,Int_t &cpn0,
1706                                         Int_t &cpn1,Int_t &cpn2) const{
1707     // decode geometry into detector module number. There are two decoding
1708     // Scheams. Old which does not follow the ALICE coordinate system
1709     // requirements, and New which dose.
1710     // Inputs:
1711     //    Int_t mod      The module number assoicated with this set
1712     //                   of copy numbers.
1713     // Output:
1714     //    Int_t cpn0     The lowest copy number
1715     //    Int_t cpn1     The middle copy number
1716     //    Int_t cpn2     the highest copy number
1717     // Return:
1718     //    none.
1719
1720     cpn0 = 1;
1721     cpn2 = 0;
1722     if(mod<4) cpn1 = mod+1;
1723     else if(mod==4||mod==5) cpn1 = mod-3;
1724     else cpn1 = mod-1;
1725     return;
1726 }
1727 //______________________________________________________________________
1728 void AliITSInitGeometry::DecodeDetectorLayersvSDD03(Int_t mod,Int_t &lay,
1729                                                  Int_t &lad,Int_t &det) const{
1730     // decode geometry into detector module number. There are two decoding
1731     // Scheams. Old which does not follow the ALICE coordinate system
1732     // requirements, and New which dose. Note, this use of layer ladder
1733     // and detector numbers are strictly for internal use of this
1734     // specific code. They do not represent the "standard" layer ladder
1735     // or detector numbering except in a very old and obsoleate sence.
1736     // Inputs:
1737     //    Int_t mod      The module number assoicated with this set
1738     //                   of copy numbers.
1739     // Output:
1740     //    Int_t lay     The layer number
1741     //    Int_t lad     The ladder number
1742     //    Int_t det     the dettector number
1743     // Return:
1744     //    none.
1745
1746     lad = det = 1;
1747     lay = mod+1;
1748     return;
1749 }
1750 //______________________________________________________________________
1751 void AliITSInitGeometry::DecodeDetectorvSSD03(
1752     Int_t &mod,Int_t dtype,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
1753     // decode geometry into detector module number. There are two decoding
1754     // Scheams. Old which does not follow the ALICE coordinate system
1755     // requirements, and New which dose.
1756     // Inputs:
1757     //    Int_t dtype    The detector type 1=ITSA 2=IGAR 3=IFRA
1758     //    Int_t cpn0     The lowest copy number
1759     //    Int_t cpn1     The middle copy number
1760     //    Int_t cpn2     the highest copy number
1761     // Output:
1762     //    Int_t &mod     The module number assoicated with this set
1763     //                   of copy numbers.
1764     // Return:
1765     //    none.
1766
1767     if(dtype==2){mod=2; return;}
1768     if(dtype==3){mod=3; return;}
1769     mod = cpn0-1;
1770     if(cpn0==3) mod = 4;
1771     cpn1=cpn2;
1772     return;
1773 }
1774 //______________________________________________________________________
1775 void AliITSInitGeometry::RecodeDetectorvSSD03(Int_t mod,Int_t &cpn0,
1776                                         Int_t &cpn1,Int_t &cpn2) const {
1777     // decode geometry into detector module number. There are two decoding
1778     // Scheams. Old which does not follow the ALICE coordinate system
1779     // requirements, and New which dose.
1780     // Inputs:
1781     //    Int_t mod      The module number assoicated with this set
1782     //                   of copy numbers.
1783     // Output:
1784     //    Int_t cpn0     The lowest copy number
1785     //    Int_t cpn1     The middle copy number
1786     //    Int_t cpn2     the highest copy number
1787     // Return:
1788     //    none.
1789
1790     cpn1=1;
1791     cpn2=0;
1792     if(mod<2) cpn0=mod+1;
1793     else if (mod==2||mod==3) cpn0=1;
1794     else cpn0 = 3;
1795     return;
1796 }
1797 //______________________________________________________________________
1798 void AliITSInitGeometry::DecodeDetectorLayersvSSD03(Int_t mod,Int_t &lay,
1799                                                 Int_t &lad,Int_t &det) const {
1800     // decode geometry into detector module number. There are two decoding
1801     // Scheams. Old which does not follow the ALICE coordinate system
1802     // requirements, and New which dose. Note, this use of layer ladder
1803     // and detector numbers are strictly for internal use of this
1804     // specific code. They do not represent the "standard" layer ladder
1805     // or detector numbering except in a very old and obsoleate sence.
1806     // Inputs:
1807     //    Int_t mod      The module number assoicated with this set
1808     //                   of copy numbers.
1809     // Output:
1810     //    Int_t lay     The layer number
1811     //    Int_t lad     The ladder number
1812     //    Int_t det     the dettector number
1813     // Return:
1814     //    none.
1815
1816     lad = det = 1;
1817     lay = mod+1;
1818     return;
1819 }
1820 //______________________________________________________________________
1821 void AliITSInitGeometry::DecodeDetectorvITS04(
1822     Int_t &mod,Int_t dtype,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
1823     // decode geometry into detector module number. There are two decoding
1824     // Scheams. Old which does not follow the ALICE coordinate system
1825     // requirements, and New which dose.
1826     // Inputs:
1827     //    Int_t dtype    The detector type 1=ITSA 2=IGAR 3=IFRA
1828     //    Int_t cpn0     The lowest copy number
1829     //    Int_t cpn1     The middle copy number
1830     //    Int_t cpn2     the highest copy number
1831     // Output:
1832     //    Int_t &mod     The module number assoicated with this set
1833     //                   of copy numbers.
1834     // Return:
1835     //    none.
1836
1837     mod = dtype-1;
1838     cpn0 = cpn1 = cpn2;
1839     return;
1840 }
1841 //______________________________________________________________________
1842 void AliITSInitGeometry::RecodeDetectorvITS04(Int_t mod,Int_t &cpn0,
1843                                         Int_t &cpn1,Int_t &cpn2) const {
1844     // decode geometry into detector module number. There are two decoding
1845     // Scheams. Old which does not follow the ALICE coordinate system
1846     // requirements, and New which dose.
1847     // Inputs:
1848     //    Int_t mod      The module number assoicated with this set
1849     //                   of copy numbers.
1850     // Output:
1851     //    Int_t cpn0     The lowest copy number
1852     //    Int_t cpn1     The middle copy number
1853     //    Int_t cpn2     the highest copy number
1854     // Return:
1855     //    none.
1856
1857     cpn1 = cpn2 = 0;
1858     switch(mod){
1859     case 0:case 1:case 2:case 3:{
1860         cpn0 = mod+1;
1861     }break;
1862     case 4: case 5:{
1863         cpn0 = mod-3;
1864     }break;
1865     case 6:case 7:case 8:case 9:{
1866         cpn0 = mod-5;
1867     } break;
1868     default:
1869         cpn0 = 0;
1870         break;
1871     }// end switch
1872     return;
1873 }
1874 //______________________________________________________________________
1875 void AliITSInitGeometry::DecodeDetectorLayersvITS04(Int_t mod,Int_t &lay,
1876                                              Int_t &lad,Int_t &det) const{
1877     // decode geometry into detector module number. There are two decoding
1878     // Scheams. Old which does not follow the ALICE coordinate system
1879     // requirements, and New which dose. Note, this use of layer ladder
1880     // and detector numbers are strictly for internal use of this
1881     // specific code. They do not represent the "standard" layer ladder
1882     // or detector numbering except in a very old and obsoleate sence.
1883     // Inputs:
1884     //    Int_t mod      The module number assoicated with this set
1885     //                   of copy numbers.
1886     // Output:
1887     //    Int_t lay     The layer number
1888     //    Int_t lad     The ladder number
1889     //    Int_t det     the dettector number
1890     // Return:
1891     //    none.
1892
1893     lad = 1;
1894     switch(mod){
1895     case 0:case 1:case 2:case 3:{
1896         lay = mod/2 +1;
1897         det = mod%2 +1;
1898     }break;
1899     case 4: case 5:{
1900         lay = mod -1;
1901     }break;
1902     case 6:case 7:case 8:case 9:{
1903         lay = mod/2 +2;
1904         det = mod%2 +1;
1905     }break;
1906     default:
1907         lay = 0;
1908         det = 0;
1909         break;
1910     } // end switch
1911     return;
1912 }
1913 //______________________________________________________________________
1914 void AliITSInitGeometry::DecodeDetectorvPPRasymmFMD(Int_t &mod,Int_t layer,Int_t cpn0,
1915                                         Int_t cpn1,Int_t cpn2) const {
1916     // decode geometry into detector module number. There are two decoding
1917     // Scheams. Old which does not follow the ALICE coordinate system
1918     // requirements, and New which dose.
1919     // Inputs:
1920     //    Int_t layer    The ITS layer
1921     //    Int_t cpn0     The lowest copy number
1922     //    Int_t cpn1     The middle copy number
1923     //    Int_t cpn2     the highest copy number
1924     // Output:
1925     //    Int_t &mod     The module number assoicated with this set
1926     //                   of copy numbers.
1927     // Return:
1928     //    none.
1929     const Int_t kDetPerLadderSPD[2]={2,4};
1930     const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
1931     const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
1932     Int_t lay=-1,lad=-1,det=-1,i;
1933
1934     if(fDecode){ // New decoding scheam
1935         switch (layer){
1936         case 1:{
1937             lay = layer;
1938             det = 5-cpn2;
1939             if(cpn0==4&&cpn1==1) lad=1;
1940             else if(cpn0==4&&cpn1==2) lad=20;
1941             else if(cpn0<4){
1942                 lad = 8-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
1943             }else{ // cpn0>4
1944                 lad = 28-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
1945             } // end if
1946         } break;
1947         case 2:{
1948             lay = layer;
1949             det = 5-cpn2;
1950             if(cpn0==4&&cpn1==1) lad=1;
1951             else if(cpn0<4){
1952                 lad = 14-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
1953             }else{ // cpn0>4
1954                 lad = 54-cpn1-kDetPerLadderSPD[layer-1]*(cpn0-1);
1955             } // end if
1956         } break;
1957         case 3:{
1958             lay = layer;
1959             if(cpn0<5) lad = 5-cpn0;
1960             else lad = 19-cpn0;
1961             det = 7-cpn1;
1962         } break;
1963         case 4:{
1964             lay = layer;
1965             if(cpn0<7) lad = 7-cpn0;
1966             else lad = 29-cpn0;
1967             det = 9-cpn1;
1968         } break;
1969         case 5:{
1970             lay = layer;
1971             if(cpn0<10) lad = 10-cpn0;
1972             else lad = 44-cpn0;
1973             det = 23-cpn1;
1974         } break;
1975         case 6:{
1976             lay = layer;
1977             if(cpn0<9) lad = 9-cpn0;
1978             else lad = 47-cpn0;
1979             det = 26-cpn1;
1980         } break;
1981         } // end switch
1982         mod = 0;
1983         for(i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
1984         mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
1985         return;
1986     } // end if
1987     // Old decoding scheam
1988     switch(layer){
1989     case 1: case 2:{
1990         lay = layer;
1991         lad = cpn1+kDetPerLadderSPD[layer-1]*(cpn0-1);
1992         det = cpn2;
1993         }break;
1994     case 3: case 4:{
1995         lay = layer;
1996         lad = cpn0;
1997         det = cpn1;
1998         }break;
1999     case 5: case 6:{
2000         lay = layer;
2001         lad = cpn0;
2002         det = cpn1;
2003         }break;
2004     default:{
2005         }break;
2006     } // end switch
2007     mod = 0;
2008     for(i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
2009     mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
2010     return;
2011 }
2012 //______________________________________________________________________
2013 void AliITSInitGeometry::RecodeDetectorvPPRasymmFMD(Int_t mod,Int_t &cpn0,
2014                                         Int_t &cpn1,Int_t &cpn2){
2015     // decode geometry into detector module number. There are two decoding
2016     // Scheams. Old which does not follow the ALICE coordinate system
2017     // requirements, and New which dose.
2018     // Inputs:
2019     //    Int_t mod      The module number assoicated with this set
2020     //                   of copy numbers.
2021     // Output:
2022     //    Int_t cpn0     The lowest copy number
2023     //    Int_t cpn1     The middle copy number
2024     //    Int_t cpn2     the highest copy number
2025     // Return:
2026     //    none.
2027     const Int_t kITSgeoTreeCopys[6][3]= {{10, 2, 4},// lay=1
2028                                          {10, 4, 4},// lay=2
2029                                          {14, 6, 1},// lay=3
2030                                          {22, 8, 1},// lay=4
2031                                          {34,22, 1},// lay=5
2032                                          {38,25, 1}};//lay=6
2033     const Int_t kDetPerLadderSPD[2]={2,4};
2034     //    const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
2035     //    const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
2036     Int_t lay,lad,det;
2037
2038     cpn0 = cpn1 = cpn2 = 0;
2039     DecodeDetectorLayers(mod,lay,lad,det);
2040     if(fDecode){ // New decoding scheam
2041         switch (lay){
2042         case 1:{
2043             cpn2 = 5-det;     // Detector 1-4
2044             cpn1 = 1+(lad-1)%kDetPerLadderSPD[lay-1];
2045             cpn0 = 5-(lad+kDetPerLadderSPD[lay-1])/kDetPerLadderSPD[lay-1];
2046             if(mod>27) cpn0 = 15-(lad+kDetPerLadderSPD[lay-1])/
2047                            kDetPerLadderSPD[lay-1];
2048         } break;
2049         case 2:{
2050             cpn2 = 5-det;     // Detector 1-4
2051             cpn1 = 4-(lad+2)%kDetPerLadderSPD[lay-1];
2052             cpn0 = 1+(14-cpn1-lad)/kDetPerLadderSPD[lay-1];
2053             if(mod>131) cpn0 = 1+(54-lad-cpn1)/kDetPerLadderSPD[lay-1];
2054         } break;
2055         case 3:{
2056             cpn2 = 1;
2057             if(lad<5) cpn0 = 5-lad;
2058             else cpn0 = 19-lad;
2059             cpn1 = 7-det;
2060         } break;
2061         case 4:{
2062             cpn2 = 1;
2063             if(lad<7) cpn0 = 7-lad;
2064             else cpn0 = 29-lad;
2065             cpn1 = 9-det;
2066         } break;
2067         case 5:{
2068             cpn2 = 1;
2069             if(lad<10) cpn0 = 10-lad;
2070             else cpn0 = 44-lad;
2071             cpn1 = 23-det;
2072         } break;
2073         case 6:{
2074             cpn2 = 1;
2075             if(lad<9) cpn0 = 9-lad;
2076             else cpn0 = 47-lad;
2077             cpn1 = 26-det;
2078         } break;
2079         default:{
2080             Error("RecodeDetector","New: mod=%d lay=%d not 1-6.");
2081             return;
2082         } break;
2083         } // end switch
2084         if(cpn0<1||cpn1<1||cpn2<1||
2085            cpn0>kITSgeoTreeCopys[lay-1][0]||
2086            cpn1>kITSgeoTreeCopys[lay-1][1]||
2087            cpn2>kITSgeoTreeCopys[lay-1][2])
2088             Error("RecodeDetector",
2089                   "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
2090                   cpn0,cpn1,cpn2,mod,lay,lad,det);
2091         return;
2092     } // end if
2093     // Old encoding
2094     switch (lay){
2095     case 1: case 2:{
2096         cpn2 = det;     // Detector 1-4
2097         cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
2098         cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
2099     } break;
2100     case 3: case 4: case 5 : case 6:{
2101         cpn2 = 1;
2102         cpn1 = det;
2103         cpn0 = lad;
2104     } break;
2105     default:{
2106         Error("RecodeDetector","Old: mod=%d lay=%d not 1-6.");
2107         return;
2108     } break;
2109     } // end switch
2110     if(cpn0<1||cpn1<1||cpn2<1||
2111        cpn0>kITSgeoTreeCopys[lay-1][0]||
2112        cpn1>kITSgeoTreeCopys[lay-1][1]||
2113        cpn2>kITSgeoTreeCopys[lay-1][2])
2114         Error("RecodeDetector",
2115               "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
2116               cpn0,cpn1,cpn2,mod,lay,lad,det);
2117     return;
2118 }
2119 //______________________________________________________________________
2120 void AliITSInitGeometry::DecodeDetectorLayersvPPRasymmFMD(Int_t mod,Int_t &lay,
2121                                               Int_t &lad,Int_t &det){
2122     // decode geometry into detector module number. There are two decoding
2123     // Scheams. Old which does not follow the ALICE coordinate system
2124     // requirements, and New which dose. Note, this use of layer ladder
2125     // and detector numbers are strictly for internal use of this
2126     // specific code. They do not represent the "standard" layer ladder
2127     // or detector numbering except in a very old and obsoleate sence.
2128     // Inputs:
2129     //    Int_t mod      The module number assoicated with this set
2130     //                   of copy numbers.
2131     // Output:
2132     //    Int_t lay     The layer number
2133     //    Int_t lad     The ladder number
2134     //    Int_t det     the dettector number
2135     // Return:
2136     //    none.
2137   //    const Int_t kDetPerLadderSPD[2]={2,4};
2138     const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
2139     const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
2140     Int_t mod2;
2141
2142     det  = 0;
2143     lad  = 0;
2144     lay  = 0;
2145     mod2 = 0;
2146     do{
2147         mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
2148         lay++;
2149     }while(mod2<=mod); // end while
2150     if(lay>6||lay<1) Error("DecodeDetectorLayers","0<lay=%d>6",lay);
2151     mod2 -= kLadPerLayer[lay-1]*kDetPerLadder[lay-1];
2152     do{
2153         lad++;
2154         mod2 += kDetPerLadder[lay-1];
2155     }while(mod2<=mod); // end while
2156     if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayers",
2157             "lad=%d>kLadPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
2158                                             kLadPerLayer[lay-1],mod,mod2);
2159     mod2 -= kDetPerLadder[lay-1];
2160     det = mod-mod2+1;
2161     if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
2162            "det=%d>detPerLayer[lay-1=%d]=%d mod=%d mod2=%d lad=%d",det,
2163                                   lay-1,kDetPerLadder[lay-1],mod,mod2,lad);
2164     return;
2165 }
2166 //______________________________________________________________________
2167 void AliITSInitGeometry::DecodeDetectorv11Hybrid(Int_t &mod,Int_t layer,Int_t cpn0,
2168                                         Int_t cpn1,Int_t cpn2) const {
2169     // decode geometry into detector module number
2170     // Inputs:
2171     //    Int_t layer    The ITS layer
2172     //    Int_t cpn0     The lowest copy number
2173     //    Int_t cpn1     The middle copy number
2174     //    Int_t cpn2     the highest copy number
2175     // Output:
2176     //    Int_t &mod     The module number assoicated with this set
2177     //                   of copy numbers.
2178     // Return:
2179     //    none.
2180   const Int_t kDetPerLadderSPD[2]={2,4};
2181   const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
2182   const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
2183   Int_t lad=-1,det=-1;
2184
2185   switch(layer) {
2186   case 1: case 2:{
2187     if (SPDIsTGeoNative()) {
2188       lad = cpn1+kDetPerLadderSPD[layer-1]*(cpn0-1)+1;
2189       det = cpn2 + 1;
2190     } else {
2191       lad = cpn1+kDetPerLadderSPD[layer-1]*(cpn0-1);
2192       det = cpn2;
2193     }
2194   } break;
2195   case 3: case 4:{
2196     if (SDDIsTGeoNative()) {
2197       lad = cpn0+1;
2198       det = cpn1+1;
2199     } else {
2200       lad = cpn0;
2201       det = cpn1;
2202     }
2203   } break;
2204   case 5: case 6:{
2205     if (SSDIsTGeoNative()) {
2206       lad = cpn0+1;
2207       det = cpn1+1;
2208     } else {
2209       lad = cpn0;
2210       det = cpn1;
2211     }
2212   } break;
2213   default:{
2214   } break;
2215   } // end switch
2216   mod = 0;
2217   for(Int_t i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
2218   mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
2219   return;
2220 }
2221
2222 /*
2223 //______________________________________________________________________
2224 void AliITSInitGeometry::RecodeDetectorv11Hybrid(Int_t mod,Int_t &cpn0,
2225                                         Int_t &cpn1,Int_t &cpn2) {
2226     // decode geometry into detector module number. There are two decoding
2227     // Scheams. Old which does not follow the ALICE coordinate system
2228     // requirements, and New which dose.
2229     // Inputs:
2230     //    Int_t mod      The module number assoicated with this set
2231     //                   of copy numbers.
2232     // Output:
2233     //    Int_t cpn0     The lowest copy number
2234     //    Int_t cpn1     The middle copy number
2235     //    Int_t cpn2     the highest copy number
2236     // Return:
2237     //    none.
2238     const Int_t kITSgeoTreeCopys[6][3]= {{10, 2, 4},// lay=1
2239                                          {10, 4, 4},// lay=2
2240                                          {14, 6, 1},// lay=3
2241                                          {22, 8, 1},// lay=4
2242                                          {34,22, 1},// lay=5
2243                                          {38,25, 1}};//lay=6
2244     const Int_t kDetPerLadderSPD[2]={2,4};
2245     Int_t lay,lad,det;
2246
2247     cpn0 = cpn1 = cpn2 = 0;
2248     DecodeDetectorLayersv11Hybrid(mod,lay,lad,det);
2249     // Old encoding
2250     switch (lay){
2251     case 1: case 2:{
2252         cpn2 = det;     // Detector 1-4
2253         cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
2254         cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
2255     } break;
2256     case 3: case 4: case 5 : case 6:{
2257         cpn2 = 1;
2258         cpn1 = det;
2259         cpn0 = lad;
2260     } break;
2261     default:{
2262         Error("RecodeDetector","Old: mod=%d lay=%d not 1-6.");
2263         return;
2264     } break;
2265     } // end switch
2266     if(cpn0<1||cpn1<1||cpn2<1||
2267        cpn0>kITSgeoTreeCopys[lay-1][0]||
2268        cpn1>kITSgeoTreeCopys[lay-1][1]||
2269        cpn2>kITSgeoTreeCopys[lay-1][2])
2270         Error("RecodeDetector",
2271               "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
2272               cpn0,cpn1,cpn2,mod,lay,lad,det);
2273     return;
2274 }
2275 */
2276
2277
2278 //______________________________________________________________________
2279 void AliITSInitGeometry::RecodeDetectorv11Hybrid(Int_t mod,Int_t &cpn0,
2280                                         Int_t &cpn1,Int_t &cpn2) {
2281     // decode geometry into detector module number. There are two decoding
2282     // Scheams. Old which does not follow the ALICE coordinate system
2283     // requirements, and New which does.
2284     // Inputs:
2285     //    Int_t mod      The module number assoicated with this set
2286     //                   of copy numbers.
2287     // Output:
2288     //    Int_t cpn0     The lowest copy number  (SPD sector or SDD/SSD ladder)
2289     //    Int_t cpn1     The middle copy number  (SPD stave or SDD/SSD module)
2290     //    Int_t cpn2     the highest copy number (SPD ladder or 1 for SDD/SSD)
2291     // Return:
2292     //    none.
2293
2294   const Int_t kDetPerLadderSPD[2]={2,4};
2295   Int_t lay,lad,det;
2296   DecodeDetectorLayersv11Hybrid(mod,lay,lad,det);
2297
2298   if (lay<3) { // SPD
2299     cpn2 = det;     // Detector 1-4
2300     cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
2301     cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
2302     if (SPDIsTGeoNative()) {
2303       cpn2--;
2304       cpn1--;
2305     }
2306   } else { // SDD and SSD
2307     cpn2 = 1;
2308     cpn1 = det;
2309     cpn0 = lad;
2310     if (lay<5) { // SDD
2311       if (SDDIsTGeoNative()) {
2312         cpn1--;
2313         cpn0--;
2314       }
2315     } else { //SSD
2316       if (SSDIsTGeoNative()) {
2317         cpn1--;
2318         cpn0--;
2319       }
2320     }
2321   }
2322 }
2323
2324
2325
2326
2327 // //______________________________________________________________________
2328 // void AliITSInitGeometry::DecodeDetectorLayersv11Hybrid(Int_t mod,Int_t &lay,
2329 //                                               Int_t &lad,Int_t &det) {
2330
2331 //     // decode module number into detector indices for v11Hybrid
2332 //     // Inputs:
2333 //     //    Int_t mod      The module number associated with this set
2334 //     //                   of copy numbers.
2335 //     // Output:
2336 //     //    Int_t lay     The layer number
2337 //     //    Int_t lad     The ladder number
2338 //     //    Int_t det     the dettector number
2339 //     // Return:
2340 //     //    none.
2341
2342 //     const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
2343 //     const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
2344 //     Int_t mod2 = 0;
2345 //     det  = 0;
2346 //     lad  = 0;
2347 //     lay  = 0;
2348
2349 //     do{
2350 //         mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
2351 //         lay++;
2352 //     } while(mod2<=mod); // end while
2353 //     if(lay>6||lay<1) Error("DecodeDetectorLayers","0<lay=%d>6",lay);
2354 //     mod2 -= kLadPerLayer[lay-1]*kDetPerLadder[lay-1];
2355 //     do{
2356 //         lad++;
2357 //         mod2 += kDetPerLadder[lay-1];
2358 //     } while(mod2<=mod); // end while
2359 //     if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayers",
2360 //             "lad=%d>kLadPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
2361 //                                             kLadPerLayer[lay-1],mod,mod2);
2362 //     mod2 -= kDetPerLadder[lay-1];
2363 //     det = mod-mod2+1;
2364 //     if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
2365 //            "det=%d>detPerLayer[lay-1=%d]=%d mod=%d mod2=%d lad=%d",det,
2366 //                                   lay-1,kDetPerLadder[lay-1],mod,mod2,lad);
2367 //     return;
2368 // }
2369
2370 //______________________________________________________________________
2371 void AliITSInitGeometry::DecodeDetectorLayersv11Hybrid(Int_t mod,Int_t &lay,
2372                                               Int_t &lad,Int_t &det) {
2373
2374   // decode module number into detector indices for v11Hybrid
2375   // mod starts from 0
2376   // lay, lad, det start from 1
2377
2378   // Inputs:
2379   //    Int_t mod      The module number associated with this set
2380   //                   of copy numbers.
2381   // Output:
2382   //    Int_t lay     The layer number
2383   //    Int_t lad     The ladder number
2384   //    Int_t det     the dettector number
2385
2386   const Int_t kDetPerLadder[6] = {4,4,6,8,22,25};
2387   const Int_t kLadPerLayer[6]  = {20,40,14,22,34,38};
2388
2389   Int_t mod2 = 0;
2390   lay  = 0;
2391
2392   do {
2393     mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
2394     lay++;
2395   } while(mod2<=mod); // end while
2396   if(lay>6) Error("DecodeDetectorLayers","lay=%d>6",lay);
2397
2398   mod2 = kLadPerLayer[lay-1]*kDetPerLadder[lay-1] - mod2+mod;
2399   lad = mod2/kDetPerLadder[lay-1];
2400
2401   if(lad>=kLadPerLayer[lay-1]||lad<0) Error("DecodeDetectorLayers",
2402                                             "lad=%d not in the correct range",lad);
2403   det = (mod2 - lad*kDetPerLadder[lay-1])+1;
2404   if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
2405                                             "det=%d not in the correct range",det);
2406   lad++;
2407 }
2408
2409 //______________________________________________________________________
2410 Bool_t AliITSInitGeometry::WriteVersionString(Char_t *str,Int_t length,
2411                         AliITSVersion_t maj,Int_t min,
2412                         const Char_t *cvsDate,const Char_t *cvsRevision)const{
2413     // fills the string str with the major and minor version number
2414     // Inputs:
2415     //   Char_t *str          The character string to hold the major
2416     //                        and minor version numbers in
2417     //   Int_t  length        The maximum number of characters which
2418     //                        can be accomidated by this string.
2419     //                        str[length-1] must exist and will be set to zero
2420     //   AliITSVersion_t maj  The major number
2421     //   Int_t           min  The minor number
2422     //   Char_t *cvsDate      The date string from cvs
2423     //   Char_t *cvsRevision  The Revision string from cvs
2424     // Outputs:
2425     //   Char_t *str          The character string holding the major and minor
2426     //                        version numbers. str[length-1] must exist
2427     //                        and will be set to zero
2428     // Return:
2429     //   kTRUE if no errors
2430     Int_t i,n,cvsDateLength,cvsRevisionLength;
2431
2432     cvsDateLength = (Int_t)strlen(cvsDate);
2433     cvsRevisionLength = (Int_t)strlen(cvsRevision);
2434     i = (Int_t)maj;
2435     n = 50+(Int_t)(TMath::Log10(TMath::Abs((Double_t)i)))+1+
2436         (Int_t)(TMath::Log10(TMath::Abs((Double_t)min)))+1
2437         +cvsDateLength-6+cvsRevisionLength-10;
2438     if(GetDebug()>1) printf("AliITSInitGeometry::WriteVersionString:"
2439                         "length=%d major=%d minor=%d cvsDate=%s[%d] "
2440                         "cvsRevision=%s[%d] n=%d\n",length,i,min,cvsDate,
2441                         cvsDateLength,cvsRevision,cvsRevisionLength,n);
2442     if(i<0) n++;
2443     if(min<0) n++;
2444     if(length<n){// not enough space to write in output string.
2445         Warning("WriteVersionString","Output string not long enough "
2446                 "lenght=%d must be at least %d long\n",length,n);
2447         return kFALSE;
2448     } // end if length<n
2449     char *cvsrevision = new char[cvsRevisionLength-10];
2450     char *cvsdate = new char[cvsDateLength-6];
2451     for(i=0;i<cvsRevisionLength-10;i++)
2452         if(10+i<cvsRevisionLength-1)
2453             cvsrevision[i] = cvsRevision[10+i]; else cvsrevision[i] = 0;
2454     for(i=0;i<cvsDateLength-6;i++) if(6+i<cvsDateLength-1)
2455         cvsdate[i] = cvsDate[6+i]; else cvsdate[i] = 0;
2456     for(i=0;i<length;i++) str[i] = 0; // zero it out for now.
2457     i = (Int_t)maj;
2458     sprintf(str,"Major Version= %d Minor Version= %d Revision: %s Date: %s",
2459             i,min,cvsrevision,cvsdate);
2460     if(GetDebug()>1)printf("AliITSInitGeometry::WriteVersionString: "
2461                        "n=%d str=%s revision[%zu] date[%zu]\n",
2462                        n,str,strlen(cvsrevision),strlen(cvsdate));
2463     delete[] cvsrevision;
2464     delete[] cvsdate;
2465     return kTRUE;
2466 }
2467 //______________________________________________________________________
2468 Bool_t AliITSInitGeometry::ReadVersionString(const Char_t *str,Int_t length,
2469                                              AliITSVersion_t &maj,Int_t &min,
2470                                              TDatime &dt)const{
2471     // fills the string str with the major and minor version number
2472     // Inputs:
2473     //   Char_t *str   The character string to holding the major and minor
2474     //                 version numbers in
2475     //   Int_t  length The maximum number of characters which can be
2476     //                 accomidated by this string. str[length-1] must exist
2477     // Outputs:
2478     //   Char_t *str   The character string holding the major and minor
2479     //                 version numbers unchanged. str[length-1] must exist.
2480     //   AliITSVersion_t maj  The major number
2481     //   Int_t           min  The minor number
2482     //   TDatime         dt   The date and time of the cvs commit
2483     // Return:
2484     //   kTRUE if no errors
2485     Bool_t ok;
2486     Char_t cvsRevision[10],cvsDate[11],cvsTime[9];
2487     Int_t i,m,n=strlen(str),year,month,day,hours,minuits,seconds;
2488
2489     if(GetDebug()>1)printf("AliITSInitGeometry::ReadVersionString:"
2490                        "str=%s length=%d\n",
2491                        str,length);
2492     if(n<35) return kFALSE; // not enough space for numbers
2493     m = sscanf(str,"Major Version= %d  Minor Version= %d Revision: %s "
2494                "Date: %s %s",&i,&min,cvsRevision,cvsDate,cvsTime);
2495     ok = m==5;
2496     if(!ok) return !ok;
2497     m = sscanf(cvsDate,"%d/%d/%d",&year,&month,&day);
2498     ok = m==3;
2499     if(!ok) return !ok;
2500     m = sscanf(cvsTime,"%d:%d:%d",&hours,&minuits,&seconds);
2501     ok = m==3;
2502     if(!ok) return !ok;
2503     dt.Set(year,month,day,hours,minuits,seconds);
2504     if(GetDebug()>1)printf("AliITSInitGeometry::ReadVersionString: i=%d min=%d "
2505                        "cvsRevision=%s cvsDate=%s cvsTime=%s m=%d\n",
2506                        i,min,cvsRevision,cvsDate,cvsTime,m);
2507     if(GetDebug()>1)printf("AliITSInitGeometry::ReadVersionString: year=%d"
2508                        " month=%d day=%d hours=%d minuits=%d seconds=%d\n",
2509                        year,month,day,hours,minuits,seconds);
2510     switch (i){
2511     case kvITS04:{
2512         maj = kvITS04;
2513     } break;
2514     case kvSPD02:{
2515         maj = kvSPD02;
2516     } break;
2517     case kvSDD03:{
2518         maj = kvSDD03;
2519     } break;
2520     case kvSSD03:{
2521         maj = kvSSD03;
2522     } break;
2523     case kvPPRasymmFMD:{
2524         maj = kvPPRasymmFMD;
2525     } break;
2526     case kv11:{
2527         maj = kv11;
2528     } break;
2529     case kv11Hybrid:{
2530         maj = kv11Hybrid;
2531     } break;
2532     default:{
2533         maj = kvDefault;
2534     } break;
2535     } // end switch
2536     return ok;
2537 }