G4DNAMolecularReaction Class Reference

#include <G4DNAMolecularReaction.hh>

Inheritance diagram for G4DNAMolecularReaction:

Public Member Functions
	G4DNAMolecularReaction ()
	G4DNAMolecularReaction (G4VDNAReactionModel *)
	~G4DNAMolecularReaction () override=default
	G4DNAMolecularReaction (const G4DNAMolecularReaction &other)=delete
G4DNAMolecularReaction &	operator= (const G4DNAMolecularReaction &other)=delete
G4bool	TestReactibility (const G4Track &, const G4Track &, double currentStepTime, bool userStepTimeLimit) override
std::vector< std::unique_ptr< G4ITReactionChange > >	FindReaction (G4ITReactionSet *, const double, const double, const bool) override
std::unique_ptr< G4ITReactionChange >	MakeReaction (const G4Track &, const G4Track &) override
void	SetReactionModel (G4VDNAReactionModel *)
Public Member Functions inherited from G4VITReactionProcess
	G4VITReactionProcess ()=default
virtual	~G4VITReactionProcess ()=default
	G4VITReactionProcess (const G4VITReactionProcess &other)=delete
G4VITReactionProcess &	operator= (const G4VITReactionProcess &other)=delete
virtual void	Initialize ()
virtual G4bool	IsApplicable (const G4ITType &, const G4ITType &) const
virtual void	SetReactionTable (const G4ITReactionTable *)

Protected Attributes
const G4DNAMolecularReactionTable *&	fMolReactionTable
G4VDNAReactionModel *	fpReactionModel
Protected Attributes inherited from G4VITReactionProcess
const G4ITReactionTable *	fpReactionTable = nullptr
G4String	fName

Detailed Description

G4DNAMolecularReaction is the reaction process used in G4DNAMolecularStepByStepModel. It test whether molecules can react after testing. If so, the reaction is made.

Deprecated

This class will be removed

Definition at line 63 of file G4DNAMolecularReaction.hh.

Constructor & Destructor Documentation

G4DNAMolecularReaction() [1/3]

G4DNAMolecularReaction::G4DNAMolecularReaction

(

)

Definition at line 50 of file G4DNAMolecularReaction.cc.

    : 
     fMolReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable))
    , fpReactionModel(nullptr)
{
}

Referenced by G4DNAMolecularReaction(), G4DNAMolecularReaction(), and operator=().

G4DNAMolecularReaction() [2/3]

G4DNAMolecularReaction::G4DNAMolecularReaction ( G4VDNAReactionModel * pReactionModel )

explicit

Definition at line 57 of file G4DNAMolecularReaction.cc.

    : G4DNAMolecularReaction()
{
    fpReactionModel = pReactionModel;
}

~G4DNAMolecularReaction()

G4DNAMolecularReaction::~G4DNAMolecularReaction ( )

overridedefault

G4DNAMolecularReaction() [3/3]

G4DNAMolecularReaction::G4DNAMolecularReaction ( const G4DNAMolecularReaction & other )

delete

Member Function Documentation

FindReaction()

std::vector< std::unique_ptr< G4ITReactionChange > > G4DNAMolecularReaction::FindReaction ( G4ITReactionSet * pReactionSet, const double currentStepTime, const double , const bool reachedUserStepTimeLimit )

overridevirtual

Implements G4VITReactionProcess.

Definition at line 134 of file G4DNAMolecularReaction.cc.

{
    std::vector<std::unique_ptr<G4ITReactionChange>> fReactionInfo;
    fReactionInfo.clear();
 
    if (pReactionSet == nullptr)
    {
        return fReactionInfo;
    }
 
    G4ITReactionPerTrackMap& reactionPerTrackMap = pReactionSet->GetReactionMap();
    for (auto tracks_i = reactionPerTrackMap.cbegin();
         tracks_i != reactionPerTrackMap.cend();
         tracks_i = reactionPerTrackMap.cbegin())
    {
        G4Track* pTrackA = tracks_i->first;
        if (pTrackA->GetTrackStatus() == fStopAndKill)
        {
            continue;
        }
 
        G4ITReactionPerTrackPtr reactionPerTrack = tracks_i->second;
        G4ITReactionList& reactionList = reactionPerTrack->GetReactionList();
 
        assert(reactionList.cbegin() != reactionList.cend());
 
        for (auto it = reactionList.cbegin(); it != reactionList.cend(); it = reactionList.cbegin())
        {
            G4ITReactionPtr reaction(*it);
            G4Track* pTrackB = reaction->GetReactant(pTrackA);
            if (pTrackB->GetTrackStatus() == fStopAndKill)
            {
                continue;
            }
 
            if (pTrackB == pTrackA)
            {
                G4ExceptionDescription exceptionDescription;
                exceptionDescription
                    << "The IT reaction process sent back a reaction between trackA and trackB. ";
                exceptionDescription << "The problem is trackA == trackB";
                G4Exception("G4ITModelProcessor::FindReaction",
                            "ITModelProcessor005",
                            FatalErrorInArgument,
                            exceptionDescription);
            }
 
            pReactionSet->SelectThisReaction(std::move(reaction));
 
            if (TestReactibility(*pTrackA, *pTrackB, currentStepTime, reachedUserStepTimeLimit))
            {
                auto pReactionChange = MakeReaction(*pTrackA, *pTrackB);
 
                if (pReactionChange)
                {
                    fReactionInfo.push_back(std::move(pReactionChange));
                    break;
                }
            }
        }
    }
 
    pReactionSet->CleanAllReaction();
    return fReactionInfo;
}

MakeReaction()

std::unique_ptr< G4ITReactionChange > G4DNAMolecularReaction::MakeReaction ( const G4Track & trackA, const G4Track & trackB )

overridevirtual

Implements G4VITReactionProcess.

Definition at line 85 of file G4DNAMolecularReaction.cc.

{
    std::unique_ptr<G4ITReactionChange> pChanges(new G4ITReactionChange());
    pChanges->Initialize(trackA, trackB);
 
    const auto pMoleculeA = GetMolecule(trackA)->GetMolecularConfiguration();
    const auto pMoleculeB = GetMolecule(trackB)->GetMolecularConfiguration();
 
    const auto pReactionData = fMolReactionTable->GetReactionData(pMoleculeA, pMoleculeB);
    // Notify molecule (reaction) counter
    if (G4MoleculeCounterManager::Instance()->GetIsActive()) {
      G4MoleculeCounterManager::Instance()->RecordReaction(pReactionData, trackA.GetGlobalTime());
    }
    const G4int nbProducts = pReactionData->GetNbProducts();
 
    if (nbProducts != 0)
    {
        const G4double D1 = pMoleculeA->GetDiffusionCoefficient();
        const G4double D2 = pMoleculeB->GetDiffusionCoefficient();
        const G4double sqrD1 = D1 == 0. ? 0. : std::sqrt(D1);
        const G4double sqrD2 = D2 == 0. ? 0. : std::sqrt(D2);
        const G4double inv_numerator = 1./(sqrD1 + sqrD2);
        const G4ThreeVector reactionSite = sqrD2 * inv_numerator * trackA.GetPosition()
                                         + sqrD1 * inv_numerator * trackB.GetPosition();
 
        for (G4int j = 0; j < nbProducts; ++j)
        {
            auto pProduct = new G4Molecule(pReactionData->GetProduct(j));
            auto pProductTrack = pProduct->BuildTrack(trackA.GetGlobalTime(), reactionSite);
 
            pProductTrack->SetTrackStatus(fAlive);
 
            G4ITTrackHolder::Instance()->Push(pProductTrack);
 
            pChanges->AddSecondary(pProductTrack);
            G4MoleculeFinder::Instance()->Push(pProductTrack);
        }
    }
 
    pChanges->KillParents(true);
    return pChanges;
}

Referenced by FindReaction().

operator=()

G4DNAMolecularReaction & G4DNAMolecularReaction::operator= ( const G4DNAMolecularReaction & other )

delete

SetReactionModel()

void G4DNAMolecularReaction::SetReactionModel

(

G4VDNAReactionModel *

pReactionModel

)

Definition at line 129 of file G4DNAMolecularReaction.cc.

{
    fpReactionModel = pReactionModel;
}

TestReactibility()

G4bool G4DNAMolecularReaction::TestReactibility ( const G4Track & trackA, const G4Track & trackB, double currentStepTime, bool userStepTimeLimit )

overridevirtual

Implements G4VITReactionProcess.

Definition at line 63 of file G4DNAMolecularReaction.cc.

{
    const auto pMoleculeA = GetMolecule(trackA)->GetMolecularConfiguration();
    const auto pMoleculeB = GetMolecule(trackB)->GetMolecularConfiguration();
 
    const G4double reactionRadius = fpReactionModel->GetReactionRadius(pMoleculeA, pMoleculeB);
 
    G4double separationDistance = -1.;
 
    if (currentStepTime == 0.)
    {
        userStepTimeLimit = false;
    }
 
    G4bool output = fpReactionModel->FindReaction(trackA, trackB, reactionRadius,
                                                  separationDistance, userStepTimeLimit);
    return output;
}

Referenced by FindReaction().

Member Data Documentation

fMolReactionTable

const G4DNAMolecularReactionTable*& G4DNAMolecularReaction::fMolReactionTable

protected

Definition at line 84 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), and MakeReaction().

fpReactionModel

G4VDNAReactionModel* G4DNAMolecularReaction::fpReactionModel

protected

Definition at line 85 of file G4DNAMolecularReaction.hh.

Referenced by G4DNAMolecularReaction(), G4DNAMolecularReaction(), SetReactionModel(), and TestReactibility().

---

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

• G4DNAMolecularReaction.hh
• G4DNAMolecularReaction.cc