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 59 of file G4MaterialPropertiesTable.hh.

Constructor & Destructor Documentation

G4MaterialPropertiesTable()

G4MaterialPropertiesTable::G4MaterialPropertiesTable

(

)

Definition at line 62 of file G4MaterialPropertiesTable.cc.

{
  // elements of these 2 vectors must be in same order as
  // the corresponding enums in G4MaterialPropertiesIndex.hh
  fMatPropNames.assign(kNumberOfPropertyIndex, "");
  fMatPropNames[kRINDEX] =                    "RINDEX";
  fMatPropNames[kREFLECTIVITY] =              "REFLECTIVITY";
  fMatPropNames[kREALRINDEX] =                "REALRINDEX";
  fMatPropNames[kIMAGINARYRINDEX] =           "IMAGINARYRINDEX";
  fMatPropNames[kEFFICIENCY] =                "EFFICIENCY";
  fMatPropNames[kTRANSMITTANCE] =             "TRANSMITTANCE";
  fMatPropNames[kSPECULARLOBECONSTANT] =      "SPECULARLOBECONSTANT";
  fMatPropNames[kSPECULARSPIKECONSTANT] =     "SPECULARSPIKECONSTANT";
  fMatPropNames[kBACKSCATTERCONSTANT] =       "BACKSCATTERCONSTANT";
  fMatPropNames[kGROUPVEL] =                  "GROUPVEL";
  fMatPropNames[kMIEHG] =                     "MIEHG";
  fMatPropNames[kRAYLEIGH] =                  "RAYLEIGH";
  fMatPropNames[kWLSCOMPONENT] =              "WLSCOMPONENT";
  fMatPropNames[kWLSABSLENGTH] =              "WLSABSLENGTH";
  fMatPropNames[kWLSCOMPONENT2] =             "WLSCOMPONENT2";
  fMatPropNames[kWLSABSLENGTH2] =             "WLSABSLENGTH2";
  fMatPropNames[kABSLENGTH] =                 "ABSLENGTH";
  fMatPropNames[kPROTONSCINTILLATIONYIELD] =  "PROTONSCINTILLATIONYIELD";
  fMatPropNames[kDEUTERONSCINTILLATIONYIELD] ="DEUTERONSCINTILLATIONYIELD";
  fMatPropNames[kTRITONSCINTILLATIONYIELD] =  "TRITONSCINTILLATIONYIELD";
  fMatPropNames[kALPHASCINTILLATIONYIELD] =   "ALPHASCINTILLATIONYIELD";
  fMatPropNames[kIONSCINTILLATIONYIELD] =     "IONSCINTILLATIONYIELD";
  fMatPropNames[kELECTRONSCINTILLATIONYIELD] ="ELECTRONSCINTILLATIONYIELD";
  fMatPropNames[kSCINTILLATIONCOMPONENT1] =   "SCINTILLATIONCOMPONENT1";
  fMatPropNames[kSCINTILLATIONCOMPONENT2] =   "SCINTILLATIONCOMPONENT2";
  fMatPropNames[kSCINTILLATIONCOMPONENT3] =   "SCINTILLATIONCOMPONENT3";
  fMatPropNames[kCOATEDRINDEX] =              "COATEDRINDEX";
 
  fMP.assign(kNumberOfPropertyIndex, nullptr);
 
  fMatConstPropNames.assign(kNumberOfConstPropertyIndex, "");
  fMatConstPropNames[kSURFACEROUGHNESS] =             "SURFACEROUGHNESS";
  fMatConstPropNames[kISOTHERMAL_COMPRESSIBILITY] =   "ISOTHERMAL_COMPRESSIBILITY";
  fMatConstPropNames[kRS_SCALE_FACTOR] =              "RS_SCALE_FACTOR";
  fMatConstPropNames[kWLSMEANNUMBERPHOTONS] =         "WLSMEANNUMBERPHOTONS";
  fMatConstPropNames[kWLSTIMECONSTANT] =              "WLSTIMECONSTANT";
  fMatConstPropNames[kWLSMEANNUMBERPHOTONS2] =        "WLSMEANNUMBERPHOTONS2";
  fMatConstPropNames[kWLSTIMECONSTANT2] =             "WLSTIMECONSTANT2";
  fMatConstPropNames[kMIEHG_FORWARD] =                "MIEHG_FORWARD";
  fMatConstPropNames[kMIEHG_BACKWARD] =               "MIEHG_BACKWARD";
  fMatConstPropNames[kMIEHG_FORWARD_RATIO] =          "MIEHG_FORWARD_RATIO";
  fMatConstPropNames[kSCINTILLATIONYIELD] =           "SCINTILLATIONYIELD";
  fMatConstPropNames[kRESOLUTIONSCALE] =              "RESOLUTIONSCALE";
  fMatConstPropNames[kFERMIPOT] =                     "FERMIPOT";
  fMatConstPropNames[kDIFFUSION] =                    "DIFFUSION";
  fMatConstPropNames[kSPINFLIP] =                     "SPINFLIP";
  fMatConstPropNames[kLOSS] =                         "LOSS";
  fMatConstPropNames[kLOSSCS] =                       "LOSSCS";
  fMatConstPropNames[kABSCS] =                        "ABSCS";
  fMatConstPropNames[kSCATCS] =                       "SCATCS";
  fMatConstPropNames[kMR_NBTHETA] =                   "MR_NBTHETA";
  fMatConstPropNames[kMR_NBE] =                       "MR_NBE";
  fMatConstPropNames[kMR_RRMS] =                      "MR_RRMS";
  fMatConstPropNames[kMR_CORRLEN] =                   "MR_CORRLEN";
  fMatConstPropNames[kMR_THETAMIN] =                  "MR_THETAMIN";
  fMatConstPropNames[kMR_THETAMAX] =                  "MR_THETAMAX";
  fMatConstPropNames[kMR_EMIN] =                      "MR_EMIN";
  fMatConstPropNames[kMR_EMAX] =                      "MR_EMAX";
  fMatConstPropNames[kMR_ANGNOTHETA] =                "MR_ANGNOTHETA";
  fMatConstPropNames[kMR_ANGNOPHI] =                  "MR_ANGNOPHI";
  fMatConstPropNames[kMR_ANGCUT] =                    "MR_ANGCUT";
  fMatConstPropNames[kSCINTILLATIONTIMECONSTANT1] =   "SCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kSCINTILLATIONTIMECONSTANT2] =   "SCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kSCINTILLATIONTIMECONSTANT3] =   "SCINTILLATIONTIMECONSTANT3";
  fMatConstPropNames[kSCINTILLATIONRISETIME1] =       "SCINTILLATIONRISETIME1";
  fMatConstPropNames[kSCINTILLATIONRISETIME2] =       "SCINTILLATIONRISETIME2";
  fMatConstPropNames[kSCINTILLATIONRISETIME3] =       "SCINTILLATIONRISETIME3";
  fMatConstPropNames[kSCINTILLATIONYIELD1] =          "SCINTILLATIONYIELD1";
  fMatConstPropNames[kSCINTILLATIONYIELD2] =          "SCINTILLATIONYIELD2";
  fMatConstPropNames[kSCINTILLATIONYIELD3] =          "SCINTILLATIONYIELD3";
  fMatConstPropNames[kPROTONSCINTILLATIONYIELD1] =    "PROTONSCINTILLATIONYIELD1";
  fMatConstPropNames[kPROTONSCINTILLATIONYIELD2] =    "PROTONSCINTILLATIONYIELD2";
  fMatConstPropNames[kPROTONSCINTILLATIONYIELD3] =    "PROTONSCINTILLATIONYIELD3";
  fMatConstPropNames[kDEUTERONSCINTILLATIONYIELD1] =  "DEUTERONSCINTILLATIONYIELD1";
  fMatConstPropNames[kDEUTERONSCINTILLATIONYIELD2] =  "DEUTERONSCINTILLATIONYIELD2";
  fMatConstPropNames[kDEUTERONSCINTILLATIONYIELD3] =  "DEUTERONSCINTILLATIONYIELD3";
  fMatConstPropNames[kTRITONSCINTILLATIONYIELD1] =    "TRITONSCINTILLATIONYIELD1";
  fMatConstPropNames[kTRITONSCINTILLATIONYIELD2] =    "TRITONSCINTILLATIONYIELD2";
  fMatConstPropNames[kTRITONSCINTILLATIONYIELD3] =    "TRITONSCINTILLATIONYIELD3";
  fMatConstPropNames[kALPHASCINTILLATIONYIELD1] =     "ALPHASCINTILLATIONYIELD1";
  fMatConstPropNames[kALPHASCINTILLATIONYIELD2] =     "ALPHASCINTILLATIONYIELD2";
  fMatConstPropNames[kALPHASCINTILLATIONYIELD3] =     "ALPHASCINTILLATIONYIELD3";
  fMatConstPropNames[kIONSCINTILLATIONYIELD1] =       "IONSCINTILLATIONYIELD1";
  fMatConstPropNames[kIONSCINTILLATIONYIELD2] =       "IONSCINTILLATIONYIELD2";
  fMatConstPropNames[kIONSCINTILLATIONYIELD3] =       "IONSCINTILLATIONYIELD3";
  fMatConstPropNames[kELECTRONSCINTILLATIONYIELD1] =  "ELECTRONSCINTILLATIONYIELD1";
  fMatConstPropNames[kELECTRONSCINTILLATIONYIELD2] =  "ELECTRONSCINTILLATIONYIELD2";
  fMatConstPropNames[kELECTRONSCINTILLATIONYIELD3] =  "ELECTRONSCINTILLATIONYIELD3";
  fMatConstPropNames[kCOATEDTHICKNESS] =              "COATEDTHICKNESS";
  fMatConstPropNames[kCOATEDFRUSTRATEDTRANSMISSION] = "COATEDFRUSTRATEDTRANSMISSION";
  fMatConstPropNames[kPROTONSCINTILLATIONTIMECONSTANT1] =   "PROTONSCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kPROTONSCINTILLATIONTIMECONSTANT2] =   "PROTONSCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kPROTONSCINTILLATIONTIMECONSTANT3] =   "PROTONSCINTILLATIONTIMECONSTANT3";
  fMatConstPropNames[kDEUTERONSCINTILLATIONTIMECONSTANT1] = "DEUTERONSCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kDEUTERONSCINTILLATIONTIMECONSTANT2] = "DEUTERONSCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kDEUTERONSCINTILLATIONTIMECONSTANT3] = "DEUTERONSCINTILLATIONTIMECONSTANT3";
  fMatConstPropNames[kTRITONSCINTILLATIONTIMECONSTANT1] =   "TRITONSCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kTRITONSCINTILLATIONTIMECONSTANT2] =   "TRITONSCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kTRITONSCINTILLATIONTIMECONSTANT3] =   "TRITONSCINTILLATIONTIMECONSTANT3";
  fMatConstPropNames[kALPHASCINTILLATIONTIMECONSTANT1] =    "ALPHASCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kALPHASCINTILLATIONTIMECONSTANT2] =    "ALPHASCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kALPHASCINTILLATIONTIMECONSTANT3] =    "ALPHASCINTILLATIONTIMECONSTANT3";
  fMatConstPropNames[kIONSCINTILLATIONTIMECONSTANT1] =      "IONSCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kIONSCINTILLATIONTIMECONSTANT2] =      "IONSCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kIONSCINTILLATIONTIMECONSTANT3] =      "IONSCINTILLATIONTIMECONSTANT3";
  fMatConstPropNames[kELECTRONSCINTILLATIONTIMECONSTANT1] = "ELECTRONSCINTILLATIONTIMECONSTANT1";
  fMatConstPropNames[kELECTRONSCINTILLATIONTIMECONSTANT2] = "ELECTRONSCINTILLATIONTIMECONSTANT2";
  fMatConstPropNames[kELECTRONSCINTILLATIONTIMECONSTANT3] = "ELECTRONSCINTILLATIONTIMECONSTANT3";
  fMCP.assign(kNumberOfConstPropertyIndex, {0., false});
}

