InDetMaterialManager Class Reference

InDetMaterialManager. More...

#include <InDetMaterialManager.h>

Inheritance diagram for InDetMaterialManager:

Collaboration diagram for InDetMaterialManager:

Classes
class	MaterialByWeight
class	MaterialComponent
class	MaterialDef
	Class to hold information need to create a material. More...

Public Member Functions
	InDetMaterialManager (const std::string &managerName, StoreGateSvc *detStore)
	InDetMaterialManager (const std::string &managerName, StoreGateSvc *detStore, const IRDBRecordset_ptr &weightTable, const std::string &space="", bool extraFunctionality=false)
	InDetMaterialManager (const std::string &managerName, StoreGateSvc *detStore, const IRDBRecordset_ptr &weightTable, const IRDBRecordset_ptr &compositionTable, const std::string &space="")
	InDetMaterialManager (const std::string &managerName, InDetDD::AthenaComps *)
	~InDetMaterialManager ()
void	addWeightTable (const IRDBRecordset_ptr &weightTable, const std::string &space="")
void	addWeightMaterial (const std::string &materialName, const std::string &materialBase, double weight, int linearWeightFlag)
void	addCompositionTable (const IRDBRecordset_ptr &compositionTable, const std::string &space="")
void	addScalingTable (const IRDBRecordset_ptr &scalingTable)
bool	hasMaterial (const std::string &materialName) const
const GeoMaterial *	getMaterial (std::string_view materialName)
	Get material. First looks for locally defined material and if not found looks in GeoModel material manager.
const GeoElement *	getElement (const std::string &elementName)
	Get element from GeoModel material manager.
const GeoMaterial *	getMaterial (std::string_view origMaterialName, double density, std::string_view newName={})
	Create and get material with a specified density based on an existing material.
const GeoMaterial *	getMaterialScaled (const std::string &origMaterialName, double scaleFactor, const std::string &newName="")
const GeoMaterial *	getMaterialForVolume (std::string_view materialName, double volume, std::string_view newName={})
	Create and get material with a density calculated to give weight in predefined weight table.
const GeoMaterial *	getMaterialForVolumeLength (const std::string &materialName, double volume, double length, const std::string &newName="")
const GeoMaterial *	getMaterialForVolumeLength (const std::string &name, const std::vector< std::string > &materialComponents, const std::vector< double > &factors, double volume, double length)
const GeoMaterial *	getMaterialForVolumeLength (const std::string &name, const std::string &materialComponent, double factor, double volume, double length)
const GeoMaterial *	getCompositeMaterialForVolume (const std::string &newMatName, const double volumeTot, const double volume1, const std::string &matName1, const double volume2, const std::string &matName2)
const GeoMaterial *	getMaterial (const std::string &name, const std::vector< std::string > &materialComponents, const std::vector< double > &fractWeights, double density)
void	addMaterial (GeoMaterial *material)
	Add material.
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	MaterialStore = std::map<std::string, GeoIntrusivePtr<const GeoMaterial>, std::less<>>
typedef std::map< std::string, MaterialByWeight, std::less<> >	MaterialWeightMap
typedef std::map< std::string, MaterialComponent, std::less<> >	MaterialCompositionMap
typedef std::map< std::string, double, std::less<> >	ExtraScaleFactorMap

Private Member Functions
StoredMaterialManager *	retrieveManager (const StoreGateSvc *detStore)
const GeoMaterial *	getAdditionalMaterial (std::string_view materialName) const
bool	compareDensity (double d1, double d2) const
const GeoMaterial *	getMaterialInternal (std::string_view materialName)
const GeoMaterial *	getMaterialInternal (std::string_view origMaterialName, double density, std::string_view newName={})
const GeoMaterial *	getMaterialScaledInternal (const std::string &origMaterialName, double scaleFactor, const std::string &newName="")
const GeoMaterial *	getMaterialInternal (const std::string &name, const std::vector< std::string > &materialComponents, const std::vector< double > &fractWeights, double density)
const GeoMaterial *	extraScaledMaterial (std::string_view materialName, std::string_view newName, const GeoMaterial *origMaterial)
const GeoMaterial *	extraScaledMaterial (std::string_view materialName, const GeoMaterial *origMaterial)
void	createMaterial (const MaterialDef &material)
double	getExtraScaleFactor (std::string_view materialName)
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
StoredMaterialManager *	m_materialManager
std::string	m_managerName
MaterialStore	m_store
MaterialWeightMap	m_weightMap
MaterialCompositionMap	m_matCompositionMap
ExtraScaleFactorMap	m_scalingMap
bool	m_extraFunctionality
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

InDetMaterialManager.

This provides an interface to the GeoModel Material Manager as well as allowing additional materials to be defined or standard ones redefined. It also allows creating new materials based on existing ones but with a different density. It is also possible to specify a weight table and this is used to create materials with a density such that the the total weight is correct.

Definition at line 33 of file InDetMaterialManager.h.

Member Typedef Documentation

ExtraScaleFactorMap

typedef std::map<std::string, double, std::less<> > InDetMaterialManager::ExtraScaleFactorMap

private

Definition at line 221 of file InDetMaterialManager.h.

MaterialCompositionMap

typedef std::map<std::string, MaterialComponent, std::less<> > InDetMaterialManager::MaterialCompositionMap

private

Definition at line 218 of file InDetMaterialManager.h.

MaterialStore

using InDetMaterialManager::MaterialStore = std::map<std::string, GeoIntrusivePtr<const GeoMaterial>, std::less<>>

private

Definition at line 212 of file InDetMaterialManager.h.

MaterialWeightMap

typedef std::map<std::string, MaterialByWeight, std::less<> > InDetMaterialManager::MaterialWeightMap

private

Definition at line 215 of file InDetMaterialManager.h.

Constructor & Destructor Documentation

InDetMaterialManager() [1/4]

InDetMaterialManager::InDetMaterialManager	(	const std::string &	managerName,
		StoreGateSvc *	detStore )

Definition at line 28 of file InDetMaterialManager.cxx.

  : AthMessaging(managerName),
  m_managerName(managerName),
  m_extraFunctionality(false)
{
  m_materialManager = retrieveManager(detStore);
}

InDetMaterialManager() [2/4]

InDetMaterialManager::InDetMaterialManager	(	const std::string &	managerName,
		StoreGateSvc *	detStore,
		const IRDBRecordset_ptr &	weightTable,
		const std::string &	space = "",
		bool	extraFunctionality = false )

Definition at line 38 of file InDetMaterialManager.cxx.

  : AthMessaging(managerName),
  m_managerName(managerName),
  m_extraFunctionality(extraFunctionality)
{
  m_materialManager = retrieveManager(detStore);
 
  if (weightTable) addWeightTable(weightTable, space);
 
  // For testing we add a few materials.
  //m_weightMap["sct::CoolingBlock"] = MaterialByWeight(2.418*CLHEP::gram);
  //m_weightMap["sct::CoolingBlock"] = MaterialByWeight(2*CLHEP::gram);
  //m_weightMap["sct::BrlHybrid"] = MaterialByWeight("sct::Hybrid", 8*CLHEP::gram);
  //m_weightMap["sct::FwdHybrid"] = MaterialByWeight("std::Carbon", 7.662*CLHEP::gram);
}

InDetMaterialManager() [3/4]

InDetMaterialManager::InDetMaterialManager	(	const std::string &	managerName,
		StoreGateSvc *	detStore,
		const IRDBRecordset_ptr &	weightTable,
		const IRDBRecordset_ptr &	compositionTable,
		const std::string &	space = "" )

Definition at line 58 of file InDetMaterialManager.cxx.

  : AthMessaging(managerName),
  m_managerName(managerName),
  m_extraFunctionality(true)
{
  m_materialManager = retrieveManager(detStore);
 
  if (weightTable) addWeightTable(weightTable, space);
  if (compositionTable) addCompositionTable(compositionTable, space);
}

InDetMaterialManager() [4/4]

InDetMaterialManager::InDetMaterialManager	(	const std::string &	managerName,
		InDetDD::AthenaComps *	athenaComps )

Definition at line 72 of file InDetMaterialManager.cxx.

  : AthMessaging(managerName),
  m_managerName(managerName),
  m_extraFunctionality(true)
{
  m_materialManager = retrieveManager(athenaComps->detStore());
}

~InDetMaterialManager()

InDetMaterialManager::~InDetMaterialManager ( )

default

Member Function Documentation

addCompositionTable()

void InDetMaterialManager::addCompositionTable	(	const IRDBRecordset_ptr &	compositionTable,
		const std::string &	space = "" )

Definition at line 389 of file InDetMaterialManager.cxx.

                                                                                                           {
  ATH_MSG_DEBUG("Reading in composition table: " << compositionTable->nodeName());
 
  for (const auto& rec : *compositionTable) {
    std::string materialName = rec->getString("MATERIAL");
    if (!space.empty()) {
      materialName = space + "::" + materialName;
    }
 
    std::string componentName = rec->getString("COMPONENT");
    int count = rec->getInt("COUNT");
    double factor = rec->getDouble("FACTOR");
    double actualLength = rec->getDouble("ACTUALLENGTH");
 
    m_matCompositionMap.insert(std::pair<std::string, MaterialComponent>(materialName,
                                                                         MaterialComponent(componentName,
                                                                                           count * factor,
                                                                                           actualLength)));
  }
}

addMaterial()

void InDetMaterialManager::addMaterial

(

GeoMaterial *

material

)

Add material.

Definition at line 302 of file InDetMaterialManager.cxx.

                                                       {
  GeoIntrusivePtr<const GeoMaterial> matPtr{material};
  std::string name(material->getName());
  if (m_store.find(name) != m_store.end()) {
    ATH_MSG_WARNING("Ignoring attempt to redefine an existing material: " << name);
    // Delete the material if it is not already ref counted.
    //std::cout << m_store[name] << std::endl;
  } else {
    material->lock();
    m_store[name] = std::move(matPtr);
 
    ATH_MSG_DEBUG("Created new material: " << name << ", " << material->getDensity() /
                  (Gaudi::Units::g / Gaudi::Units::cm3) << " g/cm3");
  }
}

addScalingTable()

void InDetMaterialManager::addScalingTable

(

const IRDBRecordset_ptr &

scalingTable

)

