larg4::MaterialPropertyLoader Class Reference

Stores material properties and sends them to GEANT4 geometry. More...

#include <MaterialPropertyLoader.h>

Public Member Functions
std::map< double, double >	GetMaterialProperty (std::string Material, std::string Property)
double	GetMaterialConstProperty (std::string Material, std::string Property)
std::map< std::string, double > const &	GetMaterialConstProperties (std::string Material)
std::map< std::string, std::map< double, double > > const &	GetMaterialProperties (std::string Material)
void	GetPropertiesFromServices (detinfo::DetectorPropertiesData const &detProp)
	Imports properties from LArSoft services. More...
void	UpdateGeometry (G4LogicalVolumeStore *lvs)
	Updates the material properties with the collected values. More...
Methods to set material properties
void	SetMaterialProperty (std::string Material, std::string Property, std::map< double, double > Values, double Unit)
	Stores the specified emergy-dependent material property. More...
void	SetMaterialConstProperty (std::string Material, std::string Property, double Value, double Unit)
	Stores the specified material property. More...
Setting of specific properties
void	SetBirksConstant (std::string, double, double)
void	SetReflectances (std::string, std::map< std::string, std::map< double, double >>, std::map< std::string, std::map< double, double >>)
void	SetReflectances (std::map< std::string, std::map< double, double >>)

Private Attributes
std::map< std::string, std::map< std::string, double > >	fConstPropertyList
std::map< std::string, std::map< std::string, std::map< double, double > > >	fPropertyList
std::map< std::string, double >	fBirksConstants

Detailed Description

Stores material properties and sends them to GEANT4 geometry.

Class to set material properties for different materials in the detector. Currently mainly used to set optical properties for LAr and other optical components.

Notes on the implementation of reflectivity

The reflectivity properties of the material are stored in a different way depending on whether the standard GEANT4 process or the custom simple boundary process are used in the simulation (determined by detinfo::DetectorProperties::SimpleBoundary()). For the former, reflectivity is saved as a property of the material itself with the property name "REFLECTIVITY". For the latter, the properties (both a reflectivity and a diffuse reflection fraction) are stored as properties of the "LAr" material, with a name "REFLECTANCE_\<Material\>" and "DIFFUSE_REFLECTANCE_FRACTION_\<Material\>". This is the storage policy expected by larg4::OpBoundaryProcessSimple, which implements the simple boundary model.

Definition at line 50 of file MaterialPropertyLoader.h.

Member Function Documentation

std::map<std::string, double> const& larg4::MaterialPropertyLoader::GetMaterialConstProperties ( std::string  Material )

inline

Definition at line 69 of file MaterialPropertyLoader.h.

    {
      return fConstPropertyList[Material];
    }

double larg4::MaterialPropertyLoader::GetMaterialConstProperty ( std::string  Material, std::string  Property  )

inline

Definition at line 62 of file MaterialPropertyLoader.h.

    {
      return fConstPropertyList[Material][Property];
    }

std::map<std::string, std::map<double, double> > const& larg4::MaterialPropertyLoader::GetMaterialProperties ( std::string  Material )

inline

Definition at line 76 of file MaterialPropertyLoader.h.

    {
      return fPropertyList[Material];
    }

std::map<double, double> larg4::MaterialPropertyLoader::GetMaterialProperty ( std::string  Material, std::string  Property  )

inline

Definition at line 55 of file MaterialPropertyLoader.h.

    {
      return fPropertyList[Material][Property];
    }

void larg4::MaterialPropertyLoader::GetPropertiesFromServices

(

detinfo::DetectorPropertiesData const &

detProp

)

Imports properties from LArSoft services.

The properties imported include:

