#include <G4DNAMolecularReactionTable.hh>

Inheritance diagram for G4DNAMolecularReactionTable:

Public Types
using	Reactant = const G4MolecularConfiguration

using	Data = const G4DNAMolecularReactionData

using	ReactantList = std::vector<Reactant*>

using	DataList = std::vector<Data*>

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

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

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

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

Public Member Functions
	~G4DNAMolecularReactionTable () override

void	SetReaction (G4double observedReactionRate, Reactant reactive1, Reactant reactive2)

void	SetReaction (G4DNAMolecularReactionData *)

void	SetGeometry (G4VDNAMolecularGeometry *geometry)

G4VDNAMolecularGeometry *	GetGeometry () const

Data *	GetReactionData (Reactant , Reactant ) const

Data *	GetReactionData (const G4String &, const G4String &) const

Data *	GetReaction (int reactionID) const

size_t	GetNReactions () const

const ReactantList *	CanReactWith (Reactant *) const

const SpecificDataList *	GetReativesNData (const G4MolecularConfiguration *) const

const DataList *	GetReactionData (const G4MolecularConfiguration *) const

const ReactionDataMap &	GetAllReactionData ()

DataList	GetVectorOfReactionData ()

void	ScaleReactionRateForNewTemperature (double temp_K)

void	PrintTable (G4VDNAReactionModel *=nullptr)

void	Reset ()

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 Member Functions
	G4DNAMolecularReactionTable ()

Protected Attributes
G4bool	fVerbose {false}

G4VDNAMolecularGeometry *	fGeometry {nullptr}

ReactionDataMap	fReactionData

ReactivesMV	fReactantsMV

ReactionDataMV	fReactionDataMV

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

std::unique_ptr< G4ReactionTableMessenger >	fpMessenger

Static Protected Attributes
static G4DNAMolecularReactionTable *	fpInstance

Detailed Description

G4DNAMolecularReactionTable sorts out the G4DNAMolecularReactionData for bimolecular reaction

Definition at line 174 of file G4DNAMolecularReactionTable.hh.

Member Typedef Documentation

◆ Data

using G4DNAMolecularReactionTable::Data = const G4DNAMolecularReactionData

Definition at line 187 of file G4DNAMolecularReactionTable.hh.

◆ DataList

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

Definition at line 189 of file G4DNAMolecularReactionTable.hh.

◆ Reactant

using G4DNAMolecularReactionTable::Reactant = const G4MolecularConfiguration

Definition at line 186 of file G4DNAMolecularReactionTable.hh.

◆ ReactantList

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

Definition at line 188 of file G4DNAMolecularReactionTable.hh.

◆ ReactionDataMap

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

Definition at line 192 of file G4DNAMolecularReactionTable.hh.

◆ ReactionDataMV

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

Definition at line 194 of file G4DNAMolecularReactionTable.hh.

◆ ReactivesMV

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

Definition at line 193 of file G4DNAMolecularReactionTable.hh.

◆ SpecificDataList

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

Definition at line 190 of file G4DNAMolecularReactionTable.hh.

Constructor & Destructor Documentation

◆ G4DNAMolecularReactionTable()

G4DNAMolecularReactionTable::G4DNAMolecularReactionTable ( )

protected

Definition at line 382 of file G4DNAMolecularReactionTable.cc.

    : 
     fpMessenger(new G4ReactionTableMessenger(this))
{
}

Referenced by GetReactionTable(), and Instance().

◆ ~G4DNAMolecularReactionTable()

G4DNAMolecularReactionTable::~G4DNAMolecularReactionTable ( )

overridedefault

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

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

◆ DeleteInstance()

void G4DNAMolecularReactionTable::DeleteInstance ( )

static

Definition at line 371 of file G4DNAMolecularReactionTable.cc.

{
    
        delete fpInstance;
    
    fpInstance = nullptr;
}

Referenced by G4DNAChemistryManager::Clear().

◆ GetAllReactionData()

const G4DNAMolecularReactionTable::ReactionDataMap & G4DNAMolecularReactionTable::GetAllReactionData ( )

Definition at line 636 of file G4DNAMolecularReactionTable.cc.

{
    return fReactionData;
}

◆ GetGeometry()

G4VDNAMolecularGeometry * G4DNAMolecularReactionTable::GetGeometry ( ) const

Definition at line 594 of file G4DNAMolecularReactionTable.cc.

{
  return fGeometry;
}

◆ GetNReactions()

size_t G4DNAMolecularReactionTable::GetNReactions ( ) const

Definition at line 832 of file G4DNAMolecularReactionTable.cc.

{
    return fVectorOfReactionData.size();
}

◆ GetReaction()

G4DNAMolecularReactionTable::Data * G4DNAMolecularReactionTable::GetReaction ( int reactionID ) const

Definition at line 820 of file G4DNAMolecularReactionTable.cc.

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

◆ 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);
        // Though the above is Fatal and will terminate program, put return in to quieten Coverity
        return nullptr;
    }
 
    return &(it->second);
}

◆ GetReactionData() [2/3]

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

Definition at line 761 of file G4DNAMolecularReactionTable.cc.

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

◆ GetReactionData() [3/3]

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

Definition at line 600 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);
        // Though the above is Fatal and will terminate program, put return in to quieten Coverity
        return nullptr;
    }
 
    auto 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);
}

Referenced by G4DNAIndependentReactionTimeStepper::CalculateStep(), G4DNAIRT::GetIndependentReactionTime(), GetReactionData(), G4DiffusionControlledReactionModel::GetReactionRadius(), G4DNASmoluchowskiReactionModel::GetReactionRadius(), G4DiffusionControlledReactionModel::GetTimeToEncounter(), G4DiffusionControlledReactionModel::Initialise(), G4DNASmoluchowskiReactionModel::Initialise(), G4DiffusionControlledReactionModel::InitialiseToPrint(), G4DNASmoluchowskiReactionModel::InitialiseToPrint(), G4DNAIRT::MakeReaction(), G4DNAMakeReaction::MakeReaction(), G4DNAMolecularReaction::MakeReaction(), and G4DNAIRT::Sampling().

◆ GetReactionTable()

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::GetReactionTable ( )

static

Definition at line 349 of file G4DNAMolecularReactionTable.cc.

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

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);
    }
 
    auto 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;
 
        auto itProductsVector = itReactivesMap->second.begin();
 
        for (; itProductsVector != itReactivesMap->second.end(); itProductsVector++)
        {
            G4cout << itProductsVector->first->GetName() << G4endl;
        }
    }
    return &(itReactivesMap->second);
}

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

Referenced by G4ChemEquilibrium::Initialize().

◆ Instance()

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::Instance ( )

static

Definition at line 360 of file G4DNAMolecularReactionTable.cc.

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

Referenced by G4DNAEventScheduler::CheckingReactionRadius(), G4DiffusionControlledReactionModel::GetTimeToEncounter(), G4ChemEquilibrium::Initialize(), and G4DNAChemistryManager::SetGlobalTemperature().

◆ PrintTable()

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

Definition at line 422 of file G4DNAMolecularReactionTable.cc.

{
    // Print Reactions and Interaction radius for jump step = 3ps
 
    G4IosFlagsSaver iosfs(G4cout);
 
   if ((pReactionModel != nullptr) && ((pReactionModel->GetReactionTable()) == nullptr))
   {
       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;
 
    std::size_t nbPrintable = fReactantsMV.size() * fReactantsMV.size();
 
    auto  outputReaction = new G4String[nbPrintable];
    auto  outputReactionRate = new G4String[nbPrintable];
    auto  outputRange = new G4String[nbPrintable];
    G4int n = 0;
 
    for (itReactives = fReactantsMV.begin(); itReactives != fReactantsMV.end();
         ++itReactives)
    {
        auto  moleculeA = (Reactant*)itReactives->first;
        const vector<Reactant*>* reactivesVector = CanReactWith(moleculeA);
 
        if (pReactionModel != nullptr) pReactionModel->InitialiseToPrint(moleculeA);
 
        auto  nbReactants = (G4int)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 != 0)
                {
                    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 != nullptr) 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 = (G4int)outputReaction[i].length();
        }
        if (maxlengthOutputReactionRate < (G4int)outputReactionRate[i].length())
        {
            maxlengthOutputReactionRate = (G4int)outputReactionRate[i].length();
        }
    }
 
    maxlengthOutputReaction += 2;
    maxlengthOutputReactionRate += 2;
 
    if (maxlengthOutputReaction < 10) maxlengthOutputReaction = 10;
    if (maxlengthOutputReactionRate < 30) maxlengthOutputReactionRate = 30;
 
    G4String* title;
 
    if (pReactionModel != nullptr) title = new G4String[3];
    else title = new G4String[2];
 
    title[0] = "Reaction";
    title[1] = "Reaction Rate [dm3/(mol*s)]";
 
    if (pReactionModel != nullptr) title[2] =
        "Interaction Range for chosen reaction model [nm]";
 
    G4cout << setfill(' ') << setw(maxlengthOutputReaction) << left << title[0]
        << setw(maxlengthOutputReactionRate) << left << title[1];
 
    if (pReactionModel != nullptr) G4cout << setw(2) << left << title[2];
 
    G4cout << G4endl;
 
    G4cout.fill('-');
    if (pReactionModel != nullptr) 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 != nullptr) G4cout << setw(2) << left << outputRange[i];
 
        G4cout << G4endl;
 
        G4cout.fill('-');
        if (pReactionModel != nullptr) 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;
}

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

◆ Reset()

void G4DNAMolecularReactionTable::Reset ( )

Definition at line 837 of file G4DNAMolecularReactionTable.cc.

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

Referenced by G4ReactionTableMessenger::SetNewValue().

◆ ScaleReactionRateForNewTemperature()

void G4DNAMolecularReactionTable::ScaleReactionRateForNewTemperature ( double temp_K )

Definition at line 799 of file G4DNAMolecularReactionTable.cc.

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

Referenced by G4DNAChemistryManager::SetGlobalTemperature().

◆ SetGeometry()

void G4DNAMolecularReactionTable::SetGeometry ( G4VDNAMolecularGeometry * geometry )

inline

Definition at line 211 of file G4DNAMolecularReactionTable.hh.

211{fGeometry = geometry;};

◆ SetReaction() [1/2]

void G4DNAMolecularReactionTable::SetReaction ( G4DNAMolecularReactionData * pReactionData )

Definition at line 390 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((G4int)fVectorOfReactionData.size());
}

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

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

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

Member Data Documentation

◆ fGeometry

G4VDNAMolecularGeometry* G4DNAMolecularReactionTable::fGeometry {nullptr}

protected

Definition at line 246 of file G4DNAMolecularReactionTable.hh.

246{nullptr};

Referenced by GetGeometry(), and SetGeometry().

◆ fpInstance

G4DNAMolecularReactionTable * G4DNAMolecularReactionTable::fpInstance

staticprotected

Definition at line 178 of file G4DNAMolecularReactionTable.hh.

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

◆ fpMessenger

std::unique_ptr<G4ReactionTableMessenger> G4DNAMolecularReactionTable::fpMessenger

protected

Definition at line 251 of file G4DNAMolecularReactionTable.hh.

◆ fReactantsMV

ReactivesMV G4DNAMolecularReactionTable::fReactantsMV

protected

Definition at line 248 of file G4DNAMolecularReactionTable.hh.

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

◆ fReactionData

ReactionDataMap G4DNAMolecularReactionTable::fReactionData

protected

Definition at line 247 of file G4DNAMolecularReactionTable.hh.

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

◆ fReactionDataMV

ReactionDataMV G4DNAMolecularReactionTable::fReactionDataMV

protected

Definition at line 249 of file G4DNAMolecularReactionTable.hh.

Referenced by GetReactionData(), Reset(), and SetReaction().

◆ fVectorOfReactionData

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

protected

Definition at line 250 of file G4DNAMolecularReactionTable.hh.

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

◆ fVerbose

G4bool G4DNAMolecularReactionTable::fVerbose {false}

protected

Definition at line 244 of file G4DNAMolecularReactionTable.hh.

244{false};

Referenced by CanReactWith(), and GetReativesNData().

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Data

◆ DataList

◆ Reactant

◆ ReactantList

◆ ReactionDataMap

◆ ReactionDataMV

◆ ReactivesMV

◆ SpecificDataList

Constructor & Destructor Documentation

◆ G4DNAMolecularReactionTable()

◆ ~G4DNAMolecularReactionTable()

Member Function Documentation

◆ CanReactWith()

◆ DeleteInstance()

◆ GetAllReactionData()

◆ GetGeometry()

◆ GetNReactions()

◆ GetReaction()

◆ GetReactionData() [1/3]

◆ GetReactionData() [2/3]

◆ GetReactionData() [3/3]

◆ GetReactionTable()

◆ GetReativesNData()

◆ GetVectorOfReactionData()

◆ Instance()

◆ PrintTable()

◆ Reset()

◆ ScaleReactionRateForNewTemperature()

◆ SetGeometry()

◆ SetReaction() [1/2]

◆ SetReaction() [2/2]

Member Data Documentation

◆ fGeometry

◆ fpInstance

◆ fpMessenger

◆ fReactantsMV

◆ fReactionData

◆ fReactionDataMV

◆ fVectorOfReactionData

◆ fVerbose