Materials Class Reference

Thin wrapper around the Geant4 Material system. More...

#include <Materials.h>

Public Types
enum	{ CacheSize = 100 }

Public Member Functions
	~Materials ()
	Destructor for objects that I have created.
G4Material *	getMaterial (const std::string &name, bool showErrors=true)
	Get a pointer to the G4Material with the given name.
G4Element *	getElement (const std::string &name)
	Find given chemical element.
G4Material *	createMaterial (const gearbox::Interface &parameters)
	Create a material from the parameters specified by parameters.
G4Material *	createMaterial (const GeoMaterial &parameters)
	Create Geant4 Material from Material definition in DB.
G4OpticalSurface *	createOpticalSurface (const gearbox::Interface &parameters)
	Create an optical surface from parameters, will abort on error.
G4OpticalSurface *	createOpticalSurface (const GeoOpticalSurface &surface)
	Create an optical surface from Surface definition in DB.
GeoMaterial	createMaterialConfig (const gearbox::Interface &parameters)
	Create Material from XML description.
GeoOpticalSurface	createOpticalSurfaceConfig (const gearbox::Interface &parameters)
	Create Optical Surface Configuration from XML description.
void	clear ()
	Clear all existing materials.
void	setDensityScale (double scale)
	Set the density scale to the given value.
void	resetDensityScale ()
	Disable density scaling.
std::set< std::string >	getDensityScaleIgnoredMaterials () const
	get the set of material names which will not be scaled in any way
void	setDensityScaleIgnoredMaterials (const std::set< std::string > &ignored)
	set the set of material names which will not be scaled in any way

Static Public Member Functions
static Materials &	getInstance ()
	Get a reference to the singleton instance.
static G4Material *	get (const std::string &name)
	Find given material.

Protected Member Functions
	Materials ()
	Singleton: hide constructor.
	Materials (const Materials &)=delete
	Singleton: hide copy constructor.
void	operator= (const Materials &)=delete
	Singleton: hide assignment operator.
G4Material *	findMaterial (const std::string &name)
	find an existing material by name
G4MaterialPropertiesTable *	createProperties (const std::vector< GeoMaterialProperty > &props)
	Create a properties table from a vector of properties.
void	initBuilders ()
	Initialize Nist Builder instances.

Protected Attributes
MRUCache< std::string, G4Material * >	m_materialCache
	Cache for already searched Materials.
std::vector< G4MaterialPropertiesTable * >	m_PropTables
	Vector of created G4MaterialProperties objects.
G4NistElementBuilder *	m_nistElementBuilder {nullptr}
	G4NistElementBuilder instance to create chemical elements with correct natural abundances from NIST database.
G4NistMaterialBuilder *	m_nistMaterialBuilder {nullptr}
	G4NistMaterialBuilder to create predefined materials from NIST database.
std::optional< double >	m_densityScale
	If set we scale all densities by a given factor.
std::set< std::string >	m_ignoreScaling {"G4_AIR", "Air", "Vacuum"}
	Names of materials we don't want to scale.

Detailed Description

Thin wrapper around the Geant4 Material system.

This class serves the purpose to simplify the access to the Geant4 materials using the G4NistManager and to directly create materials from a Gearbox parameter set. Since Geant4 keeps track of all defined materials, this class is also able to find Materials created directly by the user.

Care should be taken when a Material is created with a name that already exists. In that case it may be possible that we return the wrong material since the first material with the given name will be returned.

Definition at line 48 of file Materials.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Definition at line 50 of file Materials.h.

{ CacheSize = 100 };

Constructor & Destructor Documentation

~Materials()

~Materials

(

)

Destructor for objects that I have created.

Definition at line 91 of file Materials.cc.

    {
      clear();
    }

Materials()

Materials ( )

inlineprotected

Singleton: hide constructor.

Definition at line 152 of file Materials.h.

: m_materialCache(CacheSize) {};

Member Function Documentation

clear()

void clear

(

)

Clear all existing materials.

Definition at line 384 of file Materials.cc.

    {
      // delete all property tables we have
      B2DEBUG(50, "Cleaning G4MaterialPropertiesTable");
      for (G4MaterialPropertiesTable* prop : m_PropTables) delete prop;
      m_PropTables.clear();
      // and last but not least: get rid of all materials
      B2DEBUG(50, "Cleaning G4Materials");
      G4MaterialTable& materials = *G4Material::GetMaterialTable();
      for (G4Material* mat : materials) delete mat;
      materials.clear();
      B2DEBUG(50, "Cleaning G4Elements");
      G4ElementTable& elements = *G4Element::GetElementTable();
      for (G4Element* elm : elements) delete elm;
      elements.clear();
      B2DEBUG(50, "Cleaning G4Isotopes");
      auto& isotopes = const_cast<G4IsotopeTable&>(*G4Isotope::GetIsotopeTable());
      for (G4Isotope* iso : isotopes) delete iso;
      isotopes.clear();
      // delete material and element builder as they keep indices to materials they created :/
      delete m_nistMaterialBuilder;
      delete m_nistElementBuilder;
      m_nistMaterialBuilder = nullptr;
      m_nistElementBuilder = nullptr;
      // finally, get rid of the cache, it's invalid now anyway
      B2DEBUG(50, "Clean up material cache");
      m_materialCache.clear();
    }

createMaterial() [1/2]

G4Material * createMaterial

(

const gearbox::Interface &

parameters

)

Create a material from the parameters specified by parameters.

Parameters

parameters

Material properties

Returns

pointer to the newly created material, 0 if there was an error creating it

Definition at line 158 of file Materials.cc.

    {
      GeoMaterial material = createMaterialConfig(parameters);
      return createMaterial(material);
    }

createMaterial() [2/2]

G4Material * createMaterial

(

const GeoMaterial &

parameters

)

Create Geant4 Material from Material definition in DB.

Parameters

parameters

Material properties

Returns

pointer to the newly created material, 0 if there was an error creating it

Definition at line 164 of file Materials.cc.

    {
      G4Material* oldmat = getMaterial(parameters.getName(), false);
      if (oldmat) {
        //We cannot modify or delete materials, so we just use existing ones
        B2ERROR("Material with name " << parameters.getName() << " already existing");
        return oldmat;
      }
      B2DEBUG(10, "Creating Material " << parameters.getName());
      //If density is negative or smaller than epsilon we should calculate the
      //density from the used materials
      double density = parameters.getDensity() * CLHEP::g / CLHEP::cm3;
      if (density < 1e-25) {
        density = 0;
        for (const GeoMaterialComponent& component : parameters.getComponents()) {
          //Check if we can calculate density, only works if we just add materials,
          //elements do not have density
          if (component.getIselement()) {
            B2ERROR("createMaterial " << parameters.getName()
                    << ": Cannot calculate density when adding elements, please provde a density");
            return nullptr;
          }
          G4Material* mat = getMaterial(component.getName());
          if (!mat) {
            B2ERROR("createMaterial " << parameters.getName() << ": Material '" << component.getName() << "' not found");
            return nullptr;
          }
          density += mat->GetDensity() * component.getFraction();
        }
      }
 
      //Finally, create Material and add all components
      G4Material* mat = new G4Material(parameters.getName(), density, parameters.getComponents().size(),
                                       (G4State)parameters.getState(), parameters.getTemperature(), parameters.getPressure() * CLHEP::pascal);
 
      for (const GeoMaterialComponent& component : parameters.getComponents()) {
        if (component.getIselement()) {
          G4Element* cmp = getElement(component.getName());
          if (!cmp) {
            B2ERROR("Cannot create material " << parameters.getName() << ": element " << component.getName() << " not found");
#ifdef __clang_analyzer__
            continue;
#else
            return nullptr;
#endif
          }
          mat->AddElement(cmp, component.getFraction());
        } else {
          G4Material* cmp = getMaterial(component.getName());
          if (!cmp) {
            B2ERROR("Cannot create material " << parameters.getName() << ": material " << component.getName() << " not found");
#ifdef __clang_analyzer__
            continue;
#else
            return nullptr;
#endif
          }
          mat->AddMaterial(cmp, component.getFraction());
        }
      }
 
      //add properties
      mat->SetMaterialPropertiesTable(createProperties(parameters.getProperties()));
 
      //Insert into cache and return
      m_materialCache.insert(parameters.getName(), mat);
      return mat;
    }

createMaterialConfig()

GeoMaterial createMaterialConfig

(

const gearbox::Interface &

parameters

)

Create Material from XML description.

Parameters

parameters

GearDir pointing to the Material description

Returns

GeoMaterial instance describing the material and suitable for serialization

Definition at line 233 of file Materials.cc.

    {
      //Get straightforward parameters from gearbox
      string name = parameters.getString("@name");
      B2DEBUG(10, "Creating Material Config " << name);
      string stateStr = parameters.getString("state", "undefined");
      double density = parameters.getDensity("density", 0); // * CLHEP::g / CLHEP::cm3;
      double temperature = parameters.getDouble("temperature", CLHEP::STP_Temperature);
      double pressure = parameters.getDouble("pressure", CLHEP::STP_Pressure / CLHEP::pascal);
 
      // set the simple ones like they are
      GeoMaterial material;
      material.setName(name);
      material.setPressure(pressure);
      material.setTemperature(temperature);
      material.setDensity(density);
 
      //Sum up fractions to see if they are normalized
      double sumFractions(0);
 
      // Add all component materials
      for (const GearDir& component : parameters.getNodes("Components/Material")) {
        const string componentName = component.getString();
        double fraction = component.getDouble("@fraction", 1.0);
        material.addComponent({componentName, false, fraction});
        sumFractions += fraction;
      }
      // Add all component elements
      for (const GearDir& element : parameters.getNodes("Components/Element")) {
        const std::string elementName = element.getString();
        double fraction = element.getDouble("@fraction", 1.0);
        material.addComponent({elementName, true, fraction});
        sumFractions += fraction;
      }
 
      //Warn if the fractions are not normalized
      if (abs(sumFractions - 1) > numeric_limits<double>::epsilon()) {
        B2WARNING("createMaterial " << name << ": Fractions not normalized, scaling by 1/" << sumFractions);
        for (GeoMaterialComponent& cmp : material.getComponents()) {
          cmp.setFraction(cmp.getFraction() / sumFractions);
        }
      }
 
      //Determine material state
      boost::to_lower(stateStr);
      G4State state = kStateUndefined;
      if (stateStr == "solid") {
        state = kStateSolid;
      } else if (stateStr == "liquid") {
        state = kStateLiquid;
      } else if (stateStr == "gas") {
        state = kStateGas;
      } else if (stateStr != "undefined") {
        B2WARNING("createMaterial " << name << ": Unknown state '" << stateStr << "', using undefined");
      }
      material.setState(state);
 
      addProperties(material, parameters);
      // all done, return material description
      return material;
    }

createOpticalSurface() [1/2]

G4OpticalSurface * createOpticalSurface

(

const gearbox::Interface &

parameters

)

Create an optical surface from parameters, will abort on error.

Parameters

parameters

Optical surface definition

Returns

new optical surface

Definition at line 295 of file Materials.cc.

    {
      GeoOpticalSurface surface = createOpticalSurfaceConfig(parameters);
      return createOpticalSurface(surface);
    }

createOpticalSurface() [2/2]

G4OpticalSurface * createOpticalSurface

(

const GeoOpticalSurface &

surface

)

Create an optical surface from Surface definition in DB.

Parameters

surface

Optical surface definition

Returns

new optical surface

Definition at line 301 of file Materials.cc.

    {
      G4OpticalSurface* optSurf = new G4OpticalSurface(surface.getName(),
                                                       (G4OpticalSurfaceModel) surface.getModel(),
                                                       (G4OpticalSurfaceFinish) surface.getFinish(),
                                                       (G4SurfaceType) surface.getType(),
                                                       surface.getValue());
      optSurf->SetMaterialPropertiesTable(createProperties(surface.getProperties()));
      //m_OptSurfaces.push_back(optSurf);
      return optSurf;
    }

createOpticalSurfaceConfig()

GeoOpticalSurface createOpticalSurfaceConfig

(

const gearbox::Interface &

parameters

)

Create Optical Surface Configuration from XML description.

Parameters

parameters

GearDir pointing to the Optical Surface description

Returns

GeoOpticalSurface instance describing the material and suitable for serialization

Definition at line 313 of file Materials.cc.

    {
      string name         = parameters.getString("@name", "OpticalSurface");
      string modelString  = parameters.getString("Model", "glisur");
      string finishString = parameters.getString("Finish", "polished");
      string typeString   = parameters.getString("Type", "dielectric_dielectric");
      double value        = parameters.getDouble("Value", 1.0);
 
#define CHECK_ENUM_VALUE(name,value) if (name##String == #value) { name = value; }
      G4OpticalSurfaceModel model;
      boost::to_lower(modelString);
      CHECK_ENUM_VALUE(model, glisur)
      else CHECK_ENUM_VALUE(model, unified)
        else CHECK_ENUM_VALUE(model, LUT)
          else {
            B2FATAL("Unknown Optical Surface Model: " << modelString);
          }
 
      G4OpticalSurfaceFinish finish;
      boost::to_lower(finishString);
      CHECK_ENUM_VALUE(finish, polished)
      else CHECK_ENUM_VALUE(finish, polishedfrontpainted)
        else CHECK_ENUM_VALUE(finish, polishedbackpainted)
          else CHECK_ENUM_VALUE(finish, ground)
            else CHECK_ENUM_VALUE(finish, groundfrontpainted)
              else CHECK_ENUM_VALUE(finish, groundbackpainted)
                else CHECK_ENUM_VALUE(finish, polishedlumirrorair)
                  else CHECK_ENUM_VALUE(finish, polishedlumirrorglue)
                    else CHECK_ENUM_VALUE(finish, polishedair)
                      else CHECK_ENUM_VALUE(finish, polishedteflonair)
                        else CHECK_ENUM_VALUE(finish, polishedtioair)
                          else CHECK_ENUM_VALUE(finish, polishedtyvekair)
                            else CHECK_ENUM_VALUE(finish, polishedvm2000air)
                              else CHECK_ENUM_VALUE(finish, polishedvm2000glue)
                                else CHECK_ENUM_VALUE(finish, etchedlumirrorair)
                                  else CHECK_ENUM_VALUE(finish, etchedlumirrorglue)
                                    else CHECK_ENUM_VALUE(finish, etchedair)
                                      else CHECK_ENUM_VALUE(finish, etchedteflonair)
                                        else CHECK_ENUM_VALUE(finish, etchedtioair)
                                          else CHECK_ENUM_VALUE(finish, etchedtyvekair)
                                            else CHECK_ENUM_VALUE(finish, etchedvm2000air)
                                              else CHECK_ENUM_VALUE(finish, etchedvm2000glue)
                                                else CHECK_ENUM_VALUE(finish, groundlumirrorair)
                                                  else CHECK_ENUM_VALUE(finish, groundlumirrorglue)
                                                    else CHECK_ENUM_VALUE(finish, groundair)
                                                      else CHECK_ENUM_VALUE(finish, groundteflonair)
                                                        else CHECK_ENUM_VALUE(finish, groundtioair)
                                                          else CHECK_ENUM_VALUE(finish, groundtyvekair)
                                                            else CHECK_ENUM_VALUE(finish, groundvm2000air)
                                                              else CHECK_ENUM_VALUE(finish, groundvm2000glue)
                                                                else {
                                                                  B2FATAL("Unknown Optical Surface Finish: " << finishString);
                                                                }
 
      G4SurfaceType type;
      boost::to_lower(typeString);
      CHECK_ENUM_VALUE(type, dielectric_metal)
      else CHECK_ENUM_VALUE(type, dielectric_dielectric)
        else CHECK_ENUM_VALUE(type, dielectric_LUT)
          else CHECK_ENUM_VALUE(type, firsov)
            else CHECK_ENUM_VALUE(type, x_ray)
              else {
                B2FATAL("Unknown Optical Surface Type: " << typeString);
              }
#undef CHECK_ENUM_VALUE
 
      GeoOpticalSurface surface(name, model, finish, type, value);
      addProperties(surface, GearDir(parameters, "Properties"));
      return surface;
    }

createProperties()

G4MaterialPropertiesTable * createProperties ( const std::vector< GeoMaterialProperty > &  props )

protected

Create a properties table from a vector of properties.

Return 0 if the vector is empty

Definition at line 69 of file Materials.cc.

    {
      if (!props.size()) return nullptr;
      auto* table = new G4MaterialPropertiesTable();
      m_PropTables.push_back(table);
      for (const GeoMaterialProperty& prop : props) {
        std::vector<double> energies = prop.getEnergies();
        std::vector<double> values = prop.getValues();
        const size_t n = values.size();
        // convert energies to Geant4 Units
        for (double& energy : energies) energy *= CLHEP::GeV / Unit::GeV;
        table->AddProperty(prop.getName().c_str(), energies.data(), values.data(), n);
      }
      return table;
    }

findMaterial()

G4Material * findMaterial ( const std::string &  name )

protected

find an existing material by name

Definition at line 105 of file Materials.cc.

    {
      G4Material* mat{nullptr};
      if (m_materialCache.retrieve(name, mat)) {
        return mat;
      }
      initBuilders();
      mat = m_nistMaterialBuilder->FindOrBuildMaterial(name);
 
      //Try different combinations of the Material name to fallback to predefined G4 Elements
      if (!mat && name.substr(0, 3) != "G4_") {
        //Mainly for materials from single elements, e.g. G4_Al, G4_Si
        mat = m_nistMaterialBuilder->FindOrBuildMaterial("G4_" + name);
        //For predefined materials, e.g. G4_AIR, G4_TEFLON
        if (!mat) mat = m_nistMaterialBuilder->FindOrBuildMaterial("G4_" + boost::to_upper_copy(name));
      }
 
      //Insert into cache
      m_materialCache.insert(name, mat);
      return mat;
    }

get()

static G4Material * get ( const std::string &  name )

inlinestatic

Find given material.

Shorthand for Materials::getInstance().getMaterial()

See also

Materials::getMaterial

Parameters

name	of the material to find

Definition at line 63 of file Materials.h.

{ return Materials::getInstance().getMaterial(name); }

getDensityScaleIgnoredMaterials()

std::set< std::string > getDensityScaleIgnoredMaterials ( ) const

inline

get the set of material names which will not be scaled in any way

Definition at line 147 of file Materials.h.

{ return m_ignoreScaling; }

getElement()

G4Element * getElement

(

const std::string &

name

)

Find given chemical element.

Parameters

name	Name of the Element, e.g. Si, Al, He

Definition at line 150 of file Materials.cc.

    {
      initBuilders();
      G4Element* elm = m_nistElementBuilder->FindOrBuildElement(name);
      if (!elm) B2ERROR("Element '" << name << "' could not be found");
      return elm;
    }

getInstance()

Materials & getInstance ( )

static

Get a reference to the singleton instance.

Definition at line 85 of file Materials.cc.

    {
      static unique_ptr<Materials> instance(new Materials());
      return *instance;
    }

getMaterial()

G4Material * getMaterial	(	const std::string &	name,
		bool	showErrors = true
	)

Get a pointer to the G4Material with the given name.

If the given name cannot be found we also try to find it in the Nist database by prepending the name with G4_ and trying in with given case and all uppercase since single element materials are defined as e.g. G4_Si, G4_Al and other materials are defined all uppercase, e.g. G4_AIR, G4_TEFLON.

Found materials are cached internaly using an MRU cache so repitive access to materials should be O(1) in most cases

Parameters

name	Name of the material to be found
showErrors	If false don't show any errors, just return nullptr if the material cannot be found

Definition at line 127 of file Materials.cc.

    {
      G4Material* mat = findMaterial(name);
      if (!mat && showErrors) B2ERROR("Material '" << name << "' could not be found");
      // There is a chance that we want to scale densities of all materials for studies.
      // Now we have the original so we can look to the scaled one or create it if it's missing
      if (m_densityScale) {
        if (m_ignoreScaling.count(name) > 0) return mat;
        if (name.substr(0, 7) == "scaled:")
          B2WARNING("Requested an already scaled material ... scaling once more" << LogVar("material", name));
        std::string scaled = "scaled:" + std::to_string(*m_densityScale) + ":" + name;
        G4Material* scaledMat = findMaterial(scaled);
        if (!scaledMat) {
          assert(mat);
          scaledMat = new G4Material(scaled, mat->GetDensity() * *m_densityScale, mat,
                                     mat->GetState(), mat->GetTemperature(), mat->GetPressure());
          m_materialCache.insert(scaled, scaledMat);
        }
        return scaledMat;
      }
      return mat;
    }

initBuilders()

void initBuilders ( )

protected

Initialize Nist Builder instances.

Definition at line 96 of file Materials.cc.

    {
      if (!m_nistMaterialBuilder) {
        B2DEBUG(50, "Creating new Nist Builder instances");
        m_nistElementBuilder = new G4NistElementBuilder(0);
        m_nistMaterialBuilder = new G4NistMaterialBuilder(m_nistElementBuilder, 0);
      }
    }

resetDensityScale()

void resetDensityScale ( )

inline

Disable density scaling.

Definition at line 142 of file Materials.h.

      {
        m_densityScale.reset();
      }

setDensityScale()

void setDensityScale ( double  scale )

inline

Set the density scale to the given value.

Definition at line 136 of file Materials.h.

      {
        if (scale == 1.0) return resetDensityScale();
        m_densityScale = scale;
      }

setDensityScaleIgnoredMaterials()

void setDensityScaleIgnoredMaterials ( const std::set< std::string > &  ignored )

inline

set the set of material names which will not be scaled in any way

Definition at line 149 of file Materials.h.

{ m_ignoreScaling = ignored; }

Member Data Documentation

m_densityScale

std::optional<double> m_densityScale

protected

If set we scale all densities by a given factor.

Definition at line 179 of file Materials.h.

m_ignoreScaling

std::set<std::string> m_ignoreScaling {"G4_AIR", "Air", "Vacuum"}

protected

Names of materials we don't want to scale.

Definition at line 181 of file Materials.h.

m_materialCache

MRUCache<std::string, G4Material*> m_materialCache

mutableprotected

Cache for already searched Materials.

Definition at line 161 of file Materials.h.

m_nistElementBuilder

G4NistElementBuilder* m_nistElementBuilder {nullptr}

protected

G4NistElementBuilder instance to create chemical elements with correct natural abundances from NIST database.

Definition at line 168 of file Materials.h.

m_nistMaterialBuilder

G4NistMaterialBuilder* m_nistMaterialBuilder {nullptr}

protected

G4NistMaterialBuilder to create predefined materials from NIST database.

Definition at line 170 of file Materials.h.

m_PropTables

std::vector<G4MaterialPropertiesTable*> m_PropTables

protected

Vector of created G4MaterialProperties objects.

Definition at line 164 of file Materials.h.

---

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

• geometry/include/Materials.h
• geometry/src/Materials.cc