G4DNAMolecularReactionTable Class Reference

#include <G4DNAMolecularReactionTable.hh>

Inheritance diagram for G4DNAMolecularReactionTable:

Collaboration diagram for G4DNAMolecularReactionTable:

Public Member Functions
virtual	~G4DNAMolecularReactionTable ()
void	SetReaction (G4double observedReactionRate, G4MolecularConfiguration *reactive1, G4MolecularConfiguration *reactive2)
void	SetReaction (G4DNAMolecularReactionData *)
const G4DNAMolecularReactionData *	GetReactionData (G4MolecularConfiguration *, G4MolecularConfiguration *) const
const G4DNAMolecularReactionData *	GetReactionData (const G4String &, const G4String &) const
const G4DNAMolecularReactionData *	GetReaction (int reactionID) const
size_t	GetNReactions () const
const std::vector < G4MolecularConfiguration * > *	CanReactWith (G4MolecularConfiguration *) const
const std::map < G4MolecularConfiguration *, const G4DNAMolecularReactionData * > *	GetReativesNData (G4MolecularConfiguration *) const
const std::vector< const G4DNAMolecularReactionData * > *	GetReactionData (G4MolecularConfiguration *) const
const std::map < G4MolecularConfiguration *, std::map < G4MolecularConfiguration *, const G4DNAMolecularReactionData * > > &	GetAllReactionData ()
const std::vector< const G4DNAMolecularReactionData * > &	GetVectorOfReactionData ()
void	ScaleReactionRateForNewTemperature (double temp_K)
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 G4DNAMolecularReactionTable *	Instance ()
static void	DeleteInstance ()

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

Protected Member Functions
	G4DNAMolecularReactionTable ()

Protected Attributes
G4bool	fVerbose
ReactionDataMap	fReactionData
ReactivesMV	fReactantsMV
ReactionDataMV	fReactionDataMV
std::vector< const G4DNAMolecularReactionData * >	fVectorOfReactionData
G4ReactionTableMessenger *	fpMessenger

Static Protected Attributes
static G4DNAMolecularReactionTable *	fInstance

Detailed Description

G4DNAMolecularReactionTable sorts out the G4DNAMolecularReactionData for bimolecular reaction

Definition at line 199 of file G4DNAMolecularReactionTable.hh.

Member Typedef Documentation

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

protected

Definition at line 275 of file G4DNAMolecularReactionTable.hh.

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

protected

Definition at line 279 of file G4DNAMolecularReactionTable.hh.

typedef std::map<G4MolecularConfiguration*, std::vector<G4MolecularConfiguration*> > G4DNAMolecularReactionTable::ReactivesMV

protected

Definition at line 277 of file G4DNAMolecularReactionTable.hh.

Constructor & Destructor Documentation

G4DNAMolecularReactionTable::G4DNAMolecularReactionTable ( )

protected

Definition at line 244 of file G4DNAMolecularReactionTable.cc.

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

Here is the caller graph for this function:

G4DNAMolecularReactionTable::~G4DNAMolecularReactionTable ( )

virtual

Definition at line 256 of file G4DNAMolecularReactionTable.cc.

{
  // DEBUG
//    G4cout << "G4MolecularReactionTable::~G4MolecularReactionTable" << G4endl;

  if(fpMessenger) delete fpMessenger;

  ReactionDataMap::iterator it1 = fReactionData.begin();
  std::map<G4MolecularConfiguration*,
            const G4DNAMolecularReactionData*>::iterator it2;

  for(; it1 != fReactionData.end(); it1++)
  {
    for(it2 = it1->second.begin(); it2 != it1->second.end(); it2++)
    {
      const G4DNAMolecularReactionData* reactionData = it2->second;
      if(reactionData)
      {
        G4MolecularConfiguration* reactant1 =
            reactionData->GetReactant1();
        G4MolecularConfiguration* reactant2 =
            reactionData->GetReactant2();

        fReactionData[reactant1][reactant2] = 0;
        fReactionData[reactant2][reactant1] = 0;

        delete reactionData;
      }
    }
  }

  fReactionDataMV.clear();
  fReactionData.clear();
  fReactantsMV.clear();
}

Here is the call graph for this function:

Member Function Documentation

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

(

G4MolecularConfiguration *

aMolecule

)

const

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

Definition at line 545 of file G4DNAMolecularReactionTable.cc.

{
  if (fReactantsMV.empty())
  {
    G4String errMsg = "No reaction table was implemented";
    G4Exception("G4MolecularInteractionTable::CanReactWith", "",
                FatalErrorInArgument, errMsg);
    return 0;
  }

  ReactivesMV::const_iterator itReactivesMap = fReactantsMV.find(aMolecule);

  if (itReactivesMap == fReactantsMV.end())
  {
#ifdef G4VERBOSE
    if (fVerbose)
    {
      G4String errMsg = "No reaction table was implemented for this molecule : "
          + aMolecule->GetName();
//          G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
      G4cout << "--- G4MolecularInteractionTable::GetReactionData ---" << G4endl;
      G4cout << errMsg << G4endl;
    }
#endif
    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<G4MolecularConfiguration*>::const_iterator itProductsVector =
      itReactivesMap->second.begin();

      for(; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
      {
        G4cout<<(*itProductsVector)->GetName()<<G4endl;
      }
    }
    return &(itReactivesMap->second);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAMolecularReactionTable::DeleteInstance ( )

static

Definition at line 234 of file G4DNAMolecularReactionTable.cc.

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

Here is the caller graph for this function:

const std::map<G4MolecularConfiguration*, std::map<G4MolecularConfiguration*, const G4DNAMolecularReactionData*> >& G4DNAMolecularReactionTable::GetAllReactionData ( )

inline

Definition at line 253 of file G4DNAMolecularReactionTable.hh.

  {
    return fReactionData;
  }

size_t G4DNAMolecularReactionTable::GetNReactions ( ) const

inline

Definition at line 234 of file G4DNAMolecularReactionTable.hh.

  { return fVectorOfReactionData.size(); }

const G4DNAMolecularReactionData * G4DNAMolecularReactionTable::GetReaction

(

int

reactionID

)

const

Definition at line 745 of file G4DNAMolecularReactionTable.cc.

{
  for(size_t i = 0 ; i < fVectorOfReactionData.size() ; ++i)
  {
    if(fVectorOfReactionData[i]->GetReactionID() == reactionID)
      return fVectorOfReactionData[i];
  }
  return nullptr;
}

const G4DNAMolecularReactionData * G4DNAMolecularReactionTable::GetReactionData	(	G4MolecularConfiguration *	reactant1,
		G4MolecularConfiguration *	reactant2
	)		const

Definition at line 502 of file G4DNAMolecularReactionTable.cc.

{
  if (fReactionData.empty())
  {
    G4String errMsg = "No reaction table was implemented";
    G4Exception("G4MolecularInteractionTable::GetReactionData", "",
                FatalErrorInArgument, errMsg);
    return 0;
  }

  ReactionDataMap::const_iterator it1 = fReactionData.find(reactant1);

  if (it1 == fReactionData.end())
  {
    G4String errMsg =
        "No reaction table was implemented for this molecule Definition : " + reactant1
            ->GetName();
//      G4cout << "--- G4MolecularInteractionTable::GetReactionData ---" << G4endl;
//      G4cout << errMsg << G4endl;
    G4Exception("G4MolecularInteractionTable::GetReactionData", "",
                FatalErrorInArgument, errMsg);
//      return 0;
  }

  std::map<G4MolecularConfiguration*,
            const G4DNAMolecularReactionData*>::const_iterator it2 =
                 it1->second.find(reactant2);

  if (it2 == it1->second.end())
  {
    G4cout << "Name : " << reactant2->GetName() << G4endl;
    G4String errMsg = "No reaction table was implemented for this molecule : "
    + reactant2 -> GetName();
    G4Exception("G4MolecularInteractionTable::GetReactionData","",FatalErrorInArgument, errMsg);
  }

  return (it2->second);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const G4DNAMolecularReactionData * G4DNAMolecularReactionTable::GetReactionData	(	const G4String &	mol1,
		const G4String &	mol2
	)		const

Definition at line 667 of file G4DNAMolecularReactionTable.cc.

{
  G4MolecularConfiguration* conf1 = G4MoleculeTable::GetMoleculeTable()
      ->GetConfiguration(mol1);
  G4MolecularConfiguration* conf2 = G4MoleculeTable::GetMoleculeTable()
      ->GetConfiguration(mol2);

  return GetReactionData(conf1, conf2);
}

Here is the call graph for this function:

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

(

G4MolecularConfiguration *

molecule

)

const

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

Here is the call graph for this function:

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::GetReactionTable ( )

static

Definition at line 212 of file G4DNAMolecularReactionTable.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

const std::map< G4MolecularConfiguration *, const G4DNAMolecularReactionData * > * G4DNAMolecularReactionTable::GetReativesNData

(

G4MolecularConfiguration *

molecule

)

const

Definition at line 595 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())
  {
    return 0;
//    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<G4MolecularConfiguration*,
      const G4DNAMolecularReactionData*>::const_iterator itProductsVector =
      itReactivesMap->second.begin();

      for(; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
      {
        G4cout<<itProductsVector->first->GetName()<<G4endl;
      }
    }
    return &(itReactivesMap->second);
  }

  return 0;
}

Here is the call graph for this function:

const std::vector<const G4DNAMolecularReactionData*>& G4DNAMolecularReactionTable::GetVectorOfReactionData ( )

inline

Definition at line 259 of file G4DNAMolecularReactionTable.hh.

  {
    return fVectorOfReactionData;
  }

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::Instance ( void  )

static

Definition at line 223 of file G4DNAMolecularReactionTable.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAMolecularReactionTable::PrintTable

(

G4VDNAReactionModel *

pReactionModel = 0

)

Definition at line 326 of file G4DNAMolecularReactionTable.cc.

{
  // Print Reactions and Interaction radius for jump step = 3ps

  G4IosFlagsSaver iosfs(G4cout);

  if (pReactionModel)
  {
    if (!(pReactionModel->GetReactionTable())) pReactionModel->SetReactionTable(
        this);
  }

  ReactivesMV::iterator itReactives;

  map<G4MolecularConfiguration*, map<G4MolecularConfiguration*, G4bool> > alreadyPrint;

  G4cout << "Number of chemical species involved in reactions = "
         << fReactantsMV.size() << G4endl;

  G4int nbPrintable = fReactantsMV.size() * fReactantsMV.size();

  G4String *outputReaction = new G4String[nbPrintable];
  G4String *outputReactionRate = new G4String[nbPrintable];
  G4String *outputRange = new G4String[nbPrintable];
  G4int n = 0;

  for (itReactives = fReactantsMV.begin(); itReactives != fReactantsMV.end();
      itReactives++)
  {
    G4MolecularConfiguration* moleculeA = (G4MolecularConfiguration*) itReactives->first;
    const vector<G4MolecularConfiguration*>* reactivesVector = CanReactWith(moleculeA);

    if (pReactionModel) pReactionModel->InitialiseToPrint(moleculeA);

    G4int nbReactants = fReactantsMV[itReactives->first].size();

    for (G4int iReact = 0; iReact < nbReactants; iReact++)
    {

      G4MolecularConfiguration* moleculeB = (G4MolecularConfiguration*) (*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->GetObservedReactionRateConstant() / (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;

  if (pReactionModel) title = new G4String[3];
  else title = new G4String[2];

  title[0] = "Reaction";
  title[1] = "Reaction Rate [dm3/(mol*s)]";

  if (pReactionModel) title[2] =
      "Interaction Range for chosen reaction model [nm]";

  G4cout << setfill(' ') << setw(maxlengthOutputReaction) << left << title[0]
         << setw(maxlengthOutputReactionRate) << left << title[1];

  if (pReactionModel) G4cout << setw(2) << left << title[2];

  G4cout << G4endl;

  G4cout.fill('-');
  if (pReactionModel) G4cout.width(
      maxlengthOutputReaction + 2 + maxlengthOutputReactionRate + 2
      + (G4int) title[2].length());
  else G4cout.width(maxlengthOutputReaction + 2 + maxlengthOutputReactionRate);
  G4cout << "-" << G4endl;
  G4cout.fill(' ');

  for (G4int i = 0; i < n; i++)
  {
    G4cout << setw(maxlengthOutputReaction) << left << outputReaction[i]
           << setw(maxlengthOutputReactionRate) << left
           << outputReactionRate[i];

    if (pReactionModel) G4cout << setw(2) << left << outputRange[i];

    G4cout << G4endl;

    G4cout.fill('-');
    if (pReactionModel) G4cout.width(
        maxlengthOutputReaction + 2 + maxlengthOutputReactionRate + 2
        + (G4int) title[2].length());
    else G4cout.width(
        maxlengthOutputReaction + 2 + maxlengthOutputReactionRate);
    G4cout << "-" << G4endl;
    G4cout.fill(' ');
  }

  delete[] title;
  delete[] outputReaction;
  delete[] outputReactionRate;
  delete[] outputRange;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4DNAMolecularReactionTable::ScaleReactionRateForNewTemperature

(

double

temp_K

)

Definition at line 713 of file G4DNAMolecularReactionTable.cc.

{
  size_t end = fVectorOfReactionData.size();

  for(size_t i = 0 ; i < end ; ++i)
  {
    ((G4DNAMolecularReactionData*) fVectorOfReactionData[i])->
        ScaleForNewTemperature(temp_K);
  }
}

Here is the caller graph for this function:

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

Define a reaction : First argument : reaction rate Second argument : reactant 1 Third argument : reactant 2 Fourth argument : a 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 315 of file G4DNAMolecularReactionTable.cc.

{
  G4DNAMolecularReactionData* reactionData = new G4DNAMolecularReactionData(
      reactionRate, reactant1, reactant2);
  SetReaction(reactionData);
}

Here is the caller graph for this function:

void G4DNAMolecularReactionTable::SetReaction

(

G4DNAMolecularReactionData *

reactionData

)

Definition at line 294 of file G4DNAMolecularReactionTable.cc.

{
  G4MolecularConfiguration* reactant1 = reactionData->GetReactant1();
  G4MolecularConfiguration* reactant2 = reactionData->GetReactant2();

  fReactionData[reactant1][reactant2] = reactionData;
  fReactantsMV[reactant1].push_back(reactant2);
  fReactionDataMV[reactant1].push_back(reactionData);

  if (reactant1 != reactant2)
  {
    fReactionData[reactant2][reactant1] = reactionData;
    fReactantsMV[reactant2].push_back(reactant1);
    fReactionDataMV[reactant2].push_back(reactionData);
  }

  fVectorOfReactionData.push_back(reactionData);
}

Here is the call graph for this function:

Member Data Documentation

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::fInstance

staticprotected

Definition at line 203 of file G4DNAMolecularReactionTable.hh.

G4ReactionTableMessenger* G4DNAMolecularReactionTable::fpMessenger

protected

Definition at line 285 of file G4DNAMolecularReactionTable.hh.

ReactivesMV G4DNAMolecularReactionTable::fReactantsMV

protected

Definition at line 282 of file G4DNAMolecularReactionTable.hh.

ReactionDataMap G4DNAMolecularReactionTable::fReactionData

protected

Definition at line 281 of file G4DNAMolecularReactionTable.hh.

ReactionDataMV G4DNAMolecularReactionTable::fReactionDataMV

protected

Definition at line 283 of file G4DNAMolecularReactionTable.hh.

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

protected

Definition at line 284 of file G4DNAMolecularReactionTable.hh.

G4bool G4DNAMolecularReactionTable::fVerbose

protected

Definition at line 270 of file G4DNAMolecularReactionTable.hh.

---

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

• source/geant4.10.03.p03/source/processes/electromagnetic/dna/utils/include/G4DNAMolecularReactionTable.hh
• source/geant4.10.03.p03/source/processes/electromagnetic/dna/utils/src/G4DNAMolecularReactionTable.cc