#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

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

protected

Definition at line 159 of file G4DNAMolecularReactionTable.hh.

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

protected

Definition at line 161 of file G4DNAMolecularReactionTable.hh.

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

protected

Definition at line 160 of file G4DNAMolecularReactionTable.hh.

Constructor & Destructor Documentation

G4DNAMolecularReactionTable::G4DNAMolecularReactionTable ( )

protected

Definition at line 130 of file G4DNAMolecularReactionTable.cc.

References fVerbose.

Referenced by GetReactionTable().

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

G4DNAMolecularReactionTable::~G4DNAMolecularReactionTable ( )

virtual

Definition at line 138 of file G4DNAMolecularReactionTable.cc.

References fReactionData, fReactionDataMV, fReactivesMV, G4DNAMolecularReactionData::GetReactive1(), and G4DNAMolecularReactionData::GetReactive2().

 {
     // 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

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 387 of file G4DNAMolecularReactionTable.cc.

References FatalErrorInArgument, fReactivesMV, fVerbose, G4cout, G4endl, G4Exception(), and G4Molecule::GetName().

Referenced by PrintTable().

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

void G4DNAMolecularReactionTable::DeleteInstance ( )

static

Definition at line 121 of file G4DNAMolecularReactionTable.cc.

References fInstance.

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

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

Definition at line 351 of file G4DNAMolecularReactionTable.cc.

References FatalErrorInArgument, fReactionData, G4cout, G4endl, G4Exception(), and G4Molecule::GetName().

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

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

const std::vector< const G4DNAMolecularReactionData * > * G4DNAMolecularReactionTable::GetReactionData ( const G4Molecule * molecule ) const

Definition at line 473 of file G4DNAMolecularReactionTable.cc.

References FatalErrorInArgument, fReactionDataMV, G4cout, G4endl, G4Exception(), and G4Molecule::GetName().

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

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::GetReactionTable ( )

static

Definition at line 112 of file G4DNAMolecularReactionTable.cc.

References fInstance, and G4DNAMolecularReactionTable().

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

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

Definition at line 429 of file G4DNAMolecularReactionTable.cc.

References FatalErrorInArgument, fReactionData, fVerbose, G4cout, G4endl, G4Exception(), and G4Molecule::GetName().

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

void G4DNAMolecularReactionTable::PrintTable ( G4VDNAReactionModel * pReactionModel = 0 )

Definition at line 196 of file G4DNAMolecularReactionTable.cc.

References CanReactWith(), G4UIcommand::ConvertToString(), fReactionData, fReactivesMV, G4cout, G4endl, G4Molecule::GetName(), G4DNAMolecularReactionData::GetNbProducts(), G4DNAMolecularReactionData::GetProduct(), G4VDNAReactionModel::GetReactionRadius(), G4DNAMolecularReactionData::GetReactionRate(), G4VDNAReactionModel::GetReactionTable(), left, python.hepunit::m3, python.hepunit::mole, n, python.hepunit::nanometer, title(), and TRUE.

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

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 188 of file G4DNAMolecularReactionTable.cc.

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

void G4DNAMolecularReactionTable::SetReaction ( G4DNAMolecularReactionData * reactionData )

Definition at line 171 of file G4DNAMolecularReactionTable.cc.

References fReactionData, fReactionDataMV, fReactivesMV, G4DNAMolecularReactionData::GetReactive1(), and G4DNAMolecularReactionData::GetReactive2().

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