#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.
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"}
Gaudi::Property< unsigned >	m_nTheads {this, "nThreads", 0, "Number of available threads for the geometry reading"}
std::unique_ptr< GeoModelIO::ReadGeoModel >	m_sqliteReader {}
std::shared_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 31 of file GeoModelSvc.cxx.

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

GeoModelSvc::m_pSvcLocator

ISvcLocator * m_pSvcLocator

Definition GeoModelSvc.h:49

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;}

GeoModelSvc::m_atlasVersion

Gaudi::Property< std::string > m_atlasVersion

Definition GeoModelSvc.h:55

◆ caloVersion()

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

inlineoverrideprivatevirtual

Definition at line 107 of file GeoModelSvc.h.

107{return m_geoDbTagSvc->caloVersion();}

GeoModelSvc::m_geoDbTagSvc

ServiceHandle< IGeoDbTagSvc > m_geoDbTagSvc

Definition GeoModelSvc.h:53

◆ caloVersionOverride()

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

inlineoverrideprivatevirtual

Definition at line 95 of file GeoModelSvc.h.

95{return m_caloVersionOverride;}

GeoModelSvc::m_caloVersionOverride

Gaudi::Property< std::string > m_caloVersionOverride

Definition GeoModelSvc.h:64

◆ 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;}

GeoModelSvc::m_cavInfraVersionOverride

Gaudi::Property< std::string > m_cavInfraVersionOverride

Definition GeoModelSvc.h:66

◆ clear()

StatusCode GeoModelSvc::clear ( )

overridevirtual

Definition at line 607 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");
    }
  }
  m_sqliteReader.reset();
  m_sqliteDbManager.reset();
 
  return StatusCode::SUCCESS;
}

◆ compareTags()

StatusCode GeoModelSvc::compareTags ( )

Definition at line 341 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) {
      const 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 492 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 120 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 125 of file GeoModelSvc.cxx.

                                {
  PVLink 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;
    }
    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_FATAL("Failed to open SQLite database "
                    << sqliteDbPath
                    << " for reading in persistent GeoModel tree");
      return StatusCode::FAILURE;
    }
    GeoThreading::ThreadPool::getPool(m_nTheads);
    ATH_MSG_INFO(
        "Successfully opened SQLite DB file "
        << sqliteDbPath << " for reading in persistent GeoModel tree using "
        << GeoThreading::ThreadPool::getPool().nThreads() << " threads.");
    m_sqliteReader =
        std::make_unique<GeoModelIO::ReadGeoModel>(m_sqliteDbManager);
    PVConstLink vWorldPhys{m_sqliteReader->buildGeoModel()};
    worldPhys = const_pointer_cast(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
    std::unique_ptr<StoredMaterialManager> theMaterialManager{};
    try {
      theMaterialManager = std::make_unique<RDBMaterialManager>(m_pSvcLocator);
    } catch (std::runtime_error &e) {
      ATH_MSG_FATAL(e.what());
      return StatusCode::FAILURE;
    }
    ATH_CHECK(m_detStore->record(std::move(theMaterialManager), "MATERIALS"));
 
    worldPhys = createGeoWorld();
  }  // End of the GeometryDB-specific part
 
  // Create AtlasExperiment and register it within the transient detector store
  auto theExperiment =
      std::make_unique<GeoModelExperiment>(std::move(worldPhys));
  ATH_CHECK(m_detStore->record(std::move(theExperiment), "ATLAS"));
 
  int mem{}, cpu{};
  std::ofstream geoModelStats(m_statisticsToFile ? "GeoModelStatistics" : "");
  if (geoModelStats) {
    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 (geoModelStats) {
      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_sqliteDb) {
    // Close connection to the GeometryDB
    rdbAccess->shutdown();
  }
 
  return StatusCode::SUCCESS;
}

◆ getTool()

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

overridevirtual

Definition at line 598 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;}

GeoModelSvc::m_emecStandard

Gaudi::Property< bool > m_emecStandard

Definition GeoModelSvc.h:78

◆ 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 337 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.

55{this,"AtlasVersion","","ATLAS Geometry Tag"};

◆ m_bFieldVersionOverride

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

