G4DNAMolecularReactionTable Class Reference

#include <G4DNAMolecularReactionTable.hh>

Inheritance diagram for G4DNAMolecularReactionTable:

Public Types
using	Data = const G4DNAMolecularReactionData
using	DataList = std::vector< Data * >
using	Reactant = const G4MolecularConfiguration
using	ReactantList = std::vector< Reactant * >
using	ReactionDataMap = std::map< Reactant *, SpecificDataList >
using	ReactionDataMV = std::map< Reactant *, DataList >
using	ReactivesMV = std::map< Reactant *, ReactantList >
using	SpecificDataList = std::map< Reactant *, Data * >

Public Member Functions
const ReactantList *	CanReactWith (Reactant *) const
const ReactionDataMap &	GetAllReactionData ()
G4VDNAMolecularGeometry *	GetGeometry () const
size_t	GetNReactions () const
Data *	GetReaction (int reactionID) const
const DataList *	GetReactionData (const G4MolecularConfiguration *) const
Data *	GetReactionData (const G4String &, const G4String &) const
Data *	GetReactionData (Reactant *, Reactant *) const
const SpecificDataList *	GetReativesNData (const G4MolecularConfiguration *) const
DataList	GetVectorOfReactionData ()
void	PrintTable (G4VDNAReactionModel *=0)
void	ScaleReactionRateForNewTemperature (double temp_K)
void	SetGeometry (G4VDNAMolecularGeometry *geometry)
void	SetReaction (G4DNAMolecularReactionData *)
void	SetReaction (G4double observedReactionRate, Reactant *reactive1, Reactant *reactive2)
virtual	~G4DNAMolecularReactionTable ()

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

Protected Member Functions
	G4DNAMolecularReactionTable ()

Protected Attributes
G4VDNAMolecularGeometry *	fGeometry
std::unique_ptr< G4ReactionTableMessenger >	fpMessenger
ReactivesMV	fReactantsMV
ReactionDataMap	fReactionData
ReactionDataMV	fReactionDataMV
std::vector< std::unique_ptr< Data > >	fVectorOfReactionData
G4bool	fVerbose

Static Protected Attributes
static G4DNAMolecularReactionTable *	fpInstance

Detailed Description

G4DNAMolecularReactionTable sorts out the G4DNAMolecularReactionData for bimolecular reaction

Definition at line 175 of file G4DNAMolecularReactionTable.hh.

Member Typedef Documentation

Data

using G4DNAMolecularReactionTable::Data = const G4DNAMolecularReactionData

Definition at line 188 of file G4DNAMolecularReactionTable.hh.

DataList

using G4DNAMolecularReactionTable::DataList = std::vector<Data*>

Definition at line 190 of file G4DNAMolecularReactionTable.hh.

Reactant

using G4DNAMolecularReactionTable::Reactant = const G4MolecularConfiguration

Definition at line 187 of file G4DNAMolecularReactionTable.hh.

ReactantList

using G4DNAMolecularReactionTable::ReactantList = std::vector<Reactant*>

Definition at line 189 of file G4DNAMolecularReactionTable.hh.

ReactionDataMap

using G4DNAMolecularReactionTable::ReactionDataMap = std::map<Reactant*, SpecificDataList>

Definition at line 193 of file G4DNAMolecularReactionTable.hh.

ReactionDataMV

using G4DNAMolecularReactionTable::ReactionDataMV = std::map<Reactant*, DataList>

Definition at line 195 of file G4DNAMolecularReactionTable.hh.

ReactivesMV

using G4DNAMolecularReactionTable::ReactivesMV = std::map<Reactant*, ReactantList>

Definition at line 194 of file G4DNAMolecularReactionTable.hh.

SpecificDataList

using G4DNAMolecularReactionTable::SpecificDataList = std::map<Reactant*, Data*>

Definition at line 191 of file G4DNAMolecularReactionTable.hh.

Constructor & Destructor Documentation

G4DNAMolecularReactionTable()

G4DNAMolecularReactionTable::G4DNAMolecularReactionTable ( )

protected

Definition at line 382 of file G4DNAMolecularReactionTable.cc.

    : G4ITReactionTable()
    , fVerbose(false)
    , fGeometry(nullptr)
    , fpMessenger(new G4ReactionTableMessenger(this))
{
}

Referenced by GetReactionTable(), and Instance().

~G4DNAMolecularReactionTable()

G4DNAMolecularReactionTable::~G4DNAMolecularReactionTable ( )

virtualdefault

Member Function Documentation

CanReactWith()

const G4DNAMolecularReactionTable::ReactantList * G4DNAMolecularReactionTable::CanReactWith

(

Reactant *

pMolecule

)

const

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

Definition at line 656 of file G4DNAMolecularReactionTable.cc.

{
    if (fReactantsMV.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanReactWith", "",
                    FatalErrorInArgument, errMsg);
        return 0;
    }
 
    auto itReactivesMap = fReactantsMV.find(pMolecule);
 
    if (itReactivesMap == fReactantsMV.end())
    {
#ifdef G4VERBOSE
        if (fVerbose)
        {
            G4String errMsg = "No reaction table was implemented for this molecule : "
                + pMolecule->GetName();
            //          G4Exception("G4MolecularInteractionTable::CanReactWith","",FatalErrorInArgument, errMsg);
            G4cout << "--- G4MolecularInteractionTable::GetReactionData ---" << G4endl;
            G4cout << errMsg << G4endl;
        }
#endif
        return nullptr;
    }
 
    if (fVerbose)
    {
        G4cout << " G4MolecularInteractionTable::CanReactWith :" << G4endl;
        G4cout << "You are checking reactants for : " << pMolecule->GetName() << G4endl;
        G4cout << " the number of reactants is : " << itReactivesMap->second.size() << G4endl;
 
        auto itProductsVector = itReactivesMap->second.cbegin();
 
        for (; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
        {
            G4cout << (*itProductsVector)->GetName() << G4endl;
        }
    }
    return &(itReactivesMap->second);
}

References FatalErrorInArgument, fReactantsMV, fVerbose, G4cout, G4endl, G4Exception(), and G4MolecularConfiguration::GetName().

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateStep(), G4DNAMoleculeEncounterStepper::CalculateStep(), G4DNAIndependentReactionTimeStepper::CalculateStep(), PrintTable(), G4DNAIRT::Sampling(), and G4DNAIRT_geometries::Sampling().

DeleteInstance()

void G4DNAMolecularReactionTable::DeleteInstance ( )

static

Definition at line 371 of file G4DNAMolecularReactionTable.cc.

{
    if (fpInstance)
    {
        delete fpInstance;
    }
    fpInstance = nullptr;
}

References fpInstance.

Referenced by G4DNAChemistryManager::Clear().

GetAllReactionData()

const G4DNAMolecularReactionTable::ReactionDataMap & G4DNAMolecularReactionTable::GetAllReactionData

(

)

Definition at line 636 of file G4DNAMolecularReactionTable.cc.

{
    return fReactionData;
}

References fReactionData.

GetGeometry()

G4VDNAMolecularGeometry * G4DNAMolecularReactionTable::GetGeometry

(

)

const

Definition at line 596 of file G4DNAMolecularReactionTable.cc.

{
  return fGeometry;
}

References fGeometry.

Referenced by G4DNAIRT_geometries::Initialize().

GetNReactions()

size_t G4DNAMolecularReactionTable::GetNReactions

(

)

const

Definition at line 830 of file G4DNAMolecularReactionTable.cc.

{
    return fVectorOfReactionData.size();
}

References fVectorOfReactionData.

GetReaction()

G4DNAMolecularReactionTable::Data * G4DNAMolecularReactionTable::GetReaction

(

int

reactionID

)

const

Definition at line 818 of file G4DNAMolecularReactionTable.cc.

{
    for (auto& pData : fVectorOfReactionData)
    {
        if (pData->GetReactionID() == reactionID)
        {
            return pData.get();
        }
    }
    return nullptr;
}

References fVectorOfReactionData.

GetReactionData() [1/3]

const G4DNAMolecularReactionTable::DataList * G4DNAMolecularReactionTable::GetReactionData

(

const G4MolecularConfiguration *

molecule

)

const

Definition at line 737 of file G4DNAMolecularReactionTable.cc.