Definition at line 411 of file InDetMaterialManager.cxx.

                                                                           {
  if (!scalingTable || scalingTable->size()==0) return;
  ATH_MSG_DEBUG("Reading in extra material scaling table: " << scalingTable->nodeName());
  for (const auto& rec : *scalingTable) {
    std::string materialName = rec->getString("MATERIAL");
    double scalingFactor = rec->getDouble("FACTOR");
 
    if (scalingFactor >= 0 || scalingFactor == 1) {
      ATH_MSG_DEBUG("Material " << materialName << " will be scaled by: " << scalingFactor);
    } else {
      // -ve or scalefactor = 1 means will not be scaled.
      ATH_MSG_DEBUG("Material " << materialName << " will be NOT be scaled.");
    }
    if (m_scalingMap.find(materialName) != m_scalingMap.end()) {
      ATH_MSG_WARNING("Overriding material: " << materialName << " which already exists in scaling table");
    }
    m_scalingMap[materialName] = scalingFactor;
  }
}

addWeightMaterial()

void InDetMaterialManager::addWeightMaterial	(	const std::string &	materialName,
		const std::string &	materialBase,
		double	weight,
		int	linearWeightFlag )

Definition at line 372 of file InDetMaterialManager.cxx.

                                                              {
  // Weight in gr
  weight = weight * GeoModelKernelUnits::gram;
 
  if (m_weightMap.find(materialName) != m_weightMap.end()) {
    ATH_MSG_WARNING("Material: " << materialName << " already exists in weight table");
  } else {
    ATH_MSG_DEBUG("Adding " << materialName
                  << " weight " << weight
                  << " linearWeightFlag " << linearWeightFlag
                  << " to weight table");
    m_weightMap[materialName] = MaterialByWeight(materialBase, weight, linearWeightFlag);
  }
}

addWeightTable()

void InDetMaterialManager::addWeightTable	(	const IRDBRecordset_ptr &	weightTable,
		const std::string &	space = "" )

Definition at line 327 of file InDetMaterialManager.cxx.

                                                                                                 {
  ATH_MSG_DEBUG("Reading in weight table: " << weightTable->nodeName());
  for(const auto& rec : *weightTable) {
    std::string materialName = rec->getString("MATERIAL");
    if (!space.empty()) {
      materialName = space + "::" + materialName;
    }
    std::string materialBase;
    try {
      if (!rec->isFieldNull("BASEMATERIAL")) {
    materialBase = rec->getString("BASEMATERIAL");
      }
    }
    catch(std::runtime_error&) {
      ATH_MSG_DEBUG(weightTable->nodeName() << " table has no column named BASEMATERIAL");
    }
    double weight = rec->getDouble("WEIGHT") * GeoModelKernelUnits::gram;
 
    bool linearWeightFlag = false;
    if (m_extraFunctionality) {
      try {
    if(!rec->isFieldNull("LINWEIGHTFLAG")) {
      linearWeightFlag = rec->getInt("LINWEIGHTFLAG");
    }
      }
      catch(std::runtime_error&) {
    ATH_MSG_DEBUG(weightTable->nodeName() << " table has no column named LINWEIGHTFLAG");
      }
    }
 
    if (m_weightMap.find(materialName) != m_weightMap.end()) {
      ATH_MSG_WARNING("Material: " << materialName << " already exists in weight table");
    } else {
      ATH_MSG_DEBUG("Adding " << materialName
                    << " weight " << weight
                    << " linearWeightFlag " << linearWeightFlag
                    << " raw weight " << rec->getDouble("WEIGHT")
                    << " m_extraFunctionality " << m_extraFunctionality
                    << " to weight table");
      m_weightMap[materialName] = MaterialByWeight(materialBase, weight, linearWeightFlag);
    }
  }
}

compareDensity()

bool InDetMaterialManager::compareDensity ( double d1, double d2 ) const

private

Definition at line 319 of file InDetMaterialManager.cxx.

                                                               {
  if (close_to_zero(d2)){
    throw (std::runtime_error("InDetMaterialManager:compareDensity: Density is zero"));
  }
  return(std::abs(d1 / d2 - 1.) < 1e-5);
}

createMaterial()

void InDetMaterialManager::createMaterial ( const MaterialDef & material )

private

