ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
GeoModelSvc Class Reference

#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"}
 
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) {}

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 607 of file GeoModelSvc.cxx.

607  {
608  ATH_MSG_DEBUG("In clear()");
609 
610  // Call clear() for all tools
611  for (ToolHandle<IGeoModelTool> &tool : m_detectorTools) {
612  if (tool->clear().isFailure()) {
613  ATH_MSG_ERROR("clear() failed for the tool: " << tool->name());
614  return StatusCode::FAILURE;
615  } else {
616  ATH_MSG_DEBUG(tool->name() << " tool released");
617  }
618  }
619 
620  // Delete GeoModelExperiment - cascade delete of the entire GeoModel tree
621  std::vector<std::string> sgkeysExp;
622  m_detStore->keys<GeoModelExperiment>(sgkeysExp);
623  for (const std::string &key : sgkeysExp) {
624  SG::DataProxy *proxy =
625  m_detStore->proxy(ClassID_traits<GeoModelExperiment>::ID(), key);
626  if (proxy) {
627  proxy->reset();
628  ATH_MSG_DEBUG(key << " GeoModel experiment released");
629  }
630  }
631 
632  // Release stored material manager
633  std::vector<std::string> sgkeysMat;
634  m_detStore->keys<StoredMaterialManager>(sgkeysMat);
635  for (const std::string &key : sgkeysMat) {
636  SG::DataProxy *proxy =
637  m_detStore->proxy(ClassID_traits<StoredMaterialManager>::ID(), key);
638  if (proxy) {
639  proxy->reset();
640  ATH_MSG_DEBUG(key << " material manager released");
641  }
642  }
643 
644  return StatusCode::SUCCESS;
645 }

◆ compareTags()

StatusCode GeoModelSvc::compareTags ( )

Definition at line 341 of file GeoModelSvc.cxx.

341  {
342  bool tagsMatch = true;
343 
344  ATH_MSG_DEBUG("in compareTags()");
345 
346  // Get tags from TagInfoMgr
347  const ITagInfoMgr::NameTagPairVec pairs = m_tagInfoMgr->getInputTags();
348  for (const auto &pair : pairs) {
349  std::string tagPairName = pair.first;
350  if (tagPairName == "GeoAtlas") {
351  // ** Two possible cases need to be taken into account
352  // **
353  // ** 1. The retrieved ATLAS tag is following naming schema
354  // ATLAS-...-XX-YY-ZZ
355  // ** where '...' can be anything, it may also containg one or more '-'.
356  // ** If this is the case, then we need to check whether the job option
357  // tag
358  // ** is also following the same schema and they have the same
359  // 'ATLAS-...-XX' part
360  // **
361  // ** 2. The retrieved ATLAS tag is not following the schema mentioned
362  // above
363  // ** If this is the case, we just need to check the exact match
364  std::vector<std::string> tokensTagInfo, tokensJobOpt;
365 
366  // Parse Tag Info tag
367  std::string::size_type startpos = 0;
368  std::string currStr = pair.second;
369  for (std::string::size_type endpos = currStr.find('-');
370  endpos != std::string::npos; endpos = currStr.find('-', startpos)) {
371  tokensTagInfo.push_back(currStr.substr(startpos, endpos - startpos));
372  startpos = endpos + 1;
373  }
374  tokensTagInfo.push_back(currStr.substr(startpos));
375 
376  size_t tokensTagInfoSize = tokensTagInfo.size();
377  bool tagInfoFollowsTheScheme =
378  (tokensTagInfoSize >= 5 &&
379  tokensTagInfo[tokensTagInfoSize - 1].size() == 2 &&
380  tokensTagInfo[tokensTagInfoSize - 2].size() == 2 &&
381  tokensTagInfo[tokensTagInfoSize - 3].size() == 2);
382 
383  if (tagInfoFollowsTheScheme) {
384  // Parse Job Options tag
385  startpos = 0;
386  currStr = m_atlasVersion;
387  for (std::string::size_type endpos = currStr.find('-');
388  endpos != std::string::npos;
389  endpos = currStr.find('-', startpos)) {
390  tokensJobOpt.push_back(currStr.substr(startpos, endpos - startpos));
391  startpos = endpos + 1;
392  }
393  tokensJobOpt.push_back(currStr.substr(startpos));
394 
395  size_t tokensJobOptSize = tokensJobOpt.size();
396  bool jobOptFollowsTheScheme =
397  (tokensJobOptSize >= 5 &&
398  tokensJobOpt[tokensJobOptSize - 1].size() == 2 &&
399  tokensJobOpt[tokensJobOptSize - 2].size() == 2 &&
400  tokensJobOpt[tokensJobOptSize - 3].size() == 2);
401  if (jobOptFollowsTheScheme) {
402  const std::string &atlasVersion = m_atlasVersion;
403  tagsMatch = (pair.second.substr(0, currStr.size() - 6) ==
404  atlasVersion.substr(0, atlasVersion.size() - 6));
405  } else {
406  tagsMatch = false;
407  }
408  } else { // Check for the exact match
409  tagsMatch = m_atlasVersion == pair.second;
410  }
411  } else if (tagPairName == "GeoInDet")
412  tagsMatch = m_inDetVersionOverride == pair.second;
413  else if (tagPairName == "GeoPixel")
414  tagsMatch = m_pixelVersionOverride == pair.second;
415  else if (tagPairName == "GeoSCT")
416  tagsMatch = m_sctVersionOverride == pair.second;
417  else if (tagPairName == "GeoTRT")
418  tagsMatch = m_trtVersionOverride == pair.second;
419  else if (tagPairName == "GeoLAr")
420  tagsMatch = m_larVersionOverride == pair.second;
421  else if (tagPairName == "GeoTile")
422  tagsMatch = m_tileVersionOverride == pair.second;
423  else if (tagPairName == "GeoMuon")
424  tagsMatch = m_muonVersionOverride == pair.second;
425 
426  if (!tagsMatch)
427  break;
428  }
429 
430  if (!tagsMatch) {
431  msg((m_ignoreTagDifference ? MSG::WARNING : MSG::ERROR))
432  << "*** *** Geometry configured through jobOptions does not match "
433  "TagInfo tags! *** ***"
434  << endmsg;
435  ATH_MSG_INFO("** Job Option configuration: ");
436  ATH_MSG_INFO("* ATLAS tag: " << m_atlasVersion);
437  ATH_MSG_INFO("* InDet tag: " << m_inDetVersionOverride);
438  ATH_MSG_INFO("* Pixel tag: " << m_pixelVersionOverride);
439  ATH_MSG_INFO("* SCT tag: " << m_sctVersionOverride);
440  ATH_MSG_INFO("* TRT tag: " << m_trtVersionOverride);
441  ATH_MSG_INFO("* LAr tag: " << m_larVersionOverride);
442  ATH_MSG_INFO("* Tile tag: " << m_tileVersionOverride);
443  ATH_MSG_INFO("* Muon tag: " << m_muonVersionOverride);
444  ATH_MSG_INFO("* Calo tag: " << m_caloVersionOverride);
445  ATH_MSG_INFO("* MagField tag: " << m_bFieldVersionOverride);
446  ATH_MSG_INFO("* CavernInfra tag: " << m_cavInfraVersionOverride);
447  ATH_MSG_INFO("* ForwardDetectors tag: " << m_forDetVersionOverride);
448  ATH_MSG_INFO("** TAG INFO configuration: ");
449  for (const auto &pair : pairs) {
450  const std::string &tagPairName = pair.first;
451  if (tagPairName == "GeoAtlas") {
452  ATH_MSG_INFO("* ATLAS tag: " << pair.second);
453  } else if (tagPairName == "GeoInDet") {
454  ATH_MSG_INFO("*InDet tag: " << pair.second);
455  } else if (tagPairName == "GeoPixel") {
456  ATH_MSG_INFO("*Pixel tag: " << pair.second);
457  } else if (tagPairName == "GeoSCT") {
458  ATH_MSG_INFO("*SCT tag: " << pair.second);
459  } else if (tagPairName == "GeoTRT") {
460  ATH_MSG_INFO("*TRT tag: " << pair.second);
461  } else if (tagPairName == "GeoLAr") {
462  ATH_MSG_INFO("*LAr tag: " << pair.second);
463  } else if (tagPairName == "GeoTile") {
464  ATH_MSG_INFO("*Tile tag: " << pair.second);
465  } else if (tagPairName == "GeoMuon") {
466  ATH_MSG_INFO("*Muon tag: " << pair.second);
467  } else if (tagPairName == "GeoCalo") {
468  ATH_MSG_INFO("*Calo tag: " << pair.second);
469  } else if (tagPairName == "GeoMagField") {
470  ATH_MSG_INFO("*MagField tag: " << pair.second);
471  } else if (tagPairName == "GeoCavernInfra") {
472  ATH_MSG_INFO("*CavernInfra tag: " << pair.second);
473  } else if (tagPairName == "GeoForwardDetectors") {
474  ATH_MSG_INFO("*ForwardDetectors tag: " << pair.second);
475  }
476  }
477 
478  if (!m_ignoreTagDifference) {
479  ATH_MSG_INFO("*** *** Please fix geometry tag settings *** ***");
480  return StatusCode::FAILURE;
481  }
482  } else
483  ATH_MSG_DEBUG(
484  "Geometry configurations in jobOptions and TagInfo are consistent");
485 
486  return StatusCode::SUCCESS;
487 }

◆ fillTagInfo()

StatusCode GeoModelSvc::fillTagInfo ( ) const
private

Definition at line 492 of file GeoModelSvc.cxx.

492  {
493  if (m_atlasVersion == "") {
494  ATH_MSG_ERROR("ATLAS version is empty");
495  return StatusCode::FAILURE;
496  }
497 
498  if (m_tagInfoMgr->addTag("GeoAtlas", m_atlasVersion).isFailure()) {
499  ATH_MSG_ERROR("GeoModelSvc Atlas tag: " << m_atlasVersion
500  << " not added to TagInfo ");
501  return StatusCode::FAILURE;
502  }
503 
504  if (m_inDetVersionOverride != "") {
505  if (m_tagInfoMgr->addTag("GeoInDet", m_inDetVersionOverride).isFailure()) {
506  ATH_MSG_ERROR("GeoModelSvc InDet tag: " << m_inDetVersionOverride
507  << " not added to TagInfo ");
508  return StatusCode::FAILURE;
509  }
510  }
511 
512  if (m_pixelVersionOverride != "") {
513  if (m_tagInfoMgr->addTag("GeoPixel", m_pixelVersionOverride).isFailure()) {
514  ATH_MSG_ERROR("GeoModelSvc Pixel tag: " << m_pixelVersionOverride
515  << " not added to TagInfo ");
516  return StatusCode::FAILURE;
517  }
518  }
519 
520  if (m_sctVersionOverride != "") {
521  if (m_tagInfoMgr->addTag("GeoSCT", m_sctVersionOverride).isFailure()) {
522  ATH_MSG_ERROR("GeoModelSvc SCT tag: " << m_sctVersionOverride
523  << " not added to TagInfo ");
524  return StatusCode::FAILURE;
525  }
526  }
527 
528  if (m_trtVersionOverride != "") {
529  if (m_tagInfoMgr->addTag("GeoTRT", m_trtVersionOverride).isFailure()) {
530  ATH_MSG_ERROR("GeoModelSvc TRT tag: " << m_trtVersionOverride
531  << " not added to TagInfo ");
532  return StatusCode::FAILURE;
533  }
534  }
535 
536  if (m_larVersionOverride != "") {
537  if (m_tagInfoMgr->addTag("GeoLAr", m_larVersionOverride).isFailure()) {
538  ATH_MSG_ERROR("GeoModelSvc LAr tag: " << m_larVersionOverride
539  << " not added to TagInfo ");
540  return StatusCode::FAILURE;
541  }
542  }
543 
544  if (m_tileVersionOverride != "") {
545  if (m_tagInfoMgr->addTag("GeoTile", m_tileVersionOverride).isFailure()) {
546  ATH_MSG_ERROR("GeoModelSvc Tile tag: " << m_tileVersionOverride
547  << " not added to TagInfo ");
548  return StatusCode::FAILURE;
549  }
550  }
551 
552  if (m_muonVersionOverride != "") {
553  if (m_tagInfoMgr->addTag("GeoMuon", m_muonVersionOverride).isFailure()) {
554  ATH_MSG_ERROR("GeoModelSvc Muon tag: " << m_muonVersionOverride
555  << " not added to TagInfo ");
556  return StatusCode::FAILURE;
557  }
558  }
559 
560  if (m_caloVersionOverride != "") {
561  if (m_tagInfoMgr->addTag("GeoCalo", m_caloVersionOverride).isFailure()) {
562  ATH_MSG_ERROR("GeoModelSvc Calo tag: " << m_caloVersionOverride
563  << " not added to TagInfo ");
564  return StatusCode::FAILURE;
565  }
566  }
567 
568  if (m_bFieldVersionOverride != "") {
569  if (m_tagInfoMgr->addTag("GeoMagField", m_bFieldVersionOverride)
570  .isFailure()) {
571  ATH_MSG_ERROR("GeoModelSvc MagField tag: " << m_bFieldVersionOverride
572  << " not added to TagInfo ");
573  return StatusCode::FAILURE;
574  }
575  }
576 
577  if (m_cavInfraVersionOverride != "") {
578  if (m_tagInfoMgr->addTag("GeoCavernInfra", m_cavInfraVersionOverride)
579  .isFailure()) {
580  ATH_MSG_ERROR("GeoModelSvc CavernInfra tag: "
581  << m_cavInfraVersionOverride << " not added to TagInfo ");
582  return StatusCode::FAILURE;
583  }
584  }
585 
586  if (m_forDetVersionOverride != "") {
587  if (m_tagInfoMgr->addTag("GeoForwardDetectors", m_forDetVersionOverride)
588  .isFailure()) {
589  ATH_MSG_ERROR("GeoModelSvc ForwardDetectors tag: "
590  << m_forDetVersionOverride << " not added to TagInfo ");
591  return StatusCode::FAILURE;
592  }
593  }
594 
595  return StatusCode::SUCCESS;
596 }