{
    if (fReactionDataMV.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanInteractWith", "",
                    FatalErrorInArgument, errMsg);
    }
    auto it = fReactionDataMV.find(molecule);
 
    if (it == fReactionDataMV.end())
    {
        G4String errMsg = "No reaction table was implemented for this molecule Definition : "
            + molecule->GetName();
        G4Exception("G4MolecularInteractionTable::GetReactionData", "", FatalErrorInArgument, errMsg);
    }
 
    return &(it->second);
}

References FatalErrorInArgument, fReactionDataMV, G4Exception(), and G4MolecularConfiguration::GetName().

GetReactionData() [2/3]

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

Definition at line 759 of file G4DNAMolecularReactionTable.cc.

{
    const auto pConf1 = G4MoleculeTable::GetMoleculeTable()->GetConfiguration(mol1);
    const auto pConf2 = G4MoleculeTable::GetMoleculeTable()->GetConfiguration(mol2);
    return GetReactionData(pConf1, pConf2);
}

References G4MoleculeTable::GetConfiguration(), G4MoleculeTable::GetMoleculeTable(), and GetReactionData().

GetReactionData() [3/3]

G4DNAMolecularReactionTable::Data * G4DNAMolecularReactionTable::GetReactionData	(	Reactant *	pReactant1,
		Reactant *	pReactant2
	)		const

Definition at line 602 of file G4DNAMolecularReactionTable.cc.

{
    if (fReactionData.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::GetReactionData", "",
                    FatalErrorInArgument, errMsg);
    }
 
    auto it1 = fReactionData.find(pReactant1);
 
    if (it1 == fReactionData.end())
    {
        G4String errMsg =
            "No reaction table was implemented for this molecule Definition : " + pReactant1
            ->GetName();
        G4Exception("G4MolecularInteractionTable::GetReactionData", "",
                    FatalErrorInArgument, errMsg);
    }
 
    ReactionDataMap::mapped_type::const_iterator it2 = it1->second.find(pReactant2);
 
    if (it2 == it1->second.end())
    {
        G4cout << "Name : " << pReactant2->GetName() << G4endl;
        G4String errMsg = "No reaction table was implemented for this molecule : "
            + pReactant2->GetName();
        G4Exception("G4MolecularInteractionTable::GetReactionData", "", FatalErrorInArgument, errMsg);
    }
 
    return (it2->second);
}

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

Referenced by G4DNAPartiallyDiffusionControlled::GeminateRecombinationProbability(), G4DNAIRT::GetIndependentReactionTime(), G4DNAIRT_geometries::GetIndependentReactionTime(), GetReactionData(), G4DNASmoluchowskiReactionModel::GetReactionRadius(), G4DiffusionControlledReactionModel::GetReactionRadius(), G4DNAIndependentReactionTimeStepper::GetReactionType(), G4DNAPartiallyDiffusionControlled::GetTimeToEncounter(), G4DNATotallyDiffusionControlled::GetTimeToEncounter(), G4DNASmoluchowskiReactionModel::Initialise(), G4DiffusionControlledReactionModel::Initialise(), G4DNASmoluchowskiReactionModel::InitialiseToPrint(), G4DiffusionControlledReactionModel::InitialiseToPrint(), G4DNAIRT::MakeReaction(), G4DNAIRT_geometries::MakeReaction(), G4DNAMakeReaction::MakeReaction(), G4DNAMolecularReaction::MakeReaction(), G4DNAIRT::Sampling(), and G4DNAIRT_geometries::Sampling().

GetReactionTable()

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::GetReactionTable ( )

static

Definition at line 349 of file G4DNAMolecularReactionTable.cc.

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

References fpInstance, and G4DNAMolecularReactionTable().

Referenced by G4DNAIndependentReactionTimeModel::Initialize(), G4DNAMolecularIRTModel::Initialize(), G4DNAMolecularStepByStepModel::Initialize(), G4DNAChemistryManager::InitializeMaster(), and G4DNAChemistryManager::InitializeThread().

GetReativesNData()

const G4DNAMolecularReactionTable::SpecificDataList * G4DNAMolecularReactionTable::GetReativesNData

(

const G4MolecularConfiguration *

molecule

)

const

Definition at line 702 of file G4DNAMolecularReactionTable.cc.