~G4MaterialPropertiesTable()

G4MaterialPropertiesTable::~G4MaterialPropertiesTable ( )

virtual

Definition at line 178 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 459 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 434 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\n"
         << "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 525 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 489 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()) {
    G4ExceptionDescription ed;
    ed << "Material Property Vector " << key << " not found.";
    G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat214", FatalException, ed);
  }
  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 {
    G4ExceptionDescription ed;
    ed << "Material Property Vector " << key << " not found.";
    G4Exception("G4MaterialPropertiesTable::AddEntry()", "mat208", FatalException, ed);
  }
  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 359 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 421 of file G4MaterialPropertiesTable.cc.

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

AddProperty() [3/5]

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

Definition at line 427 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 299 of file G4MaterialPropertiesTable.cc.

{
  if (photonEnergies.size() != propertyValues.size()) {
    G4ExceptionDescription ed;
    ed << "AddProperty error. Number of property values must be equal to the number of\n"
       << "energy values. Property name: " << key;
    G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat204", FatalException, ed);
  }
 
  if (photonEnergies.size() == 1) {
    G4ExceptionDescription ed;
    ed << "AddProperty warning. A material property vector must have more than one value.\n"
       << "Unless you will later add an entry, this is an error.\n"
       << "Property name: " << key;
    G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat218", JustWarning, 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 vector 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 vector " << 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(), AddProperty(), AddProperty(), G4GDMLReadMaterials::PropertyRead(), G4GDMLReadSolids::PropertyRead(), and G4XrayReflection::SaveHenkeDataAsMaterialProperty().

AddProperty() [5/5]

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

Definition at line 372 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
  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 (mpv->GetVectorLength() <= 1) {
    G4ExceptionDescription ed;
    ed << "AddProperty warning. A material property vector must have more than one value.\n"
       << "Unless you will later add an entry, this is an error.\n"
       << "Property name: " << key;
    G4Exception("G4MaterialPropertiesTable::AddProperty()", "mat219", JustWarning, 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 242 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 249 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(), ConstPropertyExists(), G4Scintillation::GetScintillationYieldByParticleType(), G4UCNMaterialPropertiesTable::InitMicroRoughnessTables(), G4OpBoundaryProcess::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4Scintillation::PostStepDoIt(), and G4UCNMaterialPropertiesTable::SetMicroRoughnessParameters().

DumpTable()

void G4MaterialPropertiesTable::DumpTable

(

)

const

Definition at line 531 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 141 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 237 of file G4MaterialPropertiesTable.cc.

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

GetConstProperty() [2/3]

G4double G4MaterialPropertiesTable::GetConstProperty

(

const G4int

index

)

const

Definition at line 215 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 " << fMatConstPropNames[index] << " not found.";
  G4Exception("G4MaterialPropertiesTable::GetConstProperty()", "mat202", FatalException, ed);
  return 0.;
}

GetConstProperty() [3/3]

G4double G4MaterialPropertiesTable::GetConstProperty

(

const G4String &

key

)

const

Definition at line 229 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(), GetConstProperty(), G4UCNAbsorption::GetMeanFreePath(), G4UCNLoss::GetMeanFreePath(), G4UCNMultiScattering::GetMeanFreePath(), G4Scintillation::GetScintillationYieldByParticleType(), G4UCNMaterialPropertiesTable::InitMicroRoughnessTables(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4Scintillation::PostStepDoIt(), and G4UCNBoundaryProcess::PostStepDoIt().

GetConstPropertyIndex()

G4int G4MaterialPropertiesTable::GetConstPropertyIndex

(

const G4String &

key

)

const

Definition at line 185 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(), GetConstProperty(), and RemoveConstProperty().

GetMaterialConstPropertyNames()

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

inline

Definition at line 138 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 137 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 140 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 280 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(), G4OpRayleigh::BuildPhysicsTable(), G4OpWLS2::BuildPhysicsTable(), G4OpWLS::BuildPhysicsTable(), G4Scintillation::BuildPhysicsTable(), G4Track::CalculateVelocityForOpticalPhoton(), G4OpAbsorption::GetMeanFreePath(), G4OpMieHG::GetMeanFreePath(), G4OpWLS2::GetMeanFreePath(), G4OpWLS::GetMeanFreePath(), GetProperty(), GetProperty(), G4Scintillation::GetScintillationYieldByParticleType(), G4Cerenkov::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), and G4XrayReflection::Reflectivity().

GetProperty() [2/3]

G4MaterialPropertyVector * G4MaterialPropertiesTable::GetProperty

(

const G4int

index

)

const

Definition at line 289 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 270 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 201 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(), AddProperty(), GetProperty(), GetProperty(), and RemoveProperty().

RemoveConstProperty() [1/2]

void G4MaterialPropertiesTable::RemoveConstProperty

(

const char *

key

)

Definition at line 475 of file G4MaterialPropertiesTable.cc.

{
  RemoveConstProperty(G4String(key));
}

RemoveConstProperty() [2/2]

void G4MaterialPropertiesTable::RemoveConstProperty

(

const G4String &

key

)

Definition at line 467 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 487 of file G4MaterialPropertiesTable.cc.

{ RemoveProperty(G4String(key)); }

RemoveProperty() [2/2]

void G4MaterialPropertiesTable::RemoveProperty

(

const G4String &

key

)

Definition at line 480 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