G4DNAMakeReaction Class Reference

#include <G4DNAMakeReaction.hh>

Inheritance diagram for G4DNAMakeReaction:

Public Member Functions
	G4DNAMakeReaction ()
	G4DNAMakeReaction (G4VDNAReactionModel *)
	~G4DNAMakeReaction () override=default
	G4DNAMakeReaction (const G4DNAMakeReaction &other)=delete
G4DNAMakeReaction &	operator= (const G4DNAMakeReaction &other)=delete
G4bool	TestReactibility (const G4Track &, const G4Track &, G4double currentStepTime, G4bool userStepTimeLimit) override
std::vector< std::unique_ptr< G4ITReactionChange > >	FindReaction (G4ITReactionSet *, const G4double, const G4double, const G4bool) override
std::unique_ptr< G4ITReactionChange >	MakeReaction (const G4Track &, const G4Track &) override
void	SetReactionModel (G4VDNAReactionModel *)
void	UpdatePositionForReaction (G4Track &, G4Track &)
void	SetTimeStepComputer (G4VITTimeStepComputer *)
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
G4VITTimeStepComputer *	fpTimeStepper
G4double	fTimeStep
Protected Attributes inherited from G4VITReactionProcess
const G4ITReactionTable *	fpReactionTable = nullptr
G4String	fName

Detailed Description

Definition at line 37 of file G4DNAMakeReaction.hh.

Constructor & Destructor Documentation

G4DNAMakeReaction() [1/3]

G4DNAMakeReaction::G4DNAMakeReaction

(

)

Definition at line 41 of file G4DNAMakeReaction.cc.

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

G4DNAMakeReaction() [2/3]

G4DNAMakeReaction::G4DNAMakeReaction ( G4VDNAReactionModel *  pReactionModel )

explicit

Definition at line 50 of file G4DNAMakeReaction.cc.

        : G4DNAMakeReaction()
{
    fpReactionModel = pReactionModel;
}

~G4DNAMakeReaction()

G4DNAMakeReaction::~G4DNAMakeReaction ( )

overridedefault

G4DNAMakeReaction() [3/3]

G4DNAMakeReaction::G4DNAMakeReaction ( const G4DNAMakeReaction &  other )

delete

Member Function Documentation

FindReaction()

std::vector< std::unique_ptr< G4ITReactionChange > > G4DNAMakeReaction::FindReaction ( G4ITReactionSet *  pReactionSet, const G4double  currentStepTime, const  G4double, const  G4bool  )

overridevirtual

Implements G4VITReactionProcess.

Definition at line 185 of file G4DNAMakeReaction.cc.

{
    std::vector<std::unique_ptr<G4ITReactionChange>> ReactionInfo;
    ReactionInfo.clear();
    auto stepper = dynamic_cast<G4DNAIndependentReactionTimeStepper*>(fpTimeStepper);
    if(stepper != nullptr){
      auto pReactionChange = stepper->
                             FindReaction(pReactionSet,currentStepTime);
      if (pReactionChange != nullptr)
      {
        ReactionInfo.push_back(std::move(pReactionChange));
      }
    }
    return ReactionInfo;
}

Referenced by FindReaction().

MakeReaction()

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

overridevirtual

Implements G4VITReactionProcess.

Definition at line 71 of file G4DNAMakeReaction.cc.

{
    G4Track& tA = const_cast<G4Track&>(trackA);
    G4Track& tB = const_cast<G4Track&>(trackB);
    UpdatePositionForReaction( tA , tB );//TODO: should change it
 
    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 * tA.GetPosition()
                                         + sqrD1 * inv_numerator * tB.GetPosition();
 
        G4double u = G4UniformRand();
        auto randP = (1-u) * tA.GetPosition() + u * tB.GetPosition();
 
        for (G4int j = 0; j < nbProducts; ++j)
        {
            auto pProduct = new G4Molecule(pReactionData->GetProduct(j));
            auto pProductTrack = pProduct->BuildTrack(trackA.GetGlobalTime(), (reactionSite + randP)/2);
            pProductTrack->SetTrackStatus(fAlive);
            G4ITTrackHolder::Instance()->Push(pProductTrack);
            pChanges->AddSecondary(pProductTrack);
        }
    }
    pChanges->KillParents(true);
    return pChanges;
}

operator=()

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

delete

SetReactionModel()

void G4DNAMakeReaction::SetReactionModel

(

G4VDNAReactionModel *

pReactionModel

)

Definition at line 112 of file G4DNAMakeReaction.cc.

{
    fpReactionModel = pReactionModel;
}

SetTimeStepComputer()

