#include <G4DNAMolecularMaterial.hh>

Inheritance diagram for G4DNAMolecularMaterial:

Public Member Functions
void	DeleteInstance ()

void	Initialize ()

virtual G4bool	Notify (G4ApplicationState requestedState)

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

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

const std::vector< double > *	GetDensityTableFor (const G4Material *) const

const std::vector< double > *	GetNumMolPerVolTableFor (const G4Material *) const

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

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

G4bool	fIsInitialized

size_t	fNMaterials

Static Protected Attributes
static G4DNAMolecularMaterial *	fInstance

Detailed Description

Definition at line 50 of file G4DNAMolecularMaterial.hh.

Constructor & Destructor Documentation

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( )

protected

Definition at line 90 of file G4DNAMolecularMaterial.cc.

References Create(), and fInstance.

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

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( const G4DNAMolecularMaterial & right )

protected

Definition at line 102 of file G4DNAMolecularMaterial.cc.

References Create().

                                                                               : G4VStateDependent()
 {
     Create();
 }

G4DNAMolecularMaterial::~G4DNAMolecularMaterial ( )

protectedvirtual

Definition at line 114 of file G4DNAMolecularMaterial.cc.

References fAskedDensityTable, fAskedNumPerVolTable, fpCompDensityTable, fpCompFractionTable, and fpCompNumMolPerVolTable.

 {
     if(fpCompFractionTable)
     {
         fpCompFractionTable->clear();
         delete fpCompFractionTable;
         fpCompFractionTable = 0;
     }
     if(fpCompDensityTable)
     {
         fpCompDensityTable->clear();
         delete fpCompDensityTable;
         fpCompDensityTable = 0;
     }
     if(fpCompNumMolPerVolTable)
     {
         fpCompNumMolPerVolTable->clear();
         delete fpCompNumMolPerVolTable;
         fpCompNumMolPerVolTable = 0;
     }
 
     std::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;
         }
     }
 }

Member Function Documentation

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

protected

void G4DNAMolecularMaterial::Create ( )

protected

Definition at line 80 of file G4DNAMolecularMaterial.cc.

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

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

void G4DNAMolecularMaterial::DeleteInstance ( )

Definition at line 74 of file G4DNAMolecularMaterial.cc.

 {
     delete fInstance;
     fInstance = 0;
 }

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

inline

Definition at line 99 of file G4DNAMolecularMaterial.hh.

References fpCompDensityTable.

 {
     return fpCompDensityTable;
 }

const std::vector< double > * G4DNAMolecularMaterial::GetDensityTableFor ( const G4Material * lookForMaterial ) const

Definition at line 316 of file G4DNAMolecularMaterial.cc.

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

Referenced by G4DNABrownianTransportation::BuildPhysicsTable().

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

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

inline

Definition at line 94 of file G4DNAMolecularMaterial.hh.

References fpCompFractionTable.

 {
     return fpCompFractionTable;
 }

const std::vector< double > * G4DNAMolecularMaterial::GetNumMolPerVolTableFor ( const G4Material * lookForMaterial ) const

Definition at line 381 of file G4DNAMolecularMaterial.cc.

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

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

void G4DNAMolecularMaterial::Initialize ( )

Definition at line 157 of file G4DNAMolecularMaterial.cc.

References aMutex, fIsInitialized, fNMaterials, fpCompFractionTable, G4Material::GetMaterialTable(), InitializeDensity(), InitializeNumMolPerVol(), and SearchMolecularMaterial().

Referenced by GetDensityTableFor(), GetNumMolPerVolTableFor(), and Notify().

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

void G4DNAMolecularMaterial::InitializeDensity ( )

protected

Definition at line 192 of file G4DNAMolecularMaterial.cc.

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

Referenced by Initialize().

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

void G4DNAMolecularMaterial::InitializeNumMolPerVol ( )

protected

Definition at line 231 of file G4DNAMolecularMaterial.cc.

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

Referenced by Initialize().

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

G4DNAMolecularMaterial * G4DNAMolecularMaterial::Instance ( void )

static

Definition at line 68 of file G4DNAMolecularMaterial.cc.

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

G4bool G4DNAMolecularMaterial::Notify ( G4ApplicationState requestedState )

virtual

Implements G4VStateDependent.

Definition at line 96 of file G4DNAMolecularMaterial.cc.

References G4State_Idle, and Initialize().

 {
     if(requestedState == G4State_Idle) Initialize();
     return true;
 }

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

protected

Definition at line 107 of file G4DNAMolecularMaterial.cc.

References Create().

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

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

protected

Definition at line 448 of file G4DNAMolecularMaterial.cc.

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

Referenced by GetDensityTableFor(), and GetNumMolPerVolTableFor().

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

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

protected

Definition at line 262 of file G4DNAMolecularMaterial.cc.

References G4Material::GetIndex().

Referenced by SearchMolecularMaterial().

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

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

protected

Definition at line 284 of file G4DNAMolecularMaterial.cc.

References G4Material::GetMassOfMolecule(), G4Material::GetMatComponents(), and RecordMolecularMaterial().

Referenced by Initialize().

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