G4DNAMolecularMaterial Class Reference

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	Clear ()
const std::vector< ComponentMap > *	GetDensityTable () const
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. More...
const std::vector< ComponentMap > *	GetMassFractionTable () const
G4MolecularConfiguration *	GetMolecularConfiguration (const G4Material *) const
G4double	GetNumMoleculePerVolumeUnitForMaterial (const G4Material *mat)
	Deprecated. More...
G4double	GetNumMolPerVolForComponentInComposite (const G4Material *composite, const G4Material *component, G4double massFraction)
	Deprecated. More...
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. More...
void	Initialize ()
virtual G4bool	Notify (G4ApplicationState requestedState)
G4bool	operator!= (const G4VStateDependent &right) const
G4bool	operator== (const G4VStateDependent &right) const
void	SetMolecularConfiguration (const G4Material *, const G4String &)
	Associate a molecular configuration to a G4material. More...
void	SetMolecularConfiguration (const G4Material *, G4MolecularConfiguration *)
	Associate a molecular configuration to a G4material. More...
void	SetMolecularConfiguration (const G4String &materialName, const G4String &molUserIF)

Static Public Member Functions
static G4DNAMolecularMaterial *	Instance ()

Protected Member Functions
void	AddMaterial (const G4Material *, G4double fraction)
void	Create ()
	G4DNAMolecularMaterial ()
	G4DNAMolecularMaterial (const G4DNAMolecularMaterial &right)
void	InitializeDensity ()
void	InitializeNumMolPerVol ()
G4DNAMolecularMaterial &	operator= (const G4DNAMolecularMaterial &)
void	PrintNotAMolecularMaterial (const char *methodName, const G4Material *lookForMaterial) const
void	RecordMolecularMaterial (G4Material *parentMaterial, G4Material *molecularMaterial, G4double fraction)
void	SearchMolecularMaterial (G4Material *parentMaterial, G4Material *material, G4double currentFraction)
virtual	~G4DNAMolecularMaterial ()

Protected Attributes
std::map< const G4Material *, std::vector< G4double > *, CompareMaterial >	fAskedDensityTable
std::map< const G4Material *, std::vector< G4double > *, CompareMaterial >	fAskedNumPerVolTable
G4bool	fIsInitialized
std::map< int, G4MolecularConfiguration * >	fMaterialToMolecularConf
size_t	fNMaterials
std::vector< ComponentMap > *	fpCompDensityTable
std::vector< ComponentMap > *	fpCompFractionTable
std::vector< ComponentMap > *	fpCompNumMolPerVolTable
std::map< const G4Material *, bool, CompareMaterial >	fWarningPrinted

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();
}

References Create().

Referenced by Instance().

G4DNAMolecularMaterial() [2/2]

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( const G4DNAMolecularMaterial &  right )

protected

Definition at line 158 of file G4DNAMolecularMaterial.cc.

                                     :
    G4VStateDependent()
{
  Create();
}

References Create().

~G4DNAMolecularMaterial()

G4DNAMolecularMaterial::~G4DNAMolecularMaterial ( )

protectedvirtual

Definition at line 177 of file G4DNAMolecularMaterial.cc.

{
  Clear();
}

References 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();
}

References anonymous_namespace{G4DNAMolecularMaterial.cc}::aMutex, fAskedDensityTable, fAskedNumPerVolTable, fpCompDensityTable, fpCompFractionTable, fpCompNumMolPerVolTable, and G4TemplateAutoLock< _Mutex_t >::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;
}

References fIsInitialized, fNMaterials, fpCompDensityTable, fpCompFractionTable, and fpCompNumMolPerVolTable.

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

GetDensityTable()

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

inline

Definition at line 144 of file G4DNAMolecularMaterial.hh.

                                                               {
    return fpCompDensityTable;
  }

References 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;
}

References fAskedDensityTable, FatalException, fIsInitialized, fNMaterials, fpCompDensityTable, G4endl, G4Exception(), G4State_Init, G4Material::GetMaterialTable(), G4StateManager::GetStateManager(), Initialize(), and PrintNotAMolecularMaterial().

Referenced by G4DNAElectronHoleRecombination::FindReactant().

GetMassFractionTable()

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

inline

Definition at line 141 of file G4DNAMolecularMaterial.hh.

                                                                    {
    return fpCompFractionTable;
  }

References 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;
}

References fMaterialToMolecularConf, and eplot::material.

Referenced by G4DNAIRT_geometries::Sampling().

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.;
}

References FatalException, and G4Exception().

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.;
}

References FatalException, and G4Exception().

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;
}

References fAskedNumPerVolTable, FatalException, fIsInitialized, fNMaterials, fpCompNumMolPerVolTable, G4endl, G4Exception(), G4State_Init, G4Material::GetMaterialTable(), G4StateManager::GetStateManager(), Initialize(), and PrintNotAMolecularMaterial().