void G4DNAMakeReaction::SetTimeStepComputer

(

G4VITTimeStepComputer *

pStepper

)

Definition at line 56 of file G4DNAMakeReaction.cc.

{
    fpTimeStepper = pStepper;
}

TestReactibility()

G4bool G4DNAMakeReaction::TestReactibility ( const G4Track &  , const G4Track &  , G4double  currentStepTime, G4bool  userStepTimeLimit  )

overridevirtual

Implements G4VITReactionProcess.

Definition at line 61 of file G4DNAMakeReaction.cc.

{
    fTimeStep = currentStepTime;
    return true;
}

UpdatePositionForReaction()

void G4DNAMakeReaction::UpdatePositionForReaction	(	G4Track &	trackA,
		G4Track &	trackB
	)

Definition at line 117 of file G4DNAMakeReaction.cc.

{
    const auto pMoleculeA = GetMolecule(trackA)->GetMolecularConfiguration();
    const auto pMoleculeB = GetMolecule(trackB)->GetMolecularConfiguration();
    G4double D1 = pMoleculeA->GetDiffusionCoefficient();
    G4double D2 = pMoleculeB->GetDiffusionCoefficient();
 
    G4double reactionRadius = fpReactionModel->GetReactionRadius( pMoleculeA, pMoleculeB );
    G4ThreeVector p1 = trackA.GetPosition();
    G4ThreeVector p2 = trackB.GetPosition();
 
    G4ThreeVector S1 = p1 - p2;
    G4double distance = S1.mag();
 
    if(D1 == 0)
    {
        trackB.SetPosition(p1);
        return;
    }
    else if(D2 == 0)
    {
        trackA.SetPosition(p2);
        return;
    }
 
    if(distance == 0)
    {
        G4ExceptionDescription exceptionDescription;
        exceptionDescription << "Two particles are overlap: "
                             <<GetMolecule(trackA)->GetName()
                             <<" and "<<GetMolecule(trackB)->GetName()
                             <<" at "<<trackA.GetPosition();
        G4Exception("G4DNAMakeReaction::PrepareForReaction()",
                    "G4DNAMakeReaction003",
                    FatalErrorInArgument,exceptionDescription);
    }
    S1.setMag(reactionRadius);
 
    const G4double dt = fTimeStep;//irt - actualize molecule time
 
    if(dt > 0)// irt > 0
    {
        G4double s12 = 2.0 * D1 * dt;
        G4double s22 = 2.0 * D2 * dt;
        G4double sigma = s12 + ( s12 * s12 ) / s22;
        G4double alpha = reactionRadius * distance / (2 * (D1 + D2) * dt );
 
        G4ThreeVector S2 = (p1 + ( s12 / s22 ) * p2) +
                           G4ThreeVector(G4RandGauss::shoot(0.0, sigma),
                                         G4RandGauss::shoot(0.0, sigma),
                                         G4RandGauss::shoot(0.0, sigma));
 
        S1.setPhi(rad * G4UniformRand() * 2.0 * CLHEP::pi);
 
        S1.setTheta(rad * std::acos( 1.0 + (1. / alpha) *
                                           std::log(1.0 - G4UniformRand() *
                                                          (1.-std::exp(-2.0 * alpha)))));
 
        const G4ThreeVector R1 = (D1 * S1 + D2 * S2) / (D1 + D2);
        const G4ThreeVector R2 = D2 * (S2 - S1) / (D1 + D2);
 
        trackA.SetPosition(R1);
        trackB.SetPosition(R2);
    }
}

Referenced by MakeReaction().

Member Data Documentation

fMolReactionTable

const G4DNAMolecularReactionTable*& G4DNAMakeReaction::fMolReactionTable

protected

Definition at line 58 of file G4DNAMakeReaction.hh.

Referenced by MakeReaction().

fpReactionModel

G4VDNAReactionModel* G4DNAMakeReaction::fpReactionModel

protected

Definition at line 59 of file G4DNAMakeReaction.hh.

Referenced by G4DNAMakeReaction(), SetReactionModel(), and UpdatePositionForReaction().

fpTimeStepper

G4VITTimeStepComputer* G4DNAMakeReaction::fpTimeStepper

protected

Definition at line 60 of file G4DNAMakeReaction.hh.

Referenced by FindReaction(), and SetTimeStepComputer().

fTimeStep

G4double G4DNAMakeReaction::fTimeStep

protected

Definition at line 61 of file G4DNAMakeReaction.hh.

Referenced by TestReactibility(), and UpdatePositionForReaction().

---

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

• G4DNAMakeReaction.hh
• G4DNAMakeReaction.cc