#include <GeoModelSvc.h>

Inheritance diagram for GeoModelSvc:

Collaboration diagram for GeoModelSvc:

Public Member Functions
	GeoModelSvc (const std::string &name, ISvcLocator *svc)

virtual StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override

virtual StatusCode	finalize () override

virtual void	tagInfoUpdated () override final
	Callback from TagInfoMgr on TagInfo change. More...

StatusCode	compareTags ()

virtual const IGeoModelTool *	getTool (std::string toolName) const override

virtual StatusCode	clear () override

Private Member Functions
virtual const std::string &	atlasVersion () const override

virtual const std::string &	inDetVersionOverride () const override

virtual const std::string &	pixelVersionOverride () const override

virtual const std::string &	SCT_VersionOverride () const override

virtual const std::string &	TRT_VersionOverride () const override

virtual const std::string &	LAr_VersionOverride () const override

virtual const std::string &	tileVersionOverride () const override

virtual const std::string &	muonVersionOverride () const override

virtual const std::string &	caloVersionOverride () const override

virtual const std::string &	magFieldVersionOverride () const override

virtual const std::string &	cavernInfraVersionOverride () const override

virtual const std::string &	forwardDetectorsVersionOverride () const override

virtual const std::string &	inDetVersion () const override

virtual const std::string &	pixelVersion () const override

virtual const std::string &	SCT_Version () const override

virtual const std::string &	TRT_Version () const override

virtual const std::string &	LAr_Version () const override

virtual const std::string &	tileVersion () const override

virtual const std::string &	muonVersion () const override

virtual const std::string &	caloVersion () const override

virtual const std::string &	magFieldVersion () const override

virtual const std::string &	cavernInfraVersion () const override

virtual const std::string &	forwardDetectorsVersion () const override

virtual GeoModel::GeoConfig	geoConfig () const override

virtual const bool &	isEmecStandard () const override

StatusCode	geoInit ()

StatusCode	fillTagInfo () const

Private Attributes
ToolHandleArray< IGeoModelTool >	m_detectorTools {this,"DetectorTools",{}}

ISvcLocator *	m_pSvcLocator {nullptr}

ServiceHandle< StoreGateSvc >	m_detStore {this,"DetectorStore","DetectorStore",""}

ServiceHandle< ITagInfoMgr >	m_tagInfoMgr {this,"TagInfoMgr","TagInfoMgr",""}

ServiceHandle< IGeoDbTagSvc >	m_geoDbTagSvc {this,"GeoDbTagSvc","GeoDbTagSvc",""}

Gaudi::Property< std::string >	m_atlasVersion {this,"AtlasVersion","","ATLAS Geometry Tag"}

Gaudi::Property< std::string >	m_inDetVersionOverride {this,"InDetVersionOverride","","Overrider for InDet version"}

Gaudi::Property< std::string >	m_pixelVersionOverride {this,"PixelVersionOverride","","Overrider for Pixel version"}

Gaudi::Property< std::string >	m_sctVersionOverride {this,"SCT_VersionOverride","","Overrider for SCT version"}

Gaudi::Property< std::string >	m_trtVersionOverride {this,"TRT_VersionOverride","","Overrider for TRT version"}

Gaudi::Property< std::string >	m_larVersionOverride {this,"LAr_VersionOverride","","Overrider for LAr version"}

Gaudi::Property< std::string >	m_tileVersionOverride {this,"TileVersionOverride","","Overrider for Tile version"}

Gaudi::Property< std::string >	m_muonVersionOverride {this,"MuonVersionOverride","","Overrider for Muon version"}

Gaudi::Property< std::string >	m_caloVersionOverride {this,"CaloVersionOverride","","Overrider for Calo version"}

Gaudi::Property< std::string >	m_bFieldVersionOverride {this,"MagFieldVersionOverride","","Overrider for MagField version"}

Gaudi::Property< std::string >	m_cavInfraVersionOverride {this,"CavernInfraVersionOverride","","Overrider for CavernInfra version"}

Gaudi::Property< std::string >	m_forDetVersionOverride {this,"ForwardDetectorsVersionOverride","","Overrider for Forward Detectors version"}

Gaudi::Property< bool >	m_callBackON {this,"AlignCallbacks",true,"Read alignment in callbacks"}

Gaudi::Property< bool >	m_ignoreTagDifference {this,"IgnoreTagDifference",false,"Ignore TagInfo and configuration tag diffs"}

Gaudi::Property< bool >	m_useTagInfo {this,"UseTagInfo",true,"Use TagInfo"}

Gaudi::Property< bool >	m_statisticsToFile {this,"StatisticsToFile",false,"Generate GeoModelStatistics file in the run directory"}

Gaudi::Property< int >	m_supportedGeometry {this,"SupportedGeometry",0,"Supported geometry flag is set in jobOpt and is equal to major release version"}

Gaudi::Property< bool >	m_ignoreTagSupport {this,"IgnoreTagSupport",false,"Skip checking if the geometry tag is supported/obsolete"}

Gaudi::Property< bool >	m_emecStandard {this,"EMECStandard",false,"Activate the EMEC construction from standard Geant4 Shapes: G4GenericTrap"}

Gaudi::Property< bool >	m_sqliteDb {this,"SQLiteDB",false,"Activate GeoModel initialization from SQLite"}

