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 G4bool	TestReactibility (const G4Track &, const G4Track &, double, bool)=0
virtual std::vector< std::unique_ptr< G4ITReactionChange > >	FindReaction (G4ITReactionSet *, const double, const double, const bool)=0
virtual std::unique_ptr< G4ITReactionChange >	MakeReaction (const G4Track &, const G4Track &)=0
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 49 of file G4DNAMolecularReaction.cc.

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

G4DNAMolecularReaction() [2/3]

G4DNAMolecularReaction::G4DNAMolecularReaction ( G4VDNAReactionModel *  pReactionModel )

explicit

Definition at line 56 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 130 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.begin();
         tracks_i != reactionPerTrackMap.end();
         tracks_i = reactionPerTrackMap.begin())
    {
        G4Track* pTrackA = tracks_i->first;
        if (pTrackA->GetTrackStatus() == fStopAndKill)
        {
            continue;
        }
 
        G4ITReactionPerTrackPtr reactionPerTrack = tracks_i->second;
        G4ITReactionList& reactionList = reactionPerTrack->GetReactionList();
 
        assert(reactionList.begin() != reactionList.end());
 
        for (auto it = reactionList.begin(); it != reactionList.end(); it = reactionList.begin())
        {
            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(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 84 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);
 
    const G4int nbProducts = pReactionData->GetNbProducts();
 
    if (nbProducts)
    {
        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 125 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 62 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 MakeReaction().

fpReactionModel

G4VDNAReactionModel* G4DNAMolecularReaction::fpReactionModel

protected

Definition at line 85 of file G4DNAMolecularReaction.hh.

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

---

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

• G4DNAMolecularReaction.hh
• G4DNAMolecularReaction.cc