Referenced by G4DNAModelInterface::BuildMaterialMolPerVolTable(), G4DNASecondOrderReaction::BuildPhysicsTable(), G4DNACPA100ElasticModel::Initialise(), G4DNADingfelderChargeDecreaseModel::Initialise(), G4DNADingfelderChargeIncreaseModel::Initialise(), G4DNAMillerGreenExcitationModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4DNABornExcitationModel1::Initialise(), G4DNABornExcitationModel2::Initialise(), G4DNACPA100ExcitationModel::Initialise(), G4DNACPA100IonisationModel::Initialise(), G4DNAEmfietzoglouExcitationModel::Initialise(), G4DNARelativisticIonisationModel::Initialise(), and G4DNADummyModel::Initialise().

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;
}

References anonymous_namespace{G4DNAMolecularMaterial.cc}::aMutex, fIsInitialized, fNMaterials, fpCompFractionTable, G4Material::GetMaterialTable(), InitializeDensity(), InitializeNumMolPerVol(), SearchMolecularMaterial(), and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by G4DNAModelInterface::BuildMaterialMolPerVolTable(), GetDensityTableFor(), GetNumMolPerVolTableFor(), G4DNAChampionElasticModel::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);
  }
}

References FatalException, fNMaterials, fpCompDensityTable, fpCompFractionTable, G4endl, G4Exception(), G4Material::GetDensity(), and G4Material::GetMaterialTable().

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);
  }
}

References FatalException, fNMaterials, fpCompDensityTable, fpCompNumMolPerVolTable, G4endl, G4Exception(), and G4Material::GetMassOfMolecule().

Referenced by Initialize().

Instance()

G4DNAMolecularMaterial * G4DNAMolecularMaterial::Instance ( void  )

static

Definition at line 80 of file G4DNAMolecularMaterial.cc.

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

References fInstance, and G4DNAMolecularMaterial().

Referenced by G4DNAModelInterface::BuildMaterialMolPerVolTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4DNASecondOrderReaction::BuildPhysicsTable(), G4DNAELSEPAElasticModel::CrossSectionPerVolume(), G4DNAElectronHoleRecombination::FindReactant(), G4DNAChampionElasticModel::Initialise(), G4DNACPA100ElasticModel::Initialise(), G4DNADingfelderChargeDecreaseModel::Initialise(), G4DNADingfelderChargeIncreaseModel::Initialise(), G4DNAMeltonAttachmentModel::Initialise(), G4DNAMillerGreenExcitationModel::Initialise(), G4TDNAOneStepThermalizationModel< MODEL >::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4DNASancheExcitationModel::Initialise(), G4DNAScreenedRutherfordElasticModel::Initialise(), G4DNATransformElectronModel::Initialise(), G4DNAUeharaScreenedRutherfordElasticModel::Initialise(), G4DNABornExcitationModel1::Initialise(), G4DNABornExcitationModel2::Initialise(), G4DNABornIonisationModel1::Initialise(), G4DNABornIonisationModel2::Initialise(), G4DNACPA100ExcitationModel::Initialise(), G4DNACPA100IonisationModel::Initialise(), G4DNAEmfietzoglouExcitationModel::Initialise(), G4DNAEmfietzoglouIonisationModel::Initialise(), G4DNARelativisticIonisationModel::Initialise(), G4DNADummyModel::Initialise(), G4DNAIonElasticModel::Initialise(), and G4DNAIRT_geometries::Sampling().

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;
}

References G4State_Idle, G4State_PreInit, G4StateManager::GetStateManager(), and Initialize().

operator!=()

G4bool G4VStateDependent::operator!= ( const G4VStateDependent &  right ) const

inherited

Definition at line 66 of file G4VStateDependent.cc.

{
  return (this != &right);
}

operator=()

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

protected

Definition at line 168 of file G4DNAMolecularMaterial.cc.

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

References Create().

operator==()

G4bool G4VStateDependent::operator== ( const G4VStateDependent &  right ) const

inherited

Definition at line 61 of file G4VStateDependent.cc.

{
  return (this == &right);
}

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;
  }
}

References fWarningPrinted, G4endl, G4Exception(), G4Material::GetName(), and JustWarning.

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"
  }
}

References G4Material::GetIndex().

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);
    }
  }
}

References G4Material::GetMassOfMolecule(), eplot::material, RecordMolecularMaterial(), and SearchMolecularMaterial().

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);
}

References fMaterialToMolecularConf, G4MoleculeTable::GetConfiguration(), G4MoleculeTable::Instance(), and eplot::material.

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;
}

References fMaterialToMolecularConf, and eplot::material.

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);
}

References G4cout, G4endl, G4Material::GetMaterial(), eplot::material, and SetMolecularConfiguration().

Field 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:

• source/processes/electromagnetic/dna/utils/include/G4DNAMolecularMaterial.hh
• source/processes/electromagnetic/dna/utils/src/G4DNAMolecularMaterial.cc