Gaudi::Property< std::string >	m_sqliteDbFullPath {this,"SQLiteDBFullPath","","Explicit setting of full path to SQLiteDB. For testing purposes only"}

std::unique_ptr< GeoModelIO::ReadGeoModel >	m_sqliteReader {}

std::unique_ptr< GMDBManager >	m_sqliteDbManager {}

Detailed Description

Definition at line 26 of file GeoModelSvc.h.

Constructor & Destructor Documentation

◆ GeoModelSvc()

GeoModelSvc::GeoModelSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 30 of file GeoModelSvc.cxx.

   : base_class(name,svc)
   , m_pSvcLocator(svc)
 {
 }

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

virtual StatusCode initialize GeoModelSvc::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

◆ atlasVersion()

virtual const std::string& GeoModelSvc::atlasVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 87 of file GeoModelSvc.h.

87 {return m_atlasVersion;}

◆ caloVersion()

virtual const std::string& GeoModelSvc::caloVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 107 of file GeoModelSvc.h.

107 {return m_geoDbTagSvc->caloVersion();}

◆ caloVersionOverride()

virtual const std::string& GeoModelSvc::caloVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 95 of file GeoModelSvc.h.

95 {return m_caloVersionOverride;}

◆ cavernInfraVersion()

virtual const std::string& GeoModelSvc::cavernInfraVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 109 of file GeoModelSvc.h.

109 {return m_geoDbTagSvc->cavernInfraVersion();}

◆ cavernInfraVersionOverride()

virtual const std::string& GeoModelSvc::cavernInfraVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 97 of file GeoModelSvc.h.

97 {return m_cavInfraVersionOverride;}

◆ clear()

StatusCode GeoModelSvc::clear ( )

overridevirtual

Definition at line 572 of file GeoModelSvc.cxx.

 {
   ATH_MSG_DEBUG("In clear()"); 
  
   // Call clear() for all tools
   for (ToolHandle<IGeoModelTool>& tool : m_detectorTools) {
     if(tool->clear().isFailure()) {
       ATH_MSG_ERROR("clear() failed for the tool: " << tool->name());
       return StatusCode::FAILURE;
     } else {
       ATH_MSG_DEBUG(tool->name() << " tool released");
     }
   }
  
   // Delete GeoModelExperiment - cascade delete of the entire GeoModel tree
   std::vector<std::string> sgkeysExp;
   m_detStore->keys<GeoModelExperiment>(sgkeysExp);
   for (const std::string& key : sgkeysExp) {
     SG::DataProxy* proxy = m_detStore->proxy(ClassID_traits<GeoModelExperiment>::ID(),key);
     if(proxy) {
       proxy->reset();
       ATH_MSG_DEBUG(key << " GeoModel experiment released");
     }
   }
  
   // Release stored material manager
   std::vector<std::string> sgkeysMat;
   m_detStore->keys<StoredMaterialManager>(sgkeysMat);
   for (const std::string& key : sgkeysMat) {
     SG::DataProxy* proxy = m_detStore->proxy(ClassID_traits<StoredMaterialManager>::ID(),key);
     if(proxy) {
       proxy->reset();
       ATH_MSG_DEBUG(key << " material manager released");
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ compareTags()

StatusCode GeoModelSvc::compareTags ( )

Definition at line 329 of file GeoModelSvc.cxx.

 {
   bool tagsMatch = true;  
  
   ATH_MSG_DEBUG("in compareTags()");
  
   // Get tags from TagInfoMgr
   const ITagInfoMgr::NameTagPairVec pairs = m_tagInfoMgr->getInputTags();
   for( const auto& pair : pairs ) {
     std::string tagPairName = pair.first;
     if(tagPairName=="GeoAtlas") {
       // ** Two possible cases need to be taken into account
       // ** 
       // ** 1. The retrieved ATLAS tag is following naming schema ATLAS-...-XX-YY-ZZ
       // ** where '...' can be anything, it may also containg one or more '-'.
       // ** If this is the case, then we need to check whether the job option tag
       // ** is also following the same schema and they have the same 'ATLAS-...-XX' part
       // **
       // ** 2. The retrieved ATLAS tag is not following the schema mentioned above
       // ** If this is the case, we just need to check the exact match
       std::vector<std::string> tokensTagInfo, tokensJobOpt;
  
       // Parse Tag Info tag
       std::string::size_type startpos = 0;
       std::string currStr = pair.second;
       for(std::string::size_type endpos=currStr.find('-'); endpos!=std::string::npos; endpos=currStr.find('-',startpos)) {
     tokensTagInfo.push_back(currStr.substr(startpos,endpos-startpos));
     startpos = endpos+1;
       }
       tokensTagInfo.push_back(currStr.substr(startpos));
       
       size_t tokensTagInfoSize = tokensTagInfo.size();
       bool tagInfoFollowsTheScheme = (tokensTagInfoSize>=5 
                       && tokensTagInfo[tokensTagInfoSize-1].size()==2
                       && tokensTagInfo[tokensTagInfoSize-2].size()==2
                       && tokensTagInfo[tokensTagInfoSize-3].size()==2);
  
       if(tagInfoFollowsTheScheme) {
     // Parse Job Options tag
     startpos = 0;
     currStr = m_atlasVersion;
     for(std::string::size_type endpos=currStr.find('-'); endpos!=std::string::npos; endpos=currStr.find('-',startpos)) {
       tokensJobOpt.push_back(currStr.substr(startpos,endpos-startpos));
       startpos = endpos+1;
     }
     tokensJobOpt.push_back(currStr.substr(startpos));
     
     size_t tokensJobOptSize = tokensJobOpt.size();
     bool jobOptFollowsTheScheme = (tokensJobOptSize>=5
                        && tokensJobOpt[tokensJobOptSize-1].size()==2
                        && tokensJobOpt[tokensJobOptSize-2].size()==2
                        && tokensJobOpt[tokensJobOptSize-3].size()==2);
     if(jobOptFollowsTheScheme) {
       const std::string& atlasVersion = m_atlasVersion;
       tagsMatch = (pair.second.substr(0,currStr.size()-6)==atlasVersion.substr(0,atlasVersion.size()-6));
     }
     else {
       tagsMatch = false;
     }
       }
       else {// Check for the exact match 
     tagsMatch = m_atlasVersion == pair.second;
       }
     }
     else if(tagPairName=="GeoInDet")
       tagsMatch = m_inDetVersionOverride == pair.second;
     else if(tagPairName=="GeoPixel")
       tagsMatch = m_pixelVersionOverride == pair.second;
     else if(tagPairName=="GeoSCT")
       tagsMatch = m_sctVersionOverride == pair.second;
     else if(tagPairName=="GeoTRT")
       tagsMatch = m_trtVersionOverride == pair.second;
     else if(tagPairName=="GeoLAr")
       tagsMatch = m_larVersionOverride == pair.second;
     else if(tagPairName=="GeoTile")
       tagsMatch = m_tileVersionOverride == pair.second;
     else if(tagPairName=="GeoMuon")
       tagsMatch = m_muonVersionOverride == pair.second;
     
     if(!tagsMatch) break;
   }
  
   if(!tagsMatch) {
     msg((m_ignoreTagDifference? MSG::WARNING : MSG::ERROR)) 
       << "*** *** Geometry configured through jobOptions does not match TagInfo tags! *** ***" << endmsg;
     ATH_MSG_INFO("** Job Option configuration: ");
     ATH_MSG_INFO("* ATLAS tag: " << m_atlasVersion);
     ATH_MSG_INFO("* InDet tag: " << m_inDetVersionOverride);
     ATH_MSG_INFO("* Pixel tag: " << m_pixelVersionOverride);
     ATH_MSG_INFO("* SCT   tag: " << m_sctVersionOverride);
     ATH_MSG_INFO("* TRT   tag: " << m_trtVersionOverride);
     ATH_MSG_INFO("* LAr   tag: " << m_larVersionOverride);
     ATH_MSG_INFO("* Tile  tag: " << m_tileVersionOverride);
     ATH_MSG_INFO("* Muon  tag: " << m_muonVersionOverride);
     ATH_MSG_INFO("* Calo  tag: " << m_caloVersionOverride);
     ATH_MSG_INFO("* MagField  tag: " << m_bFieldVersionOverride);
     ATH_MSG_INFO("* CavernInfra  tag: " << m_cavInfraVersionOverride);
     ATH_MSG_INFO("* ForwardDetectors  tag: " << m_forDetVersionOverride);
     ATH_MSG_INFO("** TAG INFO configuration: ");
     for (const auto& pair : pairs) {
       std::string tagPairName = pair.first;
       if(tagPairName=="GeoAtlas")
     ATH_MSG_INFO("* ATLAS tag: " << pair.second);
       else if(tagPairName=="GeoInDet")
     ATH_MSG_INFO("*InDet  tag: " << pair.second);
       else if(tagPairName=="GeoPixel")
     ATH_MSG_INFO("*Pixel  tag: " << pair.second);
       else if(tagPairName=="GeoSCT")
     ATH_MSG_INFO("*SCT  tag: " << pair.second);
       else if(tagPairName=="GeoTRT")
     ATH_MSG_INFO("*TRT  tag: " << pair.second);
       else if(tagPairName=="GeoLAr")
     ATH_MSG_INFO("*LAr  tag: " << pair.second);
       else if(tagPairName=="GeoTile")
     ATH_MSG_INFO("*Tile  tag: " << pair.second);
       else if(tagPairName=="GeoMuon")
     ATH_MSG_INFO("*Muon  tag: " << pair.second);
       else if(tagPairName=="GeoCalo")
     ATH_MSG_INFO("*Calo  tag: " << pair.second);
       else if(tagPairName=="GeoMagField")
     ATH_MSG_INFO("*MagField  tag: " << pair.second);
       else if(tagPairName=="GeoCavernInfra")
     ATH_MSG_INFO("*CavernInfra  tag: " << pair.second);
       else if(tagPairName=="GeoForwardDetectors")
     ATH_MSG_INFO("*ForwardDetectors  tag: " << pair.second);
     }
     
     if(!m_ignoreTagDifference) {
       ATH_MSG_INFO("*** *** Please fix geometry tag settings *** ***");
       return StatusCode::FAILURE;
     }
   }
   else
     ATH_MSG_DEBUG("Geometry configurations in jobOptions and TagInfo are consistent");
  
   return StatusCode::SUCCESS;
 }

◆ fillTagInfo()

StatusCode GeoModelSvc::fillTagInfo ( ) const

private

Definition at line 470 of file GeoModelSvc.cxx.

 {
   if(m_atlasVersion == "") {
     ATH_MSG_ERROR("ATLAS version is empty");
     return StatusCode::FAILURE; 
   }
   
   if(m_tagInfoMgr->addTag("GeoAtlas",m_atlasVersion).isFailure()) {
     ATH_MSG_ERROR("GeoModelSvc Atlas tag: " << m_atlasVersion   << " not added to TagInfo ");
     return StatusCode::FAILURE; 
   }
  
   if(m_inDetVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoInDet",m_inDetVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc InDet tag: " << m_inDetVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   } 
  
   if(m_pixelVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoPixel",m_pixelVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc Pixel tag: " << m_pixelVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_sctVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoSCT",m_sctVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc SCT tag: " << m_sctVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_trtVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoTRT",m_trtVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc TRT tag: " << m_trtVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_larVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoLAr",m_larVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc LAr tag: " << m_larVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_tileVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoTile",m_tileVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc Tile tag: " << m_tileVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_muonVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoMuon",m_muonVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc Muon tag: " << m_muonVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_caloVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoCalo",m_caloVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc Calo tag: " << m_caloVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_bFieldVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoMagField",m_bFieldVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc MagField tag: " << m_bFieldVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_cavInfraVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoCavernInfra",m_cavInfraVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc CavernInfra tag: " << m_cavInfraVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   if(m_forDetVersionOverride != "") {
     if(m_tagInfoMgr->addTag("GeoForwardDetectors",m_forDetVersionOverride).isFailure()) {
       ATH_MSG_ERROR("GeoModelSvc ForwardDetectors tag: " << m_forDetVersionOverride << " not added to TagInfo ");
       return StatusCode::FAILURE; 
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ finalize()

StatusCode GeoModelSvc::finalize ( )

overridevirtual

Definition at line 117 of file GeoModelSvc.cxx.

 {
   m_tagInfoMgr->removeListener(this);
   return StatusCode::SUCCESS;
 }

◆ forwardDetectorsVersion()

virtual const std::string& GeoModelSvc::forwardDetectorsVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 110 of file GeoModelSvc.h.

110 {return m_geoDbTagSvc->forwardDetectorsVersion();}

◆ forwardDetectorsVersionOverride()

virtual const std::string& GeoModelSvc::forwardDetectorsVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 98 of file GeoModelSvc.h.

98 {return m_forDetVersionOverride;}

◆ geoConfig()

virtual GeoModel::GeoConfig GeoModelSvc::geoConfig ( ) const

inlineoverrideprivatevirtual

Definition at line 112 of file GeoModelSvc.h.

112 {return m_geoDbTagSvc->geoConfig();}

◆ geoInit()

StatusCode GeoModelSvc::geoInit ( )

private

Definition at line 123 of file GeoModelSvc.cxx.

 {
   GeoPhysVol* worldPhys{nullptr};
   ServiceHandle<IRDBAccessSvc> rdbAccess("RDBAccessSvc",name());
  
   // Setup the GeoDbTagSvc
   ATH_CHECK( m_geoDbTagSvc.retrieve() );
  
   GeoDbTagSvc* dbTagSvc = dynamic_cast<GeoDbTagSvc*>(m_geoDbTagSvc.get());
   if(dbTagSvc==nullptr) {
     ATH_MSG_FATAL("Unable to dyn-cast the IGeoDbTagSvc pointer to GeoDbTagSvc");
     return StatusCode::FAILURE;
   }
  
   // Build geometry from the SQLiteDB file
   if(m_sqliteDb) {
     std::string sqliteDbName = "Geometry/" + m_atlasVersion + ".db";
     std::string sqliteDbPath = m_sqliteDbFullPath.empty()
         ? PathResolver::find_file (sqliteDbName, "CALIBPATH")
         : m_sqliteDbFullPath.value();
     if(sqliteDbPath.empty() && m_sqliteDbFullPath.empty()) {
       ATH_MSG_FATAL("Failed to find SQLite database file " << sqliteDbName << " for reading in persistent GeoModel tree");
       return StatusCode::FAILURE;
     }
     else {
       ATH_MSG_INFO("Successfully located SQLite database file " << sqliteDbPath << " for reading in persistent GeoModel tree");
     }
     // Read raw geometry description from the file
     m_sqliteDbManager = std::make_unique<GMDBManager>(sqliteDbPath);
     if(m_sqliteDbManager->checkIsDBOpen()) {
       ATH_MSG_INFO("Successfully opened SQLite DB file " << sqliteDbPath << " for reading in persistent GeoModel tree");
     } else {
       ATH_MSG_FATAL("Failed to open SQLite database " << sqliteDbPath << " for reading in persistent GeoModel tree");
       return StatusCode::FAILURE;
     }
     m_sqliteReader = std::make_unique<GeoModelIO::ReadGeoModel>(m_sqliteDbManager.get());
     GeoVPhysVol* vWorldPhys ATLAS_THREAD_SAFE = const_cast<GeoVPhysVol*>(m_sqliteReader->buildGeoModel());
     worldPhys = dynamic_cast<GeoPhysVol*>(vWorldPhys);
     if(!worldPhys) {
       ATH_MSG_FATAL("Having Full Physical Volumes as World Volumes not supported!");
       return StatusCode::FAILURE;
     }
     ATH_MSG_INFO("Successfully read persistent GeoModel description from the file");
  
     // Initialize SqliteReadSvc and open the file for reading plain SQLite tables with DetDescr parameters
     ServiceHandle<IRDBAccessSvc> sqliteReadSvc("SqliteReadSvc",name());
     ATH_CHECK(sqliteReadSvc.retrieve());
     if(!sqliteReadSvc->connect(sqliteDbPath)) {
       ATH_MSG_FATAL("Failed to open SQLite database file " << sqliteDbPath << " for reading geometry parameters");
       return StatusCode::FAILURE;
     } else {
       ATH_MSG_INFO("Successfully opened SQLite DB file: " << sqliteDbPath << " for reading Det Descr parameters");
     }
     dbTagSvc->setParamSvcName("SqliteReadSvc");
     dbTagSvc->setSqliteReader(m_sqliteReader.get());
     if(dbTagSvc->setupConfig().isFailure()) {
       ATH_MSG_FATAL("Failed to setup Geoconfig");
       return StatusCode::FAILURE;
     }
   }
   else {
     // Build geometry from the GeometryDB
     ATH_MSG_DEBUG("** Building geometry configuration: ");
     ATH_MSG_DEBUG("* ATLAS tag: " << m_atlasVersion);
     ATH_MSG_DEBUG("* InDet tag: " << m_inDetVersionOverride);
     ATH_MSG_DEBUG("* Pixel tag: " << m_pixelVersionOverride);
     ATH_MSG_DEBUG("* SCT   tag: " << m_sctVersionOverride);
     ATH_MSG_DEBUG("* TRT   tag: " << m_trtVersionOverride);
     ATH_MSG_DEBUG("* LAr   tag: " << m_larVersionOverride);
     ATH_MSG_DEBUG("* Tile  tag: " << m_tileVersionOverride);
     ATH_MSG_DEBUG("* Muon  tag: " << m_muonVersionOverride);
     ATH_MSG_DEBUG("* Calo  tag: " << m_caloVersionOverride);
     ATH_MSG_DEBUG("* MagField  tag: " << m_bFieldVersionOverride);
     ATH_MSG_DEBUG("* CavernInfra  tag: " << m_cavInfraVersionOverride);
     ATH_MSG_DEBUG("* ForwardDetectors  tag: " << m_forDetVersionOverride);
     
     // Get RDBAccessSvc and open connection to DB
     ATH_CHECK( rdbAccess.retrieve() );
  
     if(!rdbAccess->connect()) {
       ATH_MSG_FATAL("Unable to connect to the Geometry DB");
       return StatusCode::FAILURE;
     }
  
     // Check the existence of ATLAS tag in the database
     if(rdbAccess->getChildTag("ATLAS",m_atlasVersion,"ATLAS")=="") {
       ATH_MSG_FATAL(" *** *** Wrong ATLAS layout: " << m_atlasVersion << " *** ***");
       ATH_MSG_FATAL(" Either ATLAS geometry tag has been misspelled, or the DB Release does not contain the geometry specified.");
       ATH_MSG_FATAL(" In latter case please update DB Release version");
       return StatusCode::FAILURE;
     }
  
     dbTagSvc->setParamSvcName("RDBAccessSvc");
  
     if(!m_ignoreTagSupport) {
       RDBTagDetails atlasTagDetails;
       rdbAccess->getTagDetails(atlasTagDetails, m_atlasVersion);
       const coral::AttributeSpecification& supportedSpec = atlasTagDetails["SUPPORTED"].specification();
       if(supportedSpec.type()==typeid(bool)) {
     if(!atlasTagDetails["SUPPORTED"].data<bool>()) {
       ATH_MSG_FATAL(" *** *** ATLAS layout " << m_atlasVersion << " is OBSOLETE and can NOT be supported any more! *** ***");
       return StatusCode::FAILURE;
     }
     }
       else if(supportedSpec.type()==typeid(int)) {
     if(atlasTagDetails["SUPPORTED"].data<int>()<m_supportedGeometry) {
       ATH_MSG_FATAL(" *** *** ATLAS layout " << m_atlasVersion 
             << " is OBSOLETE in rel " << m_supportedGeometry 
             << " and can NOT be supported any more! *** ***");
       return StatusCode::FAILURE;
     }
       }
     }
   
     dbTagSvc->setAtlasVersion(m_atlasVersion);
     dbTagSvc->setInDetVersionOverride(m_inDetVersionOverride);
     dbTagSvc->setPixelVersionOverride(m_pixelVersionOverride);
     dbTagSvc->setSCT_VersionOverride(m_sctVersionOverride);
     dbTagSvc->setTRT_VersionOverride(m_trtVersionOverride);
     dbTagSvc->setLAr_VersionOverride(m_larVersionOverride);
     dbTagSvc->setTileVersionOverride(m_tileVersionOverride);
     dbTagSvc->setMuonVersionOverride(m_muonVersionOverride);
     dbTagSvc->setCaloVersionOverride(m_caloVersionOverride);
     dbTagSvc->setMagFieldVersionOverride(m_bFieldVersionOverride);
     dbTagSvc->setCavernInfraVersionOverride(m_cavInfraVersionOverride);
     dbTagSvc->setForwardDetectorsVersionOverride(m_forDetVersionOverride);
     
     if(dbTagSvc->setupTags().isFailure()) {
       ATH_MSG_FATAL("Failed to setup subsystem tags");
       return StatusCode::FAILURE;
     }
     if(dbTagSvc->setupConfig().isFailure()) {
       ATH_MSG_FATAL("Failed to setup Geoconfig");
       return StatusCode::FAILURE;
     }
  
     // Create a material manager
     StoredMaterialManager *theMaterialManager{nullptr};
     try{
       theMaterialManager = new RDBMaterialManager(m_pSvcLocator);
     }
     catch(std::runtime_error& e) {
       ATH_MSG_FATAL(e.what());
       return StatusCode::FAILURE;
     }
     ATH_CHECK( m_detStore->record(theMaterialManager,"MATERIALS") );
  
     // Build the world node from which everything else will be suspended
     const GeoMaterial* air = theMaterialManager->getMaterial("std::Air");  
     const GeoBox* worldBox = new GeoBox(1000*Gaudi::Units::cm,1000*Gaudi::Units::cm, 1000*Gaudi::Units::cm);
     const GeoLogVol* worldLog = new GeoLogVol("WorldLog", worldBox, air);
     worldPhys=new GeoPhysVol(worldLog);
   } // End of the GeometryDB-specific part
  
   // Create AtlasExperiment and register it within the transient detector store
   GeoModelExperiment* theExperiment = new GeoModelExperiment(worldPhys);
   ATH_CHECK( m_detStore->record(theExperiment,"ATLAS") );
  
   int mem,cpu;
   std::unique_ptr<std::ofstream> geoModelStats;
   if(m_statisticsToFile) {
     geoModelStats = std::make_unique<std::ofstream>("GeoModelStatistics");
     *geoModelStats << "Detector Configuration flag = " << m_atlasVersion << std::endl; 
   }
     
   // Loop over all tools
   ToolHandleArray< IGeoModelTool >::iterator itPriv = m_detectorTools.begin(),
     itPrivEnd = m_detectorTools.end();
   
   for(; itPriv!=itPrivEnd; ++itPriv) {
     IGeoModelTool* theTool = &(**itPriv);
       
     mem = GeoPerfUtils::getMem();
     cpu = GeoPerfUtils::getCpu();
       
     ATH_CHECK(theTool->create());
       
     if(m_statisticsToFile) {
       *geoModelStats << theTool->name() << "\t SZ= " 
              << GeoPerfUtils::getMem() - mem << "Kb \t Time = " << (GeoPerfUtils::getCpu() - cpu) * 0.01 << "S" << std::endl;
     }
     else {
       ATH_MSG_INFO(theTool->name() << "\t SZ= " 
            << GeoPerfUtils::getMem() - mem << "Kb \t Time = " << (GeoPerfUtils::getCpu() - cpu) * 0.01 << "S");
     }
   }
     
   if(m_statisticsToFile) {
     geoModelStats->close();
   }
  
   if(!m_sqliteDb) {
     // Close connection to the GeometryDB
     rdbAccess->shutdown();
   }
  
   return StatusCode::SUCCESS;
 }

◆ getTool()

const IGeoModelTool * GeoModelSvc::getTool ( std::string toolName ) const

overridevirtual

Definition at line 562 of file GeoModelSvc.cxx.

 {
   for (const ToolHandle<IGeoModelTool>& tool : m_detectorTools) {
     if(tool->name().find(toolName)!=std::string::npos)
       return tool.get();
   }
  
   return 0;
 }

◆ inDetVersion()

virtual const std::string& GeoModelSvc::inDetVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 100 of file GeoModelSvc.h.

100 {return m_geoDbTagSvc->inDetVersion();}

◆ inDetVersionOverride()

virtual const std::string& GeoModelSvc::inDetVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 88 of file GeoModelSvc.h.

88 {return m_inDetVersionOverride;}

◆ isEmecStandard()

virtual const bool& GeoModelSvc::isEmecStandard ( ) const

inlineoverrideprivatevirtual

Definition at line 114 of file GeoModelSvc.h.

114 {return m_emecStandard;}

◆ LAr_Version()

virtual const std::string& GeoModelSvc::LAr_Version ( ) const

inlineoverrideprivatevirtual

Definition at line 104 of file GeoModelSvc.h.

104 {return m_geoDbTagSvc->LAr_Version();}

◆ LAr_VersionOverride()

virtual const std::string& GeoModelSvc::LAr_VersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 92 of file GeoModelSvc.h.

92 {return m_larVersionOverride;}

◆ magFieldVersion()

virtual const std::string& GeoModelSvc::magFieldVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 108 of file GeoModelSvc.h.

108 {return m_geoDbTagSvc->magFieldVersion();}

◆ magFieldVersionOverride()

virtual const std::string& GeoModelSvc::magFieldVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 96 of file GeoModelSvc.h.

96 {return m_bFieldVersionOverride;}

◆ muonVersion()

virtual const std::string& GeoModelSvc::muonVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 106 of file GeoModelSvc.h.

106 {return m_geoDbTagSvc->muonVersion();}

◆ muonVersionOverride()

virtual const std::string& GeoModelSvc::muonVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 94 of file GeoModelSvc.h.

94 {return m_muonVersionOverride;}

◆ pixelVersion()

virtual const std::string& GeoModelSvc::pixelVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 101 of file GeoModelSvc.h.

101 {return m_geoDbTagSvc->pixelVersion();}

◆ pixelVersionOverride()

virtual const std::string& GeoModelSvc::pixelVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 89 of file GeoModelSvc.h.

89 {return m_pixelVersionOverride;}

◆ SCT_Version()

virtual const std::string& GeoModelSvc::SCT_Version ( ) const

inlineoverrideprivatevirtual

Definition at line 102 of file GeoModelSvc.h.

102 {return m_geoDbTagSvc->SCT_Version();}

◆ SCT_VersionOverride()

virtual const std::string& GeoModelSvc::SCT_VersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 90 of file GeoModelSvc.h.

90 {return m_sctVersionOverride;}

◆ tagInfoUpdated()

void GeoModelSvc::tagInfoUpdated ( )

finaloverridevirtual

Callback from TagInfoMgr on TagInfo change.

Implements ITagInfoMgr::Listener.

Definition at line 323 of file GeoModelSvc.cxx.

 {
   compareTags().ignore();
 }

◆ tileVersion()

virtual const std::string& GeoModelSvc::tileVersion ( ) const

inlineoverrideprivatevirtual

Definition at line 105 of file GeoModelSvc.h.

105 {return m_geoDbTagSvc->tileVersion();}

◆ tileVersionOverride()

virtual const std::string& GeoModelSvc::tileVersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 93 of file GeoModelSvc.h.

93 {return m_tileVersionOverride;}

◆ TRT_Version()

virtual const std::string& GeoModelSvc::TRT_Version ( ) const

inlineoverrideprivatevirtual

Definition at line 103 of file GeoModelSvc.h.

103 {return m_geoDbTagSvc->TRT_Version();}

◆ TRT_VersionOverride()

virtual const std::string& GeoModelSvc::TRT_VersionOverride ( ) const

inlineoverrideprivatevirtual

Definition at line 91 of file GeoModelSvc.h.

91 {return m_trtVersionOverride;}

Member Data Documentation

◆ m_atlasVersion

Gaudi::Property<std::string> GeoModelSvc::m_atlasVersion {this,"AtlasVersion","","ATLAS Geometry Tag"}

private

Definition at line 55 of file GeoModelSvc.h.

◆ m_bFieldVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_bFieldVersionOverride {this,"MagFieldVersionOverride","","Overrider for MagField version"}

private

Definition at line 65 of file GeoModelSvc.h.

◆ m_callBackON

Gaudi::Property<bool> GeoModelSvc::m_callBackON {this,"AlignCallbacks",true,"Read alignment in callbacks"}

private

Definition at line 69 of file GeoModelSvc.h.

◆ m_caloVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_caloVersionOverride {this,"CaloVersionOverride","","Overrider for Calo version"}

private

Definition at line 64 of file GeoModelSvc.h.

◆ m_cavInfraVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_cavInfraVersionOverride {this,"CavernInfraVersionOverride","","Overrider for CavernInfra version"}

private

Definition at line 66 of file GeoModelSvc.h.

◆ m_detectorTools

ToolHandleArray<IGeoModelTool> GeoModelSvc::m_detectorTools {this,"DetectorTools",{}}

private

Definition at line 47 of file GeoModelSvc.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> GeoModelSvc::m_detStore {this,"DetectorStore","DetectorStore",""}

private

Definition at line 51 of file GeoModelSvc.h.

◆ m_emecStandard

Gaudi::Property<bool> GeoModelSvc::m_emecStandard {this,"EMECStandard",false,"Activate the EMEC construction from standard Geant4 Shapes: G4GenericTrap"}

private

Definition at line 78 of file GeoModelSvc.h.

◆ m_forDetVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_forDetVersionOverride {this,"ForwardDetectorsVersionOverride","","Overrider for Forward Detectors version"}

private

Definition at line 67 of file GeoModelSvc.h.

◆ m_geoDbTagSvc

ServiceHandle<IGeoDbTagSvc> GeoModelSvc::m_geoDbTagSvc {this,"GeoDbTagSvc","GeoDbTagSvc",""}

private

Definition at line 53 of file GeoModelSvc.h.

◆ m_ignoreTagDifference

Gaudi::Property<bool> GeoModelSvc::m_ignoreTagDifference {this,"IgnoreTagDifference",false,"Ignore TagInfo and configuration tag diffs"}

private

Definition at line 70 of file GeoModelSvc.h.

◆ m_ignoreTagSupport

Gaudi::Property<bool> GeoModelSvc::m_ignoreTagSupport {this,"IgnoreTagSupport",false,"Skip checking if the geometry tag is supported/obsolete"}

private

Definition at line 76 of file GeoModelSvc.h.

◆ m_inDetVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_inDetVersionOverride {this,"InDetVersionOverride","","Overrider for InDet version"}

private

Definition at line 57 of file GeoModelSvc.h.

◆ m_larVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_larVersionOverride {this,"LAr_VersionOverride","","Overrider for LAr version"}

private

Definition at line 61 of file GeoModelSvc.h.

◆ m_muonVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_muonVersionOverride {this,"MuonVersionOverride","","Overrider for Muon version"}

private

Definition at line 63 of file GeoModelSvc.h.

◆ m_pixelVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_pixelVersionOverride {this,"PixelVersionOverride","","Overrider for Pixel version"}

private

Definition at line 58 of file GeoModelSvc.h.

◆ m_pSvcLocator

ISvcLocator* GeoModelSvc::m_pSvcLocator {nullptr}

private

Definition at line 49 of file GeoModelSvc.h.

◆ m_sctVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_sctVersionOverride {this,"SCT_VersionOverride","","Overrider for SCT version"}

private

Definition at line 59 of file GeoModelSvc.h.

◆ m_sqliteDb

Gaudi::Property<bool> GeoModelSvc::m_sqliteDb {this,"SQLiteDB",false,"Activate GeoModel initialization from SQLite"}

private

Definition at line 80 of file GeoModelSvc.h.

◆ m_sqliteDbFullPath

Gaudi::Property<std::string> GeoModelSvc::m_sqliteDbFullPath {this,"SQLiteDBFullPath","","Explicit setting of full path to SQLiteDB. For testing purposes only"}

private

Definition at line 81 of file GeoModelSvc.h.

◆ m_sqliteDbManager

std::unique_ptr<GMDBManager> GeoModelSvc::m_sqliteDbManager {}

private

Definition at line 85 of file GeoModelSvc.h.

◆ m_sqliteReader

std::unique_ptr<GeoModelIO::ReadGeoModel> GeoModelSvc::m_sqliteReader {}

private

Definition at line 84 of file GeoModelSvc.h.

◆ m_statisticsToFile

Gaudi::Property<bool> GeoModelSvc::m_statisticsToFile {this,"StatisticsToFile",false,"Generate GeoModelStatistics file in the run directory"}

private

Definition at line 73 of file GeoModelSvc.h.

◆ m_supportedGeometry

Gaudi::Property<int> GeoModelSvc::m_supportedGeometry {this,"SupportedGeometry",0,"Supported geometry flag is set in jobOpt and is equal to major release version"}

private

Definition at line 75 of file GeoModelSvc.h.

◆ m_tagInfoMgr

ServiceHandle<ITagInfoMgr> GeoModelSvc::m_tagInfoMgr {this,"TagInfoMgr","TagInfoMgr",""}

private

Definition at line 52 of file GeoModelSvc.h.

◆ m_tileVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_tileVersionOverride {this,"TileVersionOverride","","Overrider for Tile version"}

private

Definition at line 62 of file GeoModelSvc.h.

◆ m_trtVersionOverride

Gaudi::Property<std::string> GeoModelSvc::m_trtVersionOverride {this,"TRT_VersionOverride","","Overrider for TRT version"}

private

Definition at line 60 of file GeoModelSvc.h.

◆ m_useTagInfo

Gaudi::Property<bool> GeoModelSvc::m_useTagInfo {this,"UseTagInfo",true,"Use TagInfo"}

private

Definition at line 72 of file GeoModelSvc.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GeoModelSvc()

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

◆ atlasVersion()

◆ caloVersion()

◆ caloVersionOverride()

◆ cavernInfraVersion()

◆ cavernInfraVersionOverride()

◆ clear()

◆ compareTags()

◆ fillTagInfo()

◆ finalize()

◆ forwardDetectorsVersion()

◆ forwardDetectorsVersionOverride()

◆ geoConfig()

◆ geoInit()

◆ getTool()

◆ inDetVersion()

◆ inDetVersionOverride()

◆ isEmecStandard()

◆ LAr_Version()

◆ LAr_VersionOverride()

◆ magFieldVersion()

◆ magFieldVersionOverride()

◆ muonVersion()

◆ muonVersionOverride()

◆ pixelVersion()

◆ pixelVersionOverride()

◆ SCT_Version()

◆ SCT_VersionOverride()

◆ tagInfoUpdated()

◆ tileVersion()

◆ tileVersionOverride()

◆ TRT_Version()

◆ TRT_VersionOverride()

Member Data Documentation

◆ m_atlasVersion

◆ m_bFieldVersionOverride

◆ m_callBackON

◆ m_caloVersionOverride

◆ m_cavInfraVersionOverride

◆ m_detectorTools

◆ m_detStore

◆ m_emecStandard

◆ m_forDetVersionOverride

◆ m_geoDbTagSvc

◆ m_ignoreTagDifference

◆ m_ignoreTagSupport

◆ m_inDetVersionOverride

◆ m_larVersionOverride

◆ m_muonVersionOverride

◆ m_pixelVersionOverride

◆ m_pSvcLocator

◆ m_sctVersionOverride

◆ m_sqliteDb

◆ m_sqliteDbFullPath

◆ m_sqliteDbManager

◆ m_sqliteReader

◆ m_statisticsToFile

◆ m_supportedGeometry

◆ m_tagInfoMgr

◆ m_tileVersionOverride

◆ m_trtVersionOverride

◆ m_useTagInfo