Definition at line 697 of file InDetMaterialManager.cxx.

                                                                {
  if (material.numComponents() == 0) {
    ATH_MSG_ERROR("Material has no components: " << material.name());
    return;
  }
 
  // If total of fractions is greater than 1.1 then assume material is define by ratio of atoms.
  double totWeight = material.totalFraction();
  bool byAtomicRatio = false;
  if (totWeight > 1.1) {
    byAtomicRatio = true;
    for (unsigned int i = 0; i < material.numComponents(); i++) {
      if (material.compName(i).find("::") != std::string::npos) {
        // If component name has "::" in it then its not an element.
        ATH_MSG_ERROR("Material, " << material.name() <<
                      ", is assumed to be defined by atomic ratio (due to total fraction > 1)"
                      " but component is not an element: " << material.compName(i));
        return;
      }
      const GeoElement* element = getElement(material.compName(i));
      if (!element) {
        ATH_MSG_ERROR("Error making material " << material.name() << ". Element not found: " <<
                      material.compName(i));
        return;
      }
      totWeight += material.fraction(i) * element->getA();
    }
  } else {
    // Check if total fraction is close to 1.
    if (std::abs(totWeight - 1) > 0.01) {
      ATH_MSG_WARNING("Total fractional weight does not sum to 1. Will renormalize. Total = " << totWeight);
    }
  }
  // Now build the material
  GeoIntrusivePtr<GeoMaterial> newMaterial{new GeoMaterial(material.name(), material.density())};
  ATH_MSG_DEBUG("Creating material: " << material.name() << " with density: "
                << material.density() / (Gaudi::Units::g / Gaudi::Units::cm3));
  if (close_to_zero(totWeight)){
    ATH_MSG_ERROR("totWeight is zero in InDetMaterialManager::createMaterial");
    return;
  }
  for (unsigned int i = 0; i < material.numComponents(); i++) {
    double fracWeight = material.fraction(i) / totWeight;
    if (material.compName(i).find("::") == std::string::npos) {
      const GeoElement* element = getElement(material.compName(i));
      if (!element) {
        ATH_MSG_ERROR("Error making material " << material.name() << ". Element not found: " << material.compName(i));
        // delete the partially created material
        return;
      }
      if (byAtomicRatio) {
        fracWeight = material.fraction(i) * element->getA() / totWeight;
      }
      newMaterial->add(const_cast<GeoElement*>(element), fracWeight);
      ATH_MSG_DEBUG(" Component: " << material.compName(i) << " " << fracWeight);
    } else {
      GeoIntrusivePtr<const GeoMaterial> materialTmp{getMaterialInternal(material.compName(i))};
      if (!materialTmp) {
        ATH_MSG_ERROR("Error making material " << material.name() << ". Component not found: " << material.compName(i));
        // delete the partially created material
        return;
      }
      if (byAtomicRatio) {
        // Should not happen as already checked that all components were elements.
        ATH_MSG_ERROR("Unexpected Error");
      }
      newMaterial->add(const_cast<GeoMaterial*>(materialTmp.get()), fracWeight);
      ATH_MSG_DEBUG(" Component: " << material.compName(i) << " " << fracWeight);
    }
  }
  newMaterial->lock();
  addMaterial(newMaterial);
}

extraScaledMaterial() [1/2]

const GeoMaterial * InDetMaterialManager::extraScaledMaterial ( std::string_view materialName, const GeoMaterial * origMaterial )

private

Definition at line 817 of file InDetMaterialManager.cxx.

                                                                                                      {
  if (!origMaterial) throw std::runtime_error(std::format("Invalid material: {}",materialName));
 
  double scaleFactor = getExtraScaleFactor(materialName);
  // -1 (or any -ve number) indicates material is not scaled. And if the scale factor
  // is 1 then there is no need to create a new material.
  if (scaleFactor < 0 || scaleFactor == 1 || materialName.find("Ether") != std::string::npos) return origMaterial;
 
  if (scaleFactor == 0) return getMaterialInternal("std::Vacuum");
 
  std::string newName = std::string{materialName} + "_ExtraScaling";
 
  // Check if it is already made.
  const GeoMaterial* newMaterial = getAdditionalMaterial(newName);
 
  // Already made so we return it.
  if (newMaterial) return newMaterial;
 
  // Otherwise we need to make it.
  double density = origMaterial->getDensity() * scaleFactor;
 
  // create new material
  GeoMaterial* newMaterialTmp = new GeoMaterial(newName, density);
  newMaterialTmp->add(const_cast<GeoMaterial*>(origMaterial), 1.);
  addMaterial(newMaterialTmp);
  newMaterial = newMaterialTmp;
 
  return newMaterial;
}

extraScaledMaterial() [2/2]

const GeoMaterial * InDetMaterialManager::extraScaledMaterial ( std::string_view materialName, std::string_view newName, const GeoMaterial * origMaterial )

private

Definition at line 806 of file InDetMaterialManager.cxx.

                                                                           {
  if (newName.empty()) {
    return extraScaledMaterial(materialName, origMaterial);
  } else {
    return extraScaledMaterial(newName, origMaterial);
  }
}

getAdditionalMaterial()

const GeoMaterial * InDetMaterialManager::getAdditionalMaterial ( std::string_view materialName ) const

private

Definition at line 127 of file InDetMaterialManager.cxx.

                                                                             {
  MaterialStore::const_iterator iter;
  if ((iter = m_store.find(materialName)) != m_store.end()) {
    return iter->second;
  } else {
    return nullptr;
  }
}

getCompositeMaterialForVolume()

const GeoMaterial * InDetMaterialManager::getCompositeMaterialForVolume	(	const std::string &	newMatName,
		const double	volumeTot,
		const double	volume1,
		const std::string &	matName1,
		const double	volume2,
		const std::string &	matName2 )

Definition at line 137 of file InDetMaterialManager.cxx.

                                                      {
  std::vector<std::string> baseMaterials;
  std::vector<double> fracWeight;
  baseMaterials.reserve(2);
  fracWeight.reserve(2);
 
  ATH_MSG_DEBUG("Composite material : " << volumeTot / Gaudi::Units::cm3 << " = " << volume1 / Gaudi::Units::cm3
                << " + " << volume2 / Gaudi::Units::cm3);
  ATH_MSG_DEBUG("Composite material : " << matName1 << " " << matName2);
 
  double density1, density2;
 
  MaterialWeightMap::const_iterator iter;
  if ((iter = m_weightMap.find(matName1)) != m_weightMap.end()) {
    const GeoMaterial* mat1 = getMaterialForVolume(matName1, volume1);
    density1 = mat1->getDensity();
    ATH_MSG_DEBUG("Composite material 1 - weight : " << density1 / (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
  } else {
    const GeoMaterial* mat1 = getMaterial(matName1);
    density1 = mat1->getDensity();
    ATH_MSG_DEBUG("Composite material 1 - standard : " << density1 / (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
  }
 
  if ((iter = m_weightMap.find(matName2)) != m_weightMap.end()) {
    const GeoMaterial* mat2 = getMaterialForVolume(matName2, volume2);
    density2 = mat2->getDensity();
    ATH_MSG_DEBUG("Composite material 2 - weight : " << density2 / (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
  } else {
    const GeoMaterial* mat2 = getMaterial(matName2);
    density2 = mat2->getDensity();
    ATH_MSG_DEBUG("Composite material 2 - standard : " << density2 / (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
  }
 
  double weight1 = density1 * volume1;
  double weight2 = density2 * volume2;
  double invWeightTot = 1.0 / (weight1 + weight2);
 
  double density = (weight1 + weight2) / volumeTot;
 
  double frac1 = weight1 / (weight1 + weight2);
  double frac2 = weight2 / (weight1 + weight2);
  double density_2 = 1.0 / (frac1 / density1 + frac2 / density2);
  double density_3 = (weight1 + weight2) / (volume1 + volume2);
  ATH_MSG_DEBUG("-> weights : " << weight1 / (GeoModelKernelUnits::gram) << " " << weight2 / (GeoModelKernelUnits::gram));
  ATH_MSG_DEBUG("-> density : " << density / (GeoModelKernelUnits::gram / Gaudi::Units::cm3) << "  " << density_2 /
                (GeoModelKernelUnits::gram / Gaudi::Units::cm3) << " " << density_3 / (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
 
 
  baseMaterials.push_back(matName1);
  baseMaterials.push_back(matName2);
  fracWeight.push_back(weight1 * invWeightTot);
  fracWeight.push_back(weight2 * invWeightTot);
 
  return getMaterial(newMatName, baseMaterials, fracWeight, density);
}

getElement()

const GeoElement * InDetMaterialManager::getElement

(

const std::string &

elementName

)

Get element from GeoModel material manager.

Definition at line 89 of file InDetMaterialManager.cxx.

                                                             {
  if(!m_materialManager) {
    std::string errorMessage("Null pointer to Stored Material Manager!");
    ATH_MSG_FATAL(errorMessage);
    throw std::runtime_error(errorMessage);
  }
  return m_materialManager->getElement(elementName);
}

getExtraScaleFactor()

double InDetMaterialManager::getExtraScaleFactor ( std::string_view materialName )

private

Definition at line 848 of file InDetMaterialManager.cxx.

                                                                     {
  // If name is found in map we return the corresponding scale factor.
  // The special name "ALL" indicates all materials are scaled.
  // Individual materials can be excluded from scaling by giving either
  // a -ve scaling factor or just specifying a scaling factor of 1.
  // A scaling factor of 0 means the material will be replaced by vacuum.
 
  ExtraScaleFactorMap::const_iterator iter = m_scalingMap.find(materialName);
  if (iter != m_scalingMap.end()) {
    return iter->second;
  } else {
    // Check for special names
    // ALL means everything scaled. Do not scale air or vacuum (unless explicity requested)
    iter = m_scalingMap.find("ALL");
    if (iter != m_scalingMap.end() && materialName != "std::Air" && materialName != "std::Vacuum") {
      return iter->second;
    }
  }
 
  // If not found then return -1 to indicate material is not to be scaled.
  return -1;
}

getMaterial() [1/3]

const GeoMaterial * InDetMaterialManager::getMaterial	(	const std::string &	name,
		const std::vector< std::string > &	materialComponents,
		const std::vector< double > &	fractWeights,
		double	density )

Definition at line 658 of file InDetMaterialManager.cxx.

                                                  {
  return extraScaledMaterial(name, getMaterialInternal(name, materialComponents, fracWeight, density));
}

getMaterial() [2/3]

const GeoMaterial * InDetMaterialManager::getMaterial

(

std::string_view

materialName

)

Get material. First looks for locally defined material and if not found looks in GeoModel material manager.

Definition at line 99 of file InDetMaterialManager.cxx.

                                                             {
  return extraScaledMaterial(materialName, getMaterialInternal(materialName));
}

getMaterial() [3/3]

const GeoMaterial * InDetMaterialManager::getMaterial	(	std::string_view	origMaterialName,
		double	density,
		std::string_view	newName = {} )

Create and get material with a specified density based on an existing material.

If a newName is supplied it creates the new material even if the orginal material has the same density. It however first checks if the material with NewName exists. If no newName is supplied then it checks the density of the existing material. If it is consistent it returns the material. If it is different it creates a material with the string "Modified" added to the name.

Definition at line 209 of file InDetMaterialManager.cxx.

                                                          {
  return extraScaledMaterial(origMaterialName, newName,
                             getMaterialInternal(origMaterialName, density, newName));
}

getMaterialForVolume()

const GeoMaterial * InDetMaterialManager::getMaterialForVolume	(	std::string_view	materialName,
		double	volume,
		std::string_view	newName = {} )

Create and get material with a density calculated to give weight in predefined weight table.

Definition at line 432 of file InDetMaterialManager.cxx.

                                                                                                             {
  // Make sure we have a valid volume size.
  if (volume <= 0) {
    ATH_MSG_ERROR("Invalid volume : " << volume);
    return nullptr;
  }
 
  // Find if material is in the weight table.
  // If so we use the information to create a material with the
  // density calculated from the volume and weight. If a base material
  // is specified in the weight table, then a new material is made
  // which is the same as the base material but with the new
  // density. If no base material is specified then there should be a
  // material already existing with that name. If the existing material already has the
  // correct density it is used, otherwise a new material is created
  // with the string "Modified" added to the material name.
 
  MaterialWeightMap::const_iterator iter;
  if (iter = m_weightMap.find(materialName); iter != m_weightMap.end()) {
    const std::string& materialBase = iter->second.name;
    double weight = iter->second.weight;
    double density = weight / volume;
    if (iter->second.linearWeightFlag) {
      ATH_MSG_ERROR("Material defined by linear weight cannot be created with getMaterialForVolume method: " <<
                    materialName);
    }
 
    ATH_MSG_VERBOSE("Found material in weight table - name, base, weight(g), volume(cm3), density(g/cm3): "
                    << materialName << ", "
                    << materialBase << ", "
                    << weight / GeoModelKernelUnits::gram << ", "
                    << volume / Gaudi::Units::cm3 << ", "
                    << density / (Gaudi::Units::g / Gaudi::Units::cm3));
 
    if (materialBase.empty()) {
      return getMaterial(materialName, density, newName);
    } else {
      if (newName.empty()) {
        return getMaterial(materialBase, density, materialName);
      } else {
        return getMaterial(materialBase, density, newName);
      }
    }
  } else {
    // If not in the weight table we just return the material.
    // This is not an error.
    ATH_MSG_VERBOSE("Material not in weight table, using standard material: "
                    << materialName
                    << ", volume(cm3) = " << volume / Gaudi::Units::cm3);
    return getMaterial(materialName);
  }
}

getMaterialForVolumeLength() [1/3]

const GeoMaterial * InDetMaterialManager::getMaterialForVolumeLength	(	const std::string &	materialName,
		double	volume,
		double	length,
		const std::string &	newName = "" )

Definition at line 486 of file InDetMaterialManager.cxx.

                                                                           {
  // In the case there is no material composition table (MaterialCompositionMap) and no linear weights are used this
  // will
  // behave the same way as getMaterialForVolume.
  // If the material is in the MaterialCompositionMap it will build a material using the components
  // from that table. If any components are defined as a linear weight the length is used to calculate the
  // weight (ie linear weight * length).
 
 
  std::string name;
  if (newName.empty()) {
    name = materialName;
  } else {
    name = newName;
  }
 
  // Make sure we have a valid volume size.
  if (volume <= 0 || length <= 0) {
    ATH_MSG_ERROR("Invalid volume or length : " << volume << ", " << length);
    return nullptr;
  }
 
  // First look in the predefinded collections
  std::pair<MaterialCompositionMap::const_iterator, MaterialCompositionMap::const_iterator> iterRange;
  iterRange = m_matCompositionMap.equal_range(materialName);
  if (iterRange.first != m_matCompositionMap.end()) {
    ATH_MSG_VERBOSE("Found material in material composition table:" << materialName);
 
    std::vector<double> factors;
    std::vector<std::string> components;
    for (MaterialCompositionMap::const_iterator iter = iterRange.first; iter != iterRange.second; ++iter) {
      double factorTmp = iter->second.factor;
      if (iter->second.actualLength > 0) factorTmp *= iter->second.actualLength / length;
      factors.push_back(factorTmp);
      components.push_back(iter->second.name);
    }
    return getMaterialForVolumeLength(name, components, factors, volume, length);
  }
 
  // Next look in weight table
  MaterialWeightMap::const_iterator iter;
  if ((iter = m_weightMap.find(materialName)) != m_weightMap.end()) {
    const std::string& materialBase = iter->second.name;
    double weight = iter->second.weight;
    double density = weight / volume;
    if (iter->second.linearWeightFlag) weight *= length;
 
    if (materialBase.empty()) {
      return getMaterial(materialName, density, newName);
    } else {
      return getMaterial(materialBase, density, name);
    }
  } else {
    // Otherwise we just return the material.
    // This is not an error.
    ATH_MSG_VERBOSE("Material not in weight table, using standard material: "
                    << materialName
                    << ", volume(cm3) = " << volume / Gaudi::Units::cm3);
    return getMaterial(materialName);
  }
}

getMaterialForVolumeLength() [2/3]

const GeoMaterial * InDetMaterialManager::getMaterialForVolumeLength	(	const std::string &	name,
		const std::string &	materialComponent,
		double	factor,
		double	volume,
		double	length )

Definition at line 550 of file InDetMaterialManager.cxx.

                                                                {
  std::vector<std::string> tmpMaterialComponents(1, materialComponent);
  std::vector<double> tmpFactors(1, factor);
  return getMaterialForVolumeLength(name, tmpMaterialComponents, tmpFactors, volume, length);
}

getMaterialForVolumeLength() [3/3]

const GeoMaterial * InDetMaterialManager::getMaterialForVolumeLength	(	const std::string &	name,
		const std::vector< std::string > &	materialComponents,
		const std::vector< double > &	factors,
		double	volume,
		double	length )

Definition at line 561 of file InDetMaterialManager.cxx.

                                                                {
  // Make sure we have a valid volume size.
  if (volume <= 0 || length <= 0) {
    ATH_MSG_ERROR("Invalid volume or length : " << volume << ", " << length);
    return nullptr;
  }
 
  if (!factors.empty() && factors.size() < materialComponents.size()) {
    ATH_MSG_WARNING("getMaterialForVolumeLength: factor vector size too small. Setting remaining factors to 1.");
  }
 
  std::vector<std::string> baseMaterials;
  std::vector<double> fracWeight;
  baseMaterials.reserve(materialComponents.size());
  fracWeight.reserve(materialComponents.size());
 
  double totWeight = 0;
  for (unsigned int iComp = 0; iComp < materialComponents.size(); ++iComp) {
    const std::string& materialName = materialComponents[iComp];
 
    // First search in MaterialWeightMap
    MaterialWeightMap::const_iterator iter;
    if ((iter = m_weightMap.find(materialName)) != m_weightMap.end()) {
      const std::string& materialBase = iter->second.name;
      double weight = iter->second.weight;
 
      if (iComp < factors.size()) {
        weight *= factors[iComp];
      }
      ATH_MSG_DEBUG("Material " << materialName
                    << " found in weight table, weight " << iter->second.weight / GeoModelKernelUnits::gram
                    << " factor " << factors[iComp]
                    << " w*fac*len " << weight * length / GeoModelKernelUnits::gram
                    << " basMat " << materialBase
                    << " linear? " << iter->second.linearWeightFlag);
 
      if (iter->second.linearWeightFlag) weight *= length;
      if (materialBase.empty()) {
        // If no base material then name should refer to an already defined material
        baseMaterials.push_back(materialName);
      } else {
        baseMaterials.push_back(materialBase);
      }
      fracWeight.push_back(weight); // Will be normalized later.
      totWeight += weight;
    } else {
      // If not in the weight table we look for a regular material.
      // I don't think this would normally be intentional so we give a warning message.
      /*
         if (msgLvl(MSG::WARNING))
         msg(MSG::WARNING)
         << "Component material not in weight table, using standard material: "
         << materialName << " with weight= "
         << factors.at(iComp) * length
         << endmsg;
         const GeoMaterial * material = getMaterialInternal(materialName);
       */
 
      // In this case the factor should correspond to the linear weight
      double weight = factors.at(iComp) * length * GeoModelKernelUnits::gram;
 
      // If material not found, will get error message when attempting to make the material. So carry on here.
      baseMaterials.push_back(materialName);
      fracWeight.push_back(weight);
      totWeight += weight;
    }
  }
 
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Creating material from multiple components: " << name << endmsg;
    for (unsigned int i = 0; i < materialComponents.size(); ++i) {
      msg(MSG::VERBOSE) << " Component " << i << ": Name = " << baseMaterials[i]
                        << " Weight(g) = " << fracWeight[i] / Gaudi::Units::g << endmsg;
    }
  }
  if (close_to_zero(totWeight)){
    ATH_MSG_ERROR("totWeight is zero in InDetMaterialManager::getMaterialForVolumeLength");
    return nullptr;
  }
  for (unsigned int i = 0; i < fracWeight.size(); ++i) {
    fracWeight[i] /= totWeight;
  }
  if (close_to_zero(volume)){
    ATH_MSG_ERROR("volume is zero in InDetMaterialManager::getMaterialForVolumeLength");
    return nullptr;
  }
  double density = totWeight / volume;
 
  return getMaterial(name, baseMaterials, fracWeight, density);
}

getMaterialInternal() [1/3]

const GeoMaterial * InDetMaterialManager::getMaterialInternal ( const std::string & name, const std::vector< std::string > & materialComponents, const std::vector< double > & fractWeights, double density )

private

Definition at line 666 of file InDetMaterialManager.cxx.

                                                          {
  const GeoMaterial* newMaterial = nullptr;
 
  // First see if we already have the material
  const GeoMaterial* material = getAdditionalMaterial(name);
 
  if (material) {
    if (!compareDensity(material->getDensity(), density)) {
      ATH_MSG_WARNING("Density is not consistent for material " << name);
    }
    newMaterial = material;
  } else {
    GeoMaterial* newMaterialTmp = new GeoMaterial(name, density);
    for (unsigned int i = 0; i < materialComponents.size(); i++) {
      const GeoMaterial* origMaterial = getMaterialInternal(materialComponents[i]);
      if (origMaterial) {
        newMaterialTmp->add(const_cast<GeoMaterial*>(origMaterial), fracWeight[i]);
      } else {
        ATH_MSG_ERROR("Material component missing " << materialComponents[i]);
      }
    }
    addMaterial(newMaterialTmp);
    newMaterial = newMaterialTmp;
  }
  return newMaterial;
}

getMaterialInternal() [2/3]

const GeoMaterial * InDetMaterialManager::getMaterialInternal ( std::string_view materialName )

private

Definition at line 109 of file InDetMaterialManager.cxx.

                                                                     {
  // First check local store of materials. If not found then get it from the GeoModel
  // manager.
  const GeoMaterial* material = getAdditionalMaterial(materialName);
 
  if (!material) {
    if(!m_materialManager) {
      std::string errorMessage("Null pointer to Stored Material Manager!");
      ATH_MSG_FATAL(errorMessage);
      throw std::runtime_error(errorMessage);
    }
    // This prints error message if not found.
    material = m_materialManager->getMaterial(materialName);
  }
  return material;
}

getMaterialInternal() [3/3]

const GeoMaterial * InDetMaterialManager::getMaterialInternal ( std::string_view origMaterialName, double density, std::string_view newName = {} )

private

Definition at line 217 of file InDetMaterialManager.cxx.

                                                                  {
  std::string newName2{newName};
  bool newNameProvided = !newName2.empty();
  if (!newNameProvided) {
    newName2 = std::string{origMaterialName} + "Modified";
  }
 
  const GeoMaterial* newMaterial = nullptr;
 
  // First see if we already have the modified material
  const GeoMaterial* material = getAdditionalMaterial(newName2);
  if (material) {
    if (!compareDensity(material->getDensity(), density)) {
      ATH_MSG_WARNING("Density is not consistent for material " << newName2
                      << "  " << material->getDensity() / (GeoModelKernelUnits::gram / Gaudi::Units::cm3)
                      << " / " << density / (GeoModelKernelUnits::gram / Gaudi::Units::cm3));
    }
    newMaterial = material;
  } else {
    const GeoMaterial* origMaterial = getMaterialInternal(origMaterialName);
    newMaterial = origMaterial;
    if (origMaterial) {
      // If no new name was provided we check if the density is compatible
      // and if so we return the original material.
      if (newNameProvided || !compareDensity(origMaterial->getDensity(), density)) {
        // create new material
        GeoMaterial* newMaterialTmp = new GeoMaterial(newName2, density);
        newMaterialTmp->add(const_cast<GeoMaterial*>(origMaterial), 1.);
        addMaterial(newMaterialTmp);
        newMaterial = newMaterialTmp;
      }
    }
  }
  return newMaterial;
}

getMaterialScaled()

const GeoMaterial * InDetMaterialManager::getMaterialScaled	(	const std::string &	origMaterialName,
		double	scaleFactor,
		const std::string &	newName = "" )

Definition at line 256 of file InDetMaterialManager.cxx.

                                                                  {
  return extraScaledMaterial(origMaterialName, newName,
                             getMaterialScaledInternal(origMaterialName, scaleFactor, newName));
}

getMaterialScaledInternal()

const GeoMaterial * InDetMaterialManager::getMaterialScaledInternal ( const std::string & origMaterialName, double scaleFactor, const std::string & newName = "" )

private

Definition at line 264 of file InDetMaterialManager.cxx.

                                                                          {
  // Don't allow large scale factors
  if (scaleFactor > 1000 || scaleFactor < 0.001) {
    ATH_MSG_ERROR("Scale factor must be between 0.001 and 1000.");
    return nullptr;
  }
 
  const GeoMaterial* origMaterial = getMaterialInternal(origMaterialName);
 
  // If scalefactor is 1 and no new name is requested
  // then just return the orginal material
  if (newName.empty() && scaleFactor == 1.) return origMaterial;
 
  const GeoMaterial* newMaterial = nullptr;
 
  if (origMaterial) {
    double density = origMaterial->getDensity() * scaleFactor;
    std::string newName2 = newName;
    if (newName2.empty()) {
      // Create name using the scale factor.
      int scaleInt = static_cast<int>(scaleFactor * 10000);
      int scale1 = scaleInt / 10000;
      int scale2 = scaleInt % 10000;
 
      std::ostringstream os;
      os << origMaterialName << scale1 << "_" << std::setw(4) << std::setfill('0') << scale2;
      newName2 = os.str();
    }
 
    newMaterial = getMaterialInternal(origMaterialName, density, newName2);
  }
 
  return newMaterial;
}

hasMaterial()

bool InDetMaterialManager::hasMaterial

(

const std::string &

materialName

)

const

Definition at line 104 of file InDetMaterialManager.cxx.

                                                                     {
  return m_weightMap.find(materialName) != m_weightMap.end();
}

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 167 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 182 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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

retrieveManager()

StoredMaterialManager * InDetMaterialManager::retrieveManager ( const StoreGateSvc * detStore )

inlineprivate

Definition at line 84 of file InDetMaterialManager.cxx.

                                                                  {
  return detStore->tryRetrieve<StoredMaterialManager>("MATERIALS");
}

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

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_extraFunctionality

bool InDetMaterialManager::m_extraFunctionality

private

Definition at line 225 of file InDetMaterialManager.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_managerName

std::string InDetMaterialManager::m_managerName

private

Definition at line 210 of file InDetMaterialManager.h.

m_matCompositionMap

MaterialCompositionMap InDetMaterialManager::m_matCompositionMap

private

Definition at line 219 of file InDetMaterialManager.h.

m_materialManager

StoredMaterialManager* InDetMaterialManager::m_materialManager

private

Definition at line 209 of file InDetMaterialManager.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.

m_scalingMap

ExtraScaleFactorMap InDetMaterialManager::m_scalingMap

private

Definition at line 222 of file InDetMaterialManager.h.

m_store

MaterialStore InDetMaterialManager::m_store

private

Definition at line 213 of file InDetMaterialManager.h.

m_weightMap

MaterialWeightMap InDetMaterialManager::m_weightMap

private

Definition at line 216 of file InDetMaterialManager.h.

---

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

• InDetMaterialManager.h
• InDetMaterialManager.cxx