private

Definition at line 65 of file GeoModelSvc.h.

65{this,"MagFieldVersionOverride","","Overrider for MagField version"};

◆ m_callBackON

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

private

Definition at line 69 of file GeoModelSvc.h.

69{this,"AlignCallbacks",true,"Read alignment in callbacks"};

◆ m_caloVersionOverride

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

private

Definition at line 64 of file GeoModelSvc.h.

64{this,"CaloVersionOverride","","Overrider for Calo version"};

◆ m_cavInfraVersionOverride

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

private

Definition at line 66 of file GeoModelSvc.h.

66{this,"CavernInfraVersionOverride","","Overrider for CavernInfra version"};

◆ m_detectorTools

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

private

Definition at line 47 of file GeoModelSvc.h.

47{this,"DetectorTools",{}};

◆ m_detStore

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

private

Definition at line 51 of file GeoModelSvc.h.

51{this,"DetectorStore","DetectorStore",""};

◆ 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.

78{this,"EMECStandard",false,"Activate the EMEC construction from standard Geant4 Shapes: G4GenericTrap"};

◆ 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.

67{this,"ForwardDetectorsVersionOverride","","Overrider for Forward Detectors version"};

◆ m_geoDbTagSvc

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

private

Definition at line 53 of file GeoModelSvc.h.

53{this,"GeoDbTagSvc","GeoDbTagSvc",""};

◆ 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.

70{this,"IgnoreTagDifference",false,"Ignore TagInfo and configuration tag diffs"};

◆ 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.

76{this,"IgnoreTagSupport",false,"Skip checking if the geometry tag is supported/obsolete"};

◆ m_inDetVersionOverride

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

private

Definition at line 57 of file GeoModelSvc.h.

57{this,"InDetVersionOverride","","Overrider for InDet version"};

◆ 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.

61{this,"LAr_VersionOverride","","Overrider for LAr version"};

◆ m_muonVersionOverride

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

private

Definition at line 63 of file GeoModelSvc.h.

63{this,"MuonVersionOverride","","Overrider for Muon version"};

◆ m_nTheads

Gaudi::Property<unsigned> GeoModelSvc::m_nTheads {this, "nThreads", 0, "Number of available threads for the geometry reading"}

private

Definition at line 82 of file GeoModelSvc.h.

82{this, "nThreads", 0, "Number of available threads for the geometry reading"};

◆ m_pixelVersionOverride

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

private

Definition at line 58 of file GeoModelSvc.h.

58{this,"PixelVersionOverride","","Overrider for Pixel version"};

◆ m_pSvcLocator

ISvcLocator* GeoModelSvc::m_pSvcLocator {nullptr}

private

Definition at line 49 of file GeoModelSvc.h.

49{nullptr};

◆ 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.

59{this,"SCT_VersionOverride","","Overrider for SCT version"};

◆ 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.

80{this,"SQLiteDB",false,"Activate GeoModel initialization from SQLite"};

◆ 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.

81{this,"SQLiteDBFullPath","","Explicit setting of full path to SQLiteDB. For testing purposes only"};

◆ m_sqliteDbManager

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

private

Definition at line 85 of file GeoModelSvc.h.

85{};

◆ m_sqliteReader

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

private

Definition at line 84 of file GeoModelSvc.h.

84{};

◆ 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.

73{this,"StatisticsToFile",false,"Generate GeoModelStatistics file in the run directory"};

◆ 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.

75{this,"SupportedGeometry",0,"Supported geometry flag is set in jobOpt and is equal to major release version"};

◆ m_tagInfoMgr

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

private

Definition at line 52 of file GeoModelSvc.h.

52{this,"TagInfoMgr","TagInfoMgr",""};

◆ m_tileVersionOverride

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

private

Definition at line 62 of file GeoModelSvc.h.

62{this,"TileVersionOverride","","Overrider for Tile version"};

◆ 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.

60{this,"TRT_VersionOverride","","Overrider for TRT version"};

◆ m_useTagInfo

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

private

Definition at line 72 of file GeoModelSvc.h.

72{this,"UseTagInfo",true,"Use TagInfo"};

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_nTheads

◆ 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