0x0
};
-AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
+TGeoHMatrix** AliGeomManager::fgOrigMatrix[kLastLayer - kFirstLayer] = {
0x0,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
+};
TGeoManager* AliGeomManager::fgGeometry = 0x0;
//_____________________________________________________________________________
-AliGeomManager* AliGeomManager::Instance()
+void AliGeomManager::LoadGeometry(const char *geomFileName)
{
-// returns AliGeomManager instance (singleton)
+// initialization
- if (!fgInstance) {
- fgInstance = new AliGeomManager();
- fgInstance->Init();
- }
- return fgInstance;
-}
+ fgGeometry = NULL;
+ if (geomFileName && (!gSystem->AccessPathName(geomFileName))) { // gemotry.root exists
+ fgGeometry = TGeoManager::Import(geomFileName);
+ AliInfoClass("Using custom geometry.root file");
+ }
+
+ 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!");
+ }
-//_____________________________________________________________________________
-void AliGeomManager::Init()
-{
-// initialization
- if(!gGeoManager) AliFatal("Impossible to initialize AliGeomManager without an active geometry");
- fgGeometry = gGeoManager;
InitSymNamesLUT();
InitPNEntriesLUT();
+ InitOrigMatricesLUT();
}
//_____________________________________________________________________________
AliGeomManager::AliGeomManager():
- TObject(),
-
- fAlignObjArray(NULL)
+ TObject()
{
// default constructor
}
AliGeomManager::~AliGeomManager()
{
// dummy destructor
- if(fAlignObjArray) fAlignObjArray->Delete();
- delete fAlignObjArray;
}
//_____________________________________________________________________________
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;
}
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);
}
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;
}
// 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(!gGeoManager) AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
+ if(!fgGeometry) {
+ AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
+ return;
+ }
- InitSymNamesLUT();
-
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]);
+ }
+ }
+}
+
+//_____________________________________________________________________________
+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++){
+ for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
+ fgOrigMatrix[iLayer] = new TGeoHMatrix*[fgLayerSize[iLayer]];
for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
- fgPNEntry[iLayer][modnum] = gGeoManager->GetAlignableEntry(fgSymName[iLayer][modnum].Data());
+ if (!fgPNEntry[iLayer][modnum]) continue;
+ TGeoHMatrix *m = GetOrigGlobalMatrix(fgPNEntry[iLayer][modnum]);
+ if (!m) continue;
+ fgOrigMatrix[iLayer][modnum] = new TGeoHMatrix(*m);
}
}
+
}
//______________________________________________________________________
// Get the transformation matrix for a given PNEntry
// by quering the TGeoManager
- if (!gGeoManager || !gGeoManager->IsClosed()) {
+ if (!fgGeometry || !fgGeometry->IsClosed()) {
AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
return NULL;
}
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();
}
//______________________________________________________________________
// Get the global transformation matrix for a given alignable volume
// identified by its symbolic name 'symname' by quering the TGeoManager
- if(!ReactIfChangedGeom()) return NULL;
- 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);
return kTRUE;
}
-//_____________________________________________________________________________
-Bool_t AliGeomManager::GetOrigGlobalMatrix(const char *symname, TGeoHMatrix &m)
+//______________________________________________________________________
+Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, 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.
- //
+ // 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 (!gGeoManager || !gGeoManager->IsClosed()) {
- AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
+ if (!fgGeometry || !fgGeometry->IsClosed()) {
+ AliErrorClass("No active geometry or geometry not yet closed!");
return kFALSE;
}
-
- if (!gGeoManager->GetListOfPhysicalNodes()) {
+ 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{
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;
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();
-
- 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);
+ }
}
//______________________________________________________________________
// 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;
// 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;
return GetPNEntry(layerId,modId);
}
-//_____________________________________________________________________________
-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)
{
// and module ID
//
- if(!fgPNEntry[0]) InitPNEntriesLUT();
- if(!ReactIfChangedGeom()) return NULL;
-
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;
// 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="";
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 {
}
}
- 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
//
// 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;
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)
{
// 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);
+ AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
if (alobj->ApplyToGeometry() == 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;
}
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);
}
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);
}
AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
if(!entry) return kFALSE;
- TClonesArray* AlObjArray = ((TClonesArray*) entry->GetObject());
-
- return ApplyAlignObjsToGeom(AlObjArray);
-}
-
-//_____________________________________________________________________________
-Bool_t AliGeomManager::ReactIfChangedGeom()
-{
- // Check if the TGeo geometry has changed. In that case reinitialize the
- // look-up table mapping volume indexes to TGeoPNEntries
- //
+ TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
- if (!gGeoManager || !gGeoManager->IsClosed()) {
- AliErrorClass("No active geometry or geometry not yet closed!");
- return kFALSE;
- }
-
- if(HasGeomChanged())
- {
- fgGeometry = gGeoManager;
- InitPNEntriesLUT();
- }
-
- return kTRUE;
+ return ApplyAlignObjsToGeom(*alignObjArray);
}
//
#include <TObject.h>
-#include <TGeoManager.h>
+
+class TGeoManager;
+class TGeoPNEntry;
+class TGeoHMatrix;
class TObjArray;
static const char* SymName(UShort_t voluid);
static const char* SymName(ELayerID layerId, Int_t modId);
- static TGeoPNEntry* GetPNEntry(Int_t index);
- static TGeoPNEntry* GetPNEntry(UShort_t index);
- static TGeoPNEntry* GetPNEntry(ELayerID layerId, Int_t modId);
-
static Bool_t GetFromGeometry(const char *symname, AliAlignObj &alobj);
static AliAlignObj* GetAlignObj(UShort_t voluid);
static AliAlignObj* GetAlignObj(ELayerID layerId, Int_t modId);
//to be used making a copy of the returned pointer to TGeoHMatrix!!
- static TGeoHMatrix* GetMatrix(TGeoPNEntry* pne);
static TGeoHMatrix* GetMatrix(Int_t index);
static TGeoHMatrix* GetMatrix(const char *symname);
static Bool_t GetTranslation(Int_t index, Double_t t[3]);
static Bool_t GetRotation(Int_t index, Double_t r[9]);
- static Bool_t GetOrigGlobalMatrix(Int_t index, TGeoHMatrix &m);
+ static TGeoHMatrix* GetOrigGlobalMatrix(Int_t index);
static Bool_t GetOrigGlobalMatrix(const char *symname, TGeoHMatrix &m);
static Bool_t GetOrigTranslation(Int_t index, Double_t t[3]);
static Bool_t GetOrigRotation(Int_t index, Double_t r[9]);
static const TGeoHMatrix* GetTracking2LocalMatrix(Int_t index);
static Bool_t GetTrackingMatrix(Int_t index, TGeoHMatrix &m);
- Bool_t ApplyAlignObjsToGeom(TObjArray* alObjArray);
+ static void LoadGeometry(const char *geomFileName = NULL);
+
+ static Bool_t ApplyAlignObjsToGeom(TObjArray& alObjArray);
- Bool_t ApplyAlignObjsToGeom(const char* fileName,
+ static Bool_t ApplyAlignObjsToGeom(const char* fileName,
const char* clArrayName);
- Bool_t ApplyAlignObjsToGeom(AliCDBParam* param,
+ static Bool_t ApplyAlignObjsToGeom(AliCDBParam* param,
AliCDBId& Id);
- Bool_t ApplyAlignObjsToGeom(const char* uri, const char* path,
+ static Bool_t ApplyAlignObjsToGeom(const char* uri, const char* path,
Int_t runnum, Int_t version,
Int_t sversion);
- Bool_t ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version,
+ static Bool_t ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version,
Int_t sversion);
- Bool_t ApplyAlignObjsFromCDB(const char* AlDetsList);
- Bool_t LoadAlignObjsFromCDBSingleDet(const char* detName);
+ static Bool_t ApplyAlignObjsFromCDB(const char* AlDetsList);
+ static Bool_t LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray);
~AliGeomManager();
- static AliGeomManager* Instance();
+ private:
+ AliGeomManager();
+ AliGeomManager(const AliGeomManager&);
+ AliGeomManager& operator=(const AliGeomManager&);
+
+ static TGeoHMatrix* GetMatrix(TGeoPNEntry* pne);
+ static TGeoHMatrix* GetOrigGlobalMatrix(TGeoPNEntry* pne);
+ static Bool_t GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m);
- protected:
+ static TGeoPNEntry* GetPNEntry(Int_t index);
+ static TGeoPNEntry* GetPNEntry(ELayerID layerId, Int_t modId);
static void InitAlignObjFromGeometry();
static void InitSymNamesLUT();
static void InitPNEntriesLUT();
+ static void InitOrigMatricesLUT();
+
+ static TGeoManager* fgGeometry;
static Int_t fgLayerSize[kLastLayer - kFirstLayer]; // Size of layers
static const char* fgLayerName[kLastLayer - kFirstLayer]; // Name of layers
static TString* fgSymName[kLastLayer - kFirstLayer]; // Symbolic volume names
static TGeoPNEntry** fgPNEntry[kLastLayer - kFirstLayer]; // TGeoPNEntries
+ static TGeoHMatrix** fgOrigMatrix[kLastLayer - kFirstLayer]; // Original matrices before misalignment
static AliAlignObj** fgAlignObjs[kLastLayer - kFirstLayer]; // Alignment objects
- private:
- AliGeomManager();
- AliGeomManager(const AliGeomManager&);
- AliGeomManager& operator=(const AliGeomManager&);
-
- static Bool_t ReactIfChangedGeom();
- static Bool_t HasGeomChanged(){return fgGeometry!=gGeoManager;}
- static TGeoManager* fgGeometry;
-
-
-
- static AliGeomManager* fgInstance; // the AliGeomManager singleton instance
-
- TObjArray* fAlignObjArray; // array with the alignment objects to be applied to the geometry
-
- void Init();
-
ClassDef(AliGeomManager, 0);
};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff