G4DNAMolecularReactionTable Class Reference

#include <G4DNAMolecularReactionTable.hh>

Inheritance diagram for G4DNAMolecularReactionTable:

Public Member Functions
virtual	~G4DNAMolecularReactionTable ()
void	SetReaction (G4double observedReactionRate, const G4Molecule *reactive1, const G4Molecule *reactive2)
void	SetReaction (G4DNAMolecularReactionData *)
const G4DNAMolecularReactionData *	GetReactionData (const G4Molecule *, const G4Molecule *) const
const std::vector< const G4Molecule * > *	CanReactWith (const G4Molecule *aMolecule) const
const std::map< const G4Molecule *, const G4DNAMolecularReactionData *, compMoleculeP > *	GetReativesNData (const G4Molecule *aMolecule) const
const std::vector< const G4DNAMolecularReactionData * > *	GetReactionData (const G4Molecule *) const
void	PrintTable (G4VDNAReactionModel *=0)
Public Member Functions inherited from G4ITReactionTable
	G4ITReactionTable ()
virtual	~G4ITReactionTable ()
	G4ITReactionTable (const G4ITReactionTable &)
G4ITReactionTable &	operator= (const G4ITReactionTable &)

Static Public Member Functions
static G4DNAMolecularReactionTable *	GetReactionTable ()
static void	DeleteInstance ()

Protected Types
typedef std::map< const G4Molecule *, std::map< const G4Molecule *, const G4DNAMolecularReactionData *, compMoleculeP >, compMoleculeP >	ReactionDataMap
typedef std::map< const G4Molecule *, std::vector< const G4Molecule * >, compMoleculeP >	ReactivesMV
typedef std::map< const G4Molecule *, std::vector< const G4DNAMolecularReactionData * >, compMoleculeP >	ReactionDataMV

Protected Member Functions
	G4DNAMolecularReactionTable ()

Protected Attributes
const G4MoleculeHandleManager *	fMoleculeHandleManager
G4bool	fVerbose
ReactionDataMap	fReactionData
ReactivesMV	fReactivesMV
ReactionDataMV	fReactionDataMV

Static Protected Attributes
static G4DNAMolecularReactionTable *	fInstance

Detailed Description

G4DNAMolecularReactionTable sorts out the G4DNAMolecularReactionData for bimolecular reaction

Definition at line 111 of file G4DNAMolecularReactionTable.hh.

Member Typedef Documentation

ReactionDataMap

typedef std::map<const G4Molecule*, std::map<const G4Molecule*, const G4DNAMolecularReactionData*, compMoleculeP>, compMoleculeP > G4DNAMolecularReactionTable::ReactionDataMap

protected

Definition at line 158 of file G4DNAMolecularReactionTable.hh.

ReactionDataMV

typedef std::map<const G4Molecule*,std::vector<const G4DNAMolecularReactionData*>,compMoleculeP> G4DNAMolecularReactionTable::ReactionDataMV

protected

Definition at line 160 of file G4DNAMolecularReactionTable.hh.

ReactivesMV

typedef std::map<const G4Molecule*,std::vector<const G4Molecule*>,compMoleculeP> G4DNAMolecularReactionTable::ReactivesMV

protected

Definition at line 159 of file G4DNAMolecularReactionTable.hh.

Constructor & Destructor Documentation

G4DNAMolecularReactionTable()

G4DNAMolecularReactionTable::G4DNAMolecularReactionTable ( )

protected

Definition at line 129 of file G4DNAMolecularReactionTable.cc.

                                                         : G4ITReactionTable(),
    fMoleculeHandleManager(G4MoleculeHandleManager::Instance())
{
//    G4cout << "G4DNAMolecularReactionTable::G4DNAMolecularReactionTable()" << G4endl;
    fVerbose = false;
    return;
}

Referenced by GetReactionTable().

~G4DNAMolecularReactionTable()

G4DNAMolecularReactionTable::~G4DNAMolecularReactionTable ( )

virtual

Definition at line 137 of file G4DNAMolecularReactionTable.cc.

{
    // DEBUG
//    G4cout << "G4MolecularReactionTable::~G4MolecularReactionTable" << G4endl;
    ReactionDataMap::iterator it1 = fReactionData.begin();
 
    std::map<const G4Molecule*,
             const G4DNAMolecularReactionData*,
             compMoleculeP>::iterator it2;
 
    for(;it1!=fReactionData.end();it1++)
    {
        for(it2 = it1->second.begin();it2 != it1->second.end();it2++)
        {
            const G4DNAMolecularReactionData* reactionData = it2->second;
            if(reactionData)
            {
                const G4Molecule* reactive1 = reactionData->GetReactive1();
                const G4Molecule* reactive2 = reactionData->GetReactive2();
 
                fReactionData[reactive1][reactive2] = 0;
                fReactionData[reactive2][reactive1] = 0;
 
                delete reactionData;
            }
        }
    }
 
    fReactionDataMV.clear();
    fReactionData.clear();
    fReactivesMV.clear();
}

Member Function Documentation

CanReactWith()

const std::vector< const G4Molecule * > * G4DNAMolecularReactionTable::CanReactWith

(

const G4Molecule *

aMolecule

)

const

Given a molecule's type, it returns with which a reaction is allowed

Definition at line 386 of file G4DNAMolecularReactionTable.cc.

{
    if(fReactivesMV.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
        return 0;
    }
 
    ReactivesMV::const_iterator itReactivesMap = fReactivesMV.find(aMolecule) ;
 
    if(itReactivesMap == fReactivesMV.end())
    {
        G4cout<<"Nom : " << aMolecule->GetName()<<G4endl;
        G4String errMsg = "No reaction table was implemented for this molecule Definition : "
                + aMolecule -> GetName();
        G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
        return 0;
    }
    else
    {
        if(fVerbose)
        {
            G4cout<< " G4MolecularInteractionTable::CanReactWith :"<<G4endl;
            G4cout<<"You are checking reactants for : " << aMolecule->GetName()<<G4endl;
            G4cout<<" the number of reactants is : " << itReactivesMap->second.size()<<G4endl;
 
            std::vector<const G4Molecule*>::const_iterator itProductsVector =
                    itReactivesMap->second.begin();
 
            for( ; itProductsVector !=  itReactivesMap->second.end(); itProductsVector++)
            {
                G4cout<<(*itProductsVector)->GetName()<<G4endl;
            }
        }
        return &(itReactivesMap->second);
    }
    return 0;
}

Referenced by PrintTable().

DeleteInstance()

void G4DNAMolecularReactionTable::DeleteInstance ( )

static

Definition at line 120 of file G4DNAMolecularReactionTable.cc.

{
    // DEBUG
//        G4cout << "G4MolecularReactionTable::DeleteInstance" << G4endl;
    if(fInstance)
        delete fInstance;
    fInstance = 0;
}

GetReactionData() [1/2]

const std::vector< const G4DNAMolecularReactionData * > * G4DNAMolecularReactionTable::GetReactionData

(

const G4Molecule *

molecule

)

const

Definition at line 472 of file G4DNAMolecularReactionTable.cc.

{
    if(fReactionDataMV.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanInteractWith","",FatalErrorInArgument, errMsg);
        return 0 ;
    }
    ReactionDataMV::const_iterator it = fReactionDataMV.find(molecule) ;
 
    if(it == fReactionDataMV.end())
    {
        G4cout<<"Nom : " << molecule->GetName()<<G4endl;
        G4String errMsg = "No reaction table was implemented for this molecule Definition : "
                + molecule -> GetName();
        G4Exception("G4MolecularInteractionTable::GetReactionData","",FatalErrorInArgument, errMsg);
        return 0; // coverity
    }
 
    return &(it->second);
}

GetReactionData() [2/2]

const G4DNAMolecularReactionData * G4DNAMolecularReactionTable::GetReactionData	(	const G4Molecule *	reactive1,
		const G4Molecule *	reactive2
	)		const

Definition at line 350 of file G4DNAMolecularReactionTable.cc.

{
    if(fReactionData.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanInteractWith","",FatalErrorInArgument, errMsg);
        return 0;
    }
 
    ReactionDataMap::const_iterator it1 = fReactionData.find(reactive1);
 
    if(it1 == fReactionData.end())
    {
        G4cout<<"Nom : " << reactive1->GetName()<<G4endl;
        G4String errMsg = "No reaction table was implemented for this molecule Definition : "
                + reactive1 -> GetName();
        G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
    }
 
    std::map<const G4Molecule*,
             const G4DNAMolecularReactionData*,
             compMoleculeP>::const_iterator it2 =  it1->second.find(reactive2);
 
    if(it2 == it1->second.end())
    {
        G4cout<<"Nom : " << reactive2->GetName()<<G4endl;
        G4String errMsg = "No reaction table was implemented for this molecule Definition : "
                + reactive2 -> GetName();
        G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
    }
 
    return (it2->second);
}

Referenced by G4DNASmoluchowskiReactionModel::Initialise(), G4DNASmoluchowskiReactionModel::InitialiseToPrint(), and G4DNAMolecularReaction::MakeReaction().

GetReactionTable()

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::GetReactionTable ( )

static

Definition at line 111 of file G4DNAMolecularReactionTable.cc.

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

Referenced by G4EmDNAPhysicsChemistry::ConstructReactionTable().

GetReativesNData()

const std::map< const G4Molecule *, const G4DNAMolecularReactionData *, compMoleculeP > * G4DNAMolecularReactionTable::GetReativesNData

(

const G4Molecule *

aMolecule

)

const

Definition at line 428 of file G4DNAMolecularReactionTable.cc.

{
 
    if(fReactionData.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanInteractWith","",FatalErrorInArgument, errMsg);
        return 0;
    }
 
    ReactionDataMap::const_iterator itReactivesMap = fReactionData.find(molecule) ;
 
    if(itReactivesMap == fReactionData.end())
    {
        G4cout<<"Nom : " << molecule->GetName()<<G4endl;
        G4String errMsg = "No reaction table was implemented for this molecule Definition : "
                + molecule -> GetName();
        G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
    }
    else
    {
        if(fVerbose)
        {
            G4cout<< " G4MolecularInteractionTable::CanReactWith :"<<G4endl;
            G4cout<<"You are checking reactants for : " << molecule->GetName()<<G4endl;
            G4cout<<" the number of reactants is : " << itReactivesMap->second.size()<<G4endl;
 
            std::map<const G4Molecule*,
                     const G4DNAMolecularReactionData*,
                     compMoleculeP>::const_iterator itProductsVector =
                    itReactivesMap->second.begin();
 
            for( ; itProductsVector !=  itReactivesMap->second.end(); itProductsVector++)
            {
                G4cout<<itProductsVector->first->GetName()<<G4endl;
            }
        }
        return &(itReactivesMap->second);
    }
 
    return 0;
}

PrintTable()

void G4DNAMolecularReactionTable::PrintTable

(

G4VDNAReactionModel *

pReactionModel = 0

)

Definition at line 195 of file G4DNAMolecularReactionTable.cc.

{
    // Print Reactions and Interaction radius for jump step = 3ps
 
    if(pReactionModel)
    {
        if(!(pReactionModel->GetReactionTable()))
            pReactionModel -> SetReactionTable(this);
    }
 
    ReactivesMV::iterator itReactives;
 
    map<G4Molecule*,map<G4Molecule*, G4bool> > alreadyPrint;
 
    G4cout<<"Nombre particules intervenants dans les reactions = "<< fReactivesMV.size() <<G4endl;
 
    G4int nbPrintable = fReactivesMV.size()*fReactivesMV.size();
 
    G4String *outputReaction = new G4String[nbPrintable];
    G4String *outputReactionRate = new G4String[nbPrintable];
    G4String *outputRange = new G4String[nbPrintable];
    G4int n = 0;
 
    for(itReactives = fReactivesMV.begin() ; itReactives != fReactivesMV.end() ; itReactives++)
    {
        G4Molecule* moleculeA = (G4Molecule*) itReactives->first;
        const vector<const G4Molecule*>* reactivesVector = CanReactWith(moleculeA);
 
        if(pReactionModel)
            pReactionModel -> InitialiseToPrint(moleculeA);
 
        G4int nbReactants = fReactivesMV[itReactives->first].size();
 
        for(G4int iReact = 0 ; iReact < nbReactants ; iReact++)
        {
 
            G4Molecule* moleculeB = (G4Molecule*) (*reactivesVector)[iReact];
 
            const G4DNAMolecularReactionData* reactionData = fReactionData[moleculeA][moleculeB];
 
            //-----------------------------------------------------------
            // Name of the reaction
            if(!alreadyPrint[moleculeA][moleculeB])
            {
                outputReaction[n]=
                        moleculeA->GetName()
                        +" + " +
                        moleculeB->GetName();
 
                G4int nbProducts = reactionData->GetNbProducts();
 
                if(nbProducts)
                {
                    outputReaction[n] += " -> "+ reactionData->GetProduct(0)->GetName();
 
                    for(G4int j =  1 ; j < nbProducts ; j++)
                    {
                        outputReaction[n]+=" + "+reactionData->GetProduct(j)->GetName();
                    }
                }
                else
                {
                    outputReaction[n]+=" -> No product";
                }
 
                //-----------------------------------------------------------
                // Interaction Rate
                outputReactionRate[n] = G4UIcommand::ConvertToString(reactionData->GetReactionRate()/(1e-3*m3/(mole*s)));
 
                //-----------------------------------------------------------
                // Calculation of the Interaction Range
                G4double interactionRange = -1;
                if(pReactionModel)
                    interactionRange = pReactionModel->GetReactionRadius(iReact);
 
                if(interactionRange!=-1)
                {
                    outputRange[n] = G4UIcommand::ConvertToString(interactionRange/nanometer);
                }
                else
                {
                    outputRange[n] = "";
                }
 
                alreadyPrint[moleculeB][moleculeA] = TRUE;
                n++;
            }
        }
    }
    G4cout<<"Number of possible reactions: "<< n << G4endl;
 
    ////////////////////////////////////////////////////////////////////
    // Tableau dynamique en fonction du nombre de caractère maximal dans
    // chaque colonne
    ////////////////////////////////////////////////////////////////////
 
    G4int maxlengthOutputReaction = -1;
    G4int maxlengthOutputReactionRate = -1;
 
    for(G4int i = 0 ; i < n ; i++)
    {
        if(maxlengthOutputReaction < (G4int) outputReaction[i].length())
        {
            maxlengthOutputReaction = outputReaction[i].length();
        }
        if(maxlengthOutputReactionRate < (G4int)outputReactionRate[i].length())
        {
            maxlengthOutputReactionRate = outputReactionRate[i].length();
        }
    }
 
    maxlengthOutputReaction+=2;
    maxlengthOutputReactionRate+=2;
 
    if(maxlengthOutputReaction<10) maxlengthOutputReaction = 10;
    if(maxlengthOutputReactionRate<30) maxlengthOutputReactionRate = 30;
 
    G4String title[3];
 
    title[0] = "Reaction";
    title[1] = "Reaction Rate [dm3/(mol*s)]";
    title[2] = "Interaction Range for chosen reaction model";
 
    G4cout<< setfill(' ')
          << setw(maxlengthOutputReaction)     << left << title[0]
          << setw(maxlengthOutputReactionRate) << left << title[1]
          << setw(2)  << left << title[2]
          << G4endl;
 
    G4cout.fill('-');
    G4cout.width(maxlengthOutputReaction+2+maxlengthOutputReactionRate+2+(G4int)title[2].length());
    G4cout<<"-"<<G4endl;
    G4cout.fill(' ');
 
    for(G4int i = 0 ; i < n ; i ++)
    {
        G4cout<< setw(maxlengthOutputReaction)<< left  << outputReaction[i]
              << setw(maxlengthOutputReactionRate) << left << outputReactionRate[i]
              << setw(2)  << left <<outputRange[i]
              <<G4endl;
 
        G4cout.fill('-');
        G4cout.width(maxlengthOutputReaction+2+maxlengthOutputReactionRate+2+(G4int)title[2].length());
        G4cout<<"-"<<G4endl;
        G4cout.fill(' ');
    }
 
    delete [] outputReaction;
    delete [] outputReactionRate;
    delete [] outputRange;
}

SetReaction() [1/2]

void G4DNAMolecularReactionTable::SetReaction

(

G4DNAMolecularReactionData *

reactionData

)

Definition at line 170 of file G4DNAMolecularReactionTable.cc.

{
    const G4Molecule* reactive1 = reactionData->GetReactive1() ;
    const G4Molecule* reactive2 = reactionData->GetReactive2() ;
 
    fReactionData[reactive1][reactive2] = reactionData;
    fReactivesMV[reactive1].push_back(reactive2);
    fReactionDataMV[reactive1].push_back(reactionData);
 
    if(reactive1 != reactive2)
    {
        fReactionData[reactive2][reactive1] = reactionData;
        fReactivesMV[reactive2].push_back(reactive1);
        fReactionDataMV[reactive2].push_back(reactionData);
    }
}

SetReaction() [2/2]

void G4DNAMolecularReactionTable::SetReaction	(	G4double	observedReactionRate,
		const G4Molecule *	reactive1,
		const G4Molecule *	reactive2
	)

Define a reaction : First argument : reaction rate Second argument : reactant 1 Third argument : reactant 2 Fourth argument : a std std::vector holding the molecular products if this last argument is NULL then it will be interpreted as a reaction giving no products

Definition at line 187 of file G4DNAMolecularReactionTable.cc.

{
    G4DNAMolecularReactionData* reactionData = new G4DNAMolecularReactionData(reactionRate, reactive1, reactive2);
    SetReaction(reactionData);
}

Referenced by SetReaction().

Member Data Documentation

fInstance

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::fInstance

staticprotected

Definition at line 115 of file G4DNAMolecularReactionTable.hh.

Referenced by DeleteInstance(), and GetReactionTable().

fMoleculeHandleManager

const G4MoleculeHandleManager* G4DNAMolecularReactionTable::fMoleculeHandleManager

protected

Definition at line 150 of file G4DNAMolecularReactionTable.hh.

fReactionData

ReactionDataMap G4DNAMolecularReactionTable::fReactionData

protected

Definition at line 162 of file G4DNAMolecularReactionTable.hh.

Referenced by GetReactionData(), GetReativesNData(), PrintTable(), SetReaction(), and ~G4DNAMolecularReactionTable().

fReactionDataMV

ReactionDataMV G4DNAMolecularReactionTable::fReactionDataMV

protected

Definition at line 164 of file G4DNAMolecularReactionTable.hh.

Referenced by GetReactionData(), SetReaction(), and ~G4DNAMolecularReactionTable().

fReactivesMV

ReactivesMV G4DNAMolecularReactionTable::fReactivesMV

protected

Definition at line 163 of file G4DNAMolecularReactionTable.hh.

Referenced by CanReactWith(), PrintTable(), SetReaction(), and ~G4DNAMolecularReactionTable().

fVerbose

G4bool G4DNAMolecularReactionTable::fVerbose

protected

Definition at line 151 of file G4DNAMolecularReactionTable.hh.

Referenced by CanReactWith(), G4DNAMolecularReactionTable(), and GetReativesNData().

---

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

• G4DNAMolecularReactionTable.hh
• G4DNAMolecularReactionTable.cc