{
    if (fReactionData.empty())
    {
        G4String errMsg = "No reaction table was implemented";
        G4Exception("G4MolecularInteractionTable::CanInteractWith", "",
                    FatalErrorInArgument, errMsg);
    }
 
    ReactionDataMap::const_iterator itReactivesMap = fReactionData.find(molecule);
 
    if (itReactivesMap == fReactionData.end())
    {
        return nullptr;
    }
 
    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;
 
        SpecificDataList::const_iterator itProductsVector = itReactivesMap->second.begin();
 
        for (; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
        {
            G4cout << itProductsVector->first->GetName() << G4endl;
        }
    }
    return &(itReactivesMap->second);
}

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

GetVectorOfReactionData()

G4DNAMolecularReactionTable::DataList G4DNAMolecularReactionTable::GetVectorOfReactionData

(

)

Definition at line 641 of file G4DNAMolecularReactionTable.cc.

{
    DataList dataList;
 
    for (const auto& pData : fVectorOfReactionData)
    {
        dataList.emplace_back(pData.get());
    }
 
    return dataList;
}

References fVectorOfReactionData.

Referenced by G4DNAGillespieDirectMethod::Reaction().

Instance()

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::Instance ( void  )

static

Definition at line 360 of file G4DNAMolecularReactionTable.cc.

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

References fpInstance, and G4DNAMolecularReactionTable().

Referenced by G4DNAEventScheduler::CheckingReactionRadius(), G4DNAPartiallyDiffusionControlled::GeminateRecombinationProbability(), G4DNAPartiallyDiffusionControlled::GetTimeToEncounter(), G4DNATotallyDiffusionControlled::GetTimeToEncounter(), and G4DNAChemistryManager::SetGlobalTemperature().

PrintTable()

void G4DNAMolecularReactionTable::PrintTable

(

G4VDNAReactionModel *

pReactionModel = 0

)

Definition at line 424 of file G4DNAMolecularReactionTable.cc.

