RDBMaterialManager Class Reference

This is a material manager which gets material definitions from the Geometry DB (Oracle) More...

#include <RDBMaterialManager.h>

Inheritance diagram for RDBMaterialManager:

Collaboration diagram for RDBMaterialManager:

Classes
struct	DetectorAuxData

Public Types
using	MaterialMap = std::map<std::string, GeoIntrusivePtr<GeoMaterial>>
using	MaterialMapIterator = MaterialMap::const_iterator

Public Member Functions
	RDBMaterialManager (ISvcLocator *pSvcLocator)
virtual	~RDBMaterialManager ()
virtual const GeoMaterial *	getMaterial (const std::string &name) override
virtual const GeoElement *	getElement (const std::string &name) override
virtual const GeoElement *	getElement (unsigned int atomicNumber) override
virtual void	addMaterial (const std::string &space, GeoMaterial *material) override
virtual StoredMaterialManager::MaterialMapIterator	begin () const override
virtual StoredMaterialManager::MaterialMapIterator	end () const override
virtual size_t	size () override
virtual std::ostream &	printAll (std::ostream &o=std::cout) const override
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Types
using	GeoEleVec = std::vector<GeoIntrusivePtr<GeoElement>>

Private Member Functions
StatusCode	readMaterialsFromDB (ISvcLocator *pSvcLocator)
void	buildSpecialMaterials ()
GeoElement *	searchElementVector (const std::string &name) const
GeoElement *	searchElementVector (const unsigned int atomicNumber) const
GeoMaterial *	searchMaterialMap (const std::string &name) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
IRDBRecordset_ptr	m_elements
GeoEleVec	m_elementVector
StoredMaterialManager::MaterialMap	m_materialMap
std::map< std::string, DetectorAuxData >	m_detData
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

This is a material manager which gets material definitions from the Geometry DB (Oracle)

Author

Joe Boudreau

Definition at line 28 of file RDBMaterialManager.h.

Member Typedef Documentation

GeoEleVec

using RDBMaterialManager::GeoEleVec = std::vector<GeoIntrusivePtr<GeoElement>>

private

Definition at line 70 of file RDBMaterialManager.h.

MaterialMap

using StoredMaterialManager::MaterialMap = std::map<std::string, GeoIntrusivePtr<GeoMaterial>>

inherited

Definition at line 30 of file StoredMaterialManager.h.

MaterialMapIterator

using StoredMaterialManager::MaterialMapIterator = MaterialMap::const_iterator

inherited

Definition at line 31 of file StoredMaterialManager.h.

Constructor & Destructor Documentation

RDBMaterialManager()

RDBMaterialManager::RDBMaterialManager

(

ISvcLocator *

pSvcLocator

)

Definition at line 24 of file RDBMaterialManager.cxx.

  : AthMessaging("GeoModelSvc::RDBMaterialManager")
{
  if(!readMaterialsFromDB(pSvcLocator).isSuccess()) {
    throw std::runtime_error("RDBMaterialManager failed to read Geometry DB");
  }
}

~RDBMaterialManager()

RDBMaterialManager::~RDBMaterialManager ( )

virtualdefault

Member Function Documentation

addMaterial()

void RDBMaterialManager::addMaterial ( const std::string & space, GeoMaterial * material )

overridevirtual

Implements StoredMaterialManager.

Definition at line 404 of file RDBMaterialManager.cxx.

{
  ATH_MSG_VERBOSE(" ***** RDBMaterialManager::addMaterial() ");
  const std::string& key = material->getName();
  const auto [it_material, success] = m_materialMap.emplace(key,material);
  if(success) {
    it_material->second->lock();
  }
  else {
    // Warn if we already have material with the same name defined
    ATH_MSG_WARNING(" Attempt to redefine material " << key
            << "!. The existing instance is kept. Please choose another name for new material");
  }
}

begin()

StoredMaterialManager::MaterialMapIterator RDBMaterialManager::begin ( ) const

overridevirtual

Implements StoredMaterialManager.

Definition at line 419 of file RDBMaterialManager.cxx.

{
  return m_materialMap.begin();
}

buildSpecialMaterials()

void RDBMaterialManager::buildSpecialMaterials ( )

private

Definition at line 451 of file RDBMaterialManager.cxx.

{
  // Create special materials
  GeoElement* ethElement = new GeoElement("Ether","ET",500.0,0.0);
  m_elementVector.push_back(ethElement);  
  GeoMaterial* ether = new GeoMaterial("special::Ether",0.0);   
  ether->add(ethElement,1.);
  addMaterial("special",ether);
  // "Alternative" assembly material
  GeoMaterial* hu = new GeoMaterial("special::HyperUranium",0.0);   
  hu->add(ethElement,1.);
  addMaterial("special",hu);
}

