G4DNAMolecularMaterial Class Reference

#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
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, 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

Static Protected Attributes
static G4DNAMolecularMaterial *	fInstance

Detailed Description

Definition at line 50 of file G4DNAMolecularMaterial.hh.

Constructor & Destructor Documentation

G4DNAMolecularMaterial() [1/2]

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( )

protected

Definition at line 85 of file G4DNAMolecularMaterial.cc.

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

Referenced by Instance().

G4DNAMolecularMaterial() [2/2]

G4DNAMolecularMaterial::G4DNAMolecularMaterial ( const G4DNAMolecularMaterial &  right )

protected

Definition at line 97 of file G4DNAMolecularMaterial.cc.

                                                                              : G4VStateDependent()
{
    Create();
}

~G4DNAMolecularMaterial()

G4DNAMolecularMaterial::~G4DNAMolecularMaterial ( )

protectedvirtual

Definition at line 109 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;
    }
 
    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

AddMaterial()

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

protected

Create()

void G4DNAMolecularMaterial::Create ( )

protected

Definition at line 76 of file G4DNAMolecularMaterial.cc.

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

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

DeleteInstance()

void G4DNAMolecularMaterial::DeleteInstance

(

)

Definition at line 70 of file G4DNAMolecularMaterial.cc.

{
    delete fInstance;
    fInstance = 0;
}

GetDensityTable()

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

inline

Definition at line 97 of file G4DNAMolecularMaterial.hh.

{
    return fpCompDensityTable;
}

GetDensityTableFor()

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

(

const G4Material *

lookForMaterial

)

const

Definition at line 302 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(int i = 0 ; i < int(materialTable->size()) ; 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;
}

Referenced by G4DNABrownianTransportation::BuildPhysicsTable().

GetMassFractionTable()

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

inline

Definition at line 92 of file G4DNAMolecularMaterial.hh.

{
    return fpCompFractionTable;
}

GetNumMolPerVolTableFor()

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

(

const G4Material *

lookForMaterial

)

const

Definition at line 367 of file G4DNAMolecularMaterial.cc.

{
    if(!fpCompNumMolPerVolTable)
    {
        if(fIsInitialized)
        {
            G4ExceptionDescription exceptionDescription;
            exceptionDescription << "The pointer fpCompNumMolPerVolTable is not initialized will 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(int i = 0 ; i < int(materialTable->size()) ; 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;
}

Referenced by G4DNASecondOrderReaction::BuildPhysicsTable(), G4DNAChampionElasticModel::Initialise(), G4DNADingfelderChargeDecreaseModel::Initialise(), G4DNADingfelderChargeIncreaseModel::Initialise(), G4DNAMeltonAttachmentModel::Initialise(), G4DNAMillerGreenExcitationModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4DNASancheExcitationModel::Initialise(), G4DNASancheSolvatationModel::Initialise(), G4DNAScreenedRutherfordElasticModel::Initialise(), G4DNATransformElectronModel::Initialise(), G4DNABornExcitationModel::Initialise(), G4DNABornIonisationModel::Initialise(), and G4DNAEmfietzoglouExcitationModel::Initialise().

Initialize()

void G4DNAMolecularMaterial::Initialize

(

)

Definition at line 275 of file G4DNAMolecularMaterial.cc.

{
    if(fIsInitialized) return;
 
    const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
 
    if(fpCompFractionTable==0)
    {
        fpCompFractionTable = new vector<ComponentMap>(materialTable->size());
    }
 
    G4Material* mat(0);
 
    for(int i = 0 ; i < int(materialTable->size()) ; i++)
    {
        mat = materialTable->at(i);
        SearchMolecularMaterial(mat,mat,1);
 
        mat = 0;
    }
 
    InitializeDensity();
    InitializeNumMolPerVol();
 
    fIsInitialized = true;
}

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

InitializeDensity()

void G4DNAMolecularMaterial::InitializeDensity ( )

protected

Definition at line 204 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(int i = 0 ; i < int(materialTable->size()) ; 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);
    }
}

Referenced by Initialize().

InitializeNumMolPerVol()

void G4DNAMolecularMaterial::InitializeNumMolPerVol ( )

protected

Definition at line 243 of file G4DNAMolecularMaterial.cc.

{
    if(fpCompDensityTable)
    {
        const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
        fpCompNumMolPerVolTable = new vector<ComponentMap>(G4Material::GetMaterialTable()->size());
 
        const G4Material* compMat(0);
 
        for(int i = 0 ; i < int(materialTable->size()) ; 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);
    }
}

Referenced by Initialize().

Instance()

G4DNAMolecularMaterial * G4DNAMolecularMaterial::Instance ( )

static

Definition at line 64 of file G4DNAMolecularMaterial.cc.

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

Referenced by G4DNABrownianTransportation::BuildPhysicsTable(), G4DNASecondOrderReaction::BuildPhysicsTable(), G4DNAChampionElasticModel::Initialise(), G4DNADingfelderChargeDecreaseModel::Initialise(), G4DNADingfelderChargeIncreaseModel::Initialise(), G4DNAMeltonAttachmentModel::Initialise(), G4DNAMillerGreenExcitationModel::Initialise(), G4DNARuddIonisationExtendedModel::Initialise(), G4DNARuddIonisationModel::Initialise(), G4DNASancheExcitationModel::Initialise(), G4DNASancheSolvatationModel::Initialise(), G4DNAScreenedRutherfordElasticModel::Initialise(), G4DNATransformElectronModel::Initialise(), G4DNABornExcitationModel::Initialise(), G4DNABornIonisationModel::Initialise(), and G4DNAEmfietzoglouExcitationModel::Initialise().

Notify()

G4bool G4DNAMolecularMaterial::Notify ( G4ApplicationState  requestedState )

virtual

Implements G4VStateDependent.

Definition at line 91 of file G4DNAMolecularMaterial.cc.

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

operator=()

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

protected

Definition at line 102 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 434 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;
    }
}

Referenced by GetDensityTableFor(), and GetNumMolPerVolTableFor().

RecordMolecularMaterial()

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

protected

Definition at line 151 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;
    }
}

Referenced by SearchMolecularMaterial().

SearchMolecularMaterial()

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

protected

Definition at line 173 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;
    }
}

Referenced by Initialize(), and SearchMolecularMaterial().

Member Data Documentation

fAskedDensityTable

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

mutableprotected

Definition at line 85 of file G4DNAMolecularMaterial.hh.

Referenced by GetDensityTableFor(), and ~G4DNAMolecularMaterial().

fAskedNumPerVolTable

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

mutableprotected

Definition at line 86 of file G4DNAMolecularMaterial.hh.

Referenced by GetNumMolPerVolTableFor(), and ~G4DNAMolecularMaterial().

fInstance

G4DNAMolecularMaterial * G4DNAMolecularMaterial::fInstance

staticprotected

Definition at line 66 of file G4DNAMolecularMaterial.hh.

Referenced by Create(), DeleteInstance(), G4DNAMolecularMaterial(), and Instance().

fIsInitialized

G4bool G4DNAMolecularMaterial::fIsInitialized

protected

Definition at line 89 of file G4DNAMolecularMaterial.hh.

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

fpCompDensityTable

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

protected

Definition at line 82 of file G4DNAMolecularMaterial.hh.

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

fpCompFractionTable

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

protected

Definition at line 81 of file G4DNAMolecularMaterial.hh.

Referenced by Create(), GetMassFractionTable(), Initialize(), InitializeDensity(), and ~G4DNAMolecularMaterial().

fpCompNumMolPerVolTable

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

protected

Definition at line 83 of file G4DNAMolecularMaterial.hh.

Referenced by Create(), GetNumMolPerVolTableFor(), InitializeNumMolPerVol(), and ~G4DNAMolecularMaterial().

fWarningPrinted

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

mutableprotected

Definition at line 87 of file G4DNAMolecularMaterial.hh.

Referenced by PrintNotAMolecularMaterial().

---

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

• G4DNAMolecularMaterial.hh
• G4DNAMolecularMaterial.cc