{
    // Print Reactions and Interaction radius for jump step = 3ps
 
    G4IosFlagsSaver iosfs(G4cout);
 
   if (pReactionModel && !(pReactionModel->GetReactionTable()))
   {
       pReactionModel->SetReactionTable(this);
   }
 
    ReactivesMV::iterator itReactives;
 
    std::map<Reactant*, std::map<Reactant*, 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++)
    {
        Reactant* moleculeA = (Reactant*)itReactives->first;
        const vector<Reactant*>* reactivesVector = CanReactWith(moleculeA);
 
        if (pReactionModel) pReactionModel->InitialiseToPrint(moleculeA);
 
        G4int nbReactants = fReactantsMV[itReactives->first].size();
 
        for (G4int iReact = 0; iReact < nbReactants; iReact++)
        {
            auto moleculeB = (Reactant*)(*reactivesVector)[iReact];
 
            Data* 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;
}

References CanReactWith(), G4UIcommand::ConvertToString(), fReactantsMV, fReactionData, G4cout, G4endl, G4MolecularConfiguration::GetName(), G4DNAMolecularReactionData::GetNbProducts(), G4DNAMolecularReactionData::GetObservedReactionRateConstant(), G4DNAMolecularReactionData::GetProduct(), G4VDNAReactionModel::GetReactionRadius(), G4VDNAReactionModel::GetReactionTable(), G4VDNAReactionModel::InitialiseToPrint(), m3, mole, CLHEP::detail::n, nanometer, s, G4VDNAReactionModel::SetReactionTable(), and TRUE.

Referenced by G4EmDNAChemistry_option2::ConstructTimeStepModel(), G4EmDNAChemistry::ConstructTimeStepModel(), G4EmDNAChemistry_option1::ConstructTimeStepModel(), and G4ReactionTableMessenger::SetNewValue().

ScaleReactionRateForNewTemperature()

void G4DNAMolecularReactionTable::ScaleReactionRateForNewTemperature

(

double

temp_K

)

Definition at line 797 of file G4DNAMolecularReactionTable.cc.

{
    for (const auto& pData : fVectorOfReactionData)
    {
        const_cast<G4DNAMolecularReactionData*>(pData.get())->ScaleForNewTemperature(temp_K);
    }
}

References fVectorOfReactionData.

Referenced by G4DNAChemistryManager::SetGlobalTemperature().

SetGeometry()

void G4DNAMolecularReactionTable::SetGeometry ( G4VDNAMolecularGeometry *  geometry )

inline

Definition at line 212 of file G4DNAMolecularReactionTable.hh.

{fGeometry = geometry;};

References fGeometry.

SetReaction() [1/2]

void G4DNAMolecularReactionTable::SetReaction

(

G4DNAMolecularReactionData *

pReactionData

)

Definition at line 392 of file G4DNAMolecularReactionTable.cc.

{
    const auto pReactant1 = pReactionData->GetReactant1();
    const auto pReactant2 = pReactionData->GetReactant2();
 
    fReactionData[pReactant1][pReactant2] = pReactionData;
    fReactantsMV[pReactant1].push_back(pReactant2);
    fReactionDataMV[pReactant1].push_back(pReactionData);
 
    if (pReactant1 != pReactant2)
    {
        fReactionData[pReactant2][pReactant1] = pReactionData;
        fReactantsMV[pReactant2].push_back(pReactant1);
        fReactionDataMV[pReactant2].push_back(pReactionData);
    }
 
    fVectorOfReactionData.emplace_back(pReactionData);
    pReactionData->SetReactionID(fVectorOfReactionData.size());
}

References fReactantsMV, fReactionData, fReactionDataMV, fVectorOfReactionData, G4DNAMolecularReactionData::GetReactant1(), G4DNAMolecularReactionData::GetReactant2(), and G4DNAMolecularReactionData::SetReactionID().

SetReaction() [2/2]

void G4DNAMolecularReactionTable::SetReaction	(	G4double	observedReactionRate,
		Reactant *	reactive1,
		Reactant *	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 414 of file G4DNAMolecularReactionTable.cc.

{
    auto reactionData = new G4DNAMolecularReactionData(reactionRate, pReactant1, pReactant2);
    SetReaction(reactionData);
}

References SetReaction().

Referenced by G4EmDNAChemistry_option2::ConstructReactionTable(), G4EmDNAChemistry::ConstructReactionTable(), G4EmDNAChemistry_option1::ConstructReactionTable(), G4EmDNAChemistry_option3::ConstructReactionTable(), G4ReactionTableMessenger::SetNewValue(), and SetReaction().

Field Documentation

fGeometry

G4VDNAMolecularGeometry* G4DNAMolecularReactionTable::fGeometry

protected

Definition at line 245 of file G4DNAMolecularReactionTable.hh.

Referenced by GetGeometry(), and SetGeometry().

fpInstance

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::fpInstance

staticprotected

Definition at line 179 of file G4DNAMolecularReactionTable.hh.

Referenced by DeleteInstance(), GetReactionTable(), and Instance().

fpMessenger

std::unique_ptr<G4ReactionTableMessenger> G4DNAMolecularReactionTable::fpMessenger

protected

Definition at line 250 of file G4DNAMolecularReactionTable.hh.

fReactantsMV

ReactivesMV G4DNAMolecularReactionTable::fReactantsMV

protected

Definition at line 247 of file G4DNAMolecularReactionTable.hh.

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

fReactionData

ReactionDataMap G4DNAMolecularReactionTable::fReactionData

protected

Definition at line 246 of file G4DNAMolecularReactionTable.hh.

Referenced by GetAllReactionData(), GetReactionData(), GetReativesNData(), PrintTable(), and SetReaction().

fReactionDataMV

ReactionDataMV G4DNAMolecularReactionTable::fReactionDataMV

protected

Definition at line 248 of file G4DNAMolecularReactionTable.hh.

Referenced by GetReactionData(), and SetReaction().

fVectorOfReactionData

std::vector<std::unique_ptr<Data> > G4DNAMolecularReactionTable::fVectorOfReactionData

protected

Definition at line 249 of file G4DNAMolecularReactionTable.hh.

Referenced by GetNReactions(), GetReaction(), GetVectorOfReactionData(), ScaleReactionRateForNewTemperature(), and SetReaction().

fVerbose

G4bool G4DNAMolecularReactionTable::fVerbose

protected

Definition at line 243 of file G4DNAMolecularReactionTable.hh.

Referenced by CanReactWith(), and GetReativesNData().

---

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

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