◆ finalize()

StatusCode GeoModelSvc::finalize ( )
overridevirtual

Definition at line 120 of file GeoModelSvc.cxx.

120  {
121  m_tagInfoMgr->removeListener(this);
122  return StatusCode::SUCCESS;
123 }

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

125  {
126  PVLink worldPhys{nullptr};
127  ServiceHandle<IRDBAccessSvc> rdbAccess("RDBAccessSvc", name());
128 
129  // Setup the GeoDbTagSvc
130  ATH_CHECK(m_geoDbTagSvc.retrieve());
131 
132  GeoDbTagSvc *dbTagSvc = dynamic_cast<GeoDbTagSvc *>(m_geoDbTagSvc.get());
133  if (dbTagSvc == nullptr) {
134  ATH_MSG_FATAL("Unable to dyn-cast the IGeoDbTagSvc pointer to GeoDbTagSvc");
135  return StatusCode::FAILURE;
136  }
137 
138  // Build geometry from the SQLiteDB file
139  if (m_sqliteDb) {
140  std::string sqliteDbName = "Geometry/" + m_atlasVersion + ".db";
141  std::string sqliteDbPath =
142  m_sqliteDbFullPath.empty()
143  ? PathResolver::find_file(sqliteDbName, "CALIBPATH")
144  : m_sqliteDbFullPath.value();
145  if (sqliteDbPath.empty() && m_sqliteDbFullPath.empty()) {
146  ATH_MSG_FATAL("Failed to find SQLite database file "
147  << sqliteDbName
148  << " for reading in persistent GeoModel tree");
149  return StatusCode::FAILURE;
150  }
151  ATH_MSG_INFO("Successfully located SQLite database file "
152  << sqliteDbPath << " for reading in persistent GeoModel tree");
153  // Read raw geometry description from the file
154  m_sqliteDbManager = std::make_unique<GMDBManager>(sqliteDbPath);
155  if (!m_sqliteDbManager->checkIsDBOpen()) {
156  ATH_MSG_FATAL("Failed to open SQLite database "
157  << sqliteDbPath
158  << " for reading in persistent GeoModel tree");
159  return StatusCode::FAILURE;
160  }
161  GeoThreading::ThreadPool::getPool(m_nTheads);
162  ATH_MSG_INFO(
163  "Successfully opened SQLite DB file "
164  << sqliteDbPath << " for reading in persistent GeoModel tree using "
165  << GeoThreading::ThreadPool::getPool().nThreads() << " threads.");
166  m_sqliteReader =
167  std::make_unique<GeoModelIO::ReadGeoModel>(m_sqliteDbManager);
168  PVConstLink vWorldPhys{m_sqliteReader->buildGeoModel()};
169  worldPhys = const_pointer_cast(vWorldPhys);
170  if (!worldPhys) {
171  ATH_MSG_FATAL(
172  "Having Full Physical Volumes as World Volumes not supported!");
173  return StatusCode::FAILURE;
174  }
175  ATH_MSG_INFO(
176  "Successfully read persistent GeoModel description from the file");
177 
178  // Initialize SqliteReadSvc and open the file for reading plain SQLite
179  // tables with DetDescr parameters
180  ServiceHandle<IRDBAccessSvc> sqliteReadSvc("SqliteReadSvc", name());
181  ATH_CHECK(sqliteReadSvc.retrieve());
182  if (!sqliteReadSvc->connect(sqliteDbPath)) {
183  ATH_MSG_FATAL("Failed to open SQLite database file "
184  << sqliteDbPath << " for reading geometry parameters");
185  return StatusCode::FAILURE;
186  } else {
187  ATH_MSG_INFO("Successfully opened SQLite DB file: "
188  << sqliteDbPath << " for reading Det Descr parameters");
189  }
190  dbTagSvc->setParamSvcName("SqliteReadSvc");
191  dbTagSvc->setSqliteReader(m_sqliteReader.get());
192  if (dbTagSvc->setupConfig().isFailure()) {
193  ATH_MSG_FATAL("Failed to setup Geoconfig");
194  return StatusCode::FAILURE;
195  }
196  } else {
197  // Build geometry from the GeometryDB
198  ATH_MSG_DEBUG("** Building geometry configuration: ");
199  ATH_MSG_DEBUG("* ATLAS tag: " << m_atlasVersion);
200  ATH_MSG_DEBUG("* InDet tag: " << m_inDetVersionOverride);
201  ATH_MSG_DEBUG("* Pixel tag: " << m_pixelVersionOverride);
202  ATH_MSG_DEBUG("* SCT tag: " << m_sctVersionOverride);
203  ATH_MSG_DEBUG("* TRT tag: " << m_trtVersionOverride);
204  ATH_MSG_DEBUG("* LAr tag: " << m_larVersionOverride);
205  ATH_MSG_DEBUG("* Tile tag: " << m_tileVersionOverride);
206  ATH_MSG_DEBUG("* Muon tag: " << m_muonVersionOverride);
207  ATH_MSG_DEBUG("* Calo tag: " << m_caloVersionOverride);
208  ATH_MSG_DEBUG("* MagField tag: " << m_bFieldVersionOverride);
209  ATH_MSG_DEBUG("* CavernInfra tag: " << m_cavInfraVersionOverride);
210  ATH_MSG_DEBUG("* ForwardDetectors tag: " << m_forDetVersionOverride);
211 
212  // Get RDBAccessSvc and open connection to DB
213  ATH_CHECK(rdbAccess.retrieve());
214 
215  if (!rdbAccess->connect()) {
216  ATH_MSG_FATAL("Unable to connect to the Geometry DB");
217  return StatusCode::FAILURE;
218  }
219 
220  // Check the existence of ATLAS tag in the database
221  if (rdbAccess->getChildTag("ATLAS", m_atlasVersion, "ATLAS") == "") {
222  ATH_MSG_FATAL(" *** *** Wrong ATLAS layout: " << m_atlasVersion
223  << " *** ***");
224  ATH_MSG_FATAL(
225  " Either ATLAS geometry tag has been misspelled, or the DB Release "
226  "does not contain the geometry specified.");
227  ATH_MSG_FATAL(" In latter case please update DB Release version");
228  return StatusCode::FAILURE;
229  }
230 
231  dbTagSvc->setParamSvcName("RDBAccessSvc");
232 
233  if (!m_ignoreTagSupport) {
234  RDBTagDetails atlasTagDetails;
235  rdbAccess->getTagDetails(atlasTagDetails, m_atlasVersion);
236  const coral::AttributeSpecification &supportedSpec =
237  atlasTagDetails["SUPPORTED"].specification();
238  if (supportedSpec.type() == typeid(bool)) {
239  if (!atlasTagDetails["SUPPORTED"].data<bool>()) {
240  ATH_MSG_FATAL(
241  " *** *** ATLAS layout "
242  << m_atlasVersion
243  << " is OBSOLETE and can NOT be supported any more! *** ***");
244  return StatusCode::FAILURE;
245  }
246  } else if (supportedSpec.type() == typeid(int)) {
247  if (atlasTagDetails["SUPPORTED"].data<int>() < m_supportedGeometry) {
248  ATH_MSG_FATAL(" *** *** ATLAS layout "
249  << m_atlasVersion << " is OBSOLETE in rel "
250  << m_supportedGeometry
251  << " and can NOT be supported any more! *** ***");
252  return StatusCode::FAILURE;
253  }
254  }
255  }
256 
257  dbTagSvc->setAtlasVersion(m_atlasVersion);
258  dbTagSvc->setInDetVersionOverride(m_inDetVersionOverride);
259  dbTagSvc->setPixelVersionOverride(m_pixelVersionOverride);
260  dbTagSvc->setSCT_VersionOverride(m_sctVersionOverride);
261  dbTagSvc->setTRT_VersionOverride(m_trtVersionOverride);
262  dbTagSvc->setLAr_VersionOverride(m_larVersionOverride);
263  dbTagSvc->setTileVersionOverride(m_tileVersionOverride);
264  dbTagSvc->setMuonVersionOverride(m_muonVersionOverride);
265  dbTagSvc->setCaloVersionOverride(m_caloVersionOverride);
266  dbTagSvc->setMagFieldVersionOverride(m_bFieldVersionOverride);
267  dbTagSvc->setCavernInfraVersionOverride(m_cavInfraVersionOverride);
268  dbTagSvc->setForwardDetectorsVersionOverride(m_forDetVersionOverride);
269 
270  if (dbTagSvc->setupTags().isFailure()) {
271  ATH_MSG_FATAL("Failed to setup subsystem tags");
272  return StatusCode::FAILURE;
273  }
274  if (dbTagSvc->setupConfig().isFailure()) {
275  ATH_MSG_FATAL("Failed to setup Geoconfig");
276  return StatusCode::FAILURE;
277  }
278 
279  // Create a material manager
280  std::unique_ptr<StoredMaterialManager> theMaterialManager{};
281  try {
282  theMaterialManager = std::make_unique<RDBMaterialManager>(m_pSvcLocator);
283  } catch (std::runtime_error &e) {
284  ATH_MSG_FATAL(e.what());
285  return StatusCode::FAILURE;
286  }
287  ATH_CHECK(m_detStore->record(std::move(theMaterialManager), "MATERIALS"));
288 
289  worldPhys = createGeoWorld();
290  } // End of the GeometryDB-specific part
291 
292  // Create AtlasExperiment and register it within the transient detector store
293  auto theExperiment =
294  std::make_unique<GeoModelExperiment>(std::move(worldPhys));
295  ATH_CHECK(m_detStore->record(std::move(theExperiment), "ATLAS"));
296 
297  int mem{}, cpu{};
298  std::ofstream geoModelStats(m_statisticsToFile ? "GeoModelStatistics" : "");
299  if (geoModelStats) {
300  geoModelStats << "Detector Configuration flag = " << m_atlasVersion
301  << std::endl;
302  }
303 
304  // Loop over all tools
305  ToolHandleArray<IGeoModelTool>::iterator itPriv = m_detectorTools.begin(),
306  itPrivEnd = m_detectorTools.end();
307 
308  for (; itPriv != itPrivEnd; ++itPriv) {
309  IGeoModelTool *theTool = &(**itPriv);
310 
311  mem = GeoPerfUtils::getMem();
312  cpu = GeoPerfUtils::getCpu();
313 
314  ATH_CHECK(theTool->create());
315 
316  if (geoModelStats) {
317  geoModelStats << theTool->name()
318  << "\t SZ= " << GeoPerfUtils::getMem() - mem
319  << "Kb \t Time = " << (GeoPerfUtils::getCpu() - cpu) * 0.01
320  << "S" << std::endl;
321  } else {
322  ATH_MSG_INFO(theTool->name()
323  << "\t SZ= " << GeoPerfUtils::getMem() - mem
324  << "Kb \t Time = " << (GeoPerfUtils::getCpu() - cpu) * 0.01
325  << "S");
326  }
327  }
328 
329  if (!m_sqliteDb) {
330  // Close connection to the GeometryDB
331  rdbAccess->shutdown();
332  }
333 
334  return StatusCode::SUCCESS;
335 }

◆ getTool()

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

Definition at line 598 of file GeoModelSvc.cxx.

598  {
599  for (const ToolHandle<IGeoModelTool> &tool : m_detectorTools) {
600  if (tool->name().find(toolName) != std::string::npos)
601  return tool.get();
602  }
603 
604  return 0;
605 }

◆ 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 337 of file GeoModelSvc.cxx.

337  {
338  compareTags().ignore();
339 }

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

◆ 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::shared_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:
GeoDbTagSvc::setTileVersionOverride
void setTileVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:33
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
GeoModelSvc::m_sctVersionOverride
Gaudi::Property< std::string > m_sctVersionOverride
Definition: GeoModelSvc.h:59
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
GeoModelSvc::m_tileVersionOverride
Gaudi::Property< std::string > m_tileVersionOverride
Definition: GeoModelSvc.h:62
GeoModelSvc::m_muonVersionOverride
Gaudi::Property< std::string > m_muonVersionOverride
Definition: GeoModelSvc.h:63
GeoDbTagSvc
Definition: GeoDbTagSvc.h:16
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
GeoModelSvc::m_trtVersionOverride
Gaudi::Property< std::string > m_trtVersionOverride
Definition: GeoModelSvc.h:60
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
GeoModelSvc::m_sqliteDbFullPath
Gaudi::Property< std::string > m_sqliteDbFullPath
Definition: GeoModelSvc.h:81
GeoDbTagSvc::setupConfig
StatusCode setupConfig()
Definition: GeoDbTagSvc.cxx:93
GeoDbTagSvc::setAtlasVersion
void setAtlasVersion(const std::string &tag)
Definition: GeoDbTagSvc.h:27
DoubleEventSelectorOverlayTest.nThreads
nThreads
Definition: DoubleEventSelectorOverlayTest.py:83
GeoModelExperiment
Definition: GeoModelExperiment.h:32
athena.value
value
Definition: athena.py:124
GeoModelSvc::atlasVersion
virtual const std::string & atlasVersion() const override
Definition: GeoModelSvc.h:87
GeoModelSvc::m_supportedGeometry
Gaudi::Property< int > m_supportedGeometry
Definition: GeoModelSvc.h:75
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
GeoModelSvc::m_sqliteDbManager
std::shared_ptr< GMDBManager > m_sqliteDbManager
Definition: GeoModelSvc.h:85
GeoModelSvc::m_atlasVersion
Gaudi::Property< std::string > m_atlasVersion
Definition: GeoModelSvc.h:55
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
GeoModelSvc::m_sqliteReader
std::unique_ptr< GeoModelIO::ReadGeoModel > m_sqliteReader
Definition: GeoModelSvc.h:84
GeoModelSvc::m_detectorTools
ToolHandleArray< IGeoModelTool > m_detectorTools
Definition: GeoModelSvc.h:47
ITagInfoMgr::NameTagPairVec
std::vector< NameTagPair > NameTagPairVec
Definition: ITagInfoMgr.h:66
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
GeoDbTagSvc::setMuonVersionOverride
void setMuonVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:34
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:37
GeoModelSvc::m_caloVersionOverride
Gaudi::Property< std::string > m_caloVersionOverride
Definition: GeoModelSvc.h:64
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
GeoDbTagSvc::setInDetVersionOverride
void setInDetVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:28
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
GeoModelSvc::m_inDetVersionOverride
Gaudi::Property< std::string > m_inDetVersionOverride
Definition: GeoModelSvc.h:57
GeoModelSvc::m_nTheads
Gaudi::Property< unsigned > m_nTheads
Definition: GeoModelSvc.h:82
GeoModelSvc::m_forDetVersionOverride
Gaudi::Property< std::string > m_forDetVersionOverride
Definition: GeoModelSvc.h:67
GeoModelSvc::m_pixelVersionOverride
Gaudi::Property< std::string > m_pixelVersionOverride
Definition: GeoModelSvc.h:58
GeoModelSvc::m_larVersionOverride
Gaudi::Property< std::string > m_larVersionOverride
Definition: GeoModelSvc.h:61
GeoModelSvc::m_geoDbTagSvc
ServiceHandle< IGeoDbTagSvc > m_geoDbTagSvc
Definition: GeoModelSvc.h:53
GeoModelSvc::m_pSvcLocator
ISvcLocator * m_pSvcLocator
Definition: GeoModelSvc.h:49
GeoModelSvc::m_emecStandard
Gaudi::Property< bool > m_emecStandard
Definition: GeoModelSvc.h:78
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
GeoModelSvc::m_tagInfoMgr
ServiceHandle< ITagInfoMgr > m_tagInfoMgr
Definition: GeoModelSvc.h:52
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
GeoDbTagSvc::setLAr_VersionOverride
void setLAr_VersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:32
RDBTagDetails
coral::AttributeList RDBTagDetails
Definition: IRDBAccessSvc.h:29
GeoDbTagSvc::setCavernInfraVersionOverride
void setCavernInfraVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:37
IGeoModelTool::create
virtual StatusCode create()=0
GeoModelSvc::m_cavInfraVersionOverride
Gaudi::Property< std::string > m_cavInfraVersionOverride
Definition: GeoModelSvc.h:66
GeoDbTagSvc::setSCT_VersionOverride
void setSCT_VersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:30
GeoDbTagSvc::setSqliteReader
void setSqliteReader(GeoModelIO::ReadGeoModel *reader)
Definition: GeoDbTagSvc.h:41
GeoDbTagSvc::setTRT_VersionOverride
void setTRT_VersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:31
GeoDbTagSvc::setPixelVersionOverride
void setPixelVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:29
IGeoModelTool
Definition: IGeoModelTool.h:12
GeoModelSvc::m_statisticsToFile
Gaudi::Property< bool > m_statisticsToFile
Definition: GeoModelSvc.h:73
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path)
Definition: PathResolver.cxx:221
GeoModelSvc::m_sqliteDb
Gaudi::Property< bool > m_sqliteDb
Definition: GeoModelSvc.h:80
GeoDbTagSvc::setForwardDetectorsVersionOverride
void setForwardDetectorsVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:38
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
GeoDbTagSvc::setParamSvcName
void setParamSvcName(const std::string &name)
Definition: GeoDbTagSvc.h:40
GeoModelSvc::compareTags
StatusCode compareTags()
Definition: GeoModelSvc.cxx:341
GeoModelSvc::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: GeoModelSvc.h:51
GeoDbTagSvc::setupTags
StatusCode setupTags()
Definition: GeoDbTagSvc.cxx:30
GeoModelSvc::m_bFieldVersionOverride
Gaudi::Property< std::string > m_bFieldVersionOverride
Definition: GeoModelSvc.h:65
SG::DataProxy
Definition: DataProxy.h:45
GeoModelSvc::m_ignoreTagSupport
Gaudi::Property< bool > m_ignoreTagSupport
Definition: GeoModelSvc.h:76
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
getCpu
int getCpu()
Definition: SingleTrackValidation.cxx:53
GeoDbTagSvc::setCaloVersionOverride
void setCaloVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:35
GeoDbTagSvc::setMagFieldVersionOverride
void setMagFieldVersionOverride(const std::string &tag)
Definition: GeoDbTagSvc.h:36
ServiceHandle< IRDBAccessSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
GeoModelSvc::m_ignoreTagDifference
Gaudi::Property< bool > m_ignoreTagDifference
Definition: GeoModelSvc.h:70
Generated on Wed Nov 19 2025 21:35:02 for ATLAS Offline Software by   doxygen 1.8.18