/*
$Id$
*/
+////////////////////////////////////////////////////////////////
+// This class initializes the class AliITSgeom
+// The initialization is done starting from
+// a geometry coded by means of the ROOT geometrical modeler
+// This initialization can be used both for simulation and reconstruction
+///////////////////////////////////////////////////////////////
+
#include <TArrayD.h>
#include <TArrayF.h>
#include <TStopwatch.h>
-#include <AliITSgeomSPD.h>
-#include <AliITSgeomSDD.h>
-#include <AliITSgeomSSD.h>
-#include <AliITSsegmentationSPD.h>
-#include <AliITSsegmentationSDD.h>
-#include <AliITSsegmentationSSD.h>
#include <TGeoManager.h>
+#include <TGeoMatrix.h>
#include <TGeoVolume.h>
#include <TGeoShape.h>
#include <TGeoBBox.h>
#include <TGeoPcon.h>
#include <TGeoEltu.h>
#include <TGeoHype.h>
-#include <TClass.h>
+#include <TMath.h>
-#include <AliLog.h>
-#include "AliITSgeom.h"
+#include "AliLog.h"
+#include "AliITSsegmentationSPD.h"
+#include "AliITSsegmentationSDD.h"
+#include "AliITSsegmentationSSD.h"
#include "AliITSInitGeometry.h"
+#include <TDatime.h>
ClassImp(AliITSInitGeometry)
+
//______________________________________________________________________
AliITSInitGeometry::AliITSInitGeometry():
-TObject(),
-fName(),
-fMinorVersion(0),
-fMajorVersion(0),
-fTiming(kFALSE),
-fSegGeom(kFALSE),
-fDecode(kFALSE){
+TObject(), // Base Class
+fName(0), // Geometry name
+fMajorVersion(kvDefault), // Major versin number
+fTiming(kFALSE), // Flag to start inilization timing
+fSegGeom(kFALSE), // Flag to switch between the old use of
+ // AliITSgeomS?D class, or AliITSsegmentation
+ // class in fShape of AliITSgeom class.
+fDecode(kFALSE), // Flag for new/old decoding
+fDebug(0){ // Debug flag
// Default Creator
// Inputs:
// none.
// none.
// Return:
// A default inilized AliITSInitGeometry object
+
+ fName = "Undefined";
}
//______________________________________________________________________
-AliITSInitGeometry::AliITSInitGeometry(const Char_t *name,Int_t minorversion):
-TObject(),
-fName(name),
-fMinorVersion(minorversion),
-fMajorVersion(0),
-fTiming(kFALSE),
-fSegGeom(kFALSE),
-fDecode(kFALSE){
+AliITSInitGeometry::AliITSInitGeometry(AliITSVersion_t version):
+TObject(), // Base Class
+fName(0), // Geometry name
+fMajorVersion(version), // Major version number
+fTiming(kFALSE), // Flag to start inilization timing
+fSegGeom(kFALSE), // Flag to switch between the old use of
+ // AliITSgeomS?D class, or AliITSsegmentation
+ // class in fShape of AliITSgeom class.
+fDecode(kFALSE), // Flag for new/old decoding
+fDebug(0){ // Debug flag
// Default Creator
// Inputs:
// none.
// Return:
// A default inilized AliITSInitGeometry object
- if(fName.CompareTo("AliITSvPPRasymmFMD")==0)if(fMinorVersion==1||
- fMinorVersion==2){
- fMajorVersion=10;
- return;
- } // end if
- // if not defined geometry error
- Error("AliITSInitGeometry(name,version)"," Name must be AliITSvPPRasymmFMD"
- " and version must be 1 or 2 for now.");
- fMinorVersion = 0;
- fName = "";
- return;
+ switch (version) {
+ case kv11:
+ fName="AliITSv11";
+ break;
+ case kvDefault:
+ default:
+ AliFatal(Form("Undefined geometry: fMajorVersion=%d, ",(Int_t)fMajorVersion));
+ fName = "Undefined";
+ break;
+ } // switch
}
//______________________________________________________________________
AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(){
// A pointer to a new properly inilized AliITSgeom class. If
// pointer = 0 then failed to init.
- AliITSgeom *geom = new AliITSgeom();
- if(!InitAliITSgeom(geom)){ // Error initilization failed
- delete geom;
- geom = 0;
- } // end if
- return geom;
+
+ AliITSVersion_t version = kvDefault;
+ TDatime datetime;
+ TGeoVolume *itsV = gGeoManager->GetVolume("ITSV");
+ if(!itsV){
+ AliError("Can't find ITS volume ITSV, exiting - nothing done!");
+ return 0;
+ }// end if
+ const Char_t *title = itsV->GetTitle();
+ if(!ReadVersionString(title,version))
+ Warning("UpdateInternalGeometry","Can't read title=%s\n",title);
+ SetTiming(kFALSE);
+ SetSegGeom(kFALSE);
+ SetDecoding(kFALSE);
+ AliITSgeom *geom = CreateAliITSgeom(version);
+ AliDebug(1,"AliITSgeom object has been initialized from TGeo\n");
+ return geom;
}
//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeom(AliITSgeom *geom){
- // Initilizes the geometry transformation class AliITSgeom
+AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(Int_t major){
+ // Creates and Initilizes the geometry transformation class AliITSgeom
// to values appropreate to this specific geometry. Now that
// the segmentation is part of AliITSgeom, the detector
// segmentations are also defined here.
// Inputs:
- // AliITSgeom *geom A pointer to the AliITSgeom class
+ // Int_t major major version, see AliITSVersion_t
+ //
// Outputs:
- // AliITSgeom *geom This pointer recreated and properly inilized.
- // Return:
// none.
+ // Return:
+ // A pointer to a new properly inilized AliITSgeom class. If
+ // pointer = 0 then failed to init.
- switch(fMajorVersion){
- case 10:{ // only case defined so far
- return InitAliITSgeomPPRasymmFMD(geom);
- }break; // end case
- default:{
- Error("InitAliITSgeom","Undefine geomtery");
- return kFALSE;
- } break; // end case
+ switch(major){
+ case kv11:
+ SetGeometryName("AliITSv11");
+ SetVersion(kv11);
+ break;
+ case kvDefault:
+ default:
+ SetGeometryName("Undefined");
+ SetVersion(kvDefault);
+ break;
} // end switch
- return kFALSE;
-}
-//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
- // Initilizes the geometry transformation class AliITSgeom
- // to values appropreate to this specific geometry. Now that
- // the segmentation is part of AliITSgeom, the detector
- // segmentations are also defined here.
- // Inputs:
- // AliITSgeom *geom A pointer to the AliITSgeom class
- // Outputs:
- // AliITSgeom *geom This pointer recreated and properly inilized.
- // Return:
- // none.
- // const Double_t kcm2micron = 1.0E4;
- const Int_t kItype=0; // Type of transormation defined 0=> Geant
- const Int_t klayers = 6; // number of layers in the ITS
- const Int_t kladders[klayers] = {20,40,14,22,34,38}; // Number of ladders
- const Int_t kdetectors[klayers] = {4,4,6,8,22,25};// number of detector/lad
- const AliITSDetector idet[6] = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
- const TString pathbase = "/ALIC_1/ITSV_1/ITSD_1/";
- const TString names[2][klayers] = {
- {"%sIT12_1/I12A_%d/I10A_%d/I103_%d/I101_1/ITS1_1", // lay=1
- "%sIT12_1/I12A_%d/I20A_%d/I1D3_%d/I1D1_1/ITS2_1", // lay=2
- "%sIT34_1/I004_%d/I302_%d/ITS3_%d/", // lay=3
- "%sIT34_1/I005_%d/I402_%d/ITS4_%d/", // lay=4
- "%sIT56_1/I565_%d/I562_%d/ITS5_%d/", // lay=5
- "%sIT56_1/I569_%d/I566_%d/ITS6_%d/"},// lay=6
- {"%sIT12_1/I12B_%d/I10B_%d/I107_%d/I101_1/ITS1_1", // lay=1
- "%sIT12_1/I12B_%d/I20B_%d/I1D7_%d/I1D1_1/ITS2_1", // lay=2
- "%sIT34_1/I004_%d/I302_%d/ITS3_%d", // lay=3
- "%sIT34_1/I005_%d/I402_%d/ITS4_%d", // lay=4
- "%sIT56_1/I565_%d/I562_%d/ITS5_%d", // lay=5
- "%sIT56_1/I569_%d/I566_%d/ITS6_%d"}};// Lay=6
- /*
- Int_t itsGeomTreeCopys[knlayers][3]= {{10, 2, 4},// lay=1
- {10, 4, 4},// lay=2
- {14, 6, 1},// lay=3
- {22, 8, 1},// lay=4
- {34,22, 1},// lay=5
- {38,25, 1}};//lay=6
- */
- Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2;
- Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
- TArrayD shapePar;
- TString path,shapeName;
- TGeoHMatrix materix;
- Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
- TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
-
- if(fTiming) time->Start();
- for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
- geom->Init(kItype,klayers,kladders,kdetectors,nmods);
- for(mod=0;mod<nmods;mod++){
- DecodeDetectorLayers(mod,lay,lad,det); // Write
- geom->CreateMatrix(mod,lay,lad,det,idet[lay-1],tran,rot);
- RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
- path.Form(names[fMinorVersion-1][lay-1].Data(),
- pathbase.Data(),cpn0,cpn1,cpn2);
- geom->GetGeomMatrix(mod)->SetPath(path);
- GetTransformation(path.Data(),materix);
- geom->SetTrans(mod,materix.GetTranslation());
- geom->SetRotMatrix(mod,materix.GetRotationMatrix());
- if(initSeg[idet[lay-1]]) continue;
- GetShape(path,shapeName,shapePar);
- if(shapeName.CompareTo("BOX")){
- Error("InitITSgeom","Geometry changed without proper code update"
- "or error in reading geometry. Shape is not BOX.");
- return kFALSE;
- } // end if
- InitGeomShapePPRasymmFMD(idet[lay-1],initSeg,shapePar,geom);
- } // end for module
- if(fTiming){
- time->Stop();
- time->Print();
- delete time;
+ AliITSgeom *geom = new AliITSgeom();
+ if(!InitAliITSgeom(geom)){ // Error initilization failed
+ delete geom;
+ geom = 0;
} // end if
- return kTRUE;
+ return geom;
}
//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitGeomShapePPRasymmFMD(AliITSDetector idet,
- Bool_t *initSeg,
- TArrayD &shapePar,
- AliITSgeom *geom){
- // Initilizes the geometry segmentation class AliITSgeomS?D, or
- // AliITSsegmentationS?D depending on the vaule of fSegGeom,
- // to values appropreate to this specific geometry. Now that
- // the segmentation is part of AliITSgeom, the detector
- // segmentations are also defined here.
- // Inputs:
- // Int_t lay The layer number/name.
- // AliITSgeom *geom A pointer to the AliITSgeom class
- // Outputs:
- // AliITSgeom *geom This pointer recreated and properly inilized.
- // Return:
- // none.
- // const Double_t kcm2micron = 1.0E4;
- const Double_t kmicron2cm = 1.0E-4;
- Int_t i;
- TArrayF shapeParF;
-
- shapeParF.Set(shapePar.GetSize());
- for(i=0;i<shapePar.GetSize();i++) shapeParF[i]=shapePar[i];
- switch (idet){
- case kSPD:{
- initSeg[idet] = kTRUE;
- AliITSgeomSPD *geomSPD = new AliITSgeomSPD425Short();
- Float_t bx[256],bz[280];
- for(i=000;i<256;i++) bx[i] = 50.0*kmicron2cm; // in x all are 50 microns.
- for(i=000;i<160;i++) bz[i] = 425.0*kmicron2cm; // most are 425 microns
- // except below
- for(i=160;i<280;i++) bz[i] = 0.0*kmicron2cm; // Outside of detector.
- bz[ 31] = bz[ 32] = 625.0*kmicron2cm; // first chip boundry
- bz[ 63] = bz[ 64] = 625.0*kmicron2cm; // first chip boundry
- bz[ 95] = bz[ 96] = 625.0*kmicron2cm; // first chip boundry
- bz[127] = bz[128] = 625.0*kmicron2cm; // first chip boundry
- bz[160] = 425.0*kmicron2cm;// Set so that there is no zero pixel size for fNz.
- geomSPD->ReSetBins(shapeParF[1],256,bx,160,bz);
- geom->ReSetShape(idet,geomSPD);
- }break;
- case kSDD:{
- initSeg[idet] = kTRUE;
- AliITSgeomSDD *geomSDD = new AliITSgeomSDD256(shapeParF.GetSize(),
- shapeParF.GetArray());
- geom->ReSetShape(idet,geomSDD);
- }break;
- case kSSD:{
- initSeg[idet] = kTRUE;
- AliITSgeomSSD *geomSSD = new AliITSgeomSSD275and75(
- shapeParF.GetSize(),shapeParF.GetArray());
- geom->ReSetShape(idet,geomSSD);
- }break;
- default:{// Others, Note no kSDDp or kSSDp in this geometry.
- geom->ReSetShape(idet,0);
- Info("InitGeomShapePPRasymmFMD",
- "default Dx=%f Dy=%f Dz=%f default=%d",
- shapePar[0],shapePar[1],shapePar[2],idet);
- }break;
+Bool_t AliITSInitGeometry::InitAliITSgeom(AliITSgeom *geom){
+ // Initilizes the geometry transformation class AliITSgeom
+ // to values appropreate to this specific geometry. Now that
+ // the segmentation is part of AliITSgeom, the detector
+ // segmentations are also defined here.
+ // Inputs:
+ // AliITSgeom *geom A pointer to the AliITSgeom class
+ // Outputs:
+ // AliITSgeom *geom This pointer recreated and properly inilized.
+ // Return:
+ // none.
+
+ if(!gGeoManager){
+ AliFatal("The geometry manager has not been initialized (e.g. "
+ "TGeoManager::Import(\"geometry.root\")should be "
+ "called in advance) - exit forced");
+ return kFALSE;
+ } // end if
+ switch(fMajorVersion) {
+ case kv11: {
+ return InitAliITSgeomV11(geom);
+ } break; // end case
+ case kvDefault: default: {
+ AliFatal("Undefined geometry");
+ return kFALSE;
+ } break; // end case
} // end switch
- return kTRUE;
+ return kFALSE;
}
//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitSegmentationPPRasymmFMD(AliITSDetector idet,
- Bool_t *initSeg,
- TArrayD &shapePar,
- AliITSgeom *geom){
- // Initilizes the geometry segmentation class AliITSgeomS?D, or
- // AliITSsegmentationS?D depending on the vaule of fSegGeom,
- // to values appropreate to this specific geometry. Now that
- // the segmentation is part of AliITSgeom, the detector
- // segmentations are also defined here.
+void AliITSInitGeometry::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
+ // Transpose the rotation matrix part of a TGeoHMatrix. This
+ // is needed because TGeo stores the transpose of the rotation
+ // matrix as compared to what AliITSgeomMatrix uses (and Geant3).
// Inputs:
- // Int_t lay The layer number/name.
- // AliITSgeom *geom A pointer to the AliITSgeom class
+ // TGeoHMatrix *m The matrix to be transposed
// Outputs:
- // AliITSgeom *geom This pointer recreated and properly inilized.
+ // TGEoHMatrix *m The transposed matrix
// Return:
- // none.
- const Double_t kcm2micron = 1.0E4;
+ // none.
Int_t i;
+ Double_t r[9];
- switch (idet){
- case kSPD:{
- initSeg[idet] = kTRUE;
- AliITSsegmentationSPD *segSPD = new AliITSsegmentationSPD();
- segSPD->SetDetSize(2.*shapePar[0]*kcm2micron, // X
- 2.*shapePar[2]*kcm2micron, // Z
- 2.*shapePar[1]*kcm2micron);// Y Microns
- segSPD->SetNPads(256,160);// Number of Bins in x and z
- Float_t bx[256],bz[280];
- for(i=000;i<256;i++) bx[i] = 50.0; // in x all are 50 microns.
- for(i=000;i<160;i++) bz[i] = 425.0; // most are 425 microns
- // except below
- for(i=160;i<280;i++) bz[i] = 0.0; // Outside of detector.
- bz[ 31] = bz[ 32] = 625.0; // first chip boundry
- bz[ 63] = bz[ 64] = 625.0; // first chip boundry
- bz[ 95] = bz[ 96] = 625.0; // first chip boundry
- bz[127] = bz[128] = 625.0; // first chip boundry
- bz[160] = 425.0;// Set so that there is no zero pixel size for fNz.
- segSPD->SetBinSize(bx,bz); // Based on AliITSgeomSPD for now.
- geom->ReSetShape(idet,segSPD);
- }break;
- case kSDD:{
- initSeg[idet] = kTRUE;
- AliITSsegmentationSDD *segSDD = new AliITSsegmentationSDD();
- segSDD->SetDetSize(shapePar[0]*kcm2micron, // X
- 2.*shapePar[2]*kcm2micron, // Z
- 2.*shapePar[1]*kcm2micron);// Y Microns
- segSDD->SetNPads(256,256);// Anodes, Samples
- geom->ReSetShape(idet,segSDD);
- }break;
- case kSSD:{
- initSeg[idet] = kTRUE;
- AliITSsegmentationSSD *segSSD = new AliITSsegmentationSSD();
- segSSD->SetDetSize(2.*shapePar[0]*kcm2micron, // X
- 2.*shapePar[2]*kcm2micron, // Z
- 2.*shapePar[1]*kcm2micron);// Y Microns.
- segSSD->SetPadSize(95.,0.); // strip x pitch in microns
- segSSD->SetNPads(768,2); // number of strips on each side, sides.
- segSSD->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
- segSSD->SetAnglesLay5(0.0075,0.0275);//strip angels rad P and N
- segSSD->SetAnglesLay6(0.0275,0.0075);//strip angels rad P and N
- geom->ReSetShape(idet,segSSD);
- }break;
- default:{// Others, Note no kSDDp or kSSDp in this geometry.
- geom->ReSetShape(idet,0);
- Info("InitSegmentationPPRasymmFMD",
- "default segmentation Dx=%f Dy=%f Dz=%f default=%d",
- shapePar[0],shapePar[1],shapePar[2],idet);
- }break;
- } // end switch
- return kTRUE;
+ if(m==0) return; // no matrix to transpose.
+ for(i=0;i<9;i += 4) r[i] = m->GetRotationMatrix()[i]; // diagonals
+ r[1] = m->GetRotationMatrix()[3];
+ r[2] = m->GetRotationMatrix()[6];
+ r[3] = m->GetRotationMatrix()[1];
+ r[5] = m->GetRotationMatrix()[7];
+ r[6] = m->GetRotationMatrix()[2];
+ r[7] = m->GetRotationMatrix()[5];
+ m->SetRotation(r);
+ return;
}
+
+
//______________________________________________________________________
+Bool_t AliITSInitGeometry::InitAliITSgeomV11(AliITSgeom *geom){
+ // Initilizes the geometry transformation class AliITSgeom
+ // Now that the segmentation is part of AliITSgeom, the detector
+ // segmentations are also defined here.
+ //
+ // Inputs:
+ // AliITSgeom *geom A pointer to the AliITSgeom class
+ // Outputs:
+ // AliITSgeom *geom This pointer recreated and properly inilized.
+ // LG
+
+ const Int_t kItype = 0; // Type of transformation defined 0=> Geant
+ const Int_t klayers = 6; // number of layers in the ITS
+ const Int_t kladders[klayers] = {20,40,14,22,34,38}; // Number of ladders
+ const Int_t kdetectors[klayers] = {4,4,6,8,22,25};// number of detector/lad
+ const AliITSDetector kIdet[6] = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
+ const TString kPathbase = "/ALIC_1/ITSV_1/";
+
+ const char *pathSPDsens1, *pathSPDsens2;
+ pathSPDsens1="%sITSSPD_1/ITSSPDCarbonFiberSectorV_%d/ITSSPDSensitiveVirtualvolumeM0_1/ITSSPDlay1-Stave_%d/ITSSPDhalf-Stave%d_1/ITSSPDlay1-Ladder_%d/ITSSPDlay1-sensor_1";
+ pathSPDsens2="%sITSSPD_1/ITSSPDCarbonFiberSectorV_%d/ITSSPDSensitiveVirtualvolumeM0_1/ITSSPDlay2-Stave_%d/ITSSPDhalf-Stave%d_1/ITSSPDlay2-Ladder_%d/ITSSPDlay2-sensor_1";
+
+ const char *pathSDDsens1, *pathSDDsens2;
+ pathSDDsens1 = "%sITSsddLayer3_1/ITSsddLadd_%d/ITSsddSensor3_%d/ITSsddWafer3_%d/ITSsddSensitivL3_1";
+ pathSDDsens2 = "%sITSsddLayer4_1/ITSsddLadd_%d/ITSsddSensor4_%d/ITSsddWafer4_%d/ITSsddSensitivL4_1";
+
+ const char *pathSSDsens1, *pathSSDsens2;
+ pathSSDsens1 = "%sITSssdLayer5_1/ITSssdLay5Ladd_%d/ITSssdSensor5_%d/ITSssdSensitivL5_1";
+ pathSSDsens2 = "%sITSssdLayer6_1/ITSssdLay6Ladd_%d/ITSssdSensor6_%d/ITSssdSensitivL6_1";
+
+ const TString kNames[klayers] = {
+ pathSPDsens1, // lay=1
+ pathSPDsens2, // lay=2
+ pathSDDsens1, // lay=3
+ pathSDDsens2, // lay=4
+ pathSSDsens1, // lay=5
+ pathSSDsens2};// Lay=6
+
+ Int_t mod,nmods=0, lay, lad, det, cpn0, cpn1, cpn2, cpnHS=1;
+ Double_t tran[3]={0.,0.,0.}, rot[10]={9*0.0,1.0};
+ TArrayD shapePar;
+ TString path, shapeName;
+ TGeoHMatrix matrix;
+ Bool_t initSeg[3]={kFALSE, kFALSE, kFALSE};
+ TStopwatch *time = 0x0;
+ if(fTiming) time = new TStopwatch();
+
+ if(fTiming) time->Start();
+ for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
+ geom->Init(kItype,klayers,kladders,kdetectors,nmods);
+
+ for(mod=0; mod<nmods; mod++) {
+
+ DecodeDetectorLayers(mod,lay,lad,det);
+ geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
+ RecodeDetector(mod,cpn0,cpn1,cpn2);
+
+ if (kIdet[lay-1]==kSPD) { // we need 1 more copy number because of the half-stave
+ if (det<3) cpnHS = 0; else cpnHS = 1;
+ path.Form(kNames[lay-1].Data(),kPathbase.Data(),cpn0,cpn1,cpnHS,cpn2);
+ } else {
+ path.Form(kNames[lay-1].Data(),kPathbase.Data(),cpn0,cpn1,cpn2);
+ };
+
+ geom->GetGeomMatrix(mod)->SetPath(path);
+ GetTransformation(path.Data(),matrix);
+ geom->SetTrans(mod,matrix.GetTranslation());
+ TransposeTGeoHMatrix(&matrix); //Transpose TGeo's rotation matrixes
+ geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
+ if(initSeg[kIdet[lay-1]]) continue;
+ GetShape(path,shapeName,shapePar);
+ if(shapeName.CompareTo("BOX")){
+ Error("InitITSgeom","Geometry changed without proper code update"
+ "or error in reading geometry. Shape is not BOX.");
+ return kFALSE;
+ } // end if
+ } // end for module
+
+ if(fTiming){
+ time->Stop();
+ time->Print();
+ delete time;
+ } // end if
+ return kTRUE;
+}
+
+//_______________________________________________________________________
Bool_t AliITSInitGeometry::GetTransformation(const TString &volumePath,
TGeoHMatrix &mat){
// Returns the Transformation matrix between the volume specified
// Preserve the modeler state.
gGeoManager->PushPath();
if (!gGeoManager->cd(volumePath.Data())) {
- gGeoManager->PopPath();
- Error("GetTransformation","Error in cd-ing to ",volumePath.Data());
- return kFALSE;
+ gGeoManager->PopPath();
+ Error("GetTransformation","Error in cd-ing to %s",volumePath.Data());
+ return kFALSE;
} // end if !gGeoManager
mat = *gGeoManager->GetCurrentMatrix();
// Retstore the modeler state.
gGeoManager->PopPath();
if (!vol) return kFALSE;
TGeoShape *shape = vol->GetShape();
- TClass *class_type = shape->IsA();
- if (class_type==TGeoBBox::Class()) {
+ TClass *classType = shape->IsA();
+ if (classType==TGeoBBox::Class()) {
shapeType = "BOX";
npar = 3;
par.Set(npar);
par.AddAt(box->GetDY(),1);
par.AddAt(box->GetDZ(),2);
return kTRUE;
- }
- if (class_type==TGeoTrd1::Class()) {
+ } // end if
+ if (classType==TGeoTrd1::Class()) {
shapeType = "TRD1";
npar = 4;
par.Set(npar);
par.AddAt(trd1->GetDy(), 2);
par.AddAt(trd1->GetDz(), 3);
return kTRUE;
- }
- if (class_type==TGeoTrd2::Class()) {
+ } // end if
+ if (classType==TGeoTrd2::Class()) {
shapeType = "TRD2";
npar = 5;
par.Set(npar);
par.AddAt(trd2->GetDy2(),3);
par.AddAt(trd2->GetDz(), 4);
return kTRUE;
- }
- if (class_type==TGeoTrap::Class()) {
+ } // end if
+ if (classType==TGeoTrap::Class()) {
shapeType = "TRAP";
npar = 11;
par.Set(npar);
par.AddAt(trap->GetTl2(),9);
par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
return kTRUE;
- }
- if (class_type==TGeoTube::Class()) {
+ } // end if
+ if (classType==TGeoTube::Class()) {
shapeType = "TUBE";
npar = 3;
par.Set(npar);
par.AddAt(tube->GetRmax(),1);
par.AddAt(tube->GetDz(),2);
return kTRUE;
- }
- if (class_type==TGeoTubeSeg::Class()) {
+ } // end if
+ if (classType==TGeoTubeSeg::Class()) {
shapeType = "TUBS";
npar = 5;
par.Set(npar);
par.AddAt(tubs->GetPhi1(),3);
par.AddAt(tubs->GetPhi2(),4);
return kTRUE;
- }
- if (class_type==TGeoCone::Class()) {
+ } // end if
+ if (classType==TGeoCone::Class()) {
shapeType = "CONE";
npar = 5;
par.Set(npar);
par.AddAt(cone->GetRmin2(),3);
par.AddAt(cone->GetRmax2(),4);
return kTRUE;
- }
- if (class_type==TGeoConeSeg::Class()) {
+ } // end if
+ if (classType==TGeoConeSeg::Class()) {
shapeType = "CONS";
npar = 7;
par.Set(npar);
par.AddAt(cons->GetPhi1(),5);
par.AddAt(cons->GetPhi2(),6);
return kTRUE;
- }
- if (class_type==TGeoSphere::Class()) {
+ } // end if
+ if (classType==TGeoSphere::Class()) {
shapeType = "SPHE";
npar = 6;
par.Set(npar);
par.AddAt(sphe->GetPhi1(),4);
par.AddAt(sphe->GetPhi2(),5);
return kTRUE;
- }
- if (class_type==TGeoPara::Class()) {
+ } // end if
+ if (classType==TGeoPara::Class()) {
shapeType = "PARA";
npar = 6;
par.Set(npar);
par.AddAt(para->GetTxz(),4);
par.AddAt(para->GetTyz(),5);
return kTRUE;
- }
- if (class_type==TGeoPgon::Class()) {
+ } // end if
+ if (classType==TGeoPgon::Class()) {
shapeType = "PGON";
TGeoPgon *pgon = (TGeoPgon*)shape;
Int_t nz = pgon->GetNz();
par.AddAt(rmax[i], 4+3*i+2);
}
return kTRUE;
- }
- if (class_type==TGeoPcon::Class()) {
+ } // end if
+ if (classType==TGeoPcon::Class()) {
shapeType = "PCON";
TGeoPcon *pcon = (TGeoPcon*)shape;
Int_t nz = pcon->GetNz();
par.AddAt(rmax[i], 3+3*i+2);
}
return kTRUE;
- }
- if (class_type==TGeoEltu::Class()) {
+ } // end if
+ if (classType==TGeoEltu::Class()) {
shapeType = "ELTU";
npar = 3;
par.Set(npar);
par.AddAt(eltu->GetB(),1);
par.AddAt(eltu->GetDz(),2);
return kTRUE;
- }
- if (class_type==TGeoHype::Class()) {
+ } // end if
+ if (classType==TGeoHype::Class()) {
shapeType = "HYPE";
npar = 5;
par.Set(npar);
par.AddAt(hype->GetStIn(),3);
par.AddAt(hype->GetStOut(),4);
return kTRUE;
- }
- if (class_type==TGeoGtra::Class()) {
+ } // end if
+ if (classType==TGeoGtra::Class()) {
shapeType = "GTRA";
npar = 12;
par.Set(npar);
par.AddAt(TMath::Tan(trap->GetAlpha2()*TMath::DegToRad()),10);
par.AddAt(trap->GetTwistAngle(),11);
return kTRUE;
- }
- if (class_type==TGeoCtub::Class()) {
+ } // end if
+ if (classType==TGeoCtub::Class()) {
shapeType = "CTUB";
npar = 11;
par.Set(npar);
par.AddAt(tx[1],9);
par.AddAt(tx[2],10);
return kTRUE;
- }
+ } // end if
Error("GetShape","Getting shape parameters for shape %s not implemented",
shape->ClassName());
+ shapeType = "Unknown";
return kFALSE;
}
//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetector(Int_t &mod,Int_t layer,Int_t cpn0,
- Int_t cpn1,Int_t cpn2){
+void AliITSInitGeometry::DecodeDetector(
+ Int_t &mod,Int_t layer,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
// decode geometry into detector module number. There are two decoding
// Scheams. Old which does not follow the ALICE coordinate system
// requirements, and New which dose.
// of copy numbers.
// Return:
// none.
- const Int_t detPerLadderSPD[2]={2,4};
- const Int_t detPerLadder[6]={4,4,6,8,22,25};
- const Int_t ladPerLayer[6]={20,40,14,22,34,38};
- Int_t lay=-1,lad=-1,det=-1,i;
-
- if(fDecode){ // New decoding scheam
- switch (layer){
- case 1:{
- lay = layer;
- det = 5-cpn2;
- if(cpn0==4&&cpn1==1) lad=1;
- else if(cpn0==4&&cpn1==2) lad=20;
- else if(cpn0<4){
- lad = 8-cpn1-detPerLadderSPD[layer-1]*(cpn0-1);
- }else{ // cpn0>4
- lad = 28-cpn1-detPerLadderSPD[layer-1]*(cpn0-1);
- } // end if
- } break;
- case 2:{
- lay = layer;
- det = 5-cpn2;
- if(cpn0==4&&cpn1==1) lad=1;
- else if(cpn0<4){
- lad = 14-cpn1-detPerLadderSPD[layer-1]*(cpn0-1);
- }else{ // cpn0>4
- lad = 54-cpn1-detPerLadderSPD[layer-1]*(cpn0-1);
- } // end if
- } break;
- case 3:{
- lay = layer;
- if(cpn0<5) lad = 5-cpn0;
- else lad = 19-cpn0;
- det = 7-cpn1;
- } break;
- case 4:{
- lay = layer;
- if(cpn0<7) lad = 7-cpn0;
- else lad = 29-cpn0;
- det = 9-cpn1;
- } break;
- case 5:{
- lay = layer;
- if(cpn0<10) lad = 10-cpn0;
- else lad = 44-cpn0;
- det = 23-cpn1;
- } break;
- case 6:{
- lay = layer;
- if(cpn0<9) lad = 9-cpn0;
- else lad = 47-cpn0;
- det = 26-cpn1;
- } break;
- } // end switch
- mod = 0;
- for(i=0;i<layer-1;i++) mod += ladPerLayer[i]*detPerLadder[i];
- mod += detPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
- return;
- } // end if
- // Old decoding scheam
- switch(layer){
- case 1: case 2:{
- lay = layer;
- lad = cpn1+detPerLadderSPD[layer-1]*(cpn0-1);
- det = cpn2;
- }break;
- case 3: case 4:{
- lay = layer;
- lad = cpn0;
- det = cpn1;
- }break;
- case 5: case 6:{
- lay = layer;
- lad = cpn0;
- det = cpn1;
- }break;
+
+ // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't
+ // like them but I see not better way for the moment.
+ switch (fMajorVersion){
+ case kvDefault:{
+ Error("DecodeDetector","Major version = kvDefault, not supported");
+ }break;
+ case kv11:{
+ return DecodeDetectorv11(mod,layer,cpn0,cpn1,cpn2);
+ }break;
default:{
- }break;
+ Error("DecodeDetector","Major version = %d, not supported",
+ (Int_t)fMajorVersion);
+ return;
+ }break;
} // end switch
- mod = 0;
- for(i=0;i<layer-1;i++) mod += ladPerLayer[i]*detPerLadder[i];
- mod += detPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
return;
}
//______________________________________________________________________
// Int_t cpn2 the highest copy number
// Return:
// none.
- const Int_t itsGeomTreeCopys[6][3]= {{10, 2, 4},// lay=1
- {10, 4, 4},// lay=2
- {14, 6, 1},// lay=3
- {22, 8, 1},// lay=4
- {34,22, 1},// lay=5
- {38,25, 1}};//lay=6
- const Int_t detPerLadderSPD[2]={2,4};
- // const Int_t detPerLadder[6]={4,4,6,8,22,25};
- // const Int_t ladPerLayer[6]={20,40,14,22,34,38};
- Int_t lay,lad,det;
- cpn0 = cpn1 = cpn2 = 0;
- DecodeDetectorLayers(mod,lay,lad,det);
- if(fDecode){ // New decoding scheam
- switch (lay){
- case 1:{
- cpn2 = 5-det; // Detector 1-4
- cpn1 = 1+(lad-1)%detPerLadderSPD[lay-1];
- cpn0 = 5-(lad+detPerLadderSPD[lay-1])/detPerLadderSPD[lay-1];
- if(mod>27) cpn0 = 15-(lad+detPerLadderSPD[lay-1])/
- detPerLadderSPD[lay-1];
- } break;
- case 2:{
- cpn2 = 5-det; // Detector 1-4
- cpn1 = 4-(lad+2)%detPerLadderSPD[lay-1];
- cpn0 = 1+(14-cpn1-lad)/detPerLadderSPD[lay-1];
- if(mod>131) cpn0 = 1+(54-lad-cpn1)/detPerLadderSPD[lay-1];
- } break;
- case 3:{
- cpn2 = 1;
- if(lad<5) cpn0 = 5-lad;
- else cpn0 = 19-lad;
- cpn1 = 7-det;
- } break;
- case 4:{
- cpn2 = 1;
- if(lad<7) cpn0 = 7-lad;
- else cpn0 = 29-lad;
- cpn1 = 9-det;
- } break;
- case 5:{
- cpn2 = 1;
- if(lad<10) cpn0 = 10-lad;
- else cpn0 = 44-lad;
- cpn1 = 23-det;
- } break;
- case 6:{
- cpn2 = 1;
- if(lad<9) cpn0 = 9-lad;
- else cpn0 = 47-lad;
- cpn1 = 26-det;
- } break;
- default:{
- Error("RecodeDetector","New: mod=%d lay=%d not 1-6.");
- return;
- } break;
- } // end switch
- if(cpn0<1||cpn1<1||cpn2<1||
- cpn0>itsGeomTreeCopys[lay-1][0]||
- cpn1>itsGeomTreeCopys[lay-1][1]||
- cpn2>itsGeomTreeCopys[lay-1][2])
- Error("RecodeDetector",
- "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
- cpn0,cpn1,cpn2,mod,lay,lad,det);
+ // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't
+ // like them but I see not better way for the moment.
+ switch (fMajorVersion){
+ case kvDefault:{
+ Error("RecodeDetector","Major version = kvDefault, not supported");
return;
- } // end if
- // Old encoding
- switch (lay){
- case 1: case 2:{
- cpn2 = det; // Detector 1-4
- cpn0 = (lad+detPerLadderSPD[lay-1]-1)/detPerLadderSPD[lay-1];
- cpn1 = (lad+detPerLadderSPD[lay-1]-1)%detPerLadderSPD[lay-1] + 1;
- } break;
- case 3: case 4: case 5 : case 6:{
- cpn2 = 1;
- cpn1 = det;
- cpn0 = lad;
- } break;
+ }
+ case kv11:{
+ return RecodeDetectorv11(mod,cpn0,cpn1,cpn2);
+ }break;
default:{
- Error("RecodeDetector","Old: mod=%d lay=%d not 1-6.");
+ Error("RecodeDetector","Major version = %d, not supported",
+ (Int_t)fMajorVersion);
return;
- } break;
+ }break;
} // end switch
- if(cpn0<1||cpn1<1||cpn2<1||
- cpn0>itsGeomTreeCopys[lay-1][0]||
- cpn1>itsGeomTreeCopys[lay-1][1]||
- cpn2>itsGeomTreeCopys[lay-1][2])
- Error("RecodeDetector",
- "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
- cpn0,cpn1,cpn2,mod,lay,lad,det);
return;
}
//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &lay,
+void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &layer,
Int_t &lad,Int_t &det){
// decode geometry into detector module number. There are two decoding
// Scheams. Old which does not follow the ALICE coordinate system
// Int_t det the dettector number
// Return:
// none.
- // const Int_t detPerLadderSPD[2]={2,4};
- const Int_t detPerLadder[6]={4,4,6,8,22,25};
- const Int_t ladPerLayer[6]={20,40,14,22,34,38};
- Int_t mod2;
-
- det = 0;
- lad = 0;
- lay = 0;
- mod2 = 0;
- do{
- mod2 += ladPerLayer[lay]*detPerLadder[lay];
- lay++;
- }while(mod2<=mod); // end while
- if(lay>6||lay<1) Error("DecodeDetectorLayers","0<lay=%d>6",lay);
- mod2 -= ladPerLayer[lay-1]*detPerLadder[lay-1];
- do{
- lad++;
- mod2 += detPerLadder[lay-1];
- }while(mod2<=mod); // end while
- if(lad>ladPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayera",
- "lad=%d>ladPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
- ladPerLayer[lay-1],mod,mod2);
- mod2 -= detPerLadder[lay-1];
- det = mod-mod2+1;
- if(det>detPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
- "det=%d>detPerLayer[lay-1=%d]=%d mod=%d mod2=%d lad=%d",det,
- lay-1,detPerLadder[lay-1],mod,mod2,lad);
+
+ // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't
+ // like them but I see not better way for the moment.
+ switch (fMajorVersion) {
+ case kvDefault:{
+ Error("DecodeDetectorLayers",
+ "Major version = kvDefault, not supported");
+ return;
+ }break;
+ case kv11:{
+ return DecodeDetectorLayersv11(mod,layer,lad,det);
+ }break;
+ default:{
+ Error("DecodeDetectorLayers","Major version = %d, not supported",
+ (Int_t)fMajorVersion);
+ return;
+ }break;
+ } // end switch
return;
}
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorv11(Int_t &mod,Int_t layer,
+ Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
+ // decode geometry into detector module number
+ // Inputs:
+ // Int_t layer The ITS layer
+ // Int_t cpn0 The lowest copy number
+ // Int_t cpn1 The middle copy number
+ // Int_t cpn2 the highest copy number
+ // Output:
+ // Int_t &mod The module number assoicated with this set
+ // of copy numbers.
+ // Return:
+ // none.
+ const Int_t kDetPerLadderSPD[2]={2,4};
+ const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
+ const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
+ Int_t lad=-1,det=-1;
+
+ switch(layer) {
+ case 1: case 2:{
+ lad = cpn1+kDetPerLadderSPD[layer-1]*(cpn0-1);
+ det = cpn2;
+ } break;
+ case 3: case 4:{
+ lad = cpn0+1;
+ det = cpn1+1;
+ } break;
+ case 5: case 6:{
+ lad = cpn0+1;
+ det = cpn1+1;
+ } break;
+ default:{
+ } break;
+ } // end switch
+ mod = 0;
+ for(Int_t i=0;i<layer-1;i++) mod += kLadPerLayer[i]*kDetPerLadder[i];
+ mod += kDetPerLadder[layer-1]*(lad-1)+det-1;// module start at zero.
+ return;
+}
+
+
+//______________________________________________________________________
+void AliITSInitGeometry::RecodeDetectorv11(Int_t mod,Int_t &cpn0,
+ Int_t &cpn1,Int_t &cpn2) {
+ // decode geometry into detector module number using the new decoding
+ // Scheme.
+ // Inputs:
+ // Int_t mod The module number assoicated with this set
+ // of copy numbers.
+ // Output:
+ // Int_t cpn0 The lowest copy number (SPD sector or SDD/SSD ladder)
+ // Int_t cpn1 The middle copy number (SPD stave or SDD/SSD module)
+ // Int_t cpn2 the highest copy number (SPD ladder or 1 for SDD/SSD)
+ // Return:
+ // none.
+ const Int_t kDetPerLadderSPD[2]={2,4};
+ Int_t lay,lad,det;
+
+ DecodeDetectorLayersv11(mod,lay,lad,det);
+ if (lay<3) { // SPD
+ cpn2 = det; // Detector 1-4
+ cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
+ cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
+ } else { // SDD and SSD
+ cpn2 = 1;
+ cpn1 = det;
+ cpn0 = lad;
+ if (lay<5) { // SDD
+ cpn1--;
+ cpn0--;
+ } else { //SSD
+ cpn1--;
+ cpn0--;
+ } // end if Lay<5/else
+ } // end if lay<3/else
+
+}
+
+
+//______________________________________________________________________
+void AliITSInitGeometry::DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
+ Int_t &lad,Int_t &det) {
+
+ // decode module number into detector indices for v11
+ // mod starts from 0
+ // lay, lad, det start from 1
+
+ // Inputs:
+ // Int_t mod The module number associated with this set
+ // of copy numbers.
+ // Output:
+ // Int_t lay The layer number
+ // Int_t lad The ladder number
+ // Int_t det the dettector number
+
+ const Int_t kDetPerLadder[6] = {4,4,6,8,22,25};
+ const Int_t kLadPerLayer[6] = {20,40,14,22,34,38};
+
+ Int_t mod2 = 0;
+ lay = 0;
+
+ do {
+ mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
+ lay++;
+ } while(mod2<=mod); // end while
+ if(lay>6) Error("DecodeDetectorLayers","lay=%d>6",lay);
+
+ mod2 = kLadPerLayer[lay-1]*kDetPerLadder[lay-1] - mod2+mod;
+ lad = mod2/kDetPerLadder[lay-1];
+
+ if(lad>=kLadPerLayer[lay-1]||lad<0) Error("DecodeDetectorLayers",
+ "lad=%d not in the correct range",lad);
+ det = (mod2 - lad*kDetPerLadder[lay-1])+1;
+ if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
+ "det=%d not in the correct range",det);
+ lad++;
+}
+
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::WriteVersionString(Char_t *str,Int_t length,AliITSVersion_t maj)const{
+ // fills the string str with the major version number
+ // Inputs:
+ // Char_t *str The character string to hold the major version number
+ // Int_t length The maximum number of characters which
+ // can be accommodated by this string.
+ // str[length-1] must exist
+ // AliITSVersion_t maj The major number
+
+
+ Int_t i = (Int_t)maj;
+
+ snprintf(str,length-1,"Major Version= %d",i);
+ return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSInitGeometry::ReadVersionString(const Char_t *str,AliITSVersion_t &maj)const{
+ // fills the string str with the major and minor version number
+ // Inputs:
+ // Char_t *str The character string to holding the major version number
+ // Int_t length The maximum number of characters which can be
+ // accommodated by this string. str[length-1] must exist
+ // Outputs:
+ // AliITSVersion_t maj The major number
+
+ // Return:
+ // kTRUE if no errors
+
+ Bool_t retcode=kFALSE;
+ Int_t n=strlen(str);
+ if(n<15) return retcode; // not enough space for numbers
+ Int_t m,i;
+ m = sscanf(str,"Major Version= %2d",&i);
+ maj = kvDefault;
+ if(m>0){
+ retcode = kTRUE;
+ if(i==11){
+ maj = kv11;
+ }
+ }
+ return retcode;
+}
+
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff