Cosmetics, init values provided in c'tor
[u/mrichter/AliRoot.git] / STEER / AliGeomManager.cxx
index 65a4e49..10be86c 100644 (file)
 #include <TClonesArray.h>
 #include <TGeoMatrix.h>
 #include <TGeoPhysicalNode.h>
+#include <TSystem.h>
+#include <TStopwatch.h>
+#include <TGeoOverlap.h>
+#include <TPluginManager.h>
+#include <TROOT.h>
 
 #include "AliGeomManager.h"
 #include "AliLog.h"
 #include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
 #include "AliCDBManager.h"
 #include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
@@ -45,9 +50,10 @@ Int_t AliGeomManager::fgLayerSize[kLastLayer - kFirstLayer] = {
   36, 36,   // TPC inner and outer chambers
   90, 90, 90, 90, 90, 90,  // 6 TRD chambers' layers
   1638,     // TOF
-  1, 1,     // PHOS ??
+  5, 5,     // PHOS,CPV
   7,        // HMPID ??
-  1         // MUON ??
+  1,         // MUON ??
+  12        // EMCAL
 };
 
 const char* AliGeomManager::fgLayerName[kLastLayer - kFirstLayer] = {
@@ -58,9 +64,10 @@ const char* AliGeomManager::fgLayerName[kLastLayer - kFirstLayer] = {
   "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
   "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
   "TOF layer",
-  "?","?",
-  "HMPID layer",
-  "?"
+  "PHOS EMC layer","PHOS CPV layer",
+  "HMPID layer", 
+  "MUON ?",
+  "EMCAL layer"
 };
 
 TString* AliGeomManager::fgSymName[kLastLayer - kFirstLayer] = {
@@ -73,6 +80,7 @@ TString* AliGeomManager::fgSymName[kLastLayer - kFirstLayer] = {
   0x0,
   0x0,0x0,
   0x0,
+  0x0,
   0x0
 };
 
@@ -86,10 +94,11 @@ TGeoPNEntry** AliGeomManager::fgPNEntry[kLastLayer - kFirstLayer] = {
   0x0,
   0x0,0x0,
   0x0,
+  0x0,
   0x0
 };
 
-AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
+TGeoHMatrix** AliGeomManager::fgOrigMatrix[kLastLayer - kFirstLayer] = {
   0x0,0x0,
   0x0,0x0,
   0x0,0x0,
@@ -99,41 +108,73 @@ AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
   0x0,
   0x0,0x0,
   0x0,
+  0x0,
   0x0
 };
 
-AliGeomManager* AliGeomManager::fgInstance = 0x0;
+AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
+  0x0,0x0,
+  0x0,0x0,
+  0x0,0x0,
+  0x0,0x0,
+  0x0,0x0,0x0,
+  0x0,0x0,0x0,
+  0x0,
+  0x0,0x0,
+  0x0,
+  0x0,
+  0x0
+};
 
 TGeoManager* AliGeomManager::fgGeometry = 0x0;
 
 //_____________________________________________________________________________
-AliGeomManager* AliGeomManager::Instance()
+void AliGeomManager::LoadGeometry(const char *geomFileName)
 {
-// returns AliGeomManager instance (singleton)
+  // initialization
+  // Load geometry either from a file
+  // or from the corresponding CDB entry
+
+  fgGeometry = NULL;
+  if (geomFileName && (!gSystem->AccessPathName(geomFileName))) { // gemotry.root exists
+    fgGeometry = TGeoManager::Import(geomFileName);
+    AliInfoClass("Using custom geometry.root file");
+  }
 
-       if (!fgInstance) {
-         fgInstance = new AliGeomManager();
-         fgInstance->Init();
-       }
-       return fgInstance;
+  if (!fgGeometry) {
+    AliInfoClass("Using geometry from CDB");
+
+    AliCDBPath path("GRP","Geometry","Data");
+       
+    AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
+    if(!entry) AliFatalClass("Couldn't load geometry data from CDB!");
+
+    entry->SetOwner(0);
+    fgGeometry = (TGeoManager*) entry->GetObject();
+    if (!fgGeometry) AliFatalClass("Couldn't find TGeoManager in the specified CDB entry!");
+  }
+
+  InitSymNamesLUT();
+  InitPNEntriesLUT();
+  InitOrigMatricesLUT();
 }
 
 //_____________________________________________________________________________
-void AliGeomManager::Init()
+void AliGeomManager::SetGeometry(TGeoManager *geom)
 {
-// initialization
-  if(!gGeoManager) AliFatal("Impossible to initialize AliGeomManager without an active geometry");
-  fgGeometry = gGeoManager;
+  // Load already active geometry
+  if (!geom) AliFatalClass("Pointer to the active geometry is 0x0!");
+
+  fgGeometry = geom;
+
   InitSymNamesLUT();
   InitPNEntriesLUT();
+  InitOrigMatricesLUT();
 }
 
 //_____________________________________________________________________________
 AliGeomManager::AliGeomManager():
-  TObject(),
-
-  //  fgGeometry(NULL),
-  fAlignObjArray(NULL)
+  TObject()
 {
   // default constructor
 }
@@ -142,8 +183,6 @@ AliGeomManager::AliGeomManager():
 AliGeomManager::~AliGeomManager()
 {
   // dummy destructor
-  if(fAlignObjArray) fAlignObjArray->Delete();
-  delete fAlignObjArray;
 }
 
 //_____________________________________________________________________________
@@ -320,27 +359,25 @@ Bool_t AliGeomManager::GetFromGeometry(const char *symname, AliAlignObj &alobj)
   alobj.SetPars(0,0,0,0,0,0);
   alobj.SetSymName(symname);
 
-  if (!gGeoManager || !gGeoManager->IsClosed()) {
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
     AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
     return kFALSE;
   }
 
-  if (!gGeoManager->GetListOfPhysicalNodes()) {
+  if (!fgGeometry->GetListOfPhysicalNodes()) {
     AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
     return kFALSE;
   }
 
-  ReactIfChangedGeom();
-  
   const char *path;
-  TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
+  TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
   if(pne){
     path = pne->GetTitle();
   }else{
     AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
     path = symname;
   }
-  TObjArray* nodesArr = gGeoManager->GetListOfPhysicalNodes();
+  TObjArray* nodesArr = fgGeometry->GetListOfPhysicalNodes();
   TGeoPhysicalNode* node = NULL;
   for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
     TGeoPhysicalNode* tempNode = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
@@ -352,7 +389,7 @@ Bool_t AliGeomManager::GetFromGeometry(const char *symname, AliAlignObj &alobj)
   }
 
   if (!node) {
-    if (!gGeoManager->cd(path)) {
+    if (!fgGeometry->cd(path)) {
       AliErrorClass(Form("%s not valid neither as symbolic volume name nor as volume path!",path));
       return kFALSE;
     }
@@ -383,13 +420,11 @@ void  AliGeomManager::InitAlignObjFromGeometry()
 
   if(fgAlignObjs[0]) return;
   
-  ReactIfChangedGeom();
-  
   for (Int_t iLayer = kFirstLayer; iLayer < AliGeomManager::kLastLayer; iLayer++) {
     fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[LayerSize(iLayer)];
     for (Int_t iModule = 0; iModule < LayerSize(iLayer); iModule++) {
       UShort_t volid = LayerToVolUID(iLayer,iModule);
-      fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0,kTRUE);
+      fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjParams("",volid,0,0,0,0,0,0,kTRUE);
       const char *symname = SymName(volid);
       if (!GetFromGeometry(symname, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
        AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,symname));
@@ -440,7 +475,7 @@ const char* AliGeomManager::SymName(ELayerID layerId, Int_t modId)
     AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
     return NULL;
   }
-  ReactIfChangedGeom();
+  InitSymNamesLUT();
 
   return fgSymName[layerId-kFirstLayer][modId].Data();
 }
@@ -455,6 +490,8 @@ void AliGeomManager::InitSymNamesLUT()
   // AliGeomManager instance and recreated if the geometry has changed
   //
 
+  if(fgSymName[0]) return;
+
   for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
     if(!fgSymName[iLayer]) fgSymName[iLayer]=new TString[fgLayerSize[iLayer]];
   }
@@ -467,32 +504,41 @@ void AliGeomManager::InitSymNamesLUT()
   TString strSDD = "ITS/SDD";
   TString strSSD = "ITS/SSD";
   TString strStave = "/Stave";
+  TString strHalfStave = "/HalfStave";
   TString strLadder = "/Ladder";
   TString strSector = "/Sector";
   TString strSensor = "/Sensor";
   TString strEntryName1;
   TString strEntryName2;
-
+  TString strEntryName3;
 
   /*********************       SPD layer1  ***********************/
   {
     modnum = 0;
-
-    for(Int_t c1 = 1; c1<=10; c1++){
+    
+    for(Int_t cSect = 0; cSect<10; cSect++){
       strEntryName1 = strSPD;
       strEntryName1 += 0;
       strEntryName1 += strSector;
-      strEntryName1 += (c1-1);
-      for(Int_t c2 =1; c2<=2; c2++){
+      strEntryName1 += cSect;
+      
+      for(Int_t cStave =0; cStave<2; cStave++){
        strEntryName2 = strEntryName1;
        strEntryName2 += strStave;
-       strEntryName2 += (c2-1);
-       for(Int_t c3 =1; c3<=4; c3++){
-         symname = strEntryName2;
-         symname += strLadder;
-         symname += (c3-1);
-         fgSymName[kSPD1-kFirstLayer][modnum] = symname.Data();
-         modnum++;
+       strEntryName2 += cStave;
+
+       for (Int_t cHS=0; cHS<2; cHS++) {
+         strEntryName3 = strEntryName2;
+         strEntryName3 += strHalfStave;
+         strEntryName3 += cHS;
+         
+         for(Int_t cLad =0; cLad<2; cLad++){
+           symname = strEntryName3;
+           symname += strLadder;
+           symname += cLad+cHS*2;
+           fgSymName[kSPD1-kFirstLayer][modnum] = symname.Data();
+           modnum++;
+         }
        }
       }
     }
@@ -502,26 +548,90 @@ void AliGeomManager::InitSymNamesLUT()
   {
     modnum = 0;
 
-    for(Int_t c1 = 1; c1<=10; c1++){
+    for(Int_t cSect = 0; cSect<10; cSect++){
       strEntryName1 = strSPD;
       strEntryName1 += 1;
       strEntryName1 += strSector;
-      strEntryName1 += (c1-1);
-      for(Int_t c2 =1; c2<=4; c2++){
+      strEntryName1 += cSect;
+
+      for(Int_t cStave =0; cStave<4; cStave++){
        strEntryName2 = strEntryName1;
        strEntryName2 += strStave;
-       strEntryName2 += (c2-1);
-       for(Int_t c3 =1; c3<=4; c3++){
-         symname = strEntryName2;
-         symname += strLadder;
-         symname += (c3-1);
-         fgSymName[kSPD2-kFirstLayer][modnum] = symname.Data();
-         modnum++;
+       strEntryName2 += cStave;
+
+       for (Int_t cHS=0; cHS<2; cHS++) {
+         strEntryName3 = strEntryName2;
+         strEntryName3 += strHalfStave;
+         strEntryName3 += cHS;
+
+         for(Int_t cLad =0; cLad<2; cLad++){
+           symname = strEntryName3;
+           symname += strLadder;
+           symname += cLad+cHS*2;
+           fgSymName[kSPD2-kFirstLayer][modnum] = symname.Data();
+           modnum++;
+         }
        }
       }
     }
   }
 
+//   /*********************       SPD layer1  ***********************/
+//   {
+//     modnum = 0;
+
+//     for(Int_t c1 = 1; c1<=10; c1++){
+//       strEntryName1 = strSPD;
+//       strEntryName1 += 0;
+//       strEntryName1 += strSector;
+//       strEntryName1 += (c1-1);
+//       for(Int_t c2 =1; c2<=2; c2++){
+//     strEntryName2 = strEntryName1;
+//     strEntryName2 += strStave;
+//     strEntryName2 += (c2-1);
+//     for(Int_t c3 =1; c3<=4; c3++){
+//       symname = strEntryName2;
+//       symname += strLadder;
+//       symname += (c3-1);
+//       fgSymName[kSPD1-kFirstLayer][modnum] = symname.Data();
+//       modnum++;
+//     }
+//       }
+//     }
+//   }
+  
+//   /*********************       SPD layer2  ***********************/
+//   {
+//     modnum = 0;
+
+//     for(Int_t c1 = 1; c1<=10; c1++){
+//       strEntryName1 = strSPD;
+//       strEntryName1 += 1;
+//       strEntryName1 += strSector;
+//       strEntryName1 += (c1-1);
+//       for(Int_t c2 =1; c2<=4; c2++){
+//     strEntryName2 = strEntryName1;
+//     strEntryName2 += strStave;
+//     strEntryName2 += (c2-1);
+//     for(Int_t c3 =1; c3<=4; c3++){
+//       symname = strEntryName2;
+//       symname += strLadder;
+//       symname += (c3-1);
+//       fgSymName[kSPD2-kFirstLayer][modnum] = symname.Data();
+//       modnum++;
+//     }
+//       }
+//     }
+//   }
+
+
+
+
+
+
+
+
+
   /*********************       SDD layer1  ***********************/
   {
     modnum=0;
@@ -706,6 +816,51 @@ void AliGeomManager::InitSymNamesLUT()
       }
     }
   }
+
+  /*********************      PHOS EMC layer   ***********************/
+  {
+    TString str = "PHOS/Module";
+    modnum=0;
+
+    for (Int_t iModule=1; iModule <= 5; iModule++) {
+      symname = str;
+      symname += iModule;
+      modnum = iModule-1;
+      fgSymName[kPHOS1-kFirstLayer][modnum] = symname.Data();
+    }
+  }
+
+  /*********************      PHOS CPV layer   ***********************/
+  {
+    TString str = "PHOS/Module";
+    modnum=0;
+
+    for (Int_t iModule=1; iModule <= 5; iModule++) {
+      symname = str;
+      symname += iModule;
+      symname += "/CPV";
+      modnum = iModule-1;
+      fgSymName[kPHOS2-kFirstLayer][modnum] = symname.Data();
+    }
+  }
+
+  /*********************      EMCAL layer   ***********************/
+  {
+    TString str = "EMCAL/FullSupermodule";
+    modnum=0;
+
+    for (Int_t iModule=1; iModule <= 12; iModule++) {
+      symname = str;
+      symname += iModule;
+      if(iModule >10) {
+       symname = "EMCAL/HalfSupermodule";
+       symname += iModule-10;
+      }
+      modnum = iModule-1;
+      fgSymName[kEMCAL-kFirstLayer][modnum] = symname.Data();
+    }
+  }
+
 }
 
 //_____________________________________________________________________________
@@ -717,16 +872,45 @@ void AliGeomManager::InitPNEntriesLUT()
   // The LUTs are static; they are created at the creation of the
   // AliGeomManager instance and recreated if the geometry has changed
   //
+  if (fgPNEntry[0]) return;
+
+  if(!fgGeometry) {
+    AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
+    return;
+  }
 
   for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
-    if(!fgPNEntry[iLayer]) fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
+    fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
+    for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
+      fgPNEntry[iLayer][modnum] = fgGeometry->GetAlignableEntry(fgSymName[iLayer][modnum]);
+    }
   }
+}
 
-  for (Int_t iLayer = 0; iLayer < (kLastLayer-kFirstLayer); iLayer++){
-    for(Int_t modnum=0; modnum<LayerSize(iLayer); modnum++){
-      fgPNEntry[iLayer-kFirstLayer][modnum] = gGeoManager->GetAlignableEntry(fgSymName[iLayer-kFirstLayer][modnum].Data());
+//_____________________________________________________________________________
+void AliGeomManager::InitOrigMatricesLUT()
+{
+  // Initialize the storage for the look-up table with the original global
+  // matrices for each alignable volume.
+  // The LUTs are static; the matrices are created on demand and recreated
+  // if the geometry has changed.
+  if (fgOrigMatrix[0]) return;
+
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
+    AliErrorClass("Impossible to initialize orignal matrices LUT without an active geometry");
+    return;
+  }
+
+  for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
+    fgOrigMatrix[iLayer] = new TGeoHMatrix*[fgLayerSize[iLayer]];
+    for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
+      if (!fgPNEntry[iLayer][modnum]) continue;
+      TGeoHMatrix *m = GetOrigGlobalMatrix(fgPNEntry[iLayer][modnum]);
+      if (!m) continue;
+      fgOrigMatrix[iLayer][modnum] = new TGeoHMatrix(*m);
     }
   }
+
 }
 
 //______________________________________________________________________
@@ -735,15 +919,20 @@ TGeoHMatrix* AliGeomManager::GetMatrix(TGeoPNEntry* pne)
   // Get the transformation matrix for a given PNEntry
   // by quering the TGeoManager
 
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
+    AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
+    return NULL;
+  }
+  
   TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
   if (pnode) return pnode->GetMatrix();
 
   const char* path = pne->GetTitle();
-  if (!gGeoManager->cd(path)) {
+  if (!fgGeometry->cd(path)) {
     AliErrorClass(Form("Volume path %s not valid!",path));
     return NULL;
   }
-  return gGeoManager->GetCurrentMatrix();
+  return fgGeometry->GetCurrentMatrix();
 }
 
 //______________________________________________________________________
@@ -752,8 +941,6 @@ TGeoHMatrix* AliGeomManager::GetMatrix(Int_t index)
   // Get the global transformation matrix for a given alignable volume
   // identified by its unique ID 'index' by quering the TGeoManager
 
-  ReactIfChangedGeom();
-
   TGeoPNEntry *pne = GetPNEntry(index);
   if (!pne) return NULL;
 
@@ -766,8 +953,12 @@ TGeoHMatrix* AliGeomManager::GetMatrix(const char* symname)
   // Get the global transformation matrix for a given alignable volume
   //  identified by its symbolic name 'symname' by quering the TGeoManager
 
-  ReactIfChangedGeom();
-  TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
+    AliErrorClass("No active geometry or geometry not yet closed!");
+    return NULL;
+  }
+
+  TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
   if (!pne) return NULL;
 
   return GetMatrix(pne);
@@ -804,34 +995,64 @@ Bool_t AliGeomManager::GetRotation(Int_t index, Double_t r[9])
 }
 
 //_____________________________________________________________________________
-Bool_t AliGeomManager::GetOrigGlobalMatrix(const char *symname, TGeoHMatrix &m)
+Bool_t AliGeomManager::GetDeltaForBranch(Int_t index, TGeoHMatrix &inclusiveD)
 {
-  // The method returns global matrix for the ideal detector geometry
-  // Symname identifies either the corresponding TGeoPNEntry or directly
-  // the volume path. The output global matrix is stored in 'm'.
-  // Returns kFALSE in case TGeo has not been initialized or the symname
-  // is invalid.
+  // The method sets the matrix passed as argument as the global delta
+  // (for the volume referred by the unique index) including the displacements
+  // of all parent volumes in the branch.
   //
+  const char* symname = SymName(index);
+  if(!symname) return kFALSE;
 
-  if (!gGeoManager || !gGeoManager->IsClosed()) {
-    AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
+  TGeoHMatrix go,invgo;
+  go = *GetOrigGlobalMatrix(index);
+  invgo = go.Inverse();
+  inclusiveD = *GetMatrix(symname);
+  inclusiveD.Multiply(&invgo);
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliGeomManager::GetDeltaForBranch(AliAlignObj& aao, TGeoHMatrix &inclusiveD)
+{
+  // The method sets the matrix passed as argument as the global delta
+  // (for the volume referred by the alignment object) including the displacements
+  // of all parent volumes in the brach.
+  //
+  Int_t index = aao.GetVolUID();
+  if(!index){
+    AliErrorClass("Either the alignment object or its index are not valid");
     return kFALSE;
   }
-  
-  if (!gGeoManager->GetListOfPhysicalNodes()) {
+  return GetDeltaForBranch(index, inclusiveD);
+}
+
+//______________________________________________________________________
+Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, TGeoHMatrix &m) 
+{
+  // Get the global transformation matrix (ideal geometry) for a given alignable volume
+  //  identified by its symbolic name 'symname' by quering the TGeoManager
+  m.Clear();
+
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
+    AliErrorClass("No active geometry or geometry not yet closed!");
+    return kFALSE;
+  }
+  if (!fgGeometry->GetListOfPhysicalNodes()) {
     AliWarningClass("gGeoManager doesn't contain any aligned nodes!");
-    if (!gGeoManager->cd(symname)) {
+    if (!fgGeometry->cd(symname)) {
       AliErrorClass(Form("Volume path %s not valid!",symname));
       return kFALSE;
     }
     else {
-      m = *gGeoManager->GetCurrentMatrix();
+      m = *fgGeometry->GetCurrentMatrix();
       return kTRUE;
     }
   }
 
+  TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
   const char* path = NULL;
-  TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
   if(pne){
     path = pne->GetTitle();
   }else{
@@ -839,21 +1060,38 @@ Bool_t AliGeomManager::GetOrigGlobalMatrix(const char *symname, TGeoHMatrix &m)
     path=symname;
   }
 
-  if (!gGeoManager->CheckPath(path)) {
-    AliErrorClass(Form("Volume path %s not valid!",path));
+  return GetOrigGlobalMatrixFromPath(path,m);
+}
+
+//_____________________________________________________________________________
+Bool_t AliGeomManager::GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m)
+{
+  // The method returns global matrix for the ideal detector geometry
+  // Symname identifies either the corresponding TGeoPNEntry or directly
+  // the volume path. The output global matrix is stored in 'm'.
+  // Returns kFALSE in case TGeo has not been initialized or the symname
+  // is invalid.
+  //
+  m.Clear();
+
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
+    AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
     return kFALSE;
   }
 
-  m.Clear();
+  if (!fgGeometry->CheckPath(path)) {
+    AliErrorClass(Form("Volume path %s not valid!",path));
+    return kFALSE;
+  }
 
-  TIter next(gGeoManager->GetListOfPhysicalNodes());
-  gGeoManager->cd(path);
+  TIter next(fgGeometry->GetListOfPhysicalNodes());
+  fgGeometry->cd(path);
 
-  while(gGeoManager->GetLevel()){
+  while(fgGeometry->GetLevel()){
 
     TGeoPhysicalNode *physNode = NULL;
     next.Reset();
-    TGeoNode *node = gGeoManager->GetCurrentNode();
+    TGeoNode *node = fgGeometry->GetCurrentNode();
     while ((physNode=(TGeoPhysicalNode*)next())) 
       if (physNode->GetNode() == node) break;
 
@@ -866,27 +1104,52 @@ Bool_t AliGeomManager::GetOrigGlobalMatrix(const char *symname, TGeoHMatrix &m)
 
     m.MultiplyLeft(lm);
 
-    gGeoManager->CdUp();
+    fgGeometry->CdUp();
   }
 
   return kTRUE;
 }
 
+//_____________________________________________________________________________
+TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(TGeoPNEntry* pne)
+{
+  // The method returns global matrix for the ideal detector geometry
+  // using the corresponding TGeoPNEntry as an input.
+  // The method creates a new matrix, so it has to be used carefully in order
+  // to avoid memory leaks.
+  // In case of missing TGeoManager the method return NULL.
+
+  if (!fgGeometry || !fgGeometry->IsClosed()) {
+    AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
+    return NULL;
+  }
+
+  const char* path = pne->GetTitle();
+  static TGeoHMatrix m;
+  if (!GetOrigGlobalMatrixFromPath(path,m))
+    return NULL;
+
+  return &m;
+}
+
 //______________________________________________________________________
-Bool_t AliGeomManager::GetOrigGlobalMatrix(Int_t index, TGeoHMatrix &m)
+TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(Int_t index)
 {
   // Get the original (ideal geometry) TGeo matrix for
   // a given module identified by 'index'.
-  // The method is slow, so it should be used
-  // with great care.
-
-  m.Clear();
-
-  ReactIfChangedGeom();
-  const char *symname = SymName(index);
-  if (!symname) return kFALSE;
+  // In general the method is slow, so we use
+  // LUT for fast access. The LUT is reset in case of
+  // new geometry is loaded.
+  Int_t modId;
+  ELayerID layerId = VolUIDToLayer(index,modId);
 
-  return GetOrigGlobalMatrix(symname,m);
+  if (fgOrigMatrix[layerId-kFirstLayer][modId])
+    return fgOrigMatrix[layerId-kFirstLayer][modId];
+  else {
+    TGeoPNEntry *pne = GetPNEntry(index);
+    if (!pne) return NULL;
+    return GetOrigGlobalMatrix(pne);
+  }
 }
 
 //______________________________________________________________________
@@ -895,10 +1158,10 @@ Bool_t AliGeomManager::GetOrigTranslation(Int_t index, Double_t t[3])
   // Get the original translation vector (ideal geometry)
   // for a given module 'index' by quering the TGeoManager
 
-  TGeoHMatrix m;
-  if (!GetOrigGlobalMatrix(index,m)) return kFALSE;
+  TGeoHMatrix *m = GetOrigGlobalMatrix(index);
+  if (!m) return kFALSE;
 
-  Double_t *trans = m.GetTranslation();
+  Double_t *trans = m->GetTranslation();
   for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
 
   return kTRUE;
@@ -910,10 +1173,10 @@ Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
   // Get the original rotation matrix (ideal geometry)
   // for a given module 'index' by quering the TGeoManager
 
-  TGeoHMatrix m;
-  if (!GetOrigGlobalMatrix(index,m)) return kFALSE;
+  TGeoHMatrix *m = GetOrigGlobalMatrix(index);
+  if (!m) return kFALSE;
 
-  Double_t *rot = m.GetRotationMatrix();
+  Double_t *rot = m->GetRotationMatrix();
   for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
 
   return kTRUE;
@@ -922,10 +1185,9 @@ Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
 //______________________________________________________________________
 const TGeoHMatrix* AliGeomManager::GetTracking2LocalMatrix(Int_t index)
 {
-  // Get the matrix which transforms from the tracking to local r.s.
+  // Get the matrix which transforms from the tracking to the local RS
   // The method queries directly the TGeoPNEntry
 
-  ReactIfChangedGeom();
   TGeoPNEntry *pne = GetPNEntry(index);
   if (!pne) return NULL;
 
@@ -967,21 +1229,12 @@ TGeoPNEntry* AliGeomManager::GetPNEntry(Int_t voluid) {
 }
 
 //_____________________________________________________________________________
-TGeoPNEntry* AliGeomManager::GetPNEntry(UShort_t voluid) {
-  // Returns the TGeoPNEntry for the given global volume ID "voluid"
-  //
-  Int_t modId;
-  ELayerID layerId = VolUIDToLayer(voluid,modId);
-  return GetPNEntry(layerId,modId);
-}
-
-//_____________________________________________________________________________
 TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
 {
   // Returns the TGeoPNEntry for a given layer
   // and module ID
   //
-  ReactIfChangedGeom();
+
   if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
     AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
     return NULL;
@@ -991,6 +1244,56 @@ TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
 }
 
 //_____________________________________________________________________________
+void AliGeomManager::CheckOverlapsOverPNs(Double_t threshold)
+{
+  // Check for overlaps/extrusions on physical nodes only;
+  // this overlap-checker is meant to be used to check overlaps/extrusions
+  // originated by the application of alignment objects.
+  //
+
+  TObjArray* ovexlist = new TObjArray(64);
+
+  AliInfoClass("********* Checking overlaps/extrusions over physical nodes only *********");
+  TObjArray* pnList = gGeoManager->GetListOfPhysicalNodes();
+  TGeoVolume* mvol = 0;
+  TGeoPhysicalNode* pn;
+  TObjArray* overlaps = new TObjArray(64);
+  overlaps->SetOwner();
+
+  TStopwatch timer2;
+  timer2.Start();
+  for(Int_t pni=0; pni<pnList->GetEntriesFast(); pni++){
+    pn = (TGeoPhysicalNode*) pnList->UncheckedAt(pni);
+    // checking the volume of the mother (go upper in the tree in case it is an assembly)
+    Int_t levup=1;
+    while(((TGeoVolume*)pn->GetVolume(pn->GetLevel()-levup))->IsAssembly()) levup++;
+      //Printf("Going to upper level");
+    mvol = pn->GetVolume(pn->GetLevel()-levup);
+    if(!mvol->IsSelected()){
+      AliInfoClass(Form("Checking overlaps for volume %s",mvol->GetName()));
+      mvol->CheckOverlaps(threshold);
+      ovexlist = gGeoManager->GetListOfOverlaps();
+      TIter next(ovexlist);
+      TGeoOverlap *ov;
+      while ((ov=(TGeoOverlap*)next())) overlaps->Add(ov->Clone());
+      mvol->SelectVolume();
+    }
+  }
+  mvol->SelectVolume(kTRUE); // clears the list of selected volumes
+
+  AliInfoClass(Form("Number of overlapping/extruding PNs: %d",overlaps->GetEntriesFast()));
+  timer2.Stop();
+  timer2.Print();
+
+  TIter nextN(overlaps);
+  TGeoOverlap *ovlp;
+  while ((ovlp=(TGeoOverlap*)nextN())) ovlp->PrintInfo();
+
+  overlaps->Delete();
+  delete overlaps;
+}
+
+//_____________________________________________________________________________
 Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
 {
   // Calls AddAlignObjsFromCDBSingleDet for the detectors appearing in
@@ -1005,9 +1308,9 @@ Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
   // Finally an overlaps check is performed.
   //
  
-  if(!fAlignObjArray) fAlignObjArray = new TObjArray();
-  fAlignObjArray->Clear();     
-  fAlignObjArray->SetOwner(0);
+  TObjArray alignObjArray;
+  alignObjArray.Clear();       
+  alignObjArray.SetOwner(0);
 
   TString alObjsNotLoaded="";
   TString alObjsLoaded="";
@@ -1019,8 +1322,8 @@ Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
   
   while((str = (TObjString*) iter.Next())){
     TString det(str->String());
-    AliInfo(Form("Loading alignment objs for %s",det.Data()));
-    if(!LoadAlignObjsFromCDBSingleDet(det.Data())){
+    AliInfoClass(Form("Loading alignment objs for %s",det.Data()));
+    if(!LoadAlignObjsFromCDBSingleDet(det.Data(),alignObjArray)){
       alObjsNotLoaded += det.Data();
       alObjsNotLoaded += " ";
     } else {
@@ -1029,16 +1332,16 @@ Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
     }
   }
 
-  if(!alObjsLoaded.IsNull()) AliInfo(Form("Alignment objects loaded for: %s",
-                                       alObjsLoaded.Data()));
-  if(!alObjsNotLoaded.IsNull()) AliInfo(Form("Didn't/couldn't load alignment objects for: %s",
-                                          alObjsNotLoaded.Data()));
+  if(!alObjsLoaded.IsNull()) AliInfoClass(Form("Alignment objects loaded for: %s",
+                                              alObjsLoaded.Data()));
+  if(!alObjsNotLoaded.IsNull()) AliInfoClass(Form("Didn't/couldn't load alignment objects for: %s",
+                                                 alObjsNotLoaded.Data()));
  
-  return(ApplyAlignObjsToGeom(fAlignObjArray));
+  return ApplyAlignObjsToGeom(alignObjArray);
 }
 
 //_____________________________________________________________________________
-Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName)
+Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray)
 {
   // Adds the alignable objects found in the CDBEntry for the detector
   // passed as argument to the array of all alignment objects to be applyed
@@ -1046,7 +1349,7 @@ Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName)
   //
   // Fills array of single detector's alignable objects from CDB
   
-  AliDebug(2, Form("Loading alignment objs for detector: %s",detName));
+  AliDebugClass(2, Form("Loading alignment objs for detector: %s",detName));
   
   AliCDBEntry *entry;
        
@@ -1054,56 +1357,57 @@ Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName)
        
   entry=AliCDBManager::Instance()->Get(path.GetPath());
   if(!entry){ 
-       AliDebug(2,Form("Couldn't load alignment data for detector %s",detName));
+       AliDebugClass(2,Form("Couldn't load alignment data for detector %s",detName));
        return kFALSE;
   }
   entry->SetOwner(1);
   TClonesArray *alignArray = (TClonesArray*) entry->GetObject();       
   alignArray->SetOwner(0);
-  AliDebug(2,Form("Found %d alignment objects for %s",
-                       alignArray->GetEntries(),detName));
+  AliDebugClass(2,Form("Found %d alignment objects for %s",
+                      alignArray->GetEntries(),detName));
 
   AliAlignObj *alignObj=0;
   TIter iter(alignArray);
        
   // loop over align objects in detector
   while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
-       fAlignObjArray->Add(alignObj);
+       alignObjArray.Add(alignObj);
   }
   // delete entry --- Don't delete, it is cached!
        
-  AliDebug(2, Form("fAlignObjArray entries: %d",fAlignObjArray->GetEntries() ));
+  AliDebugClass(2, Form("fAlignObjArray entries: %d",alignObjArray.GetEntries() ));
   return kTRUE;
 
 }
 
 //_____________________________________________________________________________
-Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray* alObjArray)
+Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray& alignObjArray, Bool_t ovlpcheck)
 {
   // Read collection of alignment objects (AliAlignObj derived) saved
   // in the TClonesArray alObjArray and apply them to gGeoManager
   //
-  ReactIfChangedGeom();
-
-  alObjArray->Sort();
-  Int_t nvols = alObjArray->GetEntriesFast();
+  alignObjArray.Sort();
+  Int_t nvols = alignObjArray.GetEntriesFast();
 
   Bool_t flag = kTRUE;
 
   for(Int_t j=0; j<nvols; j++)
     {
-      AliAlignObj* alobj = (AliAlignObj*) alObjArray->UncheckedAt(j);
-      if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
+      AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
+      if (alobj->ApplyToGeometry(ovlpcheck) == kFALSE) flag = kFALSE;
     }
 
   if (AliDebugLevelClass() >= 1) {
-    gGeoManager->GetTopNode()->CheckOverlaps(1);
-    TObjArray* ovexlist = gGeoManager->GetListOfOverlaps();
+    fgGeometry->GetTopNode()->CheckOverlaps(1);
+    TObjArray* ovexlist = fgGeometry->GetListOfOverlaps();
     if(ovexlist->GetEntriesFast()){  
-      AliError("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
+      AliErrorClass("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
    }
   }
 
+  // Update the TGeoPhysicalNodes
+  fgGeometry->RefreshPhysicalNodes();
+
   return flag;
 
 }
@@ -1122,14 +1426,14 @@ Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* fileName, const char* cl
     return kFALSE;
   }
 
-  TClonesArray* alObjArray = ((TClonesArray*) inFile->Get(clArrayName));
+  TClonesArray* alignObjArray = ((TClonesArray*) inFile->Get(clArrayName));
   inFile->Close();
-  if (!alObjArray) {
+  if (!alignObjArray) {
     AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
     return kFALSE;
   }
 
-  return ApplyAlignObjsToGeom(alObjArray);
+  return ApplyAlignObjsToGeom(*alignObjArray);
 
 }
 
@@ -1144,9 +1448,9 @@ Bool_t AliGeomManager::ApplyAlignObjsToGeom(AliCDBParam* param, AliCDBId& Id)
 
   AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(param);
   AliCDBEntry* entry = storage->Get(Id);
-  TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
+  TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
 
-  return ApplyAlignObjsToGeom(AlObjArray);
+  return ApplyAlignObjsToGeom(*alignObjArray);
 
 }
 
@@ -1179,21 +1483,7 @@ Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, I
   AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
 
   if(!entry) return kFALSE;
-  TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
-
-  return ApplyAlignObjsToGeom(AlObjArray);
-}
+  TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
 
-//_____________________________________________________________________________
-void AliGeomManager::ReactIfChangedGeom()
-{
-  // Check if the TGeo geometry has changed. In that case reinitialize the
-  // look-up tables
-  //
-  if(HasGeomChanged())
-    {
-      fgGeometry = gGeoManager;
-      InitSymNamesLUT();
-      InitPNEntriesLUT();
-    }
+  return ApplyAlignObjsToGeom(*alignObjArray);
 }