G4MaterialPropertiesTable Class Reference

#include <G4MaterialPropertiesTable.hh>

Inheritance diagram for G4MaterialPropertiesTable:

Public Member Functions
	G4MaterialPropertiesTable ()
virtual	~G4MaterialPropertiesTable ()
void	AddConstProperty (const G4String &key, G4double propertyValue, G4bool createNewKey=false)
void	AddConstProperty (const char *key, G4double propertyValue, G4bool createNewKey=false)
G4MaterialPropertyVector *	AddProperty (const G4String &key, const std::vector< G4double > &photonEnergies, const std::vector< G4double > &propertyValues, G4bool createNewKey=false, G4bool spline=false)
G4MaterialPropertyVector *	AddProperty (const char *key, G4double *photonEnergies, G4double *propertyValues, G4int numEntries, G4bool createNewKey=false, G4bool spline=false)
void	AddProperty (const G4String &key, G4MaterialPropertyVector *opv, G4bool createNewKey=false)
void	AddProperty (const char *key, G4MaterialPropertyVector *opv, G4bool createNewKey=false)
void	AddProperty (const G4String &key, const G4String &mat)
void	RemoveConstProperty (const G4String &key)
void	RemoveConstProperty (const char *key)
void	RemoveProperty (const G4String &key)
void	RemoveProperty (const char *key)
G4double	GetConstProperty (const G4String &key) const
G4double	GetConstProperty (const char *key) const
G4double	GetConstProperty (const G4int index) const
G4bool	ConstPropertyExists (const G4String &key) const
G4bool	ConstPropertyExists (const char *key) const
G4bool	ConstPropertyExists (const G4int index) const
G4MaterialPropertyVector *	GetProperty (const char *key) const
G4MaterialPropertyVector *	GetProperty (const G4String &key) const
G4MaterialPropertyVector *	GetProperty (const G4int index) const
void	AddEntry (const G4String &key, G4double aPhotonEnergy, G4double aPropertyValue)
void	AddEntry (const char *key, G4double aPhotonEnergy, G4double aPropertyValue)
G4int	GetConstPropertyIndex (const G4String &key) const
G4int	GetPropertyIndex (const G4String &key) const
void	DumpTable () const
const std::vector< G4String > &	GetMaterialPropertyNames () const
const std::vector< G4String > &	GetMaterialConstPropertyNames () const
const std::vector< G4MaterialPropertyVector * > &	GetProperties () const
const std::vector< std::pair< G4double, G4bool > > &	GetConstProperties () const

Detailed Description

Definition at line 61 of file G4MaterialPropertiesTable.hh.

Constructor & Destructor Documentation

G4MaterialPropertiesTable()

G4MaterialPropertiesTable::G4MaterialPropertiesTable

(

)

Definition at line 65 of file G4MaterialPropertiesTable.cc.

{
  // elements of these 2 vectors must be in same order as
  // the corresponding enums in G4MaterialPropertiesIndex.hh
  fMatPropNames.emplace_back("RINDEX");
  fMatPropNames.emplace_back("REFLECTIVITY");
  fMatPropNames.emplace_back("REALRINDEX");
  fMatPropNames.emplace_back("IMAGINARYRINDEX");
  fMatPropNames.emplace_back("EFFICIENCY");
  fMatPropNames.emplace_back("TRANSMITTANCE");
  fMatPropNames.emplace_back("SPECULARLOBECONSTANT");
  fMatPropNames.emplace_back("SPECULARSPIKECONSTANT");
  fMatPropNames.emplace_back("BACKSCATTERCONSTANT");
  fMatPropNames.emplace_back("GROUPVEL");
  fMatPropNames.emplace_back("MIEHG");
  fMatPropNames.emplace_back("RAYLEIGH");
  fMatPropNames.emplace_back("WLSCOMPONENT");
  fMatPropNames.emplace_back("WLSABSLENGTH");
  fMatPropNames.emplace_back("WLSCOMPONENT2");
  fMatPropNames.emplace_back("WLSABSLENGTH2");
  fMatPropNames.emplace_back("ABSLENGTH");
  fMatPropNames.emplace_back("PROTONSCINTILLATIONYIELD");
  fMatPropNames.emplace_back("DEUTERONSCINTILLATIONYIELD");
  fMatPropNames.emplace_back("TRITONSCINTILLATIONYIELD");
  fMatPropNames.emplace_back("ALPHASCINTILLATIONYIELD");
  fMatPropNames.emplace_back("IONSCINTILLATIONYIELD");
  fMatPropNames.emplace_back("ELECTRONSCINTILLATIONYIELD");
  fMatPropNames.emplace_back("SCINTILLATIONCOMPONENT1");
  fMatPropNames.emplace_back("SCINTILLATIONCOMPONENT2");
  fMatPropNames.emplace_back("SCINTILLATIONCOMPONENT3");
  fMatPropNames.emplace_back("COATEDRINDEX");
 
  assert(fMatPropNames.size() == kNumberOfPropertyIndex);
 
  fMP.assign(kNumberOfPropertyIndex, nullptr);
 
  fMatConstPropNames.emplace_back("SURFACEROUGHNESS");
  fMatConstPropNames.emplace_back("ISOTHERMAL_COMPRESSIBILITY");
  fMatConstPropNames.emplace_back("RS_SCALE_FACTOR");
  fMatConstPropNames.emplace_back("WLSMEANNUMBERPHOTONS");
  fMatConstPropNames.emplace_back("WLSTIMECONSTANT");
  fMatConstPropNames.emplace_back("WLSMEANNUMBERPHOTONS2");
  fMatConstPropNames.emplace_back("WLSTIMECONSTANT2");
  fMatConstPropNames.emplace_back("MIEHG_FORWARD");
  fMatConstPropNames.emplace_back("MIEHG_BACKWARD");
  fMatConstPropNames.emplace_back("MIEHG_FORWARD_RATIO");
  fMatConstPropNames.emplace_back("SCINTILLATIONYIELD");
  fMatConstPropNames.emplace_back("RESOLUTIONSCALE");
  fMatConstPropNames.emplace_back("FERMIPOT");
  fMatConstPropNames.emplace_back("DIFFUSION");
  fMatConstPropNames.emplace_back("SPINFLIP");
  fMatConstPropNames.emplace_back("LOSS");
  fMatConstPropNames.emplace_back("LOSSCS");
  fMatConstPropNames.emplace_back("ABSCS");
  fMatConstPropNames.emplace_back("SCATCS");
  fMatConstPropNames.emplace_back("MR_NBTHETA");
  fMatConstPropNames.emplace_back("MR_NBE");
  fMatConstPropNames.emplace_back("MR_RRMS");
  fMatConstPropNames.emplace_back("MR_CORRLEN");
  fMatConstPropNames.emplace_back("MR_THETAMIN");
  fMatConstPropNames.emplace_back("MR_THETAMAX");
  fMatConstPropNames.emplace_back("MR_EMIN");
  fMatConstPropNames.emplace_back("MR_EMAX");
  fMatConstPropNames.emplace_back("MR_ANGNOTHETA");
  fMatConstPropNames.emplace_back("MR_ANGNOPHI");
  fMatConstPropNames.emplace_back("MR_ANGCUT");
  fMatConstPropNames.emplace_back("SCINTILLATIONTIMECONSTANT1");
  fMatConstPropNames.emplace_back("SCINTILLATIONTIMECONSTANT2");
  fMatConstPropNames.emplace_back("SCINTILLATIONTIMECONSTANT3");
  fMatConstPropNames.emplace_back("SCINTILLATIONRISETIME1");
  fMatConstPropNames.emplace_back("SCINTILLATIONRISETIME2");
  fMatConstPropNames.emplace_back("SCINTILLATIONRISETIME3");
  fMatConstPropNames.emplace_back("SCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("SCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("SCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("PROTONSCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("PROTONSCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("PROTONSCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("DEUTERONSCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("DEUTERONSCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("DEUTERONSCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("TRITONSCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("TRITONSCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("TRITONSCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("ALPHASCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("ALPHASCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("ALPHASCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("IONSCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("IONSCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("IONSCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("ELECTRONSCINTILLATIONYIELD1");
  fMatConstPropNames.emplace_back("ELECTRONSCINTILLATIONYIELD2");
  fMatConstPropNames.emplace_back("ELECTRONSCINTILLATIONYIELD3");
  fMatConstPropNames.emplace_back("COATEDTHICKNESS");
  fMatConstPropNames.emplace_back("COATEDFRUSTRATEDTRANSMISSION");
 
  assert(fMatConstPropNames.size() == kNumberOfConstPropertyIndex);
 
  fMCP.assign(kNumberOfConstPropertyIndex, { 0., false });
}

~G4MaterialPropertiesTable()

G4MaterialPropertiesTable::~G4MaterialPropertiesTable ( )

virtual

Definition at line 166 of file G4MaterialPropertiesTable.cc.

{
  for(auto prop : fMP)
  {
    delete(prop);
  }
}

Member Function Documentation

AddConstProperty() [1/2]

void G4MaterialPropertiesTable::AddConstProperty	(	const char *	key,
		G4double	propertyValue,
		G4bool	createNewKey = false
	)

Definition at line 487 of file G4MaterialPropertiesTable.cc.

{
  // Provides a way of adding a constant property to the Material Properties
  // Table given a key
  AddConstProperty(G4String(key), propertyValue, createNewKey);
}

AddConstProperty() [2/2]

void G4MaterialPropertiesTable::AddConstProperty	(	const G4String &	key,
		G4double	propertyValue,
		G4bool	createNewKey = false
	)

Definition at line 458 of file G4MaterialPropertiesTable.cc.

{
  // Provides a way of adding a constant property to the Material Properties
  // Table given a key
  if(std::find(fMatConstPropNames.cbegin(), fMatConstPropNames.cend(), key) ==
     fMatConstPropNames.cend())
  {
    if(createNewKey)
    {
      fMatConstPropNames.push_back(key);
      fMCP.emplace_back(0., true);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Attempting to create a new material constant property key " << key
         << " without setting"
         << " createNewKey parameter of AddProperty to true.";
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat207",
                  FatalException, ed);
    }
  }
  G4int index = GetConstPropertyIndex(key);
 
  fMCP[index] = std::pair<G4double, G4bool>{ propertyValue, true };
}

Referenced by AddConstProperty(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), and G4UCNMaterialPropertiesTable::SetMicroRoughnessParameters().

AddEntry() [1/2]

void G4MaterialPropertiesTable::AddEntry	(	const char *	key,
		G4double	aPhotonEnergy,
		G4double	aPropertyValue
	)

Definition at line 565 of file G4MaterialPropertiesTable.cc.

{
  AddEntry(G4String(key), aPhotonEnergy, aPropertyValue);
}

AddEntry() [2/2]

void G4MaterialPropertiesTable::AddEntry	(	const G4String &	key,
		G4double	aPhotonEnergy,
		G4double	aPropertyValue
	)

Definition at line 522 of file G4MaterialPropertiesTable.cc.

{
  // Allows to add an entry pair directly to the Material Property Vector
  // given a key.
  if(std::find(fMatPropNames.cbegin(), fMatPropNames.cend(), key) ==
     fMatPropNames.cend())
  {
    G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat214",
                FatalException, "Material Property Vector not found.");
  }
  G4int index = GetPropertyIndex(key);
 
  G4MaterialPropertyVector* targetVector = fMP[index];
  if(targetVector != nullptr)
  {
    // do not allow duplicate energies
    for (std::size_t i = 0; i < targetVector->GetVectorLength(); ++i)
    {
      if(aPhotonEnergy == targetVector->Energy(i))
      {
        G4ExceptionDescription ed;
        ed << "Energy values in material property vector must be unique. "
           << "Key: " << key;
        G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat217",
                    FatalException, ed);
      }
    }
 
    targetVector->InsertValues(aPhotonEnergy, aPropertyValue);
  }
  else
  {
    G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat208",
                FatalException, "Material Property Vector not found.");
  }
  if(key == "RINDEX")
  {
    CalculateGROUPVEL();
  }
}

Referenced by AddEntry().

AddProperty() [1/5]

G4MaterialPropertyVector * G4MaterialPropertiesTable::AddProperty	(	const char *	key,
		G4double *	photonEnergies,
		G4double *	propertyValues,
		G4int	numEntries,
		G4bool	createNewKey = false,
		G4bool	spline = false
	)

Definition at line 375 of file G4MaterialPropertiesTable.cc.

{
 
  // Provides a way of adding a property to the Material Properties
  // Table given a pair of arrays and a key
  G4String k(key);
 
  std::vector<G4double> energies(photonEnergies, photonEnergies + numEntries);
  std::vector<G4double> values(propertyValues, propertyValues + numEntries);
  return AddProperty(k, energies, values, createNewKey, spline);
}

AddProperty() [2/5]

void G4MaterialPropertiesTable::AddProperty	(	const char *	key,
		G4MaterialPropertyVector *	opv,
		G4bool	createNewKey = false
	)

Definition at line 442 of file G4MaterialPropertiesTable.cc.

{
  AddProperty(G4String(key), mpv, createNewKey);
}

AddProperty() [3/5]

void G4MaterialPropertiesTable::AddProperty	(	const G4String &	key,
		const G4String &	mat
	)

Definition at line 449 of file G4MaterialPropertiesTable.cc.

{
  // load a material property vector defined in Geant4 source
  G4MaterialPropertyVector* v =
    G4OpticalMaterialProperties::GetProperty(key, mat);
  AddProperty(key, v);
}

AddProperty() [4/5]

G4MaterialPropertyVector * G4MaterialPropertiesTable::AddProperty	(	const G4String &	key,
		const std::vector< G4double > &	photonEnergies,
		const std::vector< G4double > &	propertyValues,
		G4bool	createNewKey = false,
		G4bool	spline = false
	)

Definition at line 309 of file G4MaterialPropertiesTable.cc.

{
  if(photonEnergies.size() != propertyValues.size())
  {
    G4ExceptionDescription ed;
    ed << "AddProperty error!";
    G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat204",
                FatalException, ed);
  }
 
  // G4PhysicsVector assumes energies are in increasing order
  for (std::size_t i = 0; i < photonEnergies.size() - 1; ++i)
  {
    if(photonEnergies.at(i+1) < photonEnergies.at(i))
    {
      G4ExceptionDescription ed;
      ed << "Energies in material property table must be in increasing "
         << "order. Key: " << key << " Energy: " << photonEnergies.at(i+1);
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat215",
                  FatalException, ed);
    }
  }
 
  // if the key doesn't exist, add it if requested
  if(std::find(fMatPropNames.cbegin(), fMatPropNames.cend(), key) ==
     fMatPropNames.cend())
  {
    if(createNewKey)
    {
      fMatPropNames.push_back(key);
      fMP.push_back(nullptr);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Attempting to create a new material property key " << key
         << " without setting\n"
         << "createNewKey parameter of AddProperty to true.";
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat205",
                  FatalException, ed);
    }
  }
 
  auto* mpv =
    new G4MaterialPropertyVector(photonEnergies, propertyValues, spline);
  mpv->SetVerboseLevel(1);
  if(spline)
  {
    mpv->FillSecondDerivatives();
  }
  G4int index = GetPropertyIndex(key);
  fMP[index]  = mpv;
 
  // if key is RINDEX, we calculate GROUPVEL -
  // contribution from Tao Lin (IHEP, the JUNO experiment)
  if(key == "RINDEX")
  {
    CalculateGROUPVEL();
  }
 
  return mpv;
}

Referenced by AddProperty(), G4GDMLReadMaterials::PropertyRead(), and G4GDMLReadSolids::PropertyRead().

AddProperty() [5/5]

void G4MaterialPropertiesTable::AddProperty	(	const G4String &	key,
		G4MaterialPropertyVector *	opv,
		G4bool	createNewKey = false
	)

Definition at line 389 of file G4MaterialPropertiesTable.cc.

{
  //  Provides a way of adding a property to the Material Properties
  //  Table given an G4MaterialPropertyVector Reference and a key
 
  // G4PhysicsVector assumes energies are in increasing order
  // An MPV with size==0 or 1 is also ok
  if (mpv->GetVectorLength() > 1) {
    for (std::size_t i = 0; i < mpv->GetVectorLength() - 1; ++i)
    {
      if(mpv->Energy(i+1) < mpv->Energy(i))
      {
        G4ExceptionDescription ed;
        ed << "Energies in material property vector must be in increasing "
           << "order. Key: " << key << " Energy: " << mpv->Energy(i+1);
        G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat216",
                    FatalException, ed);
      }
    }
  }
 
  // if the key doesn't exist, add it
  if(std::find(fMatPropNames.cbegin(), fMatPropNames.cend(), key) ==
     fMatPropNames.cend())
  {
    if(createNewKey)
    {
      fMatPropNames.push_back(key);
      fMP.push_back(nullptr);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Attempting to create a new material property key " << key
         << " without setting\n"
         << "createNewKey parameter of AddProperty to true.";
      G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat206",
                  FatalException, ed);
    }
  }
  G4int index = GetPropertyIndex(key);
  fMP[index]  = mpv;
 
  // if key is RINDEX, we calculate GROUPVEL -
  // contribution from Tao Lin (IHEP, the JUNO experiment)
  if(key == "RINDEX")
  {
    CalculateGROUPVEL();
  }
}

ConstPropertyExists() [1/3]

G4bool G4MaterialPropertiesTable::ConstPropertyExists

(

const char *

key

)

const

Definition at line 260 of file G4MaterialPropertiesTable.cc.

{
  std::size_t index = std::distance(
    fMatConstPropNames.cbegin(),
    std::find(fMatConstPropNames.cbegin(), fMatConstPropNames.cend(), key));
  if(index < fMatConstPropNames.size())
  {  // index is type std::size_t so >= 0
    return ConstPropertyExists((G4int)index);
  }
  return false;
}

ConstPropertyExists() [2/3]

G4bool G4MaterialPropertiesTable::ConstPropertyExists

(

const G4int

index

)

const

Definition at line 240 of file G4MaterialPropertiesTable.cc.

{
  // Returns true if a const property corresponding to 'index' exists
 
  return index >= 0 && index < (G4int) fMCP.size() && fMCP[index].second;
}

ConstPropertyExists() [3/3]

G4bool G4MaterialPropertiesTable::ConstPropertyExists

(

const G4String &

key

)

const

Definition at line 247 of file G4MaterialPropertiesTable.cc.

{
  // Returns true if a const property 'key' exists
  std::size_t index = std::distance(
    fMatConstPropNames.cbegin(),
    std::find(fMatConstPropNames.cbegin(), fMatConstPropNames.cend(), key));
  if(index < fMatConstPropNames.size())
  {  // index is type std::size_t so >= 0
    return ConstPropertyExists((G4int)index);
  }
  return false;
}

Referenced by ConstPropertyExists(), G4Scintillation::GetScintillationYieldByParticleType(), G4UCNMaterialPropertiesTable::InitMicroRoughnessTables(), G4Scintillation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), and G4UCNMaterialPropertiesTable::SetMicroRoughnessParameters().

DumpTable()

void G4MaterialPropertiesTable::DumpTable

(

)

const

Definition at line 572 of file G4MaterialPropertiesTable.cc.

{
  // material properties
  G4int j = 0;
  for(const auto& prop : fMP)
  {
    if(prop != nullptr)
    {
      G4cout << j << ": " << fMatPropNames[j] << G4endl;
      prop->DumpValues();
    }
    ++j;
  }
  // material constant properties
  j = 0;
  for(const auto& cprop : fMCP)
  {
    if(cprop.second)
    {
      G4cout << j << ": " << fMatConstPropNames[j] << " " << cprop.first
             << G4endl;
    }
    ++j;
  }
}

GetConstProperties()

const std::vector< std::pair< G4double, G4bool > > & G4MaterialPropertiesTable::GetConstProperties ( ) const

inline

Definition at line 159 of file G4MaterialPropertiesTable.hh.

  {
    return fMCP;
  }

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

GetConstProperty() [1/3]

G4double G4MaterialPropertiesTable::GetConstProperty

(

const char *

key

)

const

Definition at line 235 of file G4MaterialPropertiesTable.cc.

{
  return GetConstProperty(GetConstPropertyIndex(G4String(key)));
}

GetConstProperty() [2/3]

G4double G4MaterialPropertiesTable::GetConstProperty

(

const G4int

index

)

const

Definition at line 211 of file G4MaterialPropertiesTable.cc.

{
  // Returns the constant material property corresponding to an index
  // fatal exception if property not found
 
  if(index < (G4int) fMCP.size() && fMCP[index].second)
  {
    return fMCP[index].first;
  }
  G4ExceptionDescription ed;
  ed << "Constant Material Property Index " << index << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetConstProperty()", "mat202",
              FatalException, ed);
  return 0.;
}

GetConstProperty() [3/3]

G4double G4MaterialPropertiesTable::GetConstProperty

(

const G4String &

key

)

const

Definition at line 227 of file G4MaterialPropertiesTable.cc.

{
  // Returns the constant material property corresponding to a key
  // fatal exception if property not found
 
  return GetConstProperty(GetConstPropertyIndex(key));
}

Referenced by G4UCNMaterialPropertiesTable::ComputeMicroRoughnessTables(), GetConstProperty(), G4UCNAbsorption::GetMeanFreePath(), G4UCNLoss::GetMeanFreePath(), G4UCNMultiScattering::GetMeanFreePath(), G4Scintillation::GetScintillationYieldByParticleType(), G4UCNMaterialPropertiesTable::InitMicroRoughnessTables(), G4UCNBoundaryProcess::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpWLS::PostStepDoIt(), and G4OpWLS2::PostStepDoIt().

GetConstPropertyIndex()

G4int G4MaterialPropertiesTable::GetConstPropertyIndex

(

const G4String &

key

)

const

Definition at line 174 of file G4MaterialPropertiesTable.cc.

{
  // Returns the constant material property index corresponding to a key
 
  std::size_t index = std::distance(
    fMatConstPropNames.cbegin(),
    std::find(fMatConstPropNames.cbegin(), fMatConstPropNames.cend(), key));
  if(index < fMatConstPropNames.size())
  {
    return (G4int)index;
  }
 
  G4ExceptionDescription ed;
  ed << "Constant Material Property Index for key " << key << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetConstPropertyIndex()", "mat200",
              FatalException, ed);
  return 0;
}

Referenced by AddConstProperty(), GetConstProperty(), and RemoveConstProperty().

GetMaterialConstPropertyNames()

const std::vector< G4String > & G4MaterialPropertiesTable::GetMaterialConstPropertyNames ( ) const

inline

Definition at line 151 of file G4MaterialPropertiesTable.hh.

  {
    return fMatConstPropNames;
  }

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

GetMaterialPropertyNames()

const std::vector< G4String > & G4MaterialPropertiesTable::GetMaterialPropertyNames ( ) const

inline

Definition at line 147 of file G4MaterialPropertiesTable.hh.

  {
    return fMatPropNames;
  }

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

GetProperties()

const std::vector< G4MaterialPropertyVector * > & G4MaterialPropertiesTable::GetProperties ( ) const

inline

Definition at line 155 of file G4MaterialPropertiesTable.hh.

  {
    return fMP;
  }

Referenced by G4GDMLWriteMaterials::PropertyWrite(), and G4GDMLWriteSolids::PropertyWrite().

