GeoModelSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "GeoModelSvc.h"
 
#include <fstream>
 
#include "AthenaKernel/ClassID_traits.h"
#include "GaudiKernel/ConcurrencyFlags.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/SystemOfUnits.h"
#include "GeoDbTagSvc.h"
#include "GeoModelHelpers/ThreadPool.h"
#include "GeoModelHelpers/defineWorld.h"
#include "GeoModelKernel/GeoBox.h"
#include "GeoModelKernel/GeoLogVol.h"
#include "GeoModelKernel/GeoMaterial.h"
#include "GeoModelKernel/GeoPerfUtils.h"
#include "GeoModelKernel/GeoPhysVol.h"
#include "GeoModelKernel/GeoVolumeCursor.h"
#include "GeoModelUtilities/GeoModelExperiment.h"
#include "PathResolver/PathResolver.h"
#include "RDBAccessSvc/IRDBAccessSvc.h"
#include "RDBAccessSvc/IRDBRecord.h"
#include "RDBAccessSvc/IRDBRecordset.h"
#include "RDBMaterialManager.h"
#include "SGTools/DataProxy.h"
 
GeoModelSvc::GeoModelSvc(const std::string &name, ISvcLocator *svc)
    : base_class(name, svc), m_pSvcLocator(svc) {}
 
StatusCode GeoModelSvc::initialize()
{
  if (!m_sqliteDb && m_supportedGeometry == 0) {
    ATH_MSG_FATAL(
        "The Supported Geometry flag was not set in Job Options! Exiting ...");
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_detStore.retrieve());
 
  // --- Sebastien
  // clients (detector tools) are assuming the DetDescrCnvSvc has been
  // correctly initialized.
  // We ensure this is indeed correct by manually initialize it so there is
  // no more service-ordering problem triggered by jobO mix-up
  ServiceHandle<IConversionSvc> conversionSvc("DetDescrCnvSvc", this->name());
  ATH_CHECK(conversionSvc.retrieve());
  // --- Sebastien
 
  // Working around Gaudi Issue https://gitlab.cern.ch/gaudi/Gaudi/issues/82
  Service *convSvc = dynamic_cast<Service *>(conversionSvc.get());
  if (not convSvc) {
    ATH_MSG_ERROR("Dynamic cast to service failed");
    return StatusCode::FAILURE;
  }
  if (convSvc->FSMState() < Gaudi::StateMachine::INITIALIZED) {
    ATH_MSG_INFO("Explicitly initializing DetDescrCnvSvc");
    ATH_CHECK(convSvc->sysInitialize());
  }
 
  ATH_CHECK(m_detectorTools.retrieve());
 
  // build regular geometry
  ATH_CHECK(geoInit());
 
  if (!m_checkTagInfo) {
    // We are in a Simulation job: apply possible alignments to detectors.
    for(ToolHandle<IGeoModelTool>& theTool : m_detectorTools) {
      ATH_CHECK(theTool->align());
    }
  }
 
  if (m_useTagInfo) {
    ATH_CHECK(m_tagInfoMgr.retrieve());
    if (m_checkTagInfo) {
      m_tagInfoMgr->addListener(this);
    }
    ATH_CHECK(fillTagInfo());
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode GeoModelSvc::finalize() {
  m_tagInfoMgr->removeListener(this);
  return StatusCode::SUCCESS;
}
 
StatusCode GeoModelSvc::geoInit() {
  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
  for(ToolHandle<IGeoModelTool>& theTool : m_detectorTools) {
    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;
}
 
void GeoModelSvc::tagInfoUpdated() {
  compareTags().ignore();
}
 
StatusCode GeoModelSvc::compareTags() {
  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;
}
 
/**********************************************************************************
 ** Private Member Functions
 **********************************************************************************/
StatusCode GeoModelSvc::fillTagInfo() const {
  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;
}
 
const IGeoModelTool *GeoModelSvc::getTool(std::string toolName) const {
  for (const ToolHandle<IGeoModelTool> &tool : m_detectorTools) {
    if (tool->name().find(toolName) != std::string::npos)
      return tool.get();
  }
 
  return 0;
}
 
StatusCode GeoModelSvc::clear() {
  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;
}