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 TGeoManager* AliGeomManager::fgGeometry = 0x0;
103 //_____________________________________________________________________________
104 void AliGeomManager::LoadGeometry(const char *geomFileName)
107 // Load geometry either from a file
108 // or from the corresponding CDB entry
111 if (geomFileName && (!gSystem->AccessPathName(geomFileName))) {
112 fgGeometry = TGeoManager::Import(geomFileName);
113 AliInfoClass(Form("From now on using geometry from custom geometry file %s",geomFileName));
117 AliCDBPath path("GRP","Geometry","Data");
119 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
120 if(!entry) AliFatalClass("Couldn't load geometry data from CDB!");
123 fgGeometry = (TGeoManager*) entry->GetObject();
124 if (!fgGeometry) AliFatalClass("Couldn't find TGeoManager in the specified CDB entry!");
126 AliInfoClass(Form("From now on using geometry from CDB base folder %s",
127 AliCDBManager::Instance()->GetURI("Geometry/Align/Data")));
133 //_____________________________________________________________________________
134 void AliGeomManager::SetGeometry(TGeoManager *geom)
136 // Load already active geometry
137 if (!geom) AliFatalClass("Pointer to the active geometry is 0x0!");
143 //_____________________________________________________________________________
144 AliGeomManager::AliGeomManager():
147 // default constructor
150 //_____________________________________________________________________________
151 AliGeomManager::~AliGeomManager()
156 //_____________________________________________________________________________
157 Int_t AliGeomManager::LayerSize(Int_t layerId)
159 // Get the layer size for layer corresponding to layerId.
160 // Implemented only for ITS,TPC,TRD,TOF and HMPID
162 if (layerId < kFirstLayer || layerId >= kLastLayer) {
163 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
167 return fgLayerSize[layerId - kFirstLayer];
171 //_____________________________________________________________________________
172 const char* AliGeomManager::LayerName(Int_t layerId)
174 // Get the layer name corresponding to layerId.
175 // Implemented only for ITS,TPC,TRD,TOF and HMPID
177 if (layerId < kFirstLayer || layerId >= kLastLayer) {
178 AliErrorClass(Form("Invalid layer index %d ! Layer range is (%d -> %d) !",layerId,kFirstLayer,kLastLayer));
179 return "Invalid Layer!";
182 return fgLayerName[layerId - kFirstLayer];
186 //_____________________________________________________________________________
187 UShort_t AliGeomManager::LayerToVolUID(ELayerID layerId, Int_t modId)
189 // From detector (layer) name and module number (according to detector
190 // internal numbering) build the unique numerical identity of that volume
192 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
193 // remaining 11 for module ID inside det (2048 possible values).
194 // NO check for validity of given modId inside the layer for speed's sake.
196 return ((UShort_t(layerId) << 11) | UShort_t(modId));
199 //_____________________________________________________________________________
200 UShort_t AliGeomManager::LayerToVolUID(Int_t layerId, Int_t modId)
202 // From detector (layer) name and module number (according to detector
203 // internal numbering) build the unique numerical identity of that volume
205 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
206 // remaining 11 for module ID inside det (2048 possible values).
207 // NO check for validity of given modId inside the layer for speed's sake.
209 return ((UShort_t(layerId) << 11) | UShort_t(modId));
212 //_____________________________________________________________________________
213 UShort_t AliGeomManager::LayerToVolUIDSafe(ELayerID layerId, Int_t modId)
215 // From detector (layer) name and module number (according to detector
216 // internal numbering) build the unique numerical identity of that volume
218 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
219 // remaining 11 for module ID inside det (2048 possible values).
220 // Check validity of given modId inside the layer.
222 if(modId < 0 || modId >= LayerSize(layerId)){
223 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
226 return ((UShort_t(layerId) << 11) | UShort_t(modId));
229 //_____________________________________________________________________________
230 UShort_t AliGeomManager::LayerToVolUIDSafe(Int_t layerId, Int_t modId)
232 // From detector (layer) name and module number (according to detector
233 // internal numbering) build the unique numerical identity of that volume
235 // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
236 // remaining 11 for module ID inside det (2048 possible values).
237 // Check validity of given modId inside the layer.
239 if(modId < 0 || modId >= LayerSize(layerId)){
240 AliErrorClass(Form("Invalid volume id %d ! Range of valid ids for layer \"%s\" is [0, %d] !",modId,LayerName(layerId),LayerSize(layerId)-1));
243 return ((UShort_t(layerId) << 11) | UShort_t(modId));
246 //_____________________________________________________________________________
247 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid, Int_t &modId)
249 // From voluid, unique numerical identity of that volume inside ALICE,
250 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
251 // remaining 11 for module ID inside det (2048 possible values)), return
252 // the identity of the layer to which that volume belongs and sets the
253 // argument modId to the identity of that volume internally to the layer.
254 // NO check for validity of given voluid for speed's sake.
256 modId = voluid & 0x7ff;
258 return VolUIDToLayer(voluid);
261 //_____________________________________________________________________________
262 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayer(UShort_t voluid)
264 // From voluid, unique numerical identity of that volume inside ALICE,
265 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
266 // remaining 11 for module ID inside det (2048 possible values)), return
267 // the identity of the layer to which that volume belongs
268 // NO check for validity of given voluid for speed's sake.
270 return ELayerID(voluid >> 11);
273 //_____________________________________________________________________________
274 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid, Int_t &modId)
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)), returns
279 // the identity of the layer to which that volume belongs and sets the
280 // argument modId to the identity of that volume internally to the layer.
281 // Checks the validity of the given voluid
283 ELayerID layId = VolUIDToLayerSafe(voluid);
285 Int_t mId = Int_t(voluid & 0x7ff);
286 if( mId>=0 && mId<LayerSize(layId)){
292 AliErrorClass(Form("Invalid unique volume id: %d !",voluid));
294 return kInvalidLayer;
298 //_____________________________________________________________________________
299 AliGeomManager::ELayerID AliGeomManager::VolUIDToLayerSafe(UShort_t voluid)
301 // From voluid, unique numerical identity of that volume inside ALICE,
302 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
303 // remaining 11 for module ID inside det (2048 possible values)), returns
304 // the identity of the layer to which that volume belongs
305 // Checks the validity of the given voluid
307 if( (voluid >> 11) < kLastLayer) return ELayerID(voluid >> 11);
309 AliErrorClass(Form("Invalid layer id: %d !",(voluid >> 11)));
310 return kInvalidLayer;
314 //_____________________________________________________________________________
315 Bool_t AliGeomManager::GetFromGeometry(const char *symname, AliAlignObj &alobj)
317 // Get the alignment object which corresponds to the symbolic volume name
318 // symname (in case equal to the TGeo volume path)
319 // The method is extremely slow due to the searching by string,
320 // therefore it should be used with great care!!
321 // This method returns FALSE if the symname of the object was not
322 // valid neither to get a TGeoPEntry nor as a volume path, or if the path
323 // associated to the TGeoPNEntry was not valid.
326 // Reset the alignment object
327 alobj.SetPars(0,0,0,0,0,0);
328 alobj.SetSymName(symname);
330 if (!fgGeometry || !fgGeometry->IsClosed()) {
331 AliErrorClass("Can't get the alignment object! gGeoManager doesn't exist or it is still opened!");
335 if (!fgGeometry->GetListOfPhysicalNodes()) {
336 AliErrorClass("Can't get the alignment object! gGeoManager doesn't contain any aligned nodes!");
341 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
343 path = pne->GetTitle();
345 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
348 TObjArray* nodesArr = fgGeometry->GetListOfPhysicalNodes();
349 TGeoPhysicalNode* node = NULL;
350 for (Int_t iNode = 0; iNode < nodesArr->GetEntriesFast(); iNode++) {
351 TGeoPhysicalNode* tempNode = (TGeoPhysicalNode*) nodesArr->UncheckedAt(iNode);
352 const char *nodePath = tempNode->GetName();
353 if (strcmp(path,nodePath) == 0) {
360 if (!fgGeometry->cd(path)) {
361 AliErrorClass(Form("%s not valid neither as symbolic volume name nor as volume path!",path));
365 AliWarningClass(Form("Volume (%s) has not been misaligned!",path));
370 TGeoHMatrix align,gprime,g,ginv,l;
371 gprime = *node->GetMatrix();
372 l = *node->GetOriginalMatrix();
373 g = *node->GetMatrix(node->GetLevel()-1);
376 align = gprime * ginv;
378 return alobj.SetMatrix(align);
382 //_____________________________________________________________________________
383 void AliGeomManager::InitAlignObjFromGeometry()
385 // Loop over all alignable volumes and extract
386 // the corresponding alignment objects from
389 if(fgAlignObjs[0]) return;
391 for (Int_t iLayer = kFirstLayer; iLayer < AliGeomManager::kLastLayer; iLayer++) {
392 fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[LayerSize(iLayer)];
393 for (Int_t iModule = 0; iModule < LayerSize(iLayer); iModule++) {
394 UShort_t volid = LayerToVolUID(iLayer,iModule);
395 fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjParams("",volid,0,0,0,0,0,0,kTRUE);
396 const char *symname = SymName(volid);
397 if (!GetFromGeometry(symname, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
398 AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,symname));
404 //_____________________________________________________________________________
405 AliAlignObj* AliGeomManager::GetAlignObj(UShort_t voluid)
407 // Returns the alignment object for given volume ID
410 ELayerID layerId = VolUIDToLayer(voluid,modId);
411 return GetAlignObj(layerId,modId);
414 //_____________________________________________________________________________
415 AliAlignObj* AliGeomManager::GetAlignObj(ELayerID layerId, Int_t modId)
417 // Returns pointer to alignment object given its layer and module ID
419 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
420 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
423 InitAlignObjFromGeometry();
425 return fgAlignObjs[layerId-kFirstLayer][modId];
428 //_____________________________________________________________________________
429 const char* AliGeomManager::SymName(UShort_t voluid)
431 // Returns the symbolic volume name for given volume ID
434 ELayerID layerId = VolUIDToLayer(voluid,modId);
435 return SymName(layerId,modId);
438 //_____________________________________________________________________________
439 const char* AliGeomManager::SymName(ELayerID layerId, Int_t modId)
441 // Returns the symbolic volume name given for a given layer
445 AliErrorClass("No geometry instance loaded yet!");
448 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
449 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
453 TGeoPNEntry* pne = fgPNEntry[layerId-kFirstLayer][modId];
456 AliWarningClass(Form("Module %d of layer %s is not activated!",modId,LayerName(layerId)));
459 return pne->GetName();
463 //_____________________________________________________________________________
464 Bool_t AliGeomManager::CheckSymNamesLUT(const char* detsToBeChecked)
466 // Check the look-up table which associates the unique numerical identity of
467 // each alignable volume to the corresponding symbolic volume name.
468 // The LUT is now hold inside the geometry and handled by TGeo.
469 // The method is meant to be launched when loading a geometry to verify that
470 // no changes in the symbolic names have been introduced, which would prevent
471 // backward compatibility with alignment objects.
472 // To accept both complete and partial geometry, this method skips the check
473 // for TRD and TOF volumes which are missing in the partial geometry.
476 // TString detsString(detsToBeChecked);
477 // if(detsString.Contains("ALL")) detsString="ITS TPC TOF TRD HMPID PHOS EMCAL";
479 // Temporary measure to face the case of reconstruction over detectors not present in the geometry
480 TString detsString = "";
481 if(fgGeometry->CheckPath("ALIC_1/ITSV_1")) detsString+="ITS ";
482 if(fgGeometry->CheckPath("ALIC_1/TPC_M_1")) detsString+="TPC ";
485 TString baseTof("ALIC_1/B077_1/BSEGMO");
486 TString middleTof("_1/BTOF");
487 TString trailTof("_1/FTOA_0");
488 Bool_t tofActive=kFALSE;
490 for(Int_t sm=0; sm<18; sm++)
498 if(fgGeometry->CheckPath(tofsm.Data()))
504 if(tofActive) detsString+="TOF ";
507 TString baseTrd("ALIC_1/B077_1/BSEGMO");
508 TString middleTrd("_1/BTRD");
509 TString trailTrd("_1/UTR1_1");
510 Bool_t trdActive=kFALSE;
512 for(Int_t sm=0; sm<18; sm++)
520 if(fgGeometry->CheckPath(trdsm.Data()))
526 if(trdActive) detsString+="TRD ";
528 if(fgGeometry->CheckPath("ALIC_1/B077_1/BSEGMO0_1/BTRD0_1/UTR1_1")) detsString+="TRD ";
529 if(fgGeometry->CheckPath("ALIC_1/Hmp0_0")) detsString+="HMPID ";
530 if(fgGeometry->CheckPath("ALIC_1/PHOS_1")) detsString+="PHOS ";
531 if(fgGeometry->CheckPath("ALIC_1/XEN1_1")) detsString+="EMCAL";
536 TGeoPNEntry* pne = 0x0;
537 Int_t uid; // global unique identity
538 Int_t modnum; // unique id inside layer; in the following, set it to 0 at the start of each layer
540 if(detsString.Contains("ITS")){
541 /********************* ITS layers ***********************/
542 AliDebugClass(2,"Checking consistency of symbolic names for ITS layers");
543 TString strSPD = "ITS/SPD";
544 TString strSDD = "ITS/SDD";
545 TString strSSD = "ITS/SSD";
546 TString strStave = "/Stave";
547 TString strHalfStave = "/HalfStave";
548 TString strLadder = "/Ladder";
549 TString strSector = "/Sector";
550 TString strSensor = "/Sensor";
551 TString strEntryName1;
552 TString strEntryName2;
553 TString strEntryName3;
555 /********************* SPD layer1 ***********************/
559 for(Int_t cSect = 0; cSect<10; cSect++){
560 strEntryName1 = strSPD;
562 strEntryName1 += strSector;
563 strEntryName1 += cSect;
565 for(Int_t cStave =0; cStave<2; cStave++){
566 strEntryName2 = strEntryName1;
567 strEntryName2 += strStave;
568 strEntryName2 += cStave;
570 for (Int_t cHS=0; cHS<2; cHS++) {
571 strEntryName3 = strEntryName2;
572 strEntryName3 += strHalfStave;
573 strEntryName3 += cHS;
575 for(Int_t cLad =0; cLad<2; cLad++){
576 symname = strEntryName3;
577 symname += strLadder;
578 symname += cLad+cHS*2;
579 uid = LayerToVolUID(kSPD1,modnum++);
580 pne = fgGeometry->GetAlignableEntryByUID(uid);
583 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
586 sname = pne->GetName();
587 if(symname.CompareTo(sname))
589 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
590 "Expected was %s, found was %s!", uid, symname.Data(), sname));
599 /********************* SPD layer2 ***********************/
603 for(Int_t cSect = 0; cSect<10; cSect++){
604 strEntryName1 = strSPD;
606 strEntryName1 += strSector;
607 strEntryName1 += cSect;
609 for(Int_t cStave =0; cStave<4; cStave++){
610 strEntryName2 = strEntryName1;
611 strEntryName2 += strStave;
612 strEntryName2 += cStave;
614 for (Int_t cHS=0; cHS<2; cHS++) {
615 strEntryName3 = strEntryName2;
616 strEntryName3 += strHalfStave;
617 strEntryName3 += cHS;
619 for(Int_t cLad =0; cLad<2; cLad++){
620 symname = strEntryName3;
621 symname += strLadder;
622 symname += cLad+cHS*2;
623 uid = LayerToVolUID(kSPD2,modnum++);
624 pne = fgGeometry->GetAlignableEntryByUID(uid);
627 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
630 sname = pne->GetName();
631 if(symname.CompareTo(sname))
633 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d."
634 "Expected was %s, found was %s!", uid, symname.Data(), sname));
643 /********************* SDD layer1 ***********************/
647 for(Int_t c1 = 1; c1<=14; c1++){
648 strEntryName1 = strSDD;
650 strEntryName1 +=strLadder;
651 strEntryName1 += (c1-1);
652 for(Int_t c2 =1; c2<=6; c2++){
653 symname = strEntryName1;
654 symname += strSensor;
656 uid = LayerToVolUID(kSDD1,modnum++);
657 pne = fgGeometry->GetAlignableEntryByUID(uid);
660 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
663 sname = pne->GetName();
664 if(symname.CompareTo(sname))
666 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
667 "Expected was %s, found was %s!", uid, symname.Data(), sname));
674 /********************* SDD layer2 ***********************/
678 for(Int_t c1 = 1; c1<=22; c1++){
679 strEntryName1 = strSDD;
681 strEntryName1 +=strLadder;
682 strEntryName1 += (c1-1);
683 for(Int_t c2 = 1; c2<=8; c2++){
684 symname = strEntryName1;
685 symname += strSensor;
687 uid = LayerToVolUID(kSDD2,modnum++);
688 pne = fgGeometry->GetAlignableEntryByUID(uid);
691 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
694 sname = pne->GetName();
695 if(symname.CompareTo(sname))
697 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
698 "Expected was %s, found was %s!", uid, symname.Data(), sname));
705 /********************* SSD layer1 ***********************/
709 for(Int_t c1 = 1; c1<=34; c1++){
710 strEntryName1 = strSSD;
712 strEntryName1 +=strLadder;
713 strEntryName1 += (c1-1);
714 for(Int_t c2 = 1; c2<=22; c2++){
715 symname = strEntryName1;
716 symname += strSensor;
718 uid = LayerToVolUID(kSSD1,modnum++);
719 pne = fgGeometry->GetAlignableEntryByUID(uid);
722 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
725 sname = pne->GetName();
726 if(symname.CompareTo(sname))
728 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
729 "Expected was %s, found was %s!", uid, symname.Data(), sname));
736 /********************* SSD layer2 ***********************/
740 for(Int_t c1 = 1; c1<=38; c1++){
741 strEntryName1 = strSSD;
743 strEntryName1 +=strLadder;
744 strEntryName1 += (c1-1);
745 for(Int_t c2 = 1; c2<=25; c2++){
746 symname = strEntryName1;
747 symname += strSensor;
749 uid = LayerToVolUID(kSSD2,modnum++);
750 pne = fgGeometry->GetAlignableEntryByUID(uid);
753 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
756 sname = pne->GetName();
757 if(symname.CompareTo(sname))
759 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
760 "Expected was %s, found was %s!", uid, symname.Data(), sname));
767 AliDebugClass(2,"Consistency check for ITS symbolic names finished successfully.");
770 if(detsString.Contains("TPC"))
772 /*************** TPC inner and outer layers ****************/
774 AliDebugClass(2,"Checking consistency of symbolic names for TPC layers");
775 TString sAsector="TPC/EndcapA/Sector";
776 TString sCsector="TPC/EndcapC/Sector";
777 TString sInner="/InnerChamber";
778 TString sOuter="/OuterChamber";
780 /*************** TPC inner chambers' layer ****************/
784 for(Int_t cnt=1; cnt<=18; cnt++)
789 uid = LayerToVolUID(kTPC1,modnum++);
790 pne = fgGeometry->GetAlignableEntryByUID(uid);
793 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
796 sname = pne->GetName();
797 if(symname.CompareTo(sname))
799 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
800 "Expected was %s, found was %s!", uid, symname.Data(), sname));
805 for(Int_t cnt=1; cnt<=18; cnt++)
810 uid = LayerToVolUID(kTPC1,modnum++);
811 pne = fgGeometry->GetAlignableEntryByUID(uid);
814 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
817 sname = pne->GetName();
818 if(symname.CompareTo(sname))
820 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
821 "Expected was %s, found was %s!", uid, symname.Data(), sname));
827 /*************** TPC outer chambers' layer ****************/
831 for(Int_t cnt=1; cnt<=18; cnt++)
836 uid = LayerToVolUID(kTPC2,modnum++);
837 pne = fgGeometry->GetAlignableEntryByUID(uid);
840 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
843 sname = pne->GetName();
844 if(symname.CompareTo(sname))
846 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
847 "Expected was %s, found was %s!", uid, symname.Data(), sname));
852 for(Int_t cnt=1; cnt<=18; cnt++)
857 uid = LayerToVolUID(kTPC2,modnum++);
858 pne = fgGeometry->GetAlignableEntryByUID(uid);
861 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
864 sname = pne->GetName();
865 if(symname.CompareTo(sname))
867 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
868 "Expected was %s, found was %s!", uid, symname.Data(), sname));
874 AliDebugClass(2,"Consistency check for TPC symbolic names finished successfully.");
877 if(detsString.Contains("TOF"))
879 /********************* TOF layer ***********************/
881 AliDebugClass(2,"Checking consistency of symbolic names for TOF layers");
888 Int_t nStrips=nstrA+2*nstrB+2*nstrC;
890 TString snSM = "TOF/sm";
891 TString snSTRIP = "/strip";
893 for (Int_t isect = 0; isect < nSectors; isect++) {
894 for (Int_t istr = 1; istr <= nStrips; istr++) {
896 symname += Form("%02d",isect);
898 symname += Form("%02d",istr);
899 uid = LayerToVolUID(kTOF,modnum++);
900 if(!tofSMs[isect]) continue; // taking possible missing TOF sectors (partial geometry) into account
901 AliDebugClass(2,Form("Consistency check for symnames of TOF supermodule %d.",isect));
902 if ((isect==13 || isect==14 || isect==15) && (istr >= 39 && istr <= 53)) continue; //taking holes into account
903 pne = fgGeometry->GetAlignableEntryByUID(uid);
906 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
909 sname = pne->GetName();
910 if(symname.CompareTo(sname))
912 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
913 "Expected was %s, found was %s!", uid, symname.Data(), sname));
919 AliDebugClass(2,"Consistency check for TOF symbolic names finished successfully.");
922 if(detsString.Contains("HMPID"))
924 /********************* HMPID layer ***********************/
926 AliDebugClass(2,"Checking consistency of symbolic names for HMPID layers");
927 TString str = "/HMPID/Chamber";
929 for (modnum=0; modnum < 7; modnum++) {
932 uid = LayerToVolUID(kHMPID,modnum);
933 pne = fgGeometry->GetAlignableEntryByUID(uid);
936 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
939 sname = pne->GetName();
940 if(symname.CompareTo(sname))
942 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
943 "Expected was %s, found was %s!", uid, symname.Data(), sname));
948 AliDebugClass(2,"Consistency check for HMPID symbolic names finished successfully.");
951 if(detsString.Contains("TRD"))
953 /********************* TRD layers 1-6 *******************/
954 //!! 6 layers with index increasing in outwards direction
956 AliDebugClass(2,"Checking consistency of symbolic names for TRD layers");
957 Int_t arTRDlayId[6] = {kTRD1, kTRD2, kTRD3, kTRD4, kTRD5, kTRD6};
959 TString snStr = "TRD/sm";
960 TString snApp1 = "/st";
961 TString snApp2 = "/pl";
963 for(Int_t layer=0; layer<6; layer++){
965 for (Int_t isect = 0; isect < 18; isect++) {
966 for (Int_t icham = 0; icham < 5; icham++) {
968 symname += Form("%02d",isect);
973 uid = LayerToVolUID(arTRDlayId[layer],modnum++);
974 if(!trdSMs[isect]) continue;
975 AliDebugClass(2,Form("Consistency check for symnames of TRD supermodule %d.",isect));
976 if ((isect==13 || isect==14 || isect==15) && icham==2) continue; //keeping holes into account
977 pne = fgGeometry->GetAlignableEntryByUID(uid);
980 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
983 sname = pne->GetName();
984 if(symname.CompareTo(sname))
986 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
987 "Expected was %s, found was %s!", uid, symname.Data(), sname));
994 AliDebugClass(2,"Consistency check for TRD symbolic names finished successfully.");
997 if(detsString.Contains("PHOS"))
999 /********************* PHOS EMC layer ***********************/
1001 AliDebugClass(2,"Checking consistency of symbolic names for PHOS layers");
1004 TString str = "PHOS/Module";
1007 for (Int_t iModule=1; iModule <= 5; iModule++) {
1011 uid = LayerToVolUID(kPHOS1,modnum);
1012 pne = fgGeometry->GetAlignableEntryByUID(uid);
1015 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1018 sname = pne->GetName();
1019 if(symname.CompareTo(sname))
1021 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1022 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1028 /********************* PHOS CPV layer ***********************/
1030 TString str = "PHOS/Module";
1033 for (Int_t iModule=1; iModule <= 5; iModule++) {
1038 uid = LayerToVolUID(kPHOS2,modnum);
1039 pne = fgGeometry->GetAlignableEntryByUID(uid);
1042 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1045 sname = pne->GetName();
1046 if(symname.CompareTo(sname))
1048 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1049 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1055 AliDebugClass(2,"Consistency check for PHOS symbolic names finished successfully.");
1058 if(detsString.Contains("EMCAL"))
1060 /********************* EMCAL layer ***********************/
1062 AliDebugClass(2,"Checking consistency of symbolic names for EMCAL layers");
1063 TString str = "EMCAL/FullSupermodule";
1066 for (Int_t iModule=1; iModule <= 12; iModule++) {
1070 symname = "EMCAL/HalfSupermodule";
1071 symname += iModule-10;
1074 uid = LayerToVolUID(kEMCAL,modnum);
1075 pne = fgGeometry->GetAlignableEntryByUID(uid);
1078 AliErrorClass(Form("In the currently loaded geometry there is no TGeoPNEntry with unique id %d",uid));
1081 sname = pne->GetName();
1082 if(symname.CompareTo(sname))
1084 AliErrorClass(Form("Current loaded geometry differs in the definition of symbolic name for uid %d"
1085 "Expected was %s, found was %s!", uid, symname.Data(), sname));
1090 AliDebugClass(2,"Consistency check for EMCAL symbolic names finished successfully.");
1097 //_____________________________________________________________________________
1098 void AliGeomManager::InitPNEntriesLUT()
1100 // Initialize the look-up table which associates the unique
1101 // numerical identity of each alignable volume to the
1102 // corresponding TGeoPNEntry.
1103 // The LUTs are static; they are created at the creation of the
1104 // AliGeomManager instance and recreated if the geometry has changed
1106 if (fgPNEntry[0]) return;
1109 AliErrorClass("Impossible to initialize PNEntries LUT without an active geometry");
1113 for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++){
1114 fgPNEntry[iLayer] = new TGeoPNEntry*[fgLayerSize[iLayer]];
1115 for(Int_t modnum=0; modnum<fgLayerSize[iLayer]; modnum++){
1116 fgPNEntry[iLayer][modnum] = fgGeometry->GetAlignableEntryByUID(LayerToVolUID(iLayer+1,modnum));
1121 //______________________________________________________________________
1122 TGeoHMatrix* AliGeomManager::GetMatrix(TGeoPNEntry* pne)
1124 // Get the global transformation matrix for a given PNEntry
1125 // by quering the TGeoManager
1127 if (!fgGeometry || !fgGeometry->IsClosed()) {
1128 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1132 TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
1133 if (pnode) return pnode->GetMatrix();
1135 const char* path = pne->GetTitle();
1136 if (!fgGeometry->cd(path)) {
1137 AliErrorClass(Form("Volume path %s not valid!",path));
1140 return fgGeometry->GetCurrentMatrix();
1143 //______________________________________________________________________
1144 TGeoHMatrix* AliGeomManager::GetMatrix(Int_t index)
1146 // Get the global transformation matrix for a given alignable volume
1147 // identified by its unique ID 'index' by quering the TGeoManager
1149 TGeoPNEntry *pne = GetPNEntry(index);
1150 if (!pne) return NULL;
1152 return GetMatrix(pne);
1155 //______________________________________________________________________
1156 TGeoHMatrix* AliGeomManager::GetMatrix(const char* symname)
1158 // Get the global transformation matrix for a given alignable volume
1159 // identified by its symbolic name 'symname' by quering the TGeoManager
1161 if (!fgGeometry || !fgGeometry->IsClosed()) {
1162 AliErrorClass("No active geometry or geometry not yet closed!");
1166 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
1167 if (!pne) return NULL;
1169 return GetMatrix(pne);
1172 //______________________________________________________________________
1173 Bool_t AliGeomManager::GetTranslation(Int_t index, Double_t t[3])
1175 // Get the translation vector for a given module 'index'
1176 // by quering the TGeoManager
1178 TGeoHMatrix *m = GetMatrix(index);
1179 if (!m) return kFALSE;
1181 Double_t *trans = m->GetTranslation();
1182 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1187 //______________________________________________________________________
1188 Bool_t AliGeomManager::GetRotation(Int_t index, Double_t r[9])
1190 // Get the rotation matrix for a given module 'index'
1191 // by quering the TGeoManager
1193 TGeoHMatrix *m = GetMatrix(index);
1194 if (!m) return kFALSE;
1196 Double_t *rot = m->GetRotationMatrix();
1197 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1202 //_____________________________________________________________________________
1203 Bool_t AliGeomManager::GetDeltaForBranch(Int_t index, TGeoHMatrix &inclusiveD)
1205 // The method sets the matrix passed as argument as the global delta
1206 // (for the volume referred by the unique index) including the displacements
1207 // of all parent volumes in the branch.
1210 TGeoHMatrix go,invgo;
1211 go = *GetOrigGlobalMatrix(index);
1212 invgo = go.Inverse();
1213 inclusiveD = *GetMatrix(index);
1214 inclusiveD.Multiply(&invgo);
1219 //_____________________________________________________________________________
1220 Bool_t AliGeomManager::GetDeltaForBranch(AliAlignObj& aao, TGeoHMatrix &inclusiveD)
1222 // The method sets the matrix passed as argument as the global delta
1223 // (for the volume referred by the alignment object) including the displacements
1224 // of all parent volumes in the brach.
1226 Int_t index = aao.GetVolUID();
1228 AliErrorClass("Either the alignment object or its index are not valid");
1231 return GetDeltaForBranch(index, inclusiveD);
1234 //______________________________________________________________________
1235 Bool_t AliGeomManager::GetOrigGlobalMatrix(const char* symname, TGeoHMatrix &m)
1237 // Get the global transformation matrix (ideal geometry) for a given alignable volume
1238 // The alignable volume is identified by 'symname' which has to be either a valid symbolic
1239 // name, the query being performed after alignment, or a valid volume path if the query is
1240 // performed before alignment.
1244 if (!fgGeometry || !fgGeometry->IsClosed()) {
1245 AliErrorClass("No active geometry or geometry not yet closed!");
1248 if (!fgGeometry->GetListOfPhysicalNodes()) {
1249 AliWarningClass("gGeoManager doesn't contain any aligned nodes!");
1250 if (!fgGeometry->cd(symname)) {
1251 AliErrorClass(Form("Volume path %s not valid!",symname));
1255 m = *fgGeometry->GetCurrentMatrix();
1260 TGeoPNEntry* pne = fgGeometry->GetAlignableEntry(symname);
1261 const char* path = NULL;
1263 m = *pne->GetGlobalOrig();
1266 AliWarningClass(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
1270 return GetOrigGlobalMatrixFromPath(path,m);
1273 //_____________________________________________________________________________
1274 Bool_t AliGeomManager::GetOrigGlobalMatrixFromPath(const char *path, TGeoHMatrix &m)
1276 // The method returns the global matrix for the volume identified by
1277 // 'path' in the ideal detector geometry.
1278 // The output global matrix is stored in 'm'.
1279 // Returns kFALSE in case TGeo has not been initialized or the volume
1280 // path is not valid.
1284 if (!fgGeometry || !fgGeometry->IsClosed()) {
1285 AliErrorClass("Can't get the original global matrix! gGeoManager doesn't exist or it is still opened!");
1289 if (!fgGeometry->CheckPath(path)) {
1290 AliErrorClass(Form("Volume path %s not valid!",path));
1294 TIter next(fgGeometry->GetListOfPhysicalNodes());
1295 fgGeometry->cd(path);
1297 while(fgGeometry->GetLevel()){
1299 TGeoPhysicalNode *physNode = NULL;
1301 TGeoNode *node = fgGeometry->GetCurrentNode();
1302 while ((physNode=(TGeoPhysicalNode*)next()))
1303 if (physNode->GetNode() == node) break;
1305 TGeoMatrix *lm = NULL;
1307 lm = physNode->GetOriginalMatrix();
1308 if (!lm) lm = node->GetMatrix();
1310 lm = node->GetMatrix();
1320 //_____________________________________________________________________________
1321 TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(TGeoPNEntry* pne)
1323 // The method returns global matrix for the ideal detector geometry
1324 // using the corresponding TGeoPNEntry as an input.
1325 // The returned pointer should be copied by the user, since its content could
1326 // be overwritten by a following call to the method.
1327 // In case of missing TGeoManager the method returns NULL.
1329 if (!fgGeometry || !fgGeometry->IsClosed()) {
1330 AliErrorClass("Can't get the global matrix! gGeoManager doesn't exist or it is still opened!");
1334 return pne->GetGlobalOrig();
1337 //______________________________________________________________________
1338 TGeoHMatrix* AliGeomManager::GetOrigGlobalMatrix(Int_t index)
1340 // The method returns global matrix from the ideal detector geometry
1341 // for the volume identified by its index.
1342 // The returned pointer should be copied by the user, since its content could
1343 // be overwritten by a following call to the method.
1344 // In case of missing TGeoManager the method returns NULL.
1345 // If possible, the method uses the LUT of original ideal matrices
1346 // for fast access. The LUT is reset in case a
1347 // new geometry is loaded.
1349 TGeoPNEntry* pne = GetPNEntry(index);
1350 return pne->GetGlobalOrig();
1353 //______________________________________________________________________
1354 Bool_t AliGeomManager::GetOrigTranslation(Int_t index, Double_t t[3])
1356 // Get the original translation vector (ideal geometry)
1357 // for a given module 'index' by quering the TGeoManager
1359 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1360 if (!m) return kFALSE;
1362 Double_t *trans = m->GetTranslation();
1363 for (Int_t i = 0; i < 3; i++) t[i] = trans[i];
1368 //______________________________________________________________________
1369 Bool_t AliGeomManager::GetOrigRotation(Int_t index, Double_t r[9])
1371 // Get the original rotation matrix (ideal geometry)
1372 // for a given module 'index' by quering the TGeoManager
1374 TGeoHMatrix *m = GetOrigGlobalMatrix(index);
1375 if (!m) return kFALSE;
1377 Double_t *rot = m->GetRotationMatrix();
1378 for (Int_t i = 0; i < 9; i++) r[i] = rot[i];
1383 //______________________________________________________________________
1384 const TGeoHMatrix* AliGeomManager::GetTracking2LocalMatrix(Int_t index)
1386 // Get the matrix which transforms from the tracking to the local RS
1387 // The method queries directly the TGeoPNEntry
1389 TGeoPNEntry *pne = GetPNEntry(index);
1390 if (!pne) return NULL;
1392 const TGeoHMatrix *m = pne->GetMatrix();
1394 AliErrorClass(Form("TGeoPNEntry (%s) contains no tracking-to-local matrix !",pne->GetName()));
1399 //______________________________________________________________________
1400 Bool_t AliGeomManager::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
1402 // Get the matrix which transforms from the tracking r.s. to
1404 // Returns kFALSE in case of error.
1408 TGeoHMatrix *m1 = GetMatrix(index);
1409 if (!m1) return kFALSE;
1411 const TGeoHMatrix *m2 = GetTracking2LocalMatrix(index);
1412 if (!m2) return kFALSE;
1420 //_____________________________________________________________________________
1421 TGeoPNEntry* AliGeomManager::GetPNEntry(Int_t voluid) {
1422 // Returns the TGeoPNEntry for the given global volume ID "voluid"
1425 ELayerID layerId = VolUIDToLayer(voluid,modId);
1426 return GetPNEntry(layerId,modId);
1429 //_____________________________________________________________________________
1430 TGeoPNEntry* AliGeomManager::GetPNEntry(ELayerID layerId, Int_t modId)
1432 // Returns the TGeoPNEntry for a given layer
1436 if(modId<0 || modId>=fgLayerSize[layerId-kFirstLayer]){
1437 AliWarningClass(Form("Module number %d not in the valid range (0->%d) !",modId,fgLayerSize[layerId-kFirstLayer]-1));
1441 return fgPNEntry[layerId-kFirstLayer][modId];
1444 //_____________________________________________________________________________
1445 void AliGeomManager::CheckOverlapsOverPNs(Double_t threshold)
1447 // Check for overlaps/extrusions on physical nodes only;
1448 // this overlap-checker is meant to be used to check overlaps/extrusions
1449 // originated by the application of alignment objects.
1452 TObjArray* ovexlist = new TObjArray(64);
1454 AliInfoClass("********* Checking overlaps/extrusions over physical nodes only *********");
1455 TObjArray* pnList = gGeoManager->GetListOfPhysicalNodes();
1456 TGeoVolume* mvol = 0;
1457 TGeoPhysicalNode* pn;
1458 TObjArray* overlaps = new TObjArray(64);
1459 overlaps->SetOwner();
1463 for(Int_t pni=0; pni<pnList->GetEntriesFast(); pni++){
1464 pn = (TGeoPhysicalNode*) pnList->UncheckedAt(pni);
1465 // checking the volume of the mother (go upper in the tree in case it is an assembly)
1467 while(((TGeoVolume*)pn->GetVolume(pn->GetLevel()-levup))->IsAssembly()) levup++;
1468 //Printf("Going to upper level");
1469 mvol = pn->GetVolume(pn->GetLevel()-levup);
1470 if(!mvol->IsSelected()){
1471 AliInfoClass(Form("Checking overlaps for volume %s",mvol->GetName()));
1472 mvol->CheckOverlaps(threshold);
1473 ovexlist = gGeoManager->GetListOfOverlaps();
1474 TIter next(ovexlist);
1476 while ((ov=(TGeoOverlap*)next())) overlaps->Add(ov->Clone());
1477 mvol->SelectVolume();
1480 mvol->SelectVolume(kTRUE); // clears the list of selected volumes
1482 AliInfoClass(Form("Number of overlapping/extruding PNs: %d",overlaps->GetEntriesFast()));
1486 TIter nextN(overlaps);
1488 while ((ovlp=(TGeoOverlap*)nextN())) ovlp->PrintInfo();
1494 //_____________________________________________________________________________
1495 Bool_t AliGeomManager::ApplyAlignObjsFromCDB(const char* AlignDetsList)
1497 // Calls AddAlignObjsFromCDBSingleDet for the detectors appearing in
1498 // the list passed as argument (called by AliSimulation and
1499 // AliReconstruction)
1500 // Read the alignment objects from CDB.
1501 // Each detector is supposed to have the
1502 // alignment objects in DET/Align/Data CDB path.
1503 // All the detector objects are then collected,
1504 // sorted by geometry level (starting from ALIC) and
1505 // then applied to the TGeo geometry.
1506 // Finally an overlaps check is performed.
1509 TObjArray alignObjArray;
1510 alignObjArray.Clear();
1511 alignObjArray.SetOwner(0);
1513 TString alObjsNotLoaded="";
1514 TString alObjsLoaded="";
1516 TString AlignDetsString(AlignDetsList);
1517 TObjArray *detsarr = AlignDetsString.Tokenize(' ');
1518 TIter iter(detsarr);
1519 TObjString *str = 0;
1521 while((str = (TObjString*) iter.Next())){
1522 TString det(str->String());
1523 AliInfoClass(Form("Loading alignment objs for %s",det.Data()));
1524 if(!LoadAlignObjsFromCDBSingleDet(det.Data(),alignObjArray)){
1525 alObjsNotLoaded += det.Data();
1526 alObjsNotLoaded += " ";
1528 alObjsLoaded += det.Data();
1529 alObjsLoaded += " ";
1535 if(!alObjsLoaded.IsNull()) AliInfoClass(Form("Alignment objects loaded for: %s",
1536 alObjsLoaded.Data()));
1537 if(!alObjsNotLoaded.IsNull()) AliInfoClass(Form("Didn't/couldn't load alignment objects for: %s",
1538 alObjsNotLoaded.Data()));
1540 return ApplyAlignObjsToGeom(alignObjArray);
1543 //_____________________________________________________________________________
1544 Bool_t AliGeomManager::LoadAlignObjsFromCDBSingleDet(const char* detName, TObjArray& alignObjArray)
1546 // Adds the alignable objects found in the CDBEntry for the detector
1547 // passed as argument to the array of all alignment objects to be applyed
1550 // Fills array of single detector's alignable objects from CDB
1552 AliDebugClass(2, Form("Loading alignment objs for detector: %s",detName));
1556 AliCDBPath path(detName,"Align","Data");
1558 entry=AliCDBManager::Instance()->Get(path.GetPath());
1560 AliDebugClass(2,Form("Couldn't load alignment data for detector %s",detName));
1564 TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
1565 alignArray->SetOwner(0);
1566 AliDebugClass(2,Form("Found %d alignment objects for %s",
1567 alignArray->GetEntries(),detName));
1569 AliAlignObj *alignObj=0;
1570 TIter iter(alignArray);
1572 // loop over align objects in detector
1573 while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
1574 alignObjArray.Add(alignObj);
1576 // delete entry --- Don't delete, it is cached!
1578 AliDebugClass(2, Form("fAlignObjArray entries: %d",alignObjArray.GetEntries() ));
1583 //_____________________________________________________________________________
1584 Bool_t AliGeomManager::ApplyAlignObjsToGeom(TObjArray& alignObjArray, Bool_t ovlpcheck)
1586 // Read collection of alignment objects (AliAlignObj derived) saved
1587 // in the TClonesArray alObjArray and apply them to gGeoManager
1589 alignObjArray.Sort();
1590 Int_t nvols = alignObjArray.GetEntriesFast();
1592 Bool_t flag = kTRUE;
1594 for(Int_t j=0; j<nvols; j++)
1596 AliAlignObj* alobj = (AliAlignObj*) alignObjArray.UncheckedAt(j);
1597 flag = alobj->ApplyToGeometry(ovlpcheck);
1600 AliErrorClass(Form("Error applying alignment object for volume %s !",alobj->GetSymName()));
1602 AliDebugClass(5,Form("Alignment object for volume %s applied successfully",alobj->GetSymName()));
1607 if (AliDebugLevelClass() > 5) {
1608 fgGeometry->CheckOverlaps(0.001);
1609 TObjArray* ovexlist = fgGeometry->GetListOfOverlaps();
1610 if(ovexlist->GetEntriesFast()){
1611 AliErrorClass("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
1612 fgGeometry->PrintOverlaps();
1616 // Update the TGeoPhysicalNodes
1617 fgGeometry->RefreshPhysicalNodes();
1623 //_____________________________________________________________________________
1624 Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* fileName, const char* clArrayName)
1626 // read collection of alignment objects (AliAlignObj derived) saved
1627 // in the TClonesArray ClArrayName in the file fileName and apply
1628 // them to the geometry
1631 TFile* inFile = TFile::Open(fileName,"READ");
1632 if (!inFile || !inFile->IsOpen()) {
1633 AliErrorClass(Form("Could not open file %s !",fileName));
1637 TClonesArray* alignObjArray = ((TClonesArray*) inFile->Get(clArrayName));
1639 if (!alignObjArray) {
1640 AliErrorClass(Form("Could not get array (%s) from file (%s) !",clArrayName,fileName));
1644 return ApplyAlignObjsToGeom(*alignObjArray);
1648 //_____________________________________________________________________________
1649 Bool_t AliGeomManager::ApplyAlignObjsToGeom(AliCDBParam* param, AliCDBId& Id)
1651 // read collection of alignment objects (AliAlignObj derived) saved
1652 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1653 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1657 AliCDBStorage* storage = AliCDBManager::Instance()->GetStorage(param);
1658 AliCDBEntry* entry = storage->Get(Id);
1659 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
1661 return ApplyAlignObjsToGeom(*alignObjArray);
1665 //_____________________________________________________________________________
1666 Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* uri, const char* path, Int_t runnum, Int_t version, Int_t sversion)
1668 // read collection of alignment objects (AliAlignObj derived) saved
1669 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1670 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1674 AliCDBParam* param = AliCDBManager::Instance()->CreateParameter(uri);
1675 AliCDBId id(path, runnum, runnum, version, sversion);
1677 return ApplyAlignObjsToGeom(param, id);
1681 //_____________________________________________________________________________
1682 Bool_t AliGeomManager::ApplyAlignObjsToGeom(const char* detName, Int_t runnum, Int_t version, Int_t sversion)
1684 // read collection of alignment objects (AliAlignObj derived) saved
1685 // in the TClonesArray ClArrayName in the AliCDBEntry identified by
1686 // param (to get the AliCDBStorage) and Id; apply the alignment objects
1690 AliCDBPath path(detName,"Align","Data");
1691 AliCDBEntry* entry = AliCDBManager::Instance()->Get(path.GetPath(),runnum,version,sversion);
1693 if(!entry) return kFALSE;
1694 TClonesArray* alignObjArray = ((TClonesArray*) entry->GetObject());
1696 return ApplyAlignObjsToGeom(*alignObjArray);