1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15 //-------------------------------------------------------------------------
16 // Implementation of AliGeomManager, the geometry manager class
17 // which interfaces to TGeo and the look-up table mapping unique
18 // volume indices to symbolic volume names. For that it collects
19 // several static methods.
20 //-------------------------------------------------------------------------
24 #include <TGeoManager.h>
25 #include <TObjString.h>
26 #include <TGeoPhysicalNode.h>
27 #include <TClonesArray.h>
28 #include <TGeoMatrix.h>
29 #include <TGeoPhysicalNode.h>
31 #include <TStopwatch.h>
32 #include <TGeoOverlap.h>
33 #include <TPluginManager.h>
36 #include "AliGeomManager.h"
38 #include "AliAlignObj.h"
39 #include "AliAlignObjParams.h"
40 #include "AliCDBManager.h"
41 #include "AliCDBStorage.h"
42 #include "AliCDBEntry.h"
44 ClassImp(AliGeomManager)
46 Int_t AliGeomManager::fgLayerSize[kLastLayer - kFirstLayer] = {
47 80, 160, // ITS SPD first and second layer
48 84, 176, // ITS SDD first and second layer
49 748, 950, // ITS SSD first and second layer
50 36, 36, // TPC inner and outer chambers
51 90, 90, 90, 90, 90, 90, // 6 TRD chambers' layers
59 const char* AliGeomManager::fgLayerName[kLastLayer - kFirstLayer] = {
60 "ITS inner pixels layer", "ITS outer pixels layer",
61 "ITS inner drifts layer", "ITS outer drifts layer",
62 "ITS inner strips layer", "ITS outer strips layer",
63 "TPC inner chambers layer", "TPC outer chambers layer",
64 "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
65 "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
67 "PHOS EMC layer","PHOS CPV layer",
73 TGeoPNEntry** AliGeomManager::fgPNEntry[kLastLayer - kFirstLayer] = {
87 AliAlignObj** AliGeomManager::fgAlignObjs[kLastLayer - kFirstLayer] = {
101 const char* AliGeomManager::fgkDetectorName[AliGeomManager::fgkNDetectors] =
102 {"GRP","ITS","TPC","TRD","TOF","PHOS","HMPID","EMCAL","MUON","FMD","ZDC","PMD","T0","VZERO","ACORDE","AD","MFT","FIT"};
103 Int_t AliGeomManager::fgNalignable[fgkNDetectors] = {0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
105 TGeoManager* AliGeomManager::fgGeometry = 0x0;
107 //_____________________________________________________________________________
108 void AliGeomManager::LoadGeometry(const char *geomFileName)
111 // Load geometry either from a file
112 // or from the corresponding CDB entry
114 if(fgGeometry->IsLocked()){
115 AliErrorClass("Cannot load a new geometry, the current one being locked. Setting internal geometry to null!!");
121 if (geomFileName && (!gSystem->AccessPathName(geomFileName))) {
122 fgGeometry = TGeoManager::Import(geomFileName);
123 AliInfoClass(Form("From now on using geometry from custom geometry file \"%s\"",geomFileName));
127 AliCDBPath path("GRP","Geometry","Data");
129 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
130 if(!entry) AliFatalClass("Couldn't load geometry data from CDB!");
133 fgGeometry = (TGeoManager*) entry->GetObject();
134 if (!fgGeometry) AliFatalClass("Couldn't find TGeoManager in the specified CDB entry!");
136 AliInfoClass(Form("From now on using geometry from CDB base folder \"%s\"",
137 AliCDBManager::Instance()->GetURI("GRP/Geometry/Data")));
144 //_____________________________________________________________________________
145 void AliGeomManager::SetGeometry(TGeoManager * const geom)
147 // Load already active geometry
148 if (!geom) AliFatalClass("Pointer to the active geometry is 0x0!");
155 //_____________________________________________________________________________
156 AliGeomManager::AliGeomManager():
159 // default constructor
162 //_____________________________________________________________________________
163 AliGeomManager::~AliGeomManager()
168 //_____________________________________________________________________________
169 Int_t AliGeomManager::LayerSize(Int_t layerId)
171 // Get the layer size for layer corresponding to layerId.
172 // Implemented only for ITS,TPC,TRD,TOF and HMPID
174 if (layerId < kFirstLayer || layerId >= kLastLayer) {
175 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
179 return fgLayerSize[layerId - kFirstLayer];
183 //_____________________________________________________________________________
184 const char* AliGeomManager::LayerName(Int_t layerId)
186 // Get the layer name corresponding to layerId.
187 // Implemented only for ITS,TPC,TRD,TOF and HMPID
189 if (layerId < kFirstLayer || layerId >= kLastLayer) {
190 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
191 return "Invalid Layer!";
194 return fgLayerName[layerId - kFirstLayer];
198 //_____________________________________________________________________________
199 UShort_t AliGeomManager::LayerToVolUID(ELayerID layerId, Int_t modId)
201 // From detector (layer) name and module number (according to detector
202 // internal numbering) build the unique numerical identity of that volume
204 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
205 // remaining 11 for module ID inside det (2048 possible values).
206 // NO check for validity of given modId inside the layer for speed's sake.
208 return ((UShort_t(layerId) << 11) | UShort_t(modId));
211 //_____________________________________________________________________________
212 UShort_t AliGeomManager::LayerToVolUID(Int_t layerId, Int_t modId)
214 // From detector (layer) name and module number (according to detector
215 // internal numbering) build the unique numerical identity of that volume
217 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
218 // remaining 11 for module ID inside det (2048 possible values).
219 // NO check for validity of given modId inside the layer for speed's sake.
221 return ((UShort_t(layerId) << 11) | UShort_t(modId));
224 //_____________________________________________________________________________
225 UShort_t AliGeomManager::LayerToVolUIDSafe(ELayerID layerId, Int_t modId)
227 // From detector (layer) name and module number (according to detector
228 // internal numbering) build the unique numerical identity of that volume
230 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
231 // remaining 11 for module ID inside det (2048 possible values).
232 // Check validity of given modId inside the layer.
234 if(modId < 0 || modId >= LayerSize(layerId)){
235 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
238 return ((UShort_t(layerId) << 11) | UShort_t(modId));
241 //_____________________________________________________________________________
242 UShort_t AliGeomManager::LayerToVolUIDSafe(Int_t layerId, Int_t modId)
244 // From detector (layer) name and module number (according to detector
245 // internal numbering) build the unique numerical identity of that volume
247 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
248 // remaining 11 for module ID inside det (2048 possible values).
249 // Check validity of given modId inside the layer.
251 if(modId < 0 || modId >= LayerSize(layerId)){
252 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
255 return ((UShort_t(layerId) << 11) | UShort_t(modId));
258 //_____________________________________________________________________________
259 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid, Int_t &modId)
261 // From voluid, unique numerical identity of that volume inside ALICE,
262 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
263 // remaining 11 for module ID inside det (2048 possible values)), return
264 // the identity of the layer to which that volume belongs and sets the
265 // argument modId to the identity of that volume internally to the layer.
266 // NO check for validity of given voluid for speed's sake.
268 modId = voluid & 0x7ff;
270 return VolUIDToLayer(voluid);
273 //_____________________________________________________________________________
274 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid)
276 // From voluid, unique numerical identity of that volume inside ALICE,
277 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
278 // remaining 11 for module ID inside det (2048 possible values)), return
279 // the identity of the layer to which that volume belongs
280 // NO check for validity of given voluid for speed's sake.
282 return ELayerID(voluid >> 11);
285 //_____________________________________________________________________________
286 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid, Int_t &modId)
288 // From voluid, unique numerical identity of that volume inside ALICE,
289 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
290 // remaining 11 for module ID inside det (2048 possible values)), returns
291 // the identity of the layer to which that volume belongs and sets the
292 // argument modId to the identity of that volume internally to the layer.
293 // Checks the validity of the given voluid
295 ELayerID layId = VolUIDToLayerSafe(voluid);
296 if(layId != AliGeomManager::kInvalidLayer){
297 Int_t mId = Int_t(voluid & 0x7ff);
298 if( mId>=0 && mId<LayerSize(layId)){
304 AliErrorClass(Form("Invalid unique volume id: %d !",voluid));
306 return kInvalidLayer;
310 //_____________________________________________________________________________
311 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid)
313 // From voluid, unique numerical identity of that volume inside ALICE,
314 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
315 // remaining 11 for module ID inside det (2048 possible values)), returns
316 // the identity of the layer to which that volume belongs
317 // Checks the validity of the given voluid
319 if( (voluid >> 11) < kLastLayer) return ELayerID(voluid >> 11);
321 AliErrorClass(Form("Invalid layer id: %d !",(voluid >> 11)));
322 return kInvalidLayer;
326 //_____________________________________________________________________________
327 Bool_t AliGeomManager::GetFromGeometry(const char *symname, AliAlignObj &alobj)
329 // Get the alignment object which corresponds to the symbolic volume name
330 // symname (in case equal to the TGeo volume path)
331 // The method is extremely slow due to the searching by string,
332 // therefore it should be used with great care!!
333 // This method returns FALSE if the symname of the object was not
334 // valid neither to get a TGeoPEntry nor as a volume path, or if the path
335 // associated to the TGeoPNEntry was not valid.
338 // Reset the alignment object
339 alobj.SetPars(0,0,0,0,0,0);
340 alobj.SetSymName(symname);
342 if (!fgGeometry || !fgGeometry->IsClosed()) {
343 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
347 if (!fgGeometry->GetListOfPhysicalNodes()) {
348 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
353 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
355 path = pne->GetTitle();
357 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
360 TObjArray* nodesArr = fgGeometry->GetListOfPhysicalNodes();
361 TGeoPhysicalNode* node = NULL;
362 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
363 TGeoPhysicalNode* tempNode = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
364 const char *nodePath = tempNode->GetName();
365 if (strcmp(path,nodePath) == 0) {
372 if (!fgGeometry->cd(path)) {
373 AliErrorClass(Form("%s not valid neither as symbolic volume name nor as volume path!",path));
377 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
382 TGeoHMatrix align,gprime,g,ginv,l;
383 gprime = *node->GetMatrix();
384 l = *node->GetOriginalMatrix();
385 g = *node->GetMatrix(node->GetLevel()-1);
388 align = gprime * ginv;
390 return alobj.SetMatrix(align);
394 //_____________________________________________________________________________
395 void AliGeomManager::InitAlignObjFromGeometry()
397 // Loop over all alignable volumes and extract
398 // the corresponding alignment objects from
401 for (Int_t iLayer = kFirstLayer; iLayer < AliGeomManager::kLastLayer; iLayer++) {
402 if (!fgAlignObjs[iLayer-kFirstLayer]) {
403 fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[LayerSize(iLayer)];
405 for (Int_t iModule = 0; iModule < LayerSize(iLayer); iModule++) {
406 UShort_t volid = LayerToVolUID(iLayer,iModule);
407 fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjParams("",volid,0,0,0,0,0,0,kTRUE);
408 const char *symname = SymName(volid);
409 if (!GetFromGeometry(symname, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
410 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,symname));
416 //_____________________________________________________________________________
417 AliAlignObj* AliGeomManager::GetAlignObj(UShort_t voluid)
419 // Returns the alignment object for given volume ID
422 ELayerID layerId = VolUIDToLayer(voluid,modId);
423 return GetAlignObj(layerId,modId);
426 //_____________________________________________________________________________
427 AliAlignObj* AliGeomManager::GetAlignObj(ELayerID layerId, Int_t modId)
429 // Returns pointer to alignment object given its layer and module ID
431 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
432 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
435 InitAlignObjFromGeometry();
437 return fgAlignObjs[layerId-kFirstLayer][modId];
440 //_____________________________________________________________________________
441 const char* AliGeomManager::SymName(UShort_t voluid)
443 // Returns the symbolic volume name for given volume ID
446 ELayerID layerId = VolUIDToLayer(voluid,modId);
447 return SymName(layerId,modId);
450 //_____________________________________________________________________________
451 const char* AliGeomManager::SymName(ELayerID layerId, Int_t modId)
453 // Returns the symbolic volume name given for a given layer
457 AliErrorClass("No geometry instance loaded yet!");
460 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
461 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
465 TGeoPNEntry* pne = fgPNEntry[layerId-kFirstLayer][modId];
468 AliWarningClass(Form("Module %d of layer %s is not activated!",modId,LayerName(layerId)));
471 return pne->GetName();
475 //_____________________________________________________________________________
476 Bool_t AliGeomManager::CheckSymNamesLUT(const char* /*detsToBeChecked*/)
478 // Check the look-up table which associates the unique numerical identity of
479 // each alignable volume to the corresponding symbolic volume name.
480 // The LUT is now held inside the geometry and handled by TGeo.
481 // The method is meant to be launched when loading a geometry to verify that
482 // no changes in the symbolic names have been introduced, which would prevent
483 // backward compatibility with alignment objects.
484 // To accept both complete and partial geometry, this method skips the check
485 // for TRD and TOF volumes which are missing in the partial geometry.
488 // TString detsString(detsToBeChecked);
489 // if(detsString.Contains("ALL")) detsString="ITS TPC TOF TRD HMPID PHOS EMCAL";
491 // Temporary measure to face the case of reconstruction over detectors not present in the geometry
492 TString detsString = "";
493 if(fgGeometry->CheckPath("ALIC_1/ITSV_1")) detsString+="ITS ";
494 if(fgGeometry->CheckPath("ALIC_1/TPC_M_1")) detsString+="TPC ";
497 TString baseTof("ALIC_1/B077_1/BSEGMO");
498 TString middleTof("_1/BTOF");
499 TString trailTof("_1/FTOA_0");
500 Bool_t tofActive=kFALSE;
502 for(Int_t sm=0; sm<18; sm++)
510 if(fgGeometry->CheckPath(tofsm.Data()))
516 if(tofActive) detsString+="TOF ";
519 TString baseTrd("ALIC_1/B077_1/BSEGMO");
520 TString middleTrd("_1/BTRD");
521 TString trailTrd("_1/UTR1_1");
522 Bool_t trdActive=kFALSE;
524 for(Int_t sm=0; sm<18; sm++)
532 if(fgGeometry->CheckPath(trdsm.Data()))
538 if(trdActive) detsString+="TRD ";
540 if(fgGeometry->CheckPath("ALIC_1/Hmp0_0")) detsString+="HMPID ";
542 TString phosMod, cpvMod;
543 TString basePhos("ALIC_1/PHOS_");
544 Bool_t phosActive=kFALSE;
545 Bool_t cpvActive=kFALSE;
547 for(Int_t pmod=0; pmod<5; pmod++)
549 phosMods[pmod]=kFALSE;
554 if(fgGeometry->CheckPath(phosMod.Data()))
557 phosMods[pmod]=kTRUE;
558 if(fgGeometry->CheckPath(cpvMod.Data())) cpvActive=kTRUE;
561 if(phosActive) detsString+="PHOS ";
563 // Check over the ten EMCAL full supermodules and the two EMCAL half supermodules
565 TString baseEmcalSM("ALIC_1/XEN1_1/");
566 Bool_t emcalActive=kFALSE;
567 Bool_t emcalSMs[22] = {kFALSE};
568 for(Int_t sm=0; sm<22; sm++)
581 if(fgGeometry->CheckPath(emcalSM.Data()))
587 if(emcalActive) detsString+="EMCAL ";
592 TGeoPNEntry* pne = 0x0;
593 Int_t uid; // global unique identity
594 Int_t modnum; // unique id inside layer; in the following, set it to 0 at the start of each layer
596 if(detsString.Contains("ITS")){
597 /********************* ITS layers ***********************/
598 AliDebugClass(2,"Checking consistency of symbolic names for ITS layers");
599 TString strSPD = "ITS/SPD";
600 TString strSDD = "ITS/SDD";
601 TString strSSD = "ITS/SSD";
602 TString strStave = "/Stave";
603 TString strHalfStave = "/HalfStave";
604 TString strLadder = "/Ladder";
605 TString strSector = "/Sector";
606 TString strSensor = "/Sensor";
607 TString strEntryName1;
608 TString strEntryName2;
609 TString strEntryName3;
611 /********************* SPD layer1 ***********************/
615 for(Int_t cSect = 0; cSect<10; cSect++){
616 strEntryName1 = strSPD;
618 strEntryName1 += strSector;
619 strEntryName1 += cSect;
621 for(Int_t cStave =0; cStave<2; cStave++){
622 strEntryName2 = strEntryName1;
623 strEntryName2 += strStave;
624 strEntryName2 += cStave;
626 for (Int_t cHS=0; cHS<2; cHS++) {
627 strEntryName3 = strEntryName2;
628 strEntryName3 += strHalfStave;
629 strEntryName3 += cHS;
631 for(Int_t cLad =0; cLad<2; cLad++){
632 symname = strEntryName3;
633 symname += strLadder;
634 symname += cLad+cHS*2;
635 uid = LayerToVolUID(kSPD1,modnum++);
636 pne = fgGeometry->GetAlignableEntryByUID(uid);
639 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
642 sname = pne->GetName();
643 if(symname.CompareTo(sname))
645 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
646 "Expected was %s, found was %s!", uid, symname.Data(), sname));
655 /********************* SPD layer2 ***********************/
659 for(Int_t cSect = 0; cSect<10; cSect++){
660 strEntryName1 = strSPD;
662 strEntryName1 += strSector;
663 strEntryName1 += cSect;
665 for(Int_t cStave =0; cStave<4; cStave++){
666 strEntryName2 = strEntryName1;
667 strEntryName2 += strStave;
668 strEntryName2 += cStave;
670 for (Int_t cHS=0; cHS<2; cHS++) {
671 strEntryName3 = strEntryName2;
672 strEntryName3 += strHalfStave;
673 strEntryName3 += cHS;
675 for(Int_t cLad =0; cLad<2; cLad++){
676 symname = strEntryName3;
677 symname += strLadder;
678 symname += cLad+cHS*2;
679 uid = LayerToVolUID(kSPD2,modnum++);
680 pne = fgGeometry->GetAlignableEntryByUID(uid);
683 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
686 sname = pne->GetName();
687 if(symname.CompareTo(sname))
689 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
690 "Expected was %s, found was %s!", uid, symname.Data(), sname));
699 /********************* SDD layer1 ***********************/
703 for(Int_t c1 = 1; c1<=14; c1++){
704 strEntryName1 = strSDD;
706 strEntryName1 +=strLadder;
707 strEntryName1 += (c1-1);
708 for(Int_t c2 =1; c2<=6; c2++){
709 symname = strEntryName1;
710 symname += strSensor;
712 uid = LayerToVolUID(kSDD1,modnum++);
713 pne = fgGeometry->GetAlignableEntryByUID(uid);
716 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
719 sname = pne->GetName();
720 if(symname.CompareTo(sname))
722 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
723 "Expected was %s, found was %s!", uid, symname.Data(), sname));
730 /********************* SDD layer2 ***********************/
734 for(Int_t c1 = 1; c1<=22; c1++){
735 strEntryName1 = strSDD;
737 strEntryName1 +=strLadder;
738 strEntryName1 += (c1-1);
739 for(Int_t c2 = 1; c2<=8; c2++){
740 symname = strEntryName1;
741 symname += strSensor;
743 uid = LayerToVolUID(kSDD2,modnum++);
744 pne = fgGeometry->GetAlignableEntryByUID(uid);
747 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
750 sname = pne->GetName();
751 if(symname.CompareTo(sname))
753 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
754 "Expected was %s, found was %s!", uid, symname.Data(), sname));
761 /********************* SSD layer1 ***********************/
765 for(Int_t c1 = 1; c1<=34; c1++){
766 strEntryName1 = strSSD;
768 strEntryName1 +=strLadder;
769 strEntryName1 += (c1-1);
770 for(Int_t c2 = 1; c2<=22; c2++){
771 symname = strEntryName1;
772 symname += strSensor;
774 uid = LayerToVolUID(kSSD1,modnum++);
775 pne = fgGeometry->GetAlignableEntryByUID(uid);
778 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
781 sname = pne->GetName();
782 if(symname.CompareTo(sname))
784 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
785 "Expected was %s, found was %s!", uid, symname.Data(), sname));
792 /********************* SSD layer2 ***********************/
796 for(Int_t c1 = 1; c1<=38; c1++){
797 strEntryName1 = strSSD;
799 strEntryName1 +=strLadder;
800 strEntryName1 += (c1-1);
801 for(Int_t c2 = 1; c2<=25; c2++){
802 symname = strEntryName1;
803 symname += strSensor;
805 uid = LayerToVolUID(kSSD2,modnum++);
806 pne = fgGeometry->GetAlignableEntryByUID(uid);
809 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
812 sname = pne->GetName();
813 if(symname.CompareTo(sname))
815 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
816 "Expected was %s, found was %s!", uid, symname.Data(), sname));
823 AliDebugClass(2,"Consistency check for ITS symbolic names finished successfully.");
826 if(detsString.Contains("TPC"))
828 /*************** TPC inner and outer layers ****************/
830 AliDebugClass(2,"Checking consistency of symbolic names for TPC layers");
831 TString sAsector="TPC/EndcapA/Sector";
832 TString sCsector="TPC/EndcapC/Sector";
833 TString sInner="/InnerChamber";
834 TString sOuter="/OuterChamber";
836 /*************** TPC inner chambers' layer ****************/
840 for(Int_t cnt=1; cnt<=18; cnt++)
845 uid = LayerToVolUID(kTPC1,modnum++);
846 pne = fgGeometry->GetAlignableEntryByUID(uid);
849 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
852 sname = pne->GetName();
853 if(symname.CompareTo(sname))
855 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
856 "Expected was %s, found was %s!", uid, symname.Data(), sname));
861 for(Int_t cnt=1; cnt<=18; cnt++)
866 uid = LayerToVolUID(kTPC1,modnum++);
867 pne = fgGeometry->GetAlignableEntryByUID(uid);
870 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
873 sname = pne->GetName();
874 if(symname.CompareTo(sname))
876 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
877 "Expected was %s, found was %s!", uid, symname.Data(), sname));
883 /*************** TPC outer chambers' layer ****************/
887 for(Int_t cnt=1; cnt<=18; cnt++)
892 uid = LayerToVolUID(kTPC2,modnum++);
893 pne = fgGeometry->GetAlignableEntryByUID(uid);
896 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
899 sname = pne->GetName();
900 if(symname.CompareTo(sname))
902 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
903 "Expected was %s, found was %s!", uid, symname.Data(), sname));
908 for(Int_t cnt=1; cnt<=18; cnt++)
913 uid = LayerToVolUID(kTPC2,modnum++);
914 pne = fgGeometry->GetAlignableEntryByUID(uid);
917 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
920 sname = pne->GetName();
921 if(symname.CompareTo(sname))
923 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
924 "Expected was %s, found was %s!", uid, symname.Data(), sname));
930 AliDebugClass(2,"Consistency check for TPC symbolic names finished successfully.");
933 if(detsString.Contains("TOF"))
935 /********************* TOF layer ***********************/
937 AliDebugClass(2,"Checking consistency of symbolic names for TOF layers");
944 Int_t nStrips=nstrA+2*nstrB+2*nstrC;
946 TString snSM = "TOF/sm";
947 TString snSTRIP = "/strip";
949 for (Int_t isect = 0; isect < nSectors; isect++) {
950 if(tofSMs[isect]) AliDebugClass(3,Form("Consistency check for symnames of TOF supermodule %d.",isect));
951 for (Int_t istr = 1; istr <= nStrips; istr++) {
953 symname += Form("%02d",isect);
955 symname += Form("%02d",istr);
956 uid = LayerToVolUID(kTOF,modnum++);
957 if(!tofSMs[isect]) continue; // taking possible missing TOF sectors (partial geometry) into account
958 if ((isect==13 || isect==14 || isect==15) && (istr >= 39 && istr <= 53)) continue; //taking holes into account
959 pne = fgGeometry->GetAlignableEntryByUID(uid);
962 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
965 sname = pne->GetName();
966 if(symname.CompareTo(sname))
968 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
969 "Expected was %s, found was %s!", uid, symname.Data(), sname));
975 AliDebugClass(2,"Consistency check for TOF symbolic names finished successfully.");
978 if(detsString.Contains("HMPID"))
980 /********************* HMPID layer ***********************/
982 AliDebugClass(2,"Checking consistency of symbolic names for HMPID layers");
983 TString str = "/HMPID/Chamber";
985 for (modnum=0; modnum < 7; modnum++) {
988 uid = LayerToVolUID(kHMPID,modnum);
989 pne = fgGeometry->GetAlignableEntryByUID(uid);
992 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
995 sname = pne->GetName();
996 if(symname.CompareTo(sname))
998 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
999 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1004 AliDebugClass(2,"Consistency check for HMPID symbolic names finished successfully.");
1007 if(detsString.Contains("TRD"))
1009 /********************* TRD layers 1-6 *******************/
1010 //!! 6 layers with index increasing in outwards direction
1012 AliDebugClass(2,"Checking consistency of symbolic names for TRD layers");
1013 Int_t arTRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
1015 TString snStr = "TRD/sm";
1016 TString snApp1 = "/st";
1017 TString snApp2 = "/pl";
1019 for(Int_t layer=0; layer<6; layer++){
1021 AliDebugClass(3,Form("Consistency check for symnames of TRD layer %d.",layer));
1022 for (Int_t isect = 0; isect < 18; isect++) {
1023 for (Int_t icham = 0; icham < 5; icham++) {
1025 symname += Form("%02d",isect);
1030 uid = LayerToVolUID(arTRDlayId[layer],modnum++);
1031 if(!trdSMs[isect]) continue;
1032 if ((isect==13 || isect==14 || isect==15) && icham==2) continue; //keeping holes into account
1033 pne = fgGeometry->GetAlignableEntryByUID(uid);
1036 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1039 sname = pne->GetName();
1040 if(symname.CompareTo(sname))
1042 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1043 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1050 AliDebugClass(2,"Consistency check for TRD symbolic names finished successfully.");
1053 if(detsString.Contains("PHOS"))
1055 /********************* PHOS EMC layer ***********************/
1057 AliDebugClass(2,"Checking consistency of symbolic names for PHOS layers");
1059 TString str = "PHOS/Module";
1062 for (Int_t iModule=0; iModule < 5; iModule++) {
1063 if(!phosMods[iModule]) continue;
1065 symname += (iModule+1);
1066 uid = LayerToVolUID(kPHOS1,iModule);
1067 pne = fgGeometry->GetAlignableEntryByUID(uid);
1070 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1073 sname = pne->GetName();
1074 if(symname.CompareTo(sname))
1076 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1077 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1080 /********************* PHOS CPV layer ***********************/
1081 if(!cpvActive) continue;
1083 uid = LayerToVolUID(kPHOS2,iModule);
1084 pne = fgGeometry->GetAlignableEntryByUID(uid);
1087 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1090 sname = pne->GetName();
1091 if(symname.CompareTo(sname))
1093 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1094 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1098 AliDebugClass(2,"Consistency check for PHOS symbolic names finished successfully.");
1101 if(detsString.Contains("EMCAL"))
1103 /********************* EMCAL layer ***********************/
1105 AliDebugClass(2,"Checking consistency of symbolic names for EMCAL layers");
1106 TString str = "EMCAL/FullSupermodule";
1109 for (Int_t iModule=0; iModule < 22; iModule++) {
1110 if(!emcalSMs[iModule]) continue;
1112 symname += iModule+1;
1113 if(iModule/2 == 5) {// 10,11
1114 symname = "EMCAL/HalfSupermodule";
1115 symname += iModule-9;
1116 }else if(iModule > 11) {// 12 ~ 21
1117 symname = "EMCAL/DCALSupermodule";
1118 symname += iModule-11;
1121 uid = LayerToVolUID(kEMCAL,modnum);
1122 pne = fgGeometry->GetAlignableEntryByUID(uid);
1125 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1128 sname = pne->GetName();
1129 if(symname.CompareTo(sname))
1131 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1132 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1137 AliDebugClass(2,"Consistency check for EMCAL symbolic names finished successfully.");
1144 //_____________________________________________________________________________
1145 void AliGeomManager::InitPNEntriesLUT()
1147 // Initialize the look-up table which associates the unique
1148 // numerical identity of each alignable volume to the
1149 // corresponding TGeoPNEntry.
1150 // The LUTs are static; they are created at the creation of the
1151 // AliGeomManager instance and recreated if the geometry has changed
1154 AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
1158 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
1159 if (!fgPNEntry[iLayer]) fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
1160 for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
1161 fgPNEntry[iLayer][modnum] = fgGeometry->GetAlignableEntryByUID(LayerToVolUID(iLayer+1,modnum));
1166 //______________________________________________________________________
1167 TGeoHMatrix* AliGeomManager::GetMatrix(TGeoPNEntry * const pne)
1169 // Get the global transformation matrix for a given PNEntry
1170 // by quering the TGeoManager
1172 if (!fgGeometry || !fgGeometry->IsClosed()) {
1173 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1177 TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
1178 if (pnode) return pnode->GetMatrix();
1180 const char* path = pne->GetTitle();
1181 if (!fgGeometry->cd(path)) {
1182 AliErrorClass(Form("Volume path %s not valid!",path));
1185 return fgGeometry->GetCurrentMatrix();
1188 //______________________________________________________________________
1189 TGeoHMatrix* AliGeomManager::GetMatrix(Int_t index)
1191 // Get the global transformation matrix for a given alignable volume
1192 // identified by its unique ID 'index' by quering the TGeoManager
1194 TGeoPNEntry *pne = GetPNEntry(index);
1195 if (!pne) return NULL;
1197 return GetMatrix(pne);
1200 //______________________________________________________________________
1201 TGeoHMatrix* AliGeomManager::GetMatrix(const char* symname)
1203 // Get the global transformation matrix for a given alignable volume
1204 // identified by its symbolic name 'symname' by quering the TGeoManager
1206 if (!fgGeometry || !fgGeometry->IsClosed()) {
1207 AliErrorClass("No active geometry or geometry not yet closed!");
1211 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
1212 if (!pne) return NULL;
1214 return GetMatrix(pne);
1217 //______________________________________________________________________
1218 Bool_t AliGeomManager::GetTranslation(Int_t index, Double_t t[3])
1220 // Get the translation vector for a given module 'index'
1221 // by quering the TGeoManager
1223 TGeoHMatrix *m = GetMatrix(index);
1224 if (!m) return kFALSE;
1226 Double_t *trans = m->GetTranslation();
1227 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1232 //______________________________________________________________________
1233 Bool_t AliGeomManager::GetRotation(Int_t index, Double_t r[9])
1235 // Get the rotation matrix for a given module 'index'
1236 // by quering the TGeoManager
1238 TGeoHMatrix *m = GetMatrix(index);
1239 if (!m) return kFALSE;
1241 Double_t *rot = m->GetRotationMatrix();
1242 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1247 //_____________________________________________________________________________
1248 Bool_t AliGeomManager::GetDeltaForBranch(Int_t index, TGeoHMatrix &inclusiveD)
1250 // The method sets the matrix passed as argument as the global delta
1251 // (for the volume referred by the unique index) including the displacements
1252 // of all parent volumes in the branch.
1255 TGeoHMatrix go,invgo;
1256 go = *GetOrigGlobalMatrix(index);
1257 invgo = go.Inverse();
1258 inclusiveD = *GetMatrix(index);
1259 inclusiveD.Multiply(&invgo);
1264 //_____________________________________________________________________________
1265 Bool_t AliGeomManager::GetDeltaForBranch(AliAlignObj& aao, TGeoHMatrix &inclusiveD)
1267 // The method sets the matrix passed as argument as the global delta
1268 // (for the volume referred by the alignment object) including the displacements
1269 // of all parent volumes in the brach.
1271 Int_t index = aao.GetVolUID();
1273 AliErrorClass("Either the alignment object or its index are not valid");
1276 return GetDeltaForBranch(index, inclusiveD);
1279 //______________________________________________________________________
1280 Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, TGeoHMatrix &m)
1282 // Get the global transformation matrix (ideal geometry) for a given alignable volume
1283 // The alignable volume is identified by 'symname' which has to be either a valid symbolic
1284 // name, the query being performed after alignment, or a valid volume path if the query is
1285 // performed before alignment.
1289 if (!fgGeometry || !fgGeometry->IsClosed()) {
1290 AliErrorClass("No active geometry or geometry not yet closed!");
1293 if (!fgGeometry->GetListOfPhysicalNodes()) {
1294 AliWarningClass("gGeoManager doesn't contain any aligned nodes!");
1295 if (!fgGeometry->cd(symname)) {
1296 AliErrorClass(Form("Volume path %s not valid!",symname));
1300 m = *fgGeometry->GetCurrentMatrix();
1305 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
1306 const char* path = NULL;
1308 m = *pne->GetGlobalOrig();
1311 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
1315 return GetOrigGlobalMatrixFromPath(path,m);
1318 //_____________________________________________________________________________
1319 Bool_t AliGeomManager::GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m)
1321 // The method returns the global matrix for the volume identified by
1322 // 'path' in the ideal detector geometry.
1323 // The output global matrix is stored in 'm'.
1324 // Returns kFALSE in case TGeo has not been initialized or the volume
1325 // path is not valid.
1329 if (!fgGeometry || !fgGeometry->IsClosed()) {
1330 AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
1334 if (!fgGeometry->CheckPath(path)) {
1335 AliErrorClass(Form("Volume path %s not valid!",path));
1339 TIter next(fgGeometry->GetListOfPhysicalNodes());
1340 fgGeometry->cd(path);
1342 while(fgGeometry->GetLevel()){
1344 TGeoPhysicalNode *physNode = NULL;
1346 TGeoNode *node = fgGeometry->GetCurrentNode();
1347 while ((physNode=(TGeoPhysicalNode*)next()))
1348 if (physNode->GetNode() == node) break;
1350 TGeoMatrix *lm = NULL;
1352 lm = physNode->GetOriginalMatrix();
1353 if (!lm) lm = node->GetMatrix();
1355 lm = node->GetMatrix();
1365 //_____________________________________________________________________________
1366 TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(TGeoPNEntry * const pne)
1368 // The method returns global matrix for the ideal detector geometry
1369 // using the corresponding TGeoPNEntry as an input.
1370 // The returned pointer should be copied by the user, since its content could
1371 // be overwritten by a following call to the method.
1372 // In case of missing TGeoManager the method returns NULL.
1374 if (!fgGeometry || !fgGeometry->IsClosed()) {
1375 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1379 return pne->GetGlobalOrig();
1382 //______________________________________________________________________
1383 TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(Int_t index)
1385 // The method returns global matrix from the ideal detector geometry
1386 // for the volume identified by its index.
1387 // The returned pointer should be copied by the user, since its content could
1388 // be overwritten by a following call to the method.
1389 // In case of missing TGeoManager the method returns NULL.
1390 // If possible, the method uses the LUT of original ideal matrices
1391 // for fast access. The LUT is reset in case a
1392 // new geometry is loaded.
1394 TGeoPNEntry* pne = GetPNEntry(index);
1395 return pne->GetGlobalOrig();
1398 //______________________________________________________________________
1399 Bool_t AliGeomManager::GetOrigTranslation(Int_t index, Double_t t[3])
1401 // Get the original translation vector (ideal geometry)
1402 // for a given module 'index' by quering the TGeoManager
1404 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1405 if (!m) return kFALSE;
1407 Double_t *trans = m->GetTranslation();
1408 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1413 //______________________________________________________________________
1414 Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
1416 // Get the original rotation matrix (ideal geometry)
1417 // for a given module 'index' by quering the TGeoManager
1419 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1420 if (!m) return kFALSE;
1422 Double_t *rot = m->GetRotationMatrix();
1423 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1428 //______________________________________________________________________
1429 const TGeoHMatrix* AliGeomManager::GetTracking2LocalMatrix(Int_t index)
1431 // Get the matrix which transforms from the tracking to the local RS
1432 // The method queries directly the TGeoPNEntry
1434 TGeoPNEntry *pne = GetPNEntry(index);
1435 if (!pne) return NULL;
1437 const TGeoHMatrix *m = pne->GetMatrix();
1439 AliErrorClass(Form("TGeoPNEntry (%s) contains no tracking-to-local matrix !",pne->GetName()));
1444 //______________________________________________________________________
1445 Bool_t AliGeomManager::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
1447 // Get the matrix which transforms from the tracking r.s. to
1449 // Returns kFALSE in case of error.
1453 TGeoHMatrix *m1 = GetMatrix(index);
1454 if (!m1) return kFALSE;
1456 const TGeoHMatrix *m2 = GetTracking2LocalMatrix(index);
1457 if (!m2) return kFALSE;
1465 //_____________________________________________________________________________
1466 TGeoPNEntry* AliGeomManager::GetPNEntry(Int_t voluid) {
1467 // Returns the TGeoPNEntry for the given global volume ID "voluid"
1470 ELayerID layerId = VolUIDToLayer(voluid,modId);
1471 return GetPNEntry(layerId,modId);
1474 //_____________________________________________________________________________
1475 TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
1477 // Returns the TGeoPNEntry for a given layer
1481 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
1482 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
1486 return fgPNEntry[layerId-kFirstLayer][modId];
1489 //_____________________________________________________________________________
1490 void AliGeomManager::CheckOverlapsOverPNs(Double_t threshold)
1492 // Check for overlaps/extrusions on physical nodes only;
1493 // this overlap-checker is meant to be used to check overlaps/extrusions
1494 // originated by the application of alignment objects.
1497 TObjArray* ovexlist = 0x0;
1499 AliInfoClass("********* Checking overlaps/extrusions over physical nodes only *********");
1500 TObjArray* pnList = gGeoManager->GetListOfPhysicalNodes();
1501 TGeoVolume* mvol = 0;
1502 TGeoPhysicalNode* pn;
1503 TObjArray* overlaps = new TObjArray(64);
1504 overlaps->SetOwner();
1508 for(Int_t pni=0; pni<pnList->GetEntriesFast(); pni++){
1509 pn = (TGeoPhysicalNode*) pnList->UncheckedAt(pni);
1510 // checking the volume of the mother (go upper in the tree in case it is an assembly)
1512 while(((TGeoVolume*)pn->GetVolume(pn->GetLevel()-levup))->IsAssembly()) levup++;
1513 //Printf("Going to upper level");
1514 mvol = pn->GetVolume(pn->GetLevel()-levup);
1515 if(!mvol->IsSelected()){
1516 AliInfoClass(Form("Checking overlaps for volume %s",mvol->GetName()));
1517 mvol->CheckOverlaps(threshold);
1518 ovexlist = gGeoManager->GetListOfOverlaps();
1519 TIter next(ovexlist);
1521 while ((ov=(TGeoOverlap*)next())) overlaps->Add(ov->Clone());
1522 mvol->SelectVolume();
1525 mvol->SelectVolume(kTRUE); // clears the list of selected volumes
1527 AliInfoClass(Form("Number of overlapping/extruding PNs: %d",overlaps->GetEntriesFast()));
1531 TIter nextN(overlaps);
1533 while ((ovlp=(TGeoOverlap*)nextN())) ovlp->PrintInfo();
1539 //_____________________________________________________________________________
1540 Int_t AliGeomManager::GetNalignable(const char* module)
1542 // Get number of declared alignable volumes in current geometry
1543 // for the given detector "module" passed as a vaild detector name
1544 // if the detector name is invalid return -1
1546 // return the detector index corresponding to detector
1548 for (index = 0; index < fgkNDetectors ; index++) {
1549 if ( strcmp(module, fgkDetectorName[index]) == 0 )
1552 if(index==fgkNDetectors) return -1;
1553 return fgNalignable[index];
1556 //_____________________________________________________________________________
1557 void AliGeomManager::InitNalignable()
1559 // Set number of declared alignable volumes for given detector in current geometry
1560 // by looping on the list of PNEntries
1563 Int_t nAlE = gGeoManager->GetNAlignable(); // total number of alignable entries
1564 TGeoPNEntry *pne = 0;
1565 const char* detName;
1567 for (Int_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
1568 detName = fgkDetectorName[iDet];
1571 for(Int_t iE = 0; iE < nAlE; iE++)
1573 pne = gGeoManager->GetAlignableEntry(iE);
1574 TString pneName = pne->GetName();
1575 if(pneName.Contains(detName)) nAlDet++;
1576 if(!strcmp(detName,"GRP")) if(pneName.Contains("ABSO") || pneName.Contains("DIPO") ||
1577 pneName.Contains("FRAME") || pneName.Contains("PIPE") ||
1578 pneName.Contains("SHIL")) nAlDet++;
1580 fgNalignable[iDet] = nAlDet;
1585 //_____________________________________________________________________________
1586 Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
1588 // Calls AddAlignObjsFromCDBSingleDet for the detectors appearing in
1589 // the list passed as argument (called by AliSimulation and
1590 // AliReconstruction)
1591 // Read the alignment objects from CDB.
1592 // Each detector is supposed to have the
1593 // alignment objects in DET/Align/Data CDB path.
1594 // All the detector objects are then collected,
1595 // sorted by geometry level (starting from ALIC) and
1596 // then applied to the TGeo geometry.
1597 // Finally an overlaps check is performed.
1600 TObjArray alignObjArray;
1601 alignObjArray.Clear();
1602 alignObjArray.SetOwner(0);
1604 TString alObjsNotLoaded="";
1605 TString alObjsLoaded="";
1607 TString AlignDetsString(AlignDetsList);
1608 TObjArray *detsarr = AlignDetsString.Tokenize(' ');
1609 TIter iter(detsarr);
1610 TObjString *str = 0;
1612 while((str = (TObjString*) iter.Next())){
1613 TString det(str->String());
1614 AliDebugClass(5,Form("Loading alignment objs for %s",det.Data()));
1615 if(!LoadAlignObjsFromCDBSingleDet(det.Data(),alignObjArray)){
1616 alObjsNotLoaded += det.Data();
1617 alObjsNotLoaded += " ";
1619 alObjsLoaded += det.Data();
1620 alObjsLoaded += " ";
1626 if(!alObjsLoaded.IsNull()) AliInfoClass(Form("Alignment objects loaded for: %s",
1627 alObjsLoaded.Data()));
1628 if(!alObjsNotLoaded.IsNull())
1629 AliFatalClass(Form("Could not load alignment objects from OCDB for: %s",
1630 alObjsNotLoaded.Data()));
1632 return ApplyAlignObjsToGeom(alignObjArray);
1635 //_____________________________________________________________________________
1636 Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray)
1638 // Adds the alignable objects found in the CDBEntry for the detector
1639 // passed as argument to the array of all alignment objects to be applyed
1642 // Fills array of single detector's alignable objects from CDB
1644 AliDebugClass(2, Form("Loading alignment objs for detector: %s",detName));
1648 AliCDBPath path(detName,"Align","Data");
1650 entry=AliCDBManager::Instance()->Get(path.GetPath());
1652 AliDebugClass(2,Form("Couldn't load alignment data for detector %s",detName));
1656 TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
1657 alignArray->SetOwner(0);
1658 Int_t nAlObjs = alignArray->GetEntries();
1659 AliDebugClass(2,Form("Found %d alignment objects for %s",nAlObjs,detName));
1660 Int_t nAlVols = GetNalignable(detName);
1661 if(nAlObjs!=nAlVols) AliWarningClass(Form("%d alignment objects loaded for %s, which has %d alignable volumes",nAlObjs,detName,GetNalignable(detName)));
1663 AliAlignObj *alignObj=0;
1664 TIter iter(alignArray);
1666 // loop over align objects in detector
1667 while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
1668 alignObjArray.Add(alignObj);
1670 // delete entry --- Don't delete, it is cached!
1672 AliDebugClass(2, Form("fAlignObjArray entries: %d",alignObjArray.GetEntries() ));
1677 //_____________________________________________________________________________
1678 Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray& alignObjArray, Bool_t ovlpcheck)
1680 // Read collection of alignment objects (AliAlignObj derived) saved
1681 // in the TClonesArray alObjArray and apply them to gGeoManager
1683 alignObjArray.Sort();
1684 Int_t nvols = alignObjArray.GetEntriesFast();
1686 Bool_t flag = kTRUE;
1688 for(Int_t j=0; j<nvols; j++)
1690 AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
1691 if(!alobj->ApplyToGeometry(ovlpcheck))
1694 AliDebugClass(5,Form("Error applying alignment object for volume %s !",alobj->GetSymName()));
1696 AliDebugClass(5,Form("Alignment object for volume %s applied successfully",alobj->GetSymName()));
1701 if (AliDebugLevelClass() > 5) {
1702 fgGeometry->CheckOverlaps(0.001);
1703 TObjArray* ovexlist = fgGeometry->GetListOfOverlaps();
1704 if(ovexlist->GetEntriesFast()){
1705 AliErrorClass("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
1706 fgGeometry->PrintOverlaps();
1710 // Update the TGeoPhysicalNodes
1711 fgGeometry->RefreshPhysicalNodes();
1717 //_____________________________________________________________________________
1718 Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
1720 // read collection of alignment objects (AliAlignObj derived) saved
1721 // in the TClonesArray ClArrayName in the file fileName and apply
1722 // them to the geometry
1725 TFile* inFile = TFile::Open(fileName,"READ");
1726 if (!inFile || !inFile->IsOpen()) {
1727 AliErrorClass(Form("Could not open file %s !",fileName));
1731 TClonesArray* alignObjArray = ((TClonesArray*) inFile->Get(clArrayName));
1733 if (!alignObjArray) {
1734 AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
1738 return ApplyAlignObjsToGeom(*alignObjArray);
1742 //_____________________________________________________________________________
1743 Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
1745 // read collection of alignment objects (AliAlignObj derived) saved
1746 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1747 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1751 AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(uri);
1752 AliCDBId id(path, runnum, runnum, version, sversion);
1753 AliCDBEntry* entry = storage->Get(id);
1754 TClonesArray* alignObjArray = dynamic_cast<TClonesArray*>(entry->GetObject());
1756 return ApplyAlignObjsToGeom(*alignObjArray);
1760 //_____________________________________________________________________________
1761 Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
1763 // read collection of alignment objects (AliAlignObj derived) saved
1764 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1765 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1769 AliCDBPath path(detName,"Align","Data");
1770 AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
1772 if(!entry) return kFALSE;
1773 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
1775 return ApplyAlignObjsToGeom(*alignObjArray);
1778 //_____________________________________________________________________________
1779 void AliGeomManager::ResetPNEntriesLUT()
1781 // cleans static arrays containing the information on currently loaded geometry
1783 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
1784 if (!fgPNEntry[iLayer]) continue;
1785 for (Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++) fgPNEntry[iLayer][modnum] = 0;