G4DNAMolecularMaterial Class Reference

#include <G4DNAMolecularMaterial.hh>

Inheritance diagram for G4DNAMolecularMaterial:

Collaboration diagram for G4DNAMolecularMaterial:

Public Member Functions
void	Initialize ()
void	Clear ()
virtual G4bool	Notify (G4ApplicationState requestedState)
const std::vector< double > *	GetDensityTableFor (const G4Material *) const
const std::vector< double > *	GetNumMolPerVolTableFor (const G4Material *) const
const std::vector< ComponentMap > *	GetMassFractionTable () const
const std::vector< ComponentMap > *	GetDensityTable () const
G4MolecularConfiguration *	GetMolecularConfiguration (const G4Material *) const
void	SetMolecularConfiguration (const G4Material *, G4MolecularConfiguration *)
void	SetMolecularConfiguration (const G4Material *, const G4String &)
void	SetMolecularConfiguration (const G4String &materialName, const G4String &molUserIF)
Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)
virtual	~G4VStateDependent ()
G4int	operator== (const G4VStateDependent &right) const
G4int	operator!= (const G4VStateDependent &right) const

Static Public Member Functions
static G4DNAMolecularMaterial *	Instance ()
static void	DeleteInstance ()

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, double currentFraction)
void	AddMaterial (const G4Material *, double 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< double > *, CompareMaterial >	fAskedDensityTable
std::map< const G4Material *, std::vector< double > *, 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

Definition at line 68 of file G4DNAMolecularMaterial.hh.

Constructor & Destructor Documentation

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( )

protected

Definition at line 143 of file G4DNAMolecularMaterial.cc.

                                               :
    G4VStateDependent()
{
  Create();
  fInstance = this;
}

Here is the call graph for this function:

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( const G4DNAMolecularMaterial &  right )

protected

Definition at line 169 of file G4DNAMolecularMaterial.cc.

                                     :
    G4VStateDependent()
{
  Create();
}

Here is the call graph for this function:

G4DNAMolecularMaterial::~G4DNAMolecularMaterial ( )

protectedvirtual

Definition at line 188 of file G4DNAMolecularMaterial.cc.

{
//  G4cout << "Deleting G4DNAMolecularMaterial" << G4endl;
  Clear();
  fInstance = 0;
  //assert(G4StateManager::GetStateManager()->DeregisterDependent(this) == true);
}

Here is the call graph for this function:

Member Function Documentation

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

protected

void G4DNAMolecularMaterial::Clear

(

)

Definition at line 105 of file G4DNAMolecularMaterial.cc.

{
  if (fpCompFractionTable){
    fpCompFractionTable->clear();
    delete fpCompFractionTable;
    fpCompFractionTable = 0;
  }
  if (fpCompDensityTable){
    fpCompDensityTable->clear();
    delete fpCompDensityTable;
    fpCompDensityTable = 0;
  }
  if (fpCompNumMolPerVolTable){
    fpCompNumMolPerVolTable->clear();
    delete fpCompNumMolPerVolTable;
    fpCompNumMolPerVolTable = 0;
  }

  map<const G4Material*, std::vector<double>*, CompareMaterial>::iterator it;

  for (it = fAskedDensityTable.begin(); it != fAskedDensityTable.end(); it++){
    if (it->second){
      delete it->second;
      it->second = 0;
    }
  }

  for (it = fAskedNumPerVolTable.begin(); it != fAskedNumPerVolTable.end();
      it++){
    if (it->second){
      delete it->second;
      it->second = 0;
    }
  }
}

Here is the caller graph for this function:

void G4DNAMolecularMaterial::Create ( )

protected

Definition at line 93 of file G4DNAMolecularMaterial.cc.

{
  fpCompFractionTable = 0;
  fpCompDensityTable = 0;
  fpCompNumMolPerVolTable = 0;
  fIsInitialized = false;
  fNMaterials = 0;
  fInstance = this;
}

Here is the caller graph for this function:

void G4DNAMolecularMaterial::DeleteInstance ( )

static

Definition at line 83 of file G4DNAMolecularMaterial.cc.

{
  if (fInstance){
    delete fInstance;
    fInstance = 0;
  }
}

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

inline

Definition at line 86 of file G4DNAMolecularMaterial.hh.

                                                               {
    return fpCompDensityTable;
  }

const std::vector< double > * G4DNAMolecularMaterial::GetDensityTableFor

(

const G4Material *

lookForMaterial

)

const

Definition at line 366 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_Idle){
      const_cast<G4DNAMolecularMaterial*>(this)->Initialize();
    }
    else{
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "The geant4 application is at the wrong state. State must be: "
          "G4State_Idle."
          << G4endl;
      G4Exception("G4DNAMolecularMaterial::GetDensityTableFor",
                  "G4DNAMolecularMaterial_WRONG_STATE_APPLICATION",
                  FatalException, exceptionDescription);
    }
  }

  std::map<const G4Material*, std::vector<double>*, CompareMaterial>::
    const_iterator it_askedDensityTable =
        fAskedDensityTable.find(lookForMaterial);

  if (it_askedDensityTable != fAskedDensityTable.end()){
    return it_askedDensityTable->second;
  }

  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();

  std::vector<double>* output = new std::vector<double>(materialTable->size());

  ComponentMap::const_iterator it;

  G4bool materialWasNotFound = true;

  for (size_t i = 0; i < fNMaterials; i++){
    ComponentMap& densityTable = (*fpCompDensityTable)[i];

    it = densityTable.find(lookForMaterial);

    if (it == densityTable.end()){
      (*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;
}

Here is the call graph for this function:

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

inline

Definition at line 83 of file G4DNAMolecularMaterial.hh.

                                                                    {
    return fpCompFractionTable;
  }

G4MolecularConfiguration * G4DNAMolecularMaterial::GetMolecularConfiguration

(

const G4Material *

material

)

const

Definition at line 545 of file G4DNAMolecularMaterial.cc.

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

Here is the call graph for this function:

const std::vector< double > * G4DNAMolecularMaterial::GetNumMolPerVolTableFor

(

const G4Material *

lookForMaterial

)

const

Definition at line 437 of file G4DNAMolecularMaterial.cc.

{
  if(lookForMaterial==0) 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_Idle){
      const_cast<G4DNAMolecularMaterial*>(this)->Initialize();
    }
    else{
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "The geant4 application is at the wrong state. State must be : "
          "G4State_Idle."
          << G4endl;
      G4Exception("G4DNAMolecularMaterial::GetNumMolPerVolTableFor",
                  "G4DNAMolecularMaterial_WRONG_STATE_APPLICATION",
                  FatalException, exceptionDescription);
    }
  }

  std::map<const G4Material*, std::vector<double>*, CompareMaterial>::
      const_iterator it_askedNumMolPerVolTable =
          fAskedNumPerVolTable.find(lookForMaterial);
  if (it_askedNumMolPerVolTable != fAskedNumPerVolTable.end()){
    return it_askedNumMolPerVolTable->second;
  }

  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();

  std::vector<double>* output = new std::vector<double>(materialTable->size());

  ComponentMap::const_iterator it;

  G4bool materialWasNotFound = true;

  for (size_t i = 0; i < fNMaterials; i++){
    ComponentMap& densityTable = (*fpCompNumMolPerVolTable)[i];

    it = densityTable.find(lookForMaterial);

    if (it == densityTable.end()){
      (*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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAMolecularMaterial::Initialize

(

)

Definition at line 198 of file G4DNAMolecularMaterial.cc.

{
  G4AutoLock l(&aMutex);
  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

  if (fpCompFractionTable == 0){
    fpCompFractionTable = new vector<ComponentMap>(materialTable->size());
  }

  G4Material* mat(0);

  for (size_t i = 0; i < fNMaterials; i++){
    mat = materialTable->at(i);
    SearchMolecularMaterial(mat, mat, 1);

    mat = 0;
  }

  InitializeDensity();
  InitializeNumMolPerVol();

  fIsInitialized = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAMolecularMaterial::InitializeDensity ( )

protected

Definition at line 232 of file G4DNAMolecularMaterial.cc.

{
  if (fpCompFractionTable){
    const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
    fpCompDensityTable = new vector<ComponentMap>(
        G4Material::GetMaterialTable()->size());

    G4Material* parentMat;
    const G4Material* compMat(0);
    double massFraction = -1;
    double parentDensity = -1;

    for (size_t i = 0; i < fNMaterials; i++){
      parentMat = materialTable->at(i);
      ComponentMap& massFractionComp = (*fpCompFractionTable)[i];
      ComponentMap& densityComp = (*fpCompDensityTable)[i];

      parentDensity = parentMat->GetDensity();

      for (ComponentMap::iterator it = massFractionComp.begin();
          it != massFractionComp.end(); it++){
        compMat = it->first;
        massFraction = it->second;
        densityComp[compMat] = massFraction * parentDensity;
        compMat = 0;
        massFraction = -1;
      }
    }
  }
  else{
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "The pointer fpCompFractionTable is not initialized"
                         << G4endl;
    G4Exception("G4DNAMolecularMaterial::InitializeDensity",
                "G4DNAMolecularMaterial001", FatalException,
                exceptionDescription);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAMolecularMaterial::InitializeNumMolPerVol ( )

protected

Definition at line 273 of file G4DNAMolecularMaterial.cc.

{
  if (fpCompDensityTable){
    fpCompNumMolPerVolTable = new vector<ComponentMap>(fNMaterials);

    const G4Material* compMat(0);

    for (size_t i = 0; i < fNMaterials; i++){
      ComponentMap& massFractionComp = (*fpCompFractionTable)[i];
      ComponentMap& densityComp = (*fpCompDensityTable)[i];
      ComponentMap& numMolPerVol = (*fpCompNumMolPerVolTable)[i];

      for (ComponentMap::iterator it = massFractionComp.begin();
          it != massFractionComp.end(); it++){
        compMat = it->first;
        numMolPerVol[compMat] = densityComp[compMat]
            / compMat->GetMassOfMolecule();
        compMat = 0;
      }
    }
  }
  else{
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "The pointer fpCompDensityTable is not initialized"
                         << G4endl;
    G4Exception("G4DNAMolecularMaterial::InitializeNumMolPerVol",
                "G4DNAMolecularMaterial002", FatalException,
                exceptionDescription);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4DNAMolecularMaterial * G4DNAMolecularMaterial::Instance ( void  )

static

Definition at line 75 of file G4DNAMolecularMaterial.cc.

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

Here is the caller graph for this function:

G4bool G4DNAMolecularMaterial::Notify ( G4ApplicationState  requestedState )

virtual

Implements G4VStateDependent.

Definition at line 152 of file G4DNAMolecularMaterial.cc.

{
  if (requestedState == G4State_Idle && G4StateManager::GetStateManager()
      ->GetPreviousState() == G4State_PreInit){
    Initialize();
  }
  else if (requestedState == G4State_Quit){
//    G4cout << "G4DNAMolecularMaterial::Notify ---> received G4State_Quit"
//           << G4endl;
    Clear();
    //DeleteInstance();
  }
  return true;
}

Here is the call graph for this function:

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

protected

Definition at line 179 of file G4DNAMolecularMaterial.cc.

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

Here is the call graph for this function:

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

protected

Definition at line 511 of file G4DNAMolecularMaterial.cc.

{
  std::map<const G4Material*, bool, CompareMaterial>::iterator it =
      fWarningPrinted.find(lookForMaterial);

  if (it == fWarningPrinted.end()){
    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;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 307 of file G4DNAMolecularMaterial.cc.

{
  ComponentMap& matComponent =
      (*fpCompFractionTable)[parentMaterial->GetIndex()];

  if (matComponent.empty()){
    matComponent[molecularMaterial] = fraction;
    return;
  }

  ComponentMap::iterator it = matComponent.find(molecularMaterial);

  if (it == matComponent.end()){
    matComponent[molecularMaterial] = fraction;
  }
  else{
    matComponent[molecularMaterial] = it->second + fraction;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 331 of file G4DNAMolecularMaterial.cc.

{
  if (material->GetMassOfMolecule() != 0.0){
    RecordMolecularMaterial(parentMaterial, material, currentFraction);
    return;
  }

  G4Material* compMat(0);
  G4double fraction = -1;
  std::map<G4Material*, G4double> matComponent = material->GetMatComponents();
  std::map<G4Material*, G4double>::iterator it = matComponent.begin();

  for (; it != matComponent.end(); it++){
    compMat = it->first;
    fraction = it->second;
    if (compMat->GetMassOfMolecule() == 0.0){
      SearchMolecularMaterial(parentMaterial, compMat,
                              currentFraction * fraction);
    }
    else{
      RecordMolecularMaterial(parentMaterial, compMat,
                              currentFraction * fraction);
    }

    //compMat = 0;
    //fraction = -1;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 557 of file G4DNAMolecularMaterial.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 568 of file G4DNAMolecularMaterial.cc.

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

Here is the call graph for this function:

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

Definition at line 580 of file G4DNAMolecularMaterial.cc.

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

Here is the call graph for this function:

Member Data Documentation

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

mutableprotected

Definition at line 127 of file G4DNAMolecularMaterial.hh.

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

mutableprotected

Definition at line 129 of file G4DNAMolecularMaterial.hh.

G4DNAMolecularMaterial * G4DNAMolecularMaterial::fInstance

staticprotected

Definition at line 102 of file G4DNAMolecularMaterial.hh.

G4bool G4DNAMolecularMaterial::fIsInitialized

protected

Definition at line 135 of file G4DNAMolecularMaterial.hh.

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

protected

Definition at line 133 of file G4DNAMolecularMaterial.hh.

size_t G4DNAMolecularMaterial::fNMaterials

protected

Definition at line 136 of file G4DNAMolecularMaterial.hh.

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

protected

Definition at line 123 of file G4DNAMolecularMaterial.hh.

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

protected

Definition at line 122 of file G4DNAMolecularMaterial.hh.

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

protected

Definition at line 124 of file G4DNAMolecularMaterial.hh.

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

mutableprotected

Definition at line 130 of file G4DNAMolecularMaterial.hh.

---

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

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