G4DNAMolecularMaterial builds tables of molecular densities for chosen molecular materials. The class handles homogeneous, composite and derived materials. A material of interest is labeled as molecular if built using the number of atoms rather than the mass fractions. More...

#include <G4DNAMolecularMaterial.hh>

Inheritance diagram for G4DNAMolecularMaterial:

Public Member Functions
void	Initialize ()

void	Clear ()

virtual G4bool	Notify (G4ApplicationState requestedState)

const std::vector< G4double > *	GetDensityTableFor (const G4Material *) const
	Retrieve a table of volumetric mass densities (mass per unit volume) in the G4 unit system for chosen material.

const std::vector< G4double > *	GetNumMolPerVolTableFor (const G4Material *) const
	Retrieve a table of molecular densities (number of molecules per unit volume) in the G4 unit system for chosen material.

const std::vector< ComponentMap > *	GetMassFractionTable () const

const std::vector< ComponentMap > *	GetDensityTable () const

G4MolecularConfiguration *	GetMolecularConfiguration (const G4Material *) const

void	SetMolecularConfiguration (const G4Material , G4MolecularConfiguration )
	Associate a molecular configuration to a G4material.

void	SetMolecularConfiguration (const G4Material *, const G4String &)
	Associate a molecular configuration to a G4material.

void	SetMolecularConfiguration (const G4String &materialName, const G4String &molUserIF)

G4double	GetNumMoleculePerVolumeUnitForMaterial (const G4Material *mat)
	Deprecated.

G4double	GetNumMolPerVolForComponentInComposite (const G4Material composite, const G4Material component, G4double massFraction)
	Deprecated.

Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)

virtual	~G4VStateDependent ()

G4bool	operator== (const G4VStateDependent &right) const

G4bool	operator!= (const G4VStateDependent &right) const

virtual G4bool	Notify (G4ApplicationState requestedState)=0

Static Public Member Functions
static G4DNAMolecularMaterial *	Instance ()

Protected Member Functions
	G4DNAMolecularMaterial ()

	G4DNAMolecularMaterial (const G4DNAMolecularMaterial &right)

G4DNAMolecularMaterial &	operator= (const G4DNAMolecularMaterial &)

virtual	~G4DNAMolecularMaterial ()

void	Create ()

void	InitializeNumMolPerVol ()

void	InitializeDensity ()

void	RecordMolecularMaterial (G4Material parentMaterial, G4Material molecularMaterial, G4double fraction)

void	SearchMolecularMaterial (G4Material parentMaterial, G4Material material, G4double currentFraction)

void	AddMaterial (const G4Material *, G4double fraction)

void	PrintNotAMolecularMaterial (const char methodName, const G4Material lookForMaterial) const

Protected Attributes
std::vector< ComponentMap > *	fpCompFractionTable

std::vector< ComponentMap > *	fpCompDensityTable

std::vector< ComponentMap > *	fpCompNumMolPerVolTable

std::map< const G4Material , std::vector< G4double > , CompareMaterial >	fAskedDensityTable

std::map< const G4Material , std::vector< G4double > , CompareMaterial >	fAskedNumPerVolTable

std::map< const G4Material *, bool, CompareMaterial >	fWarningPrinted

std::map< int, G4MolecularConfiguration * >	fMaterialToMolecularConf

G4bool	fIsInitialized

size_t	fNMaterials

Static Protected Attributes
static G4DNAMolecularMaterial *	fInstance

Detailed Description

G4DNAMolecularMaterial builds tables of molecular densities for chosen molecular materials. The class handles homogeneous, composite and derived materials. A material of interest is labeled as molecular if built using the number of atoms rather than the mass fractions.

Initialization: G4DNAMolecularMaterial is initialized when G4ApplicationState == G4State_Idle. It should be initialized on the master thread and used in read-only mode during stepping. The singleton is thread-shared.
For Developers: Use GetNumMolPerVolTableFor(molecule) in the concrete implementation of G4VEmModel::Initialise or G4VProcess::PreparePhysicsTable at run initialization to retrieve a read-only, thread-safe, table. The table is then built on the master thread at initialization time and shared between all threads and models.

Note: A G4material is labeled as molecular if built using the number of atoms

Definition at line 95 of file G4DNAMolecularMaterial.hh.

Constructor & Destructor Documentation

◆ G4DNAMolecularMaterial() [1/2]

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( )

protected

Definition at line 139 of file G4DNAMolecularMaterial.cc.

                                               :
    G4VStateDependent()
{
  Create();
}

Referenced by Instance().

◆ G4DNAMolecularMaterial() [2/2]

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( const G4DNAMolecularMaterial & right )

protected

Definition at line 158 of file G4DNAMolecularMaterial.cc.

                                     :
    G4VStateDependent()
{
  Create();
}

◆ ~G4DNAMolecularMaterial()

G4DNAMolecularMaterial::~G4DNAMolecularMaterial ( )

protectedvirtual

Definition at line 177 of file G4DNAMolecularMaterial.cc.

{
  Clear();
}

Member Function Documentation

◆ AddMaterial()

void G4DNAMolecularMaterial::AddMaterial	(	const G4Material *	,
		G4double	fraction
	)

protected

◆ Clear()

void G4DNAMolecularMaterial::Clear ( )

Definition at line 99 of file G4DNAMolecularMaterial.cc.

{
  G4AutoLock l2(&aMutex);
  if (fpCompFractionTable != nullptr){
    fpCompFractionTable->clear();
    delete fpCompFractionTable;
    fpCompFractionTable = nullptr;
  }
  if (fpCompDensityTable != nullptr){
    fpCompDensityTable->clear();
    delete fpCompDensityTable;
    fpCompDensityTable = nullptr;
  }
  if (fpCompNumMolPerVolTable != nullptr){
    fpCompNumMolPerVolTable->clear();
    delete fpCompNumMolPerVolTable;
    fpCompNumMolPerVolTable = nullptr;
  }
 
  std::map<const G4Material*, std::vector<G4double>*, CompareMaterial>::iterator it;
 
  for (it = fAskedDensityTable.begin(); it != fAskedDensityTable.end(); ++it){
    if (it->second != nullptr){
      delete it->second;
      it->second = nullptr;
    }
  }
 
  for (it = fAskedNumPerVolTable.begin(); it != fAskedNumPerVolTable.end(); ++it){
    if (it->second != nullptr){
      delete it->second;
      it->second = nullptr;
    }
  }
  l2.unlock();
}

Referenced by ~G4DNAMolecularMaterial().

◆ Create()

void G4DNAMolecularMaterial::Create ( )

protected

Definition at line 88 of file G4DNAMolecularMaterial.cc.

{
  fpCompFractionTable = nullptr;
  fpCompDensityTable = nullptr;
  fpCompNumMolPerVolTable = nullptr;
  fIsInitialized = false;
  fNMaterials = 0;
}

Referenced by G4DNAMolecularMaterial(), and operator=().

◆ GetDensityTable()

const std::vector< ComponentMap > * G4DNAMolecularMaterial::GetDensityTable ( ) const

inline

Definition at line 144 of file G4DNAMolecularMaterial.hh.

                                                               {
    return fpCompDensityTable;
  }

◆ GetDensityTableFor()

const std::vector< G4double > * G4DNAMolecularMaterial::GetDensityTableFor ( const G4Material * searchedMaterial ) const

Retrieve a table of volumetric mass densities (mass per unit volume) in the G4 unit system for chosen material.

Parameters

[in] searchedMaterial The material which you'd like to retrieve the volumic mass

Precondition: The searchedMaterial used in parameter must be built as a molecular material, using the number of atoms rather than the density fractions.

Returns: Pointer to a table of molecular densities for the searchedMaterial indexed on the (parent) material index.

Definition at line 348 of file G4DNAMolecularMaterial.cc.

{
  if (!fpCompDensityTable){
    if (fIsInitialized){
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "The pointer fpCompDensityTable is not initialized will the "
          "singleton of G4DNAMolecularMaterial "
          << "has already been initialized." << G4endl;
      G4Exception("G4DNAMolecularMaterial::GetDensityTableFor",
                  "G4DNAMolecularMaterial003", FatalException,
                  exceptionDescription);
    }
 
    if (G4StateManager::GetStateManager()->GetCurrentState() == G4State_Init){
      const_cast<G4DNAMolecularMaterial*>(this)->Initialize();
    }
    else{
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "The geant4 application is at the wrong state. State must be: "
          "G4State_Init."
          << G4endl;
      G4Exception("G4DNAMolecularMaterial::GetDensityTableFor",
                  "G4DNAMolecularMaterial_WRONG_STATE_APPLICATION",
                  FatalException, exceptionDescription);
    }
  }
 
  auto it_askedDensityTable = fAskedDensityTable.find(lookForMaterial);
 
  if (it_askedDensityTable != fAskedDensityTable.cend()){
    return it_askedDensityTable->second;
  }
 
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
 
  std::vector<G4double>* output = new std::vector<G4double>(materialTable->size());
 
  ComponentMap::const_iterator it;
 
  G4bool materialWasNotFound = true;
 
  for (std::size_t i = 0; i < fNMaterials; ++i){
    ComponentMap& densityTable = (*fpCompDensityTable)[i];
 
    it = densityTable.find(lookForMaterial);
 
    if (it == densityTable.cend()){
      (*output)[i] = 0.0;
    }
    else{
      materialWasNotFound = false;
      (*output)[i] = it->second;
    }
  }
 
  if (materialWasNotFound){
    PrintNotAMolecularMaterial("G4DNAMolecularMaterial::GetDensityTableFor",
                               lookForMaterial);
  }
 
  fAskedDensityTable.insert(make_pair(lookForMaterial, output));
 
  return output;
}

◆ GetMassFractionTable()

const std::vector< ComponentMap > * G4DNAMolecularMaterial::GetMassFractionTable ( ) const

inline

Definition at line 141 of file G4DNAMolecularMaterial.hh.

                                                                    {
    return fpCompFractionTable;
  }

◆ GetMolecularConfiguration()

G4MolecularConfiguration * G4DNAMolecularMaterial::GetMolecularConfiguration ( const G4Material * material ) const

Definition at line 522 of file G4DNAMolecularMaterial.cc.

{
  int material_id = material->GetIndex();
  auto it = fMaterialToMolecularConf.find(material_id);
  if(it == fMaterialToMolecularConf.cend()) return nullptr;
  return it->second;
}

◆ GetNumMoleculePerVolumeUnitForMaterial()

G4double G4DNAMolecularMaterial::GetNumMoleculePerVolumeUnitForMaterial ( const G4Material * mat )

Deprecated.

Deprecated:: Will return a G4 fatal exception. Use instead GetNumMolPerVolTableFor(molecule) at run initialization to retrieve a read-only, thread-safe, table.

Note: A G4material is labeled as molecular if built using the number of atoms.

Definition at line 575 of file G4DNAMolecularMaterial.cc.

{
  G4Exception("G4DNAMolecularMaterial::GetNumMolPerVolForComponentInComposite",
              "DEPRECATED",
              FatalException,"Use standard method: GetNumMolPerVolTableFor"
              " at the run initialization to retrieve a read-only table used"
              " during stepping. The method is thread-safe.");
  return 0.;
}

◆ GetNumMolPerVolForComponentInComposite()

G4double G4DNAMolecularMaterial::GetNumMolPerVolForComponentInComposite	(	const G4Material *	composite,
		const G4Material *	component,
		G4double	massFraction
	)

Deprecated.

Deprecated:: Will return a G4 fatal exception. Use instead GetNumMolPerVolTableFor(molecule) at run initialization to retrieve a read-only, thread-safe, table.

Note: A G4material is labeled as molecular if built using the number of atoms.

Definition at line 589 of file G4DNAMolecularMaterial.cc.

{
  G4Exception("G4DNAMolecularMaterial::GetNumMolPerVolForComponentInComposite",
               "DEPRECATED",
               FatalException,"Use standard method: GetNumMolPerVolTableFor"
              " at the run initialization to retrieve a read-only table used"
              " during stepping. The method is thread-safe.");
  return 0.;
}

◆ GetNumMolPerVolTableFor()

const std::vector< G4double > * G4DNAMolecularMaterial::GetNumMolPerVolTableFor ( const G4Material * searchedMaterial ) const

Retrieve a table of molecular densities (number of molecules per unit volume) in the G4 unit system for chosen material.

Parameters

[in] searchedMaterial The material which you'd like to retrieve the molecular density

Precondition: The searchedMaterial used in parameter must be built as a molecular material, using the number of atoms rather than the density fractions.

Returns: Pointer to a table of molecular densities for the searchedMaterial indexed on the (parent) material index.

Definition at line 418 of file G4DNAMolecularMaterial.cc.

{
  if(lookForMaterial==nullptr) return nullptr;
 
  if (!fpCompNumMolPerVolTable){
    if (fIsInitialized){
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "The pointer fpCompNumMolPerVolTable is not initialized whereas "
          "the singleton of G4DNAMolecularMaterial "
          << "has already been initialized." << G4endl;
      G4Exception("G4DNAMolecularMaterial::GetNumMolPerVolTableFor",
                  "G4DNAMolecularMaterial005", FatalException,
                  exceptionDescription);
    }
 
    if (G4StateManager::GetStateManager()->GetCurrentState() == G4State_Init){
      const_cast<G4DNAMolecularMaterial*>(this)->Initialize();
    }
    else{
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "The geant4 application is at the wrong state. State must be : "
          "G4State_Init."
          << G4endl;
      G4Exception("G4DNAMolecularMaterial::GetNumMolPerVolTableFor",
                  "G4DNAMolecularMaterial_WRONG_STATE_APPLICATION",
                  FatalException, exceptionDescription);
    }
  }
 
  auto it_askedNumMolPerVolTable = fAskedNumPerVolTable.find(lookForMaterial);
  if (it_askedNumMolPerVolTable != fAskedNumPerVolTable.cend()){
    return it_askedNumMolPerVolTable->second;
  }
 
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
 
  std::vector<G4double>* output = new std::vector<G4double>(materialTable->size());
 
  ComponentMap::const_iterator it;
 
  G4bool materialWasNotFound = true;
 
  for (std::size_t i = 0; i < fNMaterials; ++i){
    ComponentMap& densityTable = (*fpCompNumMolPerVolTable)[i];
 
    it = densityTable.find(lookForMaterial);
 
    if (it == densityTable.cend()){
      (*output)[i] = 0.0;
    }
    else{
      materialWasNotFound = false;
      (*output)[i] = it->second;
    }
  }
 
  if (materialWasNotFound){
    PrintNotAMolecularMaterial(
        "G4DNAMolecularMaterial::GetNumMolPerVolTableFor", lookForMaterial);
  }
 
  fAskedNumPerVolTable.insert(make_pair(lookForMaterial, output));
 
  return output;
}

◆ Initialize()

void G4DNAMolecularMaterial::Initialize ( )

Definition at line 184 of file G4DNAMolecularMaterial.cc.

{
  if (fIsInitialized){
    return;
  }
 
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
 
  fNMaterials = materialTable->size();
  // This is to prevent segment fault if materials are created later on
  // Actually this creation should not be done
 
  G4AutoLock l1(&aMutex);
  if (fpCompFractionTable == nullptr){
    fpCompFractionTable = new vector<ComponentMap>(materialTable->size());
  }
 
  G4Material* mat(nullptr);
 
  for (std::size_t i = 0; i < fNMaterials; ++i){
    mat = materialTable->at(i);
    SearchMolecularMaterial(mat, mat, 1);
  }
 
  InitializeDensity();
  InitializeNumMolPerVol();
  l1.unlock();
 
  fIsInitialized = true;
}

Referenced by GetDensityTableFor(), GetNumMolPerVolTableFor(), G4DNAChampionElasticModel::Initialise(), G4DNAELSEPAElasticModel::Initialise(), G4DNAIonElasticModel::Initialise(), and Notify().

◆ InitializeDensity()

void G4DNAMolecularMaterial::InitializeDensity ( )

protected

Definition at line 217 of file G4DNAMolecularMaterial.cc.

{
  if (fpCompFractionTable){
    const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
    fpCompDensityTable = new vector<ComponentMap>(
        G4Material::GetMaterialTable()->size());
 
    G4Material* parentMat;
    const G4Material* compMat(nullptr);
    G4double massFraction = -1;
    G4double parentDensity = -1;
 
    for (std::size_t i = 0; i < fNMaterials; ++i){
      parentMat = materialTable->at(i);
      ComponentMap& massFractionComp = (*fpCompFractionTable)[i];
      ComponentMap& densityComp = (*fpCompDensityTable)[i];
 
      parentDensity = parentMat->GetDensity();
 
      for (auto it = massFractionComp.cbegin();
          it != massFractionComp.cend(); ++it){
        compMat = it->first;
        massFraction = it->second;
        densityComp[compMat] = massFraction * parentDensity;
        compMat = nullptr;
        massFraction = -1;
      }
    }
  }
  else{
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "The pointer fpCompFractionTable is not initialized"
                         << G4endl;
    G4Exception("G4DNAMolecularMaterial::InitializeDensity",
                "G4DNAMolecularMaterial001", FatalException,
                exceptionDescription);
  }
}

Referenced by Initialize().

◆ InitializeNumMolPerVol()

void G4DNAMolecularMaterial::InitializeNumMolPerVol ( )

protected

Definition at line 258 of file G4DNAMolecularMaterial.cc.

{
  if (fpCompDensityTable){
    fpCompNumMolPerVolTable = new vector<ComponentMap>(fNMaterials);
 
    const G4Material* compMat(nullptr);
 
    for (std::size_t i = 0; i < fNMaterials; ++i){
      ComponentMap& massFractionComp = (*fpCompFractionTable)[i];
      ComponentMap& densityComp = (*fpCompDensityTable)[i];
      ComponentMap& numMolPerVol = (*fpCompNumMolPerVolTable)[i];
 
      for (auto it = massFractionComp.cbegin();
          it != massFractionComp.cend(); ++it){
        compMat = it->first;
        numMolPerVol[compMat] = densityComp[compMat]
            / compMat->GetMassOfMolecule();
        compMat = nullptr;
      }
    }
  }
  else{
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "The pointer fpCompDensityTable is not initialized"
                         << G4endl;
    G4Exception("G4DNAMolecularMaterial::InitializeNumMolPerVol",
                "G4DNAMolecularMaterial002", FatalException,
                exceptionDescription);
  }
}

Referenced by Initialize().

◆ Instance()

G4DNAMolecularMaterial * G4DNAMolecularMaterial::Instance ( )

static

Definition at line 80 of file G4DNAMolecularMaterial.cc.

{
  if (!fInstance) fInstance = new G4DNAMolecularMaterial();
  return fInstance;
}

◆ Notify()

G4bool G4DNAMolecularMaterial::Notify ( G4ApplicationState requestedState )

virtual

Implements G4VStateDependent.

Definition at line 147 of file G4DNAMolecularMaterial.cc.

{
  if (requestedState == G4State_Idle && G4StateManager::GetStateManager()
      ->GetPreviousState() == G4State_PreInit){
    Initialize();
  }
  return true;
}

◆ operator=()

G4DNAMolecularMaterial & G4DNAMolecularMaterial::operator= ( const G4DNAMolecularMaterial & rhs )

protected

Definition at line 168 of file G4DNAMolecularMaterial.cc.

{
  if (this == &rhs) return *this;
  Create();
  return *this;
}

◆ PrintNotAMolecularMaterial()

void G4DNAMolecularMaterial::PrintNotAMolecularMaterial	(	const char *	methodName,
		const G4Material *	lookForMaterial
	)		const

protected

Definition at line 489 of file G4DNAMolecularMaterial.cc.

{
  auto it = fWarningPrinted.find(lookForMaterial);
 
  if (it == fWarningPrinted.cend()){
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "The material " << lookForMaterial->GetName()
                         << " is not defined as a molecular material."
                         << G4endl
                         << "Meaning: The elements should be added to the "
                         "material using atom count rather than mass fraction "
                         "(cf. G4Material)"
    << G4endl
    << "If you want to use DNA processes on liquid water, you should better use "
    "the NistManager to create the water material."
    << G4endl
    << "Since this message is displayed, it means that the DNA models will not "
    "be called."
    << "Please note that this message will only appear once even if you are "
    "using other methods of G4DNAMolecularMaterial."
    << G4endl;
 
    G4Exception(methodName, "MATERIAL_NOT_DEFINE_USING_ATOM_COUNT", JustWarning,
                exceptionDescription);
    fWarningPrinted[lookForMaterial] = true;
  }
}

Referenced by GetDensityTableFor(), and GetNumMolPerVolTableFor().

◆ RecordMolecularMaterial()

void G4DNAMolecularMaterial::RecordMolecularMaterial	(	G4Material *	parentMaterial,
		G4Material *	molecularMaterial,
		G4double	fraction
	)

protected

Definition at line 292 of file G4DNAMolecularMaterial.cc.

{
  ComponentMap& matComponent =
      (*fpCompFractionTable)[parentMaterial->GetIndex()];
 
  if (matComponent.empty()){
    matComponent[molecularMaterial] = fraction;
    return;
  }
 
  auto it = matComponent.find(molecularMaterial);
 
  if (it == matComponent.cend()){
    matComponent[molecularMaterial] = fraction;
  }
  else{
    matComponent[molecularMaterial] = it->second + fraction;
    // handle "base material"
  }
}

Referenced by SearchMolecularMaterial().

◆ SearchMolecularMaterial()

void G4DNAMolecularMaterial::SearchMolecularMaterial	(	G4Material *	parentMaterial,
		G4Material *	material,
		G4double	currentFraction
	)

protected

Definition at line 317 of file G4DNAMolecularMaterial.cc.

{
  if (material->GetMassOfMolecule() != 0.0){ // is a molecular material
    RecordMolecularMaterial(parentMaterial, material, currentFraction);
    return;
  }
 
  G4Material* compMat(nullptr);
  G4double fraction = -1.;
  std::map<G4Material*, G4double> matComponent = material->GetMatComponents();
  auto it = matComponent.cbegin();
 
  for (; it != matComponent.cend(); ++it){
    compMat = it->first;
    fraction = it->second;
    if (compMat->GetMassOfMolecule() == 0.0){ // is not a molecular material
      SearchMolecularMaterial(parentMaterial, compMat,
                              currentFraction * fraction);
    }
    else{ // is a molecular material
      RecordMolecularMaterial(parentMaterial, compMat,
                              currentFraction * fraction);
    }
  }
}

Referenced by Initialize(), and SearchMolecularMaterial().

◆ SetMolecularConfiguration() [1/3]

void G4DNAMolecularMaterial::SetMolecularConfiguration	(	const G4Material *	material,
		const G4String &	molConf
	)

Associate a molecular configuration to a G4material.

Parameters

[in]	material	Pointer to a G4 material. The material does not need to be defined as a molecular material.
[in]	molConf	User ID of the molecular configuration corresponding to the G4 `material`.

Parameters

[in]	material	Name of the G4 material. The material does not need to be defined as a molecular material.
[in]	molConf	User ID of the molecular configuration corresponding to the G4 `material`.

Definition at line 546 of file G4DNAMolecularMaterial.cc.

{
  assert(material != nullptr);
  int material_id = material->GetIndex();
  fMaterialToMolecularConf[material_id] =
    G4MoleculeTable::Instance()->GetConfiguration(molUserID, true);
}

◆ SetMolecularConfiguration() [2/3]

void G4DNAMolecularMaterial::SetMolecularConfiguration	(	const G4Material *	material,
		G4MolecularConfiguration *	molConf
	)

Associate a molecular configuration to a G4material.

Parameters

[in]	material	Pointer to a G4 material. The material does not need to be defined as a molecular material.
[in]	molConf	The molecular configuration corresponding to the G4 `material`.

Definition at line 534 of file G4DNAMolecularMaterial.cc.

{
  assert(material != nullptr);
  int material_id = material->GetIndex();
  fMaterialToMolecularConf[material_id] = molConf;
}

Referenced by SetMolecularConfiguration().

◆ SetMolecularConfiguration() [3/3]

void G4DNAMolecularMaterial::SetMolecularConfiguration	(	const G4String &	materialName,
		const G4String &	molUserIF
	)

Definition at line 558 of file G4DNAMolecularMaterial.cc.

{
  G4Material* material = G4Material::GetMaterial(materialName);
 
  if(material == nullptr){
    G4cout<< "Material " << materialName
          << " was not found and therefore won't be linked to "
          << molUserID << G4endl;
    return;
  }
  SetMolecularConfiguration(material, molUserID);
}

Member Data Documentation

◆ fAskedDensityTable

std::map<const G4Material*, std::vector<G4double>*, CompareMaterial> G4DNAMolecularMaterial::fAskedDensityTable

mutableprotected

Definition at line 248 of file G4DNAMolecularMaterial.hh.

Referenced by Clear(), and GetDensityTableFor().

◆ fAskedNumPerVolTable

std::map<const G4Material*, std::vector<G4double>*, CompareMaterial> G4DNAMolecularMaterial::fAskedNumPerVolTable

mutableprotected

Definition at line 250 of file G4DNAMolecularMaterial.hh.

Referenced by Clear(), and GetNumMolPerVolTableFor().

◆ fInstance

G4DNAMolecularMaterial * G4DNAMolecularMaterial::fInstance

staticprotected

Definition at line 222 of file G4DNAMolecularMaterial.hh.

Referenced by Instance().

◆ fIsInitialized

G4bool G4DNAMolecularMaterial::fIsInitialized

protected

Definition at line 256 of file G4DNAMolecularMaterial.hh.

Referenced by Create(), GetDensityTableFor(), GetNumMolPerVolTableFor(), and Initialize().

◆ fMaterialToMolecularConf

std::map<int , G4MolecularConfiguration*> G4DNAMolecularMaterial::fMaterialToMolecularConf

protected

Definition at line 254 of file G4DNAMolecularMaterial.hh.

Referenced by GetMolecularConfiguration(), and SetMolecularConfiguration().

◆ fNMaterials

size_t G4DNAMolecularMaterial::fNMaterials

protected

Definition at line 257 of file G4DNAMolecularMaterial.hh.

Referenced by Create(), GetDensityTableFor(), GetNumMolPerVolTableFor(), Initialize(), InitializeDensity(), and InitializeNumMolPerVol().

◆ fpCompDensityTable

std::vector<ComponentMap>* G4DNAMolecularMaterial::fpCompDensityTable

protected

Definition at line 244 of file G4DNAMolecularMaterial.hh.

Referenced by Clear(), Create(), GetDensityTable(), GetDensityTableFor(), InitializeDensity(), and InitializeNumMolPerVol().

◆ fpCompFractionTable

std::vector<ComponentMap>* G4DNAMolecularMaterial::fpCompFractionTable

protected

Definition at line 243 of file G4DNAMolecularMaterial.hh.

Referenced by Clear(), Create(), GetMassFractionTable(), Initialize(), and InitializeDensity().

◆ fpCompNumMolPerVolTable

std::vector<ComponentMap>* G4DNAMolecularMaterial::fpCompNumMolPerVolTable

protected

Definition at line 245 of file G4DNAMolecularMaterial.hh.

Referenced by Clear(), Create(), GetNumMolPerVolTableFor(), and InitializeNumMolPerVol().

◆ fWarningPrinted

std::map<const G4Material*, bool, CompareMaterial> G4DNAMolecularMaterial::fWarningPrinted

mutableprotected

Definition at line 251 of file G4DNAMolecularMaterial.hh.

Referenced by PrintNotAMolecularMaterial().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4DNAMolecularMaterial() [1/2]

◆ G4DNAMolecularMaterial() [2/2]

◆ ~G4DNAMolecularMaterial()

Member Function Documentation

◆ AddMaterial()

◆ Clear()

◆ Create()

◆ GetDensityTable()

◆ GetDensityTableFor()

◆ GetMassFractionTable()

◆ GetMolecularConfiguration()

◆ GetNumMoleculePerVolumeUnitForMaterial()

◆ GetNumMolPerVolForComponentInComposite()

◆ GetNumMolPerVolTableFor()

◆ Initialize()

◆ InitializeDensity()

◆ InitializeNumMolPerVol()

◆ Instance()

◆ Notify()

◆ operator=()

◆ PrintNotAMolecularMaterial()

◆ RecordMolecularMaterial()

◆ SearchMolecularMaterial()

◆ SetMolecularConfiguration() [1/3]

◆ SetMolecularConfiguration() [2/3]

◆ SetMolecularConfiguration() [3/3]

Member Data Documentation

◆ fAskedDensityTable

◆ fAskedNumPerVolTable

◆ fInstance

◆ fIsInitialized

◆ fMaterialToMolecularConf

◆ fNMaterials

◆ fpCompDensityTable

◆ fpCompFractionTable

◆ fpCompNumMolPerVolTable

◆ fWarningPrinted