GetProperty() [1/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty

(

const char *

key

)

const

Definition at line 285 of file G4MaterialPropertiesTable.cc.

{
  if(std::find(fMatPropNames.cbegin(), fMatPropNames.cend(), key) !=
     fMatPropNames.cend())
  {
    const G4int index = GetPropertyIndex(G4String(key));
    return GetProperty(index);
  }
  return nullptr;
}

Referenced by G4Cerenkov::BuildPhysicsTable(), G4Scintillation::BuildPhysicsTable(), G4OpRayleigh::BuildPhysicsTable(), G4OpWLS::BuildPhysicsTable(), G4OpWLS2::BuildPhysicsTable(), G4Track::CalculateVelocityForOpticalPhoton(), G4OpAbsorption::GetMeanFreePath(), G4OpMieHG::GetMeanFreePath(), G4OpWLS::GetMeanFreePath(), G4OpWLS2::GetMeanFreePath(), GetProperty(), G4Scintillation::GetScintillationYieldByParticleType(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), and G4Cerenkov::PostStepGetPhysicalInteractionLength().

GetProperty() [2/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty

(

const G4int

index

)

const

Definition at line 297 of file G4MaterialPropertiesTable.cc.

{
  // Returns a Material Property Vector corresponding to an index
  // returns nullptr if the property has not been defined by user
  if(index >= 0 && index < (G4int) fMP.size())
  {
    return fMP[index];
  }
  return nullptr;
}

GetProperty() [3/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty

(

const G4String &

key

)

const

Definition at line 272 of file G4MaterialPropertiesTable.cc.

{
  // Returns a Material Property Vector corresponding to a key
  if(std::find(fMatPropNames.cbegin(), fMatPropNames.cend(), key) !=
     fMatPropNames.cend())
  {
    const G4int index = GetPropertyIndex(G4String(key));
    return GetProperty(index);
  }
  return nullptr;
}

GetPropertyIndex()

G4int G4MaterialPropertiesTable::GetPropertyIndex

(

const G4String &

key

)

const

Definition at line 194 of file G4MaterialPropertiesTable.cc.

{
  // Returns the material property index corresponding to a key
  std::size_t index =
    std::distance(fMatPropNames.cbegin(),
                  std::find(fMatPropNames.cbegin(), fMatPropNames.cend(), key));
  if(index < fMatPropNames.size())
  {
    return (G4int)index;
  }
  G4ExceptionDescription ed;
  ed << "Material Property Index for key " << key << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetPropertyIndex()", "mat201",
              FatalException, ed);
  return 0;
}

Referenced by AddEntry(), AddProperty(), GetProperty(), and RemoveProperty().

RemoveConstProperty() [1/2]

void G4MaterialPropertiesTable::RemoveConstProperty

(

const char *

key

)

Definition at line 505 of file G4MaterialPropertiesTable.cc.

{
  RemoveConstProperty(G4String(key));
}

RemoveConstProperty() [2/2]

void G4MaterialPropertiesTable::RemoveConstProperty

(

const G4String &

key

)

Definition at line 496 of file G4MaterialPropertiesTable.cc.

{
  G4int index = GetConstPropertyIndex(key);
  if(index < (G4int) fMCP.size())
  {
    fMCP[index] = std::pair<G4double, G4bool>{ 0., false };
  }
}

Referenced by RemoveConstProperty(), and G4UCNMaterialPropertiesTable::SetMicroRoughnessParameters().

RemoveProperty() [1/2]

void G4MaterialPropertiesTable::RemoveProperty

(

const char *

key

)

Definition at line 517 of file G4MaterialPropertiesTable.cc.

{
  RemoveProperty(G4String(key));
}

RemoveProperty() [2/2]

void G4MaterialPropertiesTable::RemoveProperty

(

const G4String &

key

)

Definition at line 510 of file G4MaterialPropertiesTable.cc.

{
  G4int index = GetPropertyIndex(key);
  delete fMP[index];
  fMP[index] = nullptr;
}

Referenced by RemoveProperty().

---

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

• G4MaterialPropertiesTable.hh
• G4MaterialPropertiesTable.cc