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

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

◆ compareTags()

StatusCode GeoModelSvc::compareTags ( )

Definition at line 345 of file GeoModelSvc.cxx.

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

◆ fillTagInfo()

StatusCode GeoModelSvc::fillTagInfo ( ) const
private

Definition at line 496 of file GeoModelSvc.cxx.

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

◆ finalize()

StatusCode GeoModelSvc::finalize ( )
overridevirtual

Definition at line 124 of file GeoModelSvc.cxx.

124  {
125  m_tagInfoMgr->removeListener(this);
126  return StatusCode::SUCCESS;
127 }

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

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

◆ getTool()

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

Definition at line 602 of file GeoModelSvc.cxx.

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

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

341  {
342  compareTags().ignore();
343 }

◆ 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:183
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:345
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 Mon Sep 29 2025 21:35:12 for ATLAS Offline Software by   doxygen 1.8.18