• material "LAr":
  • fast scintillation light spectrum ("FASTCOMPONENT") from detinfo::LArProperties::FastScintSpectrum()
  • slow scintillation light spectrum ("SLOWCOMPONENT") from detinfo::LArProperties::SlowScintSpectrum()
  • refraction index vs. photon energy ("RINDEX") from detinfo::LArProperties::RIndexSpectrum()
  • absorption length vs. photon energy ("ABSLENGTH") from detinfo::LArProperties::AbsLengthSpectrum() _[cm]_
  • Rayleigh scattering vs. photon energy ("RAYLEIGH") from detinfo::LArProperties::RayleighSpectrum() _[cm]_
  • scintillation yield ("SCINTILLATIONYIELD") from detinfo::LArProperties::ScintYield(true) _[1/MeV]_
  • "RESOLUTIONSCALE"
  • fast scintillation light delay ("FASTTIMECONSTANT") from detinfo::LArProperties::ScintFastTimeConst() _[ns]_
  • slow scintillation light delay ("SLOWTIMECONSTANT") from detinfo::LArProperties::ScintSlowTimeConst() _[ns]_
  • scintillation yield ratio ("YIELDRATIO") detinfo::LArProperties::ScintYieldRatio()
  • electric field ("ELECTRICFIELD") from detinfo::DetectorProperties::Efield() _[kV/cm]_
  • scintillation Birks constant vs. photon energy, from detinfo::LArProperties::ScintBirksConstant() _[cm/MeV]_
  • if using the simple reflectivity model (detinfo::DetectorProperties::SimpleBoundary()), for each supported material XXX:
    • reflectivity ("REFLECTANCE_XXX") from detinfo::LArProperties::SurfaceReflectances()
    • diffused reflectivity fraction ("DIFFUSE_REFLECTANCE_FRACTION_XXX") from detinfo::LArProperties::SurfaceReflectances()
    The materials are the ones listed in the property from detinfo::LArProperties.
  • if using different scintillation yield for different particle types (according to detinfo::LArProperties::ScintByParticleType()):
    • scintillation yield "\<PARTICLE\>SCINTILLATIONYIELD" from detinfo::LArProperties::<Particle>ScintYield() (as above)
    • scintillation yield ratio "\<PARTICLE\>YIELDRATIO" from detinfo::LArProperties::<Particle>ScintYieldRatio() (as above)
    with <PARTICLE> being proton, muon, kaon, pion, electron and α particles.
• if not using the simple reflectivity model (!detinfo::DetectorProperties::SimpleBoundary()):
  • material XXX reflectivity ("REFLECTIVITY") from detinfo::LArProperties::SurfaceReflectances()
  The materials are the ones listed in the property from detinfo::LArProperties::SurfaceReflectances().
• TPB material (if simulating it, according to detinfo::LArProperties::ExtraMatProperties()):
  • refraction index vs. photon energy ("RINDEX") from detinfo::LArProperties::RIndexSpectrum()
  • wavelength shifter absorbtion length vs. photon energy ("WLSABSLENGTH") from detinfo::LArProperties::TpbAbs() _[m]_
  • "WLSCOMPONENT" from detinfo::LArProperties::TpbEm()

Definition at line 318 of file MaterialPropertyLoader.cxx.

  {
    const detinfo::LArProperties* LarProp = lar::providerFrom<detinfo::LArPropertiesService>();

    // wavelength dependent quantities

    SetMaterialProperty("LAr", "FASTCOMPONENT", LarProp->FastScintSpectrum(), 1);
    SetMaterialProperty("LAr", "SLOWCOMPONENT", LarProp->SlowScintSpectrum(), 1);
    SetMaterialProperty("LAr", "RINDEX", LarProp->RIndexSpectrum(), 1);
    SetMaterialProperty("LAr", "ABSLENGTH", LarProp->AbsLengthSpectrum(), CLHEP::cm);
    SetMaterialProperty("LAr", "RAYLEIGH", LarProp->RayleighSpectrum(), CLHEP::cm);

    // scalar properties

    SetMaterialConstProperty("LAr",
                             "SCINTILLATIONYIELD",
                             LarProp->ScintYield(true),
                             1 / CLHEP::MeV); // true = scaled down by prescale in larproperties
    SetMaterialConstProperty("LAr", "RESOLUTIONSCALE", LarProp->ScintResolutionScale(), 1);
    SetMaterialConstProperty("LAr", "FASTTIMECONSTANT", LarProp->ScintFastTimeConst(), CLHEP::ns);
    SetMaterialConstProperty("LAr", "SLOWTIMECONSTANT", LarProp->ScintSlowTimeConst(), CLHEP::ns);
    SetMaterialConstProperty("LAr", "YIELDRATIO", LarProp->ScintYieldRatio(), 1);
    SetMaterialConstProperty("LAr", "ELECTRICFIELD", detProp.Efield(), CLHEP::kilovolt / CLHEP::cm);

    SetBirksConstant("LAr", LarProp->ScintBirksConstant(), CLHEP::cm / CLHEP::MeV);
    if (detProp.SimpleBoundary())
      SetReflectances(
        "LAr", LarProp->SurfaceReflectances(), LarProp->SurfaceReflectanceDiffuseFractions());
    else
      SetReflectances(LarProp->SurfaceReflectances());

    // If we are using scint by particle type, load these

    if (LarProp->ScintByParticleType()) {
      // true = scaled down by prescale in larproperties
      SetMaterialConstProperty(
        "LAr", "PROTONSCINTILLATIONYIELD", LarProp->ProtonScintYield(true), 1. / CLHEP::MeV);
      SetMaterialConstProperty("LAr", "PROTONYIELDRATIO", LarProp->ProtonScintYieldRatio(), 1.);
      SetMaterialConstProperty(
        "LAr", "MUONSCINTILLATIONYIELD", LarProp->MuonScintYield(true), 1. / CLHEP::MeV);
      SetMaterialConstProperty("LAr", "MUONYIELDRATIO", LarProp->MuonScintYieldRatio(), 1.);
      SetMaterialConstProperty(
        "LAr", "KAONSCINTILLATIONYIELD", LarProp->KaonScintYield(true), 1. / CLHEP::MeV);
      SetMaterialConstProperty("LAr", "KAONYIELDRATIO", LarProp->KaonScintYieldRatio(), 1.);
      SetMaterialConstProperty(
        "LAr", "PIONSCINTILLATIONYIELD", LarProp->PionScintYield(true), 1. / CLHEP::MeV);
      SetMaterialConstProperty("LAr", "PIONYIELDRATIO", LarProp->PionScintYieldRatio(), 1.);
      SetMaterialConstProperty(
        "LAr", "ELECTRONSCINTILLATIONYIELD", LarProp->ElectronScintYield(true), 1. / CLHEP::MeV);
      SetMaterialConstProperty("LAr", "ELECTRONYIELDRATIO", LarProp->ElectronScintYieldRatio(), 1.);
      SetMaterialConstProperty(
        "LAr", "ALPHASCINTILLATIONYIELD", LarProp->AlphaScintYield(true), 1. / CLHEP::MeV);
      SetMaterialConstProperty("LAr", "ALPHAYIELDRATIO", LarProp->AlphaScintYieldRatio(), 1.);
    }

    // If we are simulating the TPB load this

    if (LarProp->ExtraMatProperties()) {
      SetMaterialProperty("TPB", "RINDEX", LarProp->RIndexSpectrum(), 1);
      SetMaterialProperty("TPB", "WLSABSLENGTH", LarProp->TpbAbs(), CLHEP::m);
      SetMaterialProperty("TPB", "WLSCOMPONENT", LarProp->TpbEm(), 1);

      SetMaterialConstProperty("TPB", "WLSTIMECONSTANT", LarProp->TpbTimeConstant(), CLHEP::ns);
    }
  }

void larg4::MaterialPropertyLoader::SetBirksConstant	(	std::string	Material,
		double	PropertyValue,
		double	Unit
	)

Definition at line 61 of file MaterialPropertyLoader.cxx.

  {
    fBirksConstants[Material] = PropertyValue * Unit;
    // replace with MF_LOGDEBUG()
    mf::LogInfo("MaterialPropertyLoader") << "Set Birks constant " << Material;
  }

void larg4::MaterialPropertyLoader::SetMaterialConstProperty	(	std::string	Material,
		std::string	Property,
		double	Value,
		double	Unit
	)

Stores the specified material property.

Parameters

Material	name of the material to set the property of
Property	name of the property
Value	the value of the property
Unit	unit of the property value (CLHEP)

See Also

SetMaterialProperty()

The property is stored internally and not propagated to GEANT4 (use UpdateGeometry() to that purpose). The previous value of the property is silently overwritten.

Definition at line 48 of file MaterialPropertyLoader.cxx.

  {
    fConstPropertyList[Material][Property] = PropertyValue * Unit;
    // replace with MF_LOGDEBUG()
    mf::LogInfo("MaterialPropertyLoader")
      << "Added const property " << Material << "  " << Property << " = " << PropertyValue;
  }

void larg4::MaterialPropertyLoader::SetMaterialProperty	(	std::string	Material,
		std::string	Property,
		std::map< double, double >	Values,
		double	Unit
	)

Stores the specified emergy-dependent material property.

Parameters

Material	name of the material to set the property of
Property	name of the property
Values	table of property values (see below)
Unit	unit of the property values (CLHEP)

See Also

SetMaterialConstProperty()

The property is stored internally and not propagated to GEANT4 (use UpdateGeometry() to that purpose). The previous value of the property is silently overwritten.

The table of values is in form of (energy, value) pairs, where value is measured in Units and energy is measured in electronvolt.

Definition at line 30 of file MaterialPropertyLoader.cxx.

  {
    std::map<double, double> PropVectorWithUnit;
    for (std::map<double, double>::const_iterator it = PropertyVector.begin();
         it != PropertyVector.end();
         it++) {
      PropVectorWithUnit[it->first * CLHEP::eV] = it->second * Unit;
    }
    fPropertyList[Material][Property] = PropVectorWithUnit;
    // replace with MF_LOGDEBUG()
    mf::LogInfo("MaterialPropertyLoader") << "Added property " << Material << "  " << Property;
  }

void larg4::MaterialPropertyLoader::SetReflectances	(	std::string	,
		std::map< std::string, std::map< double, double >>	Reflectances,
		std::map< std::string, std::map< double, double >>	DiffuseFractions
	)

Definition at line 260 of file MaterialPropertyLoader.cxx.

  {
    std::map<double, double> ReflectanceToStore;
    std::map<double, double> DiffuseToStore;

    for (std::map<std::string, std::map<double, double>>::const_iterator itMat =
           Reflectances.begin();
         itMat != Reflectances.end();
         ++itMat) {
      std::string ReflectancePropName = std::string("REFLECTANCE_") + itMat->first;
      ReflectanceToStore.clear();
      for (std::map<double, double>::const_iterator itEn = itMat->second.begin();
           itEn != itMat->second.end();
           ++itEn) {
        ReflectanceToStore[itEn->first] = itEn->second;
      }
      SetMaterialProperty("LAr", ReflectancePropName, ReflectanceToStore, 1);
    }

    for (std::map<std::string, std::map<double, double>>::const_iterator itMat =
           DiffuseFractions.begin();
         itMat != DiffuseFractions.end();
         ++itMat) {
      std::string DiffusePropName = std::string("DIFFUSE_REFLECTANCE_FRACTION_") + itMat->first;
      DiffuseToStore.clear();
      for (std::map<double, double>::const_iterator itEn = itMat->second.begin();
           itEn != itMat->second.end();
           ++itEn) {
        DiffuseToStore[itEn->first] = itEn->second;
      }
      SetMaterialProperty("LAr", DiffusePropName, DiffuseToStore, 1);
    }
  }

void larg4::MaterialPropertyLoader::SetReflectances

(

std::map< std::string, std::map< double, double >>

Reflectances

)

Definition at line 298 of file MaterialPropertyLoader.cxx.

  {
    std::map<double, double> ReflectanceToStore;

    for (std::map<std::string, std::map<double, double>>::const_iterator itMat =
           Reflectances.begin();
         itMat != Reflectances.end();
         ++itMat) {
      ReflectanceToStore.clear();
      for (std::map<double, double>::const_iterator itEn = itMat->second.begin();
           itEn != itMat->second.end();
           ++itEn) {
        ReflectanceToStore[itEn->first] = itEn->second;
      }
      SetMaterialProperty(itMat->first, "REFLECTIVITY", ReflectanceToStore, 1);
    }
  }

void larg4::MaterialPropertyLoader::UpdateGeometry

(

G4LogicalVolumeStore *

lvs

)

Updates the material properties with the collected values.

Parameters

lvs	the store of logical volumes to be updated

Before calling this function, properties for some materials (mostly liquid argon, but not only: see e.g. GetPropertiesFromServices()) are collected and updated. This method considers all volumes in the store lvs. For the ones made of a material we have properties for, their material properties are updated to reflect the values we have collected.

Definition at line 70 of file MaterialPropertyLoader.cxx.

  {
    std::map<std::string, G4MaterialPropertiesTable*> MaterialTables;
    std::map<std::string, bool> MaterialsSet;

    // TODO replace console output with messagefacility output
    mf::LogInfo("MaterialPropertyLoader") << "UPDATING GEOMETRY";

    // Loop over each material with a property vector and create a new material table for it
    for (std::map<std::string, std::map<std::string, std::map<double, double>>>::const_iterator i =
           fPropertyList.begin();
         i != fPropertyList.end();
         i++) {
      std::string Material = i->first;
      MaterialsSet[Material] = true;
      MaterialTables[Material] = new G4MaterialPropertiesTable;
    }

    // Loop over each material with a const property,
    // if material table does not exist, create one
    for (std::map<std::string, std::map<std::string, double>>::const_iterator i =
           fConstPropertyList.begin();
         i != fConstPropertyList.end();
         i++) {
      std::string Material = i->first;
      if (!MaterialsSet[Material]) {
        MaterialsSet[Material] = true;
        MaterialTables[Material] = new G4MaterialPropertiesTable;
      }
    }

    // For each property vector, convert to an array of g4doubles and
    // feed to materials table Lots of firsts and seconds!  See annotation
    // in MaterialPropertyLoader.h to follow what each element is

    for (std::map<std::string, std::map<std::string, std::map<double, double>>>::const_iterator i =
           fPropertyList.begin();
         i != fPropertyList.end();
         i++) {
      std::string Material = i->first;
      for (std::map<std::string, std::map<double, double>>::const_iterator j = i->second.begin();
           j != i->second.end();
           j++) {
        std::string Property = j->first;
        std::vector<G4double> g4MomentumVector;
        std::vector<G4double> g4PropertyVector;

        for (std::map<double, double>::const_iterator k = j->second.begin(); k != j->second.end();
             k++) {
          g4MomentumVector.push_back(k->first);
          g4PropertyVector.push_back(k->second);
        }
        int NoOfElements = g4MomentumVector.size();
        MaterialTables[Material]->AddProperty(
          Property.c_str(), &g4MomentumVector[0], &g4PropertyVector[0], NoOfElements);
        // replace with mf::LogVerbatim()
        mf::LogInfo("MaterialPropertyLoader")
          << "Added property " << Property << " to material table " << Material;
      }
    }

    //Add each const property element
    for (std::map<std::string, std::map<std::string, double>>::const_iterator i =
           fConstPropertyList.begin();
         i != fConstPropertyList.end();
         i++) {
      std::string Material = i->first;
      for (std::map<std::string, double>::const_iterator j = i->second.begin();
           j != i->second.end();
           j++) {
        std::string Property = j->first;
        G4double PropertyValue = j->second;
        MaterialTables[Material]->AddConstProperty(Property.c_str(), PropertyValue);
        // replace with mf::LogVerbatim()
        mf::LogInfo("MaterialPropertyLoader")
          << "Added const property " << Property << " to material table " << Material;
      }
    }

    //Loop through geometry elements and apply relevant material table where materials match
    for (G4LogicalVolumeStore::iterator i = lvs->begin(); i != lvs->end(); ++i) {
      G4LogicalVolume* volume = (*i);
      G4Material* TheMaterial = volume->GetMaterial();
      std::string Material = TheMaterial->GetName();

      //
      // create reflective surfaces corresponding to the volumes made of some
      // selected materials
      //

      //--------------------------> FIXME <-----------------(parameters from fcl files(?))
      G4MaterialPropertyVector* PropertyPointer = 0;
      if (MaterialTables[Material])
        PropertyPointer = MaterialTables[Material]->GetProperty("REFLECTIVITY");

      if (Material == "Copper") {
        std::cout << "copper foil surface set " << volume->GetName() << std::endl;
        if (PropertyPointer) {
          std::cout << "defining Copper optical boundary " << std::endl;
          G4OpticalSurface* refl_opsurfc =
            new G4OpticalSurface("Surface copper", glisur, ground, dielectric_metal);
          refl_opsurfc->SetMaterialPropertiesTable(MaterialTables[Material]);
          refl_opsurfc->SetPolish(0.2);
          new G4LogicalSkinSurface("refl_surfacec", volume, refl_opsurfc);
        }
        else
          std::cout << "Warning: Copper surface in the geometry without REFLECTIVITY assigned"
                    << std::endl;
      }

      if (Material == "G10") {
        std::cout << "G10 surface set " << volume->GetName() << std::endl;
        if (PropertyPointer) {
          std::cout << "defining G10 optical boundary " << std::endl;
          G4OpticalSurface* refl_opsurfg =
            new G4OpticalSurface("g10 Surface", glisur, ground, dielectric_metal);
          refl_opsurfg->SetMaterialPropertiesTable(MaterialTables[Material]);
          refl_opsurfg->SetPolish(0.1);
          new G4LogicalSkinSurface("refl_surfaceg", volume, refl_opsurfg);
        }
        else
          std::cout << "Warning: G10 surface in the geometry without REFLECTIVITY assigned"
                    << std::endl;
      }

      if (Material == "vm2000") {
        std::cout << "vm2000 surface set " << volume->GetName() << std::endl;
        if (PropertyPointer) {
          std::cout << "defining vm2000 optical boundary " << std::endl;
          G4OpticalSurface* refl_opsurf = new G4OpticalSurface(
            "Reflector Surface", unified, groundfrontpainted, dielectric_dielectric);
          refl_opsurf->SetMaterialPropertiesTable(MaterialTables[Material]);
          G4double sigma_alpha = 0.8;
          refl_opsurf->SetSigmaAlpha(sigma_alpha);
          new G4LogicalSkinSurface("refl_surface", volume, refl_opsurf);
        }
        else
          std::cout << "Warning: vm2000 surface in the geometry without REFLECTIVITY assigned"
                    << std::endl;
      }
      if (Material == "ALUMINUM_Al") {
        std::cout << "ALUMINUM_Al surface set " << volume->GetName() << std::endl;
        if (PropertyPointer) {
          std::cout << "defining ALUMINUM_Al optical boundary " << std::endl;
          G4OpticalSurface* refl_opsurfs =
            new G4OpticalSurface("Surface Aluminum", glisur, ground, dielectric_metal);
          refl_opsurfs->SetMaterialPropertiesTable(MaterialTables[Material]);
          refl_opsurfs->SetPolish(0.5);
          new G4LogicalSkinSurface("refl_surfaces", volume, refl_opsurfs);
        }
        else
          std::cout << "Warning: ALUMINUM_Al surface in the geometry without REFLECTIVITY assigned"
                    << std::endl;
      }
      if (Material == "STEEL_STAINLESS_Fe7Cr2Ni") {
        std::cout << "STEEL_STAINLESS_Fe7Cr2Ni surface set " << volume->GetName() << std::endl;
        if (PropertyPointer) {
          std::cout << "defining STEEL_STAINLESS_Fe7Cr2Ni optical boundary " << std::endl;
          G4OpticalSurface* refl_opsurfs =
            new G4OpticalSurface("Surface Steel", glisur, ground, dielectric_metal);
          refl_opsurfs->SetMaterialPropertiesTable(MaterialTables[Material]);
          refl_opsurfs->SetPolish(0.5);
          new G4LogicalSkinSurface("refl_surfaces", volume, refl_opsurfs);
        }
        else
          std::cout << "Warning: STEEL_STAINLESS_Fe7Cr2Ni surface in the geometry without "
                       "REFLECTIVITY assigned"
                    << std::endl;
      }
      //-----------------------------------------------------------------------------

      //
      // apply the remaining material properties
      //
      for (std::map<std::string, G4MaterialPropertiesTable*>::const_iterator j =
             MaterialTables.begin();
           j != MaterialTables.end();
           j++) {
        if (Material == j->first) {
          TheMaterial->SetMaterialPropertiesTable(j->second);
          //Birks Constant, for some reason, must be set separately
          if (fBirksConstants[Material] != 0)
            TheMaterial->GetIonisation()->SetBirksConstant(fBirksConstants[Material]);
          volume->SetMaterial(TheMaterial);
        }
      }
    }
  }

Member Data Documentation

std::map<std::string, double> larg4::MaterialPropertyLoader::fBirksConstants

private

Definition at line 208 of file MaterialPropertyLoader.h.

std::map<std::string, std::map<std::string, double> > larg4::MaterialPropertyLoader::fConstPropertyList

private

Definition at line 203 of file MaterialPropertyLoader.h.

std::map<std::string, std::map<std::string, std::map<double, double> > > larg4::MaterialPropertyLoader::fPropertyList

private

Definition at line 206 of file MaterialPropertyLoader.h.

---

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

• MaterialPropertyLoader.h
• MaterialPropertyLoader.cxx