end()

StoredMaterialManager::MaterialMapIterator RDBMaterialManager::end ( ) const

overridevirtual

Implements StoredMaterialManager.

Definition at line 424 of file RDBMaterialManager.cxx.

{
  return m_materialMap.end();
}

getElement() [1/2]

const GeoElement * RDBMaterialManager::getElement ( const std::string & name )

overridevirtual

Implements StoredMaterialManager.

Definition at line 360 of file RDBMaterialManager.cxx.

{
  ATH_MSG_VERBOSE(" ***** getElement(): " << name);
 
  GeoElement* pelement = searchElementVector(name);
  if(!pelement) {
    for(const auto& rec : *m_elements) {
      if(name == rec->getString("NAME")) {
    pelement = new GeoElement(rec->getString("NAME")
                  , rec->getString("SYMBOL")
                  , rec->getDouble("Z")
                  , rec->getDouble("A")*GeoModelKernelUnits::gram/Gaudi::Units::mole);
    
    // a table to keep the memory allocation, and easy for delete
    m_elementVector.push_back(pelement);
    break;
      }
    }
  }
  return pelement;
}

getElement() [2/2]

const GeoElement * RDBMaterialManager::getElement ( unsigned int atomicNumber )

overridevirtual

Implements StoredMaterialManager.

Definition at line 382 of file RDBMaterialManager.cxx.

{
  ATH_MSG_VERBOSE(" ***** const getElement(atomicNumber) const : " << atomicNumber);
 
  GeoElement* pelement = searchElementVector(atomicNumber);
  if(!pelement) {
    for(const auto& rec : *m_elements) {
      if(atomicNumber == rec->getDouble("A")) {
    pelement = new GeoElement(rec->getString("NAME")
                  , rec->getString("SYMBOL")
                  , rec->getDouble("Z")
                  , rec->getDouble("A")*GeoModelKernelUnits::gram/Gaudi::Units::mole);
    
    // a table to keep the memory allocation, and easy for delete
    m_elementVector.push_back( pelement);
    break;
      }
    }
  }
  return pelement;
}

getMaterial()

const GeoMaterial * RDBMaterialManager::getMaterial ( const std::string & name )

overridevirtual

Implements StoredMaterialManager.

Definition at line 250 of file RDBMaterialManager.cxx.

{
  [[maybe_unused]] static const bool specialMaterialsDone = [this]() {
    buildSpecialMaterials();
    return true;
  }();
 
  ATH_MSG_DEBUG(" ***** getMaterial( ): " << name);
 
  GeoMaterial* pmaterial = searchMaterialMap(name);
  if (pmaterial)
    return pmaterial;
 
  size_t pos = name.find("::");
  if(pos==std::string::npos) {
    ATH_MSG_ERROR("Wrong format for the material name " << name
          << ". Must be detector::material");
    return nullptr;
  }
 
  const std::string detector = name.substr(0,pos);
  auto it = m_detData.find(detector);
  if(it==m_detData.end()) {
    ATH_MSG_ERROR("Wrong detector name " << detector
          << " passed to getMaterial()");
    return nullptr;
  }
 
  IRDBRecordset_ptr tmp_materials = it->second.m_materials;
  IRDBRecordset_ptr tmp_matcomponents = it->second.m_matcomponents;
  const std::string& data_id = it->second.m_prim_key;
 
  auto it_material = std::find_if(tmp_materials->begin()
                  , tmp_materials->end()
                  , [&name, &detector](const IRDBRecord_ptr& rec) {
                    return name == detector+"::"+rec->getString("NAME");
                  });
 
  if(it_material==tmp_materials->end()) {
    ATH_MSG_VERBOSE(detector << " materials retrieved from the database don't include " << name);
    return nullptr;
  }
 
  const auto& rec = *it_material;
  std::string material_name = detector+"::"+rec->getString("NAME");
  long material_id = rec->getLong(data_id);
  double material_density = rec->getDouble("DENSITY");
  
  ATH_MSG_DEBUG(" ***** Material: name id density: "  << material_name <<" " << material_id <<" "<< material_density);
  
  pmaterial = new GeoMaterial( material_name,material_density * (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
 
  bool firstComponent = true;
  bool hasSubMaterial = false;
  bool calculateFraction = false;
  double totalFraction = 0.;
  double component_fraction = 0.;
  std::string component_name{};
 
  std::vector <const GeoElement*> elementComponents;
  std::vector <double>        elementFractions;
 
  for(const auto& rec : *tmp_matcomponents) {
    if(rec->getLong("MATERIAL_ID") == material_id) {
      component_name = rec->getString("COMPNAME");
      component_fraction = rec->getDouble("FRACTION");
 
      if(firstComponent) {
    firstComponent = false;
    if(component_fraction>=1.) {
      calculateFraction = true;
    }
      }
 
      if(component_name.find("::",0) == std::string::npos) {
    const GeoElement* p_com_element = getElement(component_name);
 
    if(calculateFraction) {
      totalFraction += component_fraction*p_com_element->getA();
      elementComponents.push_back(p_com_element);
      elementFractions.push_back(component_fraction);
    }
    else {
      pmaterial->add( p_com_element, component_fraction);
    }
      }
      else {
    hasSubMaterial = true;
    const GeoMaterial* p_com_material = getMaterial(component_name);
    pmaterial->add(p_com_material, component_fraction);
      } // Element vs Sub-Material
    } // Deal with the component
  } // Loop over records
 
  if(calculateFraction && hasSubMaterial && elementComponents.size()>0)
    ATH_MSG_WARNING(material_name << " description should be changed. Please indicate the exact fraction for elements");
 
  if(calculateFraction && !elementComponents.empty()) {
    double inv_totalFraction = totalFraction == 0 ? 1 : 1. / totalFraction;
    for(unsigned i=0; i<elementComponents.size(); ++i) {
      pmaterial->add(elementComponents[i],elementFractions[i]*elementComponents[i]->getA() * inv_totalFraction);
    }
  }
 
  // Cache new material
  addMaterial(detector,pmaterial);
    
  return pmaterial;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

printAll()

std::ostream & RDBMaterialManager::printAll ( std::ostream & o = std::cout ) const

overridevirtual

Implements StoredMaterialManager.

Definition at line 434 of file RDBMaterialManager.cxx.

{
  o << "============Material Manager Element List========================\n";
  for (GeoElement* elt : m_elementVector){
    o << elt->getSymbol() << '\t' << elt->getZ() <<  '\t' << elt->getA() * (Gaudi::Units::mole / GeoModelKernelUnits::gram) << '\t' << elt->getName() << "\n";
  }
 
  for (const auto& p : m_materialMap){
    o << "Material: " << p.first <<  " Density " << p.second->getDensity() * (Gaudi::Units::cm3 / GeoModelKernelUnits::gram)  << "\n";
    for (size_t i = 0; i< p.second->getNumElements();i++) {
      o <<" ***** ***** "<< int (p.second->getFraction(i)*100) << "% \t"  << p.second->getElement(i)->getName() << std::endl;
    }
  }
        
  return o;
}

readMaterialsFromDB()

StatusCode RDBMaterialManager::readMaterialsFromDB ( ISvcLocator * pSvcLocator )

private

Definition at line 32 of file RDBMaterialManager.cxx.

{
  SmartIF<IGeoModelSvc> iGeoModel{pSvcLocator->service("GeoModelSvc")};
  ATH_CHECK( iGeoModel.isValid() );
 
  SmartIF<IRDBAccessSvc> iAccessSvc{pSvcLocator->service("RDBAccessSvc")};
  ATH_CHECK( iAccessSvc.isValid() );
  
  const bool loadDefaults = iGeoModel->geoConfig() != GeoModel::GEO_RUN4;
  auto defaulted = [=](const IRDBRecordset_ptr pRecordset) -> bool{
    return (loadDefaults and pRecordset->size() == 0);
  };
  // Do not load defaults for RUN4
  if (loadDefaults) ATH_MSG_DEBUG("Will load material defaults if not present");
 
  // --- Elements
  DecodeVersionKey keyAtlas(iGeoModel, "ATLAS");
  m_elements = iAccessSvc->getRecordsetPtr("Elements",keyAtlas.tag(),keyAtlas.node());
  if(defaulted(m_elements)) {
    ATH_MSG_WARNING("Getting Elements with default tag");
    m_elements = iAccessSvc->getRecordsetPtr("Elements","Materials-00","Materials");
  }
 
  IRDBRecordset_ptr recMaterials{};
  IRDBRecordset_ptr recMatcomponents{};
 
  // --- Standard materials
  recMatcomponents = iAccessSvc->getRecordsetPtr("StdMatComponents",keyAtlas.tag(),keyAtlas.node());
  if(defaulted(recMatcomponents))   {
    ATH_MSG_WARNING("Getting StdMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("StdMatComponents","Materials-00","Materials");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("StdMaterials",keyAtlas.tag(),keyAtlas.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting StdMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("StdMaterials","Materials-00","Materials");
  }
  m_detData.emplace("std",DetectorAuxData{"STDMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- Pixel materials
  DecodeVersionKey keyPixel(iGeoModel, "Pixel");
  recMatcomponents = iAccessSvc->getRecordsetPtr("PixMatComponents",keyPixel.tag(),keyPixel.node());
  if(defaulted(recMatcomponents)) {
    ATH_MSG_WARNING("Getting PixMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("PixMatComponents","PixMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("PixMaterials",keyPixel.tag(),keyPixel.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting PixMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("PixMaterials","PixMaterials-00");
  }
  m_detData.emplace("pix",DetectorAuxData{"PIXMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- SCT materials
  DecodeVersionKey keySCT(iGeoModel, "SCT");
  recMatcomponents = iAccessSvc->getRecordsetPtr("SCTMatComponents",keySCT.tag(),keySCT.node());
  if(defaulted(recMatcomponents))   {
    ATH_MSG_WARNING("Getting SCTMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("SCTMatComponents","SCTMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("SCTMaterials",keySCT.tag(),keySCT.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting SCTMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("SCTMaterials","SCTMaterials-00");
  }
  m_detData.emplace("sct",DetectorAuxData{"SCTMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- TRT materials
  DecodeVersionKey keyTRT(iGeoModel, "TRT");
  recMatcomponents = iAccessSvc->getRecordsetPtr("TrtMatComponents",keyTRT.tag(),keyTRT.node());
  if(defaulted(recMatcomponents))   {
    ATH_MSG_WARNING("Getting TrtMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("TrtMatComponents","TrtMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("TrtMaterials",keyTRT.tag(),keyTRT.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting TrtMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("TrtMaterials","TrtMaterials-00");
  }
  m_detData.emplace("trt",DetectorAuxData{"TRTMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- InDet common materials
  DecodeVersionKey keyInDet(iGeoModel, "InnerDetector");
  recMatcomponents = iAccessSvc->getRecordsetPtr("InDetMatComponents",keyInDet.tag(),keyInDet.node());
  if(defaulted(recMatcomponents)) {
    ATH_MSG_DEBUG("Getting InDetMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("InDetMatComponents","InDetMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("InDetMaterials",keyInDet.tag(),keyInDet.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_DEBUG("Getting InDetMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("InDetMaterials","InDetMaterials-00");
  }
  m_detData.emplace("indet",DetectorAuxData{"INDETMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- LAr materials
  DecodeVersionKey keyLAr(iGeoModel, "LAr");    
  recMatcomponents = iAccessSvc->getRecordsetPtr("LArMatComponents",keyLAr.tag(),keyLAr.node());
  if(defaulted(recMatcomponents)) {
    ATH_MSG_WARNING("Getting LArMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("LArMatComponents","LArMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("LArMaterials",keyLAr.tag(),keyLAr.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting LArMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("LArMaterials","LArMaterials-00");
  }
  m_detData.emplace("LAr",DetectorAuxData{"LARMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- Tile materials
  DecodeVersionKey keyTile(iGeoModel, "TileCal");    
  recMatcomponents = iAccessSvc->getRecordsetPtr("TileMatComponents",keyTile.tag(),keyTile.node());
  if (defaulted(recMatcomponents)) {
    ATH_MSG_WARNING("Getting TileMatComponents with default tag" );
    recMatcomponents = iAccessSvc->getRecordsetPtr("TileMatComponents","TileMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("TileMaterials",keyTile.tag(),keyTile.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting TileMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("TileMaterials","TileMaterials-00");
  }
  m_detData.emplace("tile",DetectorAuxData{"TILEMATERIALS_DATA_ID", recMaterials, recMatcomponents});
  
  // --- Muon
  DecodeVersionKey keyMuon(iGeoModel, "MuonSpectrometer");
  recMatcomponents = iAccessSvc->getRecordsetPtr("MUOMatComponents",keyMuon.tag(),keyMuon.node());
  if(defaulted(recMatcomponents))   {
    ATH_MSG_WARNING("Getting MUOMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("MUOMatComponents","MUOMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("MUOMaterials",keyMuon.tag(),keyMuon.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting MUOMaterials with default tag" );
    recMaterials = iAccessSvc->getRecordsetPtr("MUOMaterials","MUOMaterials-00");
  }
  m_detData.emplace("muo",DetectorAuxData{"MUOMATERIALS_DATA_ID", recMaterials, recMatcomponents});
 
  // --- Shield
  recMatcomponents = iAccessSvc->getRecordsetPtr("ShieldMatComponents",keyMuon.tag(),keyMuon.node());
  if(defaulted(recMatcomponents)) {
    ATH_MSG_WARNING("Getting ShieldMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("ShieldMatComponents","ShieldMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("ShieldMaterials",keyMuon.tag(),keyMuon.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting ShieldMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("ShieldMaterials","ShieldMaterials-00");
  }
  m_detData.emplace("shield",DetectorAuxData{"SHIELDMATERIALS_DATA_ID", recMaterials, recMatcomponents});
 
  // --- Toro
  recMatcomponents = iAccessSvc->getRecordsetPtr("ToroMatComponents",keyMuon.tag(),keyMuon.node());
  if(defaulted(recMatcomponents)) {
    ATH_MSG_WARNING("Getting ToroMatComponents with default tag");
    recMatcomponents = iAccessSvc->getRecordsetPtr("ToroMatComponents","ToroMatComponents-00");
  }
  recMaterials = iAccessSvc->getRecordsetPtr("ToroMaterials",keyMuon.tag(),keyMuon.node());
  if(defaulted(recMaterials)) {
    ATH_MSG_WARNING("Getting ToroMaterials with default tag");
    recMaterials = iAccessSvc->getRecordsetPtr("ToroMaterials","ToroMaterials-00");
  }
  m_detData.emplace("toro",DetectorAuxData{"TOROMATERIALS_DATA_ID", std::move(recMaterials), std::move(recMatcomponents)});
 
  return StatusCode::SUCCESS;
}

searchElementVector() [1/2]

GeoElement * RDBMaterialManager::searchElementVector ( const std::string & name ) const

private

Definition at line 215 of file RDBMaterialManager.cxx.

{
  GeoEleVec::const_iterator it_element = std::find_if(m_elementVector.begin()
                              , m_elementVector.end()
                              , [&name](const GeoElement* element) {
                            return name == element->getName();
                              });
 
  if (it_element != m_elementVector.end()) {
    ATH_MSG_VERBOSE(" ***** in searchElementVector() search success for "  << name);
    return *it_element;
  }
 
  ATH_MSG_VERBOSE(" ***** in searchElementVector() search failed for "  << name);
  return nullptr;
}

searchElementVector() [2/2]

GeoElement * RDBMaterialManager::searchElementVector ( const unsigned int atomicNumber ) const

private

Definition at line 233 of file RDBMaterialManager.cxx.

{ 
  GeoEleVec::const_iterator it_element = std::find_if(m_elementVector.begin()
                              , m_elementVector.end()
                              , [atomicNumber](const GeoElement* element) {
                            return atomicNumber == element->getZ();
                              });
 
  if (it_element != m_elementVector.end()) {
    ATH_MSG_VERBOSE(" ***** in searchElementVector(atomicNumber) search success for atomic number "  << atomicNumber);
    return *it_element;
  }
 
  ATH_MSG_VERBOSE(" ***** in searchElementVector(atomicNumber) search success for atomic number "  << atomicNumber);
  return nullptr;
}

searchMaterialMap()

GeoMaterial * RDBMaterialManager::searchMaterialMap ( const std::string & name ) const

private

Definition at line 201 of file RDBMaterialManager.cxx.

{
  MaterialMapIterator m = m_materialMap.find(name);
 
  if (m!=m_materialMap.end()) {
    ATH_MSG_VERBOSE(" ***** in searchMaterialMap(): search success for " << name);
    return (*m).second;
  }
 
  ATH_MSG_VERBOSE(" ***** in searchMaterialMap(): search failed for "  << name);
  return nullptr;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

size()

size_t RDBMaterialManager::size ( )

overridevirtual

Implements StoredMaterialManager.

Definition at line 429 of file RDBMaterialManager.cxx.

{
  return m_materialMap.size();
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_detData

std::map<std::string,DetectorAuxData> RDBMaterialManager::m_detData

private

Definition at line 89 of file RDBMaterialManager.h.

m_elements

IRDBRecordset_ptr RDBMaterialManager::m_elements

private

Definition at line 68 of file RDBMaterialManager.h.

m_elementVector

GeoEleVec RDBMaterialManager::m_elementVector

private

Definition at line 71 of file RDBMaterialManager.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_materialMap

StoredMaterialManager::MaterialMap RDBMaterialManager::m_materialMap

private

Definition at line 72 of file RDBMaterialManager.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• RDBMaterialManager.h
• RDBMaterialManager.cxx