G4DNAMoleculeEncounterStepper Class Reference

#include <G4DNAMoleculeEncounterStepper.hh>

Inheritance diagram for G4DNAMoleculeEncounterStepper:

Data Structures
class	Utils

Public Member Functions
virtual G4double	CalculateMinTimeStep (G4double, G4double)
virtual G4double	CalculateStep (const G4Track &, const G4double &)
	G4DNAMoleculeEncounterStepper ()
	G4DNAMoleculeEncounterStepper (const G4DNAMoleculeEncounterStepper &)=delete
G4TrackVectorHandle	GetReactants ()
G4VDNAReactionModel *	GetReactionModel ()
const G4ITReactionTable *	GetReactionTable ()
G4double	GetSampledMinTimeStep ()
virtual void	Initialize ()
G4DNAMoleculeEncounterStepper &	operator= (const G4DNAMoleculeEncounterStepper &)=delete
virtual void	Prepare ()
virtual void	ResetReactants ()
void	SetReactionModel (G4VDNAReactionModel *)
void	SetReactionTable (const G4ITReactionTable *)
void	SetVerbose (int)
virtual	~G4DNAMoleculeEncounterStepper ()

Static Public Member Functions
static void	SetTimes (const G4double &, const G4double &)

Protected Attributes
const G4ITReactionTable *	fpReactionTable
G4TrackVectorHandle	fReactants
G4double	fSampledMinTimeStep

Static Protected Attributes
static G4ThreadLocal G4double	fCurrentGlobalTime = -1
static G4ThreadLocal G4double	fUserMinTimeStep = -1

Private Member Functions
void	CheckAndRecordResults (const Utils &, G4KDTreeResultHandle &)
void	InitializeForNewTrack ()

Private Attributes
G4bool	fHasAlreadyReachedNullTime
const G4DNAMolecularReactionTable *&	fMolecularReactionTable
G4ITTrackHolder *	fpTrackContainer
G4VDNAReactionModel *	fReactionModel
G4ITReactionSet *	fReactionSet
G4int	fVerbose

Detailed Description

Given a molecule G4DNAMoleculeEncounterStepper will calculate for its possible reactants what will be the minimum encounter time and the associated molecules.*

This model includes dynamical time steps as explained in "Computer-Aided Stochastic Modeling of the Radiolysis of Liquid Water", V. Michalik, M. Begusová, E. A. Bigildeev, Radiation Research, Vol. 149, No. 3 (Mar., 1998), pp. 224-236

Definition at line 70 of file G4DNAMoleculeEncounterStepper.hh.

Constructor & Destructor Documentation

G4DNAMoleculeEncounterStepper() [1/2]

G4DNAMoleculeEncounterStepper::G4DNAMoleculeEncounterStepper

(

)

Definition at line 68 of file G4DNAMoleculeEncounterStepper.cc.

    : G4VITTimeStepComputer()
    , fHasAlreadyReachedNullTime(false)
    , fMolecularReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable))
    , fReactionModel(nullptr)
    , fVerbose(0)
{
    fpTrackContainer = G4ITTrackHolder::Instance();
    fReactionSet = G4ITReactionSet::Instance();
}

References fpTrackContainer, fReactionSet, G4ITReactionSet::Instance(), and G4ITTrackHolder::Instance().

~G4DNAMoleculeEncounterStepper()

G4DNAMoleculeEncounterStepper::~G4DNAMoleculeEncounterStepper ( )

virtualdefault

G4DNAMoleculeEncounterStepper() [2/2]

G4DNAMoleculeEncounterStepper::G4DNAMoleculeEncounterStepper ( const G4DNAMoleculeEncounterStepper &  )

delete

Member Function Documentation

CalculateMinTimeStep()

G4double G4DNAMoleculeEncounterStepper::CalculateMinTimeStep ( G4double  , G4double  definedMinTimeStep  )

virtual

Implements G4VITTimeStepComputer.

Definition at line 441 of file G4DNAMoleculeEncounterStepper.cc.

                                                                                                   {
 
    G4double fTSTimeStep = DBL_MAX;
 
    for (auto pTrack : *fpTrackContainer->GetMainList())
    {
        if (pTrack == nullptr)
        {
            G4ExceptionDescription exceptionDescription;
            exceptionDescription << "No track found.";
            G4Exception("G4Scheduler::CalculateMinStep", "ITScheduler006",
                        FatalErrorInArgument, exceptionDescription);
            continue;
        }
 
        G4TrackStatus trackStatus = pTrack->GetTrackStatus();
        if (trackStatus == fStopAndKill || trackStatus == fStopButAlive)
        {
            continue;
        }
 
        G4double sampledMinTimeStep = CalculateStep(*pTrack, definedMinTimeStep);
        G4TrackVectorHandle reactants = GetReactants();
 
        if (sampledMinTimeStep < fTSTimeStep)
        {
            fTSTimeStep = sampledMinTimeStep;
            fReactionSet->CleanAllReaction();
            if (reactants)
            {
                fReactionSet->AddReactions(fTSTimeStep,
                                           const_cast<G4Track*>(pTrack),
                                           reactants);
                ResetReactants();
            }
         }
         else if (fTSTimeStep == sampledMinTimeStep && bool(reactants))
         {
             fReactionSet->AddReactions(fTSTimeStep,
                                        const_cast<G4Track*>(pTrack),
                                        reactants);
             ResetReactants();
         }
         else if (reactants)
         {
             ResetReactants();
         }
    }
 
    return fTSTimeStep;
}

References G4ITReactionSet::AddReactions(), CalculateStep(), G4ITReactionSet::CleanAllReaction(), DBL_MAX, FatalErrorInArgument, fpTrackContainer, fReactionSet, fStopAndKill, fStopButAlive, G4Exception(), G4ITTrackHolder::GetMainList(), G4VITTimeStepComputer::GetReactants(), and G4VITTimeStepComputer::ResetReactants().

CalculateStep()

G4double G4DNAMoleculeEncounterStepper::CalculateStep ( const G4Track &  trackA, const G4double &  userMinTimeStep  )

virtual

Implements G4VITTimeStepComputer.

Definition at line 121 of file G4DNAMoleculeEncounterStepper.cc.

{
    auto pMoleculeA = GetMolecule(trackA);
    InitializeForNewTrack();
    fUserMinTimeStep = userMinTimeStep;
 
#ifdef G4VERBOSE
    if (fVerbose)
    {
        G4cout
            << "_______________________________________________________________________"
            << G4endl;
        G4cout << "G4DNAMoleculeEncounterStepper::CalculateStep" << G4endl;
        G4cout << "Check done for molecule : " << pMoleculeA->GetName()
            << " (" << trackA.GetTrackID() << ") "
            << G4endl;
    }
#endif
 
    //__________________________________________________________________
    // Retrieve general informations for making reactions
    auto pMolConfA = pMoleculeA->GetMolecularConfiguration();
 
    const auto pReactantList = fMolecularReactionTable->CanReactWith(pMolConfA);
 
    if (!pReactantList)
    {
#ifdef G4VERBOSE
        //    DEBUG
        if (fVerbose > 1)
        {
            G4cout << "!!!!!!!!!!!!!!!!!!!!" << G4endl;
            G4cout << "!!! WARNING" << G4endl;
            G4cout << "G4MoleculeEncounterStepper::CalculateStep will return infinity "
                "for the reaction because the molecule "
                << pMoleculeA->GetName()
                << " does not have any reactants given in the reaction table."
                << G4endl;
            G4cout << "!!!!!!!!!!!!!!!!!!!!" << G4endl;
        }
#endif
        return DBL_MAX;
    }
 
    G4int nbReactives = pReactantList->size();
 
    if (nbReactives == 0)
    {
#ifdef G4VERBOSE
        //    DEBUG
        if (fVerbose)
        {
            // TODO replace with the warning mode of G4Exception
            G4cout << "!!!!!!!!!!!!!!!!!!!!" << G4endl;
            G4cout << "!!! WARNING" << G4endl;
            G4cout << "G4MoleculeEncounterStepper::CalculateStep will return infinity "
                "for the reaction because the molecule "
                << pMoleculeA->GetName()
                << " does not have any reactants given in the reaction table."
                << "This message can also result from a wrong implementation of the reaction table."
                << G4endl;
            G4cout << "!!!!!!!!!!!!!!!!!!!!" << G4endl;
        }
#endif
        return DBL_MAX;
    }
 
    fReactants.reset(new vector<G4Track*>());
    fReactionModel->Initialise(pMolConfA, trackA);
 
    //__________________________________________________________________
    // Start looping on possible reactants
    for (G4int i = 0; i < nbReactives; i++)
    {
        auto pMoleculeB = (*pReactantList)[i];
 
        //______________________________________________________________
        // Retrieve reaction range
        const G4double R = fReactionModel->GetReactionRadius(i);
 
        //______________________________________________________________
        // Use KdTree algorithm to find closest reactants
        G4KDTreeResultHandle resultsNearest(
            G4MoleculeFinder::Instance()->FindNearest(pMoleculeA,
                                                      pMoleculeB->GetMoleculeID()));
 
        if (resultsNearest == 0) continue;
 
        G4double r2 = resultsNearest->GetDistanceSqr();
        Utils utils(trackA, pMoleculeB);
 
        if (r2 <= R * R) // ==> Record in range
        {
            // Entering in this condition may due to the fact that molecules are very close
            // to each other
            // Therefore, if we only take the nearby reactant into account, it might have already
            // reacted. Instead, we will take all possible reactants that satisfy the condition r<R
 
            if (fHasAlreadyReachedNullTime == false)
            {
                fReactants->clear();
                fHasAlreadyReachedNullTime = true;
            }
 
            fSampledMinTimeStep = 0.;
            G4KDTreeResultHandle resultsInRange(
                G4MoleculeFinder::Instance()->FindNearestInRange(pMoleculeA,
                                                                 pMoleculeB->GetMoleculeID(),
                                                                 R));
            CheckAndRecordResults(utils,
#ifdef G4VERBOSE
                                  R,
#endif
                                  resultsInRange);
        }
        else
        {
            G4double r = sqrt(r2);
            G4double tempMinET = pow(r - R, 2) / utils.fConstant;
            // constant = 16 * (fDA + fDB + 2*sqrt(fDA*fDB))
 
            if (tempMinET <= fSampledMinTimeStep)
            {
                if (fUserMinTimeStep < DBL_MAX/*IsInf(fUserMinTimeStep) == false*/
                    && tempMinET <= fUserMinTimeStep) // ==> Record in range
                {
                    if (fSampledMinTimeStep > fUserMinTimeStep)
                    {
                        fReactants->clear();
                    }
 
                    fSampledMinTimeStep = fUserMinTimeStep;
 
                    G4double range = R + sqrt(fUserMinTimeStep*utils.fConstant);
 
                    G4KDTreeResultHandle resultsInRange(
                        G4MoleculeFinder::Instance()->
                        FindNearestInRange(pMoleculeA,
                                           pMoleculeB->GetMoleculeID(),
                                           range));
 
                    CheckAndRecordResults(utils,
#ifdef G4VERBOSE
                                          range,
#endif
                                          resultsInRange);
                }
                else // ==> Record nearest
                {
                    if (tempMinET < fSampledMinTimeStep)
                        // to avoid cases where fSampledMinTimeStep == tempMinET
                    {
                        fSampledMinTimeStep = tempMinET;
                        fReactants->clear();
                    }
 
                    CheckAndRecordResults(utils,
#ifdef G4VERBOSE
                                          R,
#endif
                                          resultsNearest);
                }
            }
        }
    }
 
#ifdef G4VERBOSE
    if (fVerbose)
    {
        G4cout << "G4MoleculeEncounterStepper::CalculateStep will finally return :"
            << G4BestUnit(fSampledMinTimeStep, "Time") << G4endl;
 
        if (fVerbose > 1)
        {
            G4cout << "Selected reactants for trackA: " << pMoleculeA->GetName()
                << " (" << trackA.GetTrackID() << ") are: ";
 
            vector<G4Track*>::iterator it;
            for (it = fReactants->begin(); it != fReactants->end(); it++)
            {
                G4Track* trackB = *it;
                G4cout << GetMolecule(trackB)->GetName() << " ("
                    << trackB->GetTrackID() << ") \t ";
            }
            G4cout << G4endl;
        }
    }
#endif
    return fSampledMinTimeStep;
}

References G4DNAMolecularReactionTable::CanReactWith(), CheckAndRecordResults(), DBL_MAX, G4DNAMoleculeEncounterStepper::Utils::fConstant, fHasAlreadyReachedNullTime, fMolecularReactionTable, G4VITTimeStepComputer::fReactants, fReactionModel, G4VITTimeStepComputer::fSampledMinTimeStep, G4VITTimeStepComputer::fUserMinTimeStep, fVerbose, G4BestUnit, G4cout, G4endl, GetMolecule(), G4Molecule::GetName(), G4VDNAReactionModel::GetReactionRadius(), G4Track::GetTrackID(), G4VDNAReactionModel::Initialise(), InitializeForNewTrack(), and G4ITFinder< T >::Instance().

Referenced by CalculateMinTimeStep().

CheckAndRecordResults()

void G4DNAMoleculeEncounterStepper::CheckAndRecordResults ( const Utils &  utils, G4KDTreeResultHandle &  results  )

private

Definition at line 313 of file G4DNAMoleculeEncounterStepper.cc.

{
    if (results == 0)
    {
#ifdef G4VERBOSE
        if (fVerbose > 1)
        {
            G4cout << "No molecule " << utils.fpMoleculeB->GetName()
                << " found to react with " << utils.fpMoleculeA->GetName()
                << G4endl;
        }
#endif
        return;
    }
 
    for (results->Rewind(); !results->End(); results->Next())
    {
        G4IT* reactiveB = results->GetItem<G4IT>();
 
        if (reactiveB == 0)
        {
            continue;
        }
 
        G4Track *trackB = reactiveB->GetTrack();
 
        if (trackB == 0)
        {
            G4ExceptionDescription exceptionDescription;
            exceptionDescription
                << "The reactant B found using the MoleculeFinder does not have a valid "
                "track attached to it. If this is done on purpose, please do "
                "not record this molecule in the MoleculeFinder."
                << G4endl;
            G4Exception("G4DNAMoleculeEncounterStepper::RetrieveResults",
                        "MoleculeEncounterStepper001", FatalErrorInArgument,
                        exceptionDescription);
            continue;
        }
 
        if (trackB->GetTrackStatus() != fAlive)
        {
            continue;
        }
 
        if (trackB == &utils.fpTrackA)
        {
            G4ExceptionDescription exceptionDescription;
            exceptionDescription
                << "A track is reacting with itself (which is impossible) ie fpTrackA == trackB"
                << G4endl;
            exceptionDescription << "Molecule A (and B) is of type : "
                << utils.fpMoleculeA->GetName() << " with trackID : "
                << utils.fpTrackA.GetTrackID() << G4endl;
 
            G4Exception("G4DNAMoleculeEncounterStepper::RetrieveResults",
                        "MoleculeEncounterStepper003", FatalErrorInArgument,
                        exceptionDescription);
 
        }
 
        if (fabs(trackB->GetGlobalTime() - utils.fpTrackA.GetGlobalTime())
        > utils.fpTrackA.GetGlobalTime() * (1 - 1 / 100))
        {
            // DEBUG
            G4ExceptionDescription exceptionDescription;
            exceptionDescription
                << "The interacting tracks are not synchronized in time" << G4endl;
            exceptionDescription
                << "trackB->GetGlobalTime() != fpTrackA.GetGlobalTime()" << G4endl;
 
            exceptionDescription << "fpTrackA : trackID : " << utils.fpTrackA.GetTrackID()
                << "\t Name :" << utils.fpMoleculeA->GetName()
                << "\t fpTrackA->GetGlobalTime() = "
                << G4BestUnit(utils.fpTrackA.GetGlobalTime(), "Time") << G4endl;
 
            exceptionDescription << "trackB : trackID : " << trackB->GetTrackID()
                << "\t Name :" << utils.fpMoleculeB->GetName()
                << "\t trackB->GetGlobalTime() = "
                << G4BestUnit(trackB->GetGlobalTime(), "Time") << G4endl;
 
            G4Exception("G4DNAMoleculeEncounterStepper::RetrieveResults",
                        "MoleculeEncounterStepper004", FatalErrorInArgument,
                        exceptionDescription);
        }
 
#ifdef G4VERBOSE
        if (fVerbose > 1)
        {
 
            G4double r2 = results->GetDistanceSqr();
            G4cout << "\t ************************************************** " << G4endl;
            G4cout << "\t Reaction between "
                << utils.fpMoleculeA->GetName() << " (" << utils.fpTrackA.GetTrackID() << ") "
                << " & " << utils.fpMoleculeB->GetName() << " (" << trackB->GetTrackID() << "), "
                << "Interaction Range = "
                << G4BestUnit(R, "Length") << G4endl;
            G4cout << "\t Real distance between reactants  = "
                << G4BestUnit((utils.fpTrackA.GetPosition() - trackB->GetPosition()).mag(), "Length") << G4endl;
            G4cout << "\t Distance between reactants calculated by nearest neighbor algorithm = "
                << G4BestUnit(sqrt(r2), "Length") << G4endl;
 
        }
#endif
 
        fReactants->push_back(trackB);
    }
}

References fAlive, FatalErrorInArgument, G4DNAMoleculeEncounterStepper::Utils::fpMoleculeA, G4DNAMoleculeEncounterStepper::Utils::fpMoleculeB, G4DNAMoleculeEncounterStepper::Utils::fpTrackA, G4VITTimeStepComputer::fReactants, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), G4Track::GetGlobalTime(), G4MolecularConfiguration::GetName(), G4Molecule::GetName(), G4Track::GetPosition(), G4IT::GetTrack(), G4Track::GetTrackID(), and G4Track::GetTrackStatus().

Referenced by CalculateStep().

GetReactants()

G4TrackVectorHandle G4VITTimeStepComputer::GetReactants ( )

inlineinherited

Definition at line 139 of file G4VITTimeStepComputer.hh.

{
    return  fReactants ;
}

References G4VITTimeStepComputer::fReactants.

Referenced by CalculateMinTimeStep(), and G4DNAIndependentReactionTimeStepper::CalculateMinTimeStep().

GetReactionModel()

G4VDNAReactionModel * G4DNAMoleculeEncounterStepper::GetReactionModel

(

)

Definition at line 431 of file G4DNAMoleculeEncounterStepper.cc.

{
    return fReactionModel;
}

References fReactionModel.

GetReactionTable()

const G4ITReactionTable * G4VITTimeStepComputer::GetReactionTable ( )

inlineinherited

Definition at line 123 of file G4VITTimeStepComputer.hh.

{
    return fpReactionTable ;
}

References G4VITTimeStepComputer::fpReactionTable.

GetSampledMinTimeStep()

G4double G4VITTimeStepComputer::GetSampledMinTimeStep ( )

inlineinherited

Definition at line 134 of file G4VITTimeStepComputer.hh.

{
    return fSampledMinTimeStep ;
}

References G4VITTimeStepComputer::fSampledMinTimeStep.

Initialize()

virtual void G4VITTimeStepComputer::Initialize ( )

inlinevirtualinherited

This macro defined in AddClone_def

Definition at line 83 of file G4VITTimeStepComputer.hh.

{;}

InitializeForNewTrack()

void G4DNAMoleculeEncounterStepper::InitializeForNewTrack ( )

private

Definition at line 103 of file G4DNAMoleculeEncounterStepper.cc.

{
    if (fReactants)
    {
        fReactants.reset();
    }
    fSampledMinTimeStep = DBL_MAX;
    fHasAlreadyReachedNullTime = false;
}

References DBL_MAX, fHasAlreadyReachedNullTime, G4VITTimeStepComputer::fReactants, and G4VITTimeStepComputer::fSampledMinTimeStep.

Referenced by CalculateStep().

operator=()

G4DNAMoleculeEncounterStepper & G4DNAMoleculeEncounterStepper::operator= ( const G4DNAMoleculeEncounterStepper &  )

delete

Prepare()

void G4DNAMoleculeEncounterStepper::Prepare ( )

virtual

Reimplemented from G4VITTimeStepComputer.

Definition at line 81 of file G4DNAMoleculeEncounterStepper.cc.

{
    G4VITTimeStepComputer::Prepare();
 
#if defined (DEBUG_MEM)
    MemStat mem_first, mem_second, mem_diff;
#endif
 
#if defined (DEBUG_MEM)
    mem_first = MemoryUsage();
#endif
    G4MoleculeFinder::Instance()->UpdatePositionMap();
 
#if defined (DEBUG_MEM)
    mem_second = MemoryUsage();
    mem_diff = mem_second - mem_first;
    G4cout << "\t || MEM || G4DNAMoleculeEncounterStepper::Prepare || "
        "After computing G4ITManager<G4Molecule>::Instance()->"
        "UpdatePositionMap, diff is : " << mem_diff << G4endl;
#endif
}

References G4cout, G4endl, G4ITFinder< T >::Instance(), G4MemStat::MemoryUsage(), G4VITTimeStepComputer::Prepare(), and G4ITFinder< T >::UpdatePositionMap().

ResetReactants()

virtual void G4VITTimeStepComputer::ResetReactants ( )

inlinevirtualinherited

Definition at line 94 of file G4VITTimeStepComputer.hh.

    {fReactants.reset();}

References G4VITTimeStepComputer::fReactants.

Referenced by CalculateMinTimeStep(), and G4DNAIndependentReactionTimeStepper::CalculateMinTimeStep().

SetReactionModel()

void G4DNAMoleculeEncounterStepper::SetReactionModel

(

G4VDNAReactionModel *

pReactionModel

)

Definition at line 426 of file G4DNAMoleculeEncounterStepper.cc.

{
    fReactionModel = pReactionModel;
}

References fReactionModel.

SetReactionTable()

void G4VITTimeStepComputer::SetReactionTable ( const G4ITReactionTable *  table )

inlineinherited

Definition at line 118 of file G4VITTimeStepComputer.hh.

{
    fpReactionTable = table;
}

References G4VITTimeStepComputer::fpReactionTable.

SetTimes()

void G4VITTimeStepComputer::SetTimes ( const G4double &  currentGlobalTime, const G4double &  userMinStepTime  )

staticinherited

Definition at line 68 of file G4VITTimeStepComputer.cc.

{
    fCurrentGlobalTime = currentGlobalTime ;
    fUserMinTimeStep   = userMinStepTime ;
}

References G4VITTimeStepComputer::fCurrentGlobalTime, and G4VITTimeStepComputer::fUserMinTimeStep.

Referenced by G4ITModelProcessor::InitializeStepper().

SetVerbose()

void G4DNAMoleculeEncounterStepper::SetVerbose

(

int

flag

)

Definition at line 436 of file G4DNAMoleculeEncounterStepper.cc.

{
    fVerbose = flag;
}

References fVerbose.

Field Documentation

fCurrentGlobalTime

G4ThreadLocal G4double G4VITTimeStepComputer::fCurrentGlobalTime = -1

staticprotectedinherited

Definition at line 106 of file G4VITTimeStepComputer.hh.

Referenced by G4VITTimeStepComputer::SetTimes().

fHasAlreadyReachedNullTime

G4bool G4DNAMoleculeEncounterStepper::fHasAlreadyReachedNullTime

private

Definition at line 99 of file G4DNAMoleculeEncounterStepper.hh.

Referenced by CalculateStep(), and InitializeForNewTrack().

fMolecularReactionTable

const G4DNAMolecularReactionTable*& G4DNAMoleculeEncounterStepper::fMolecularReactionTable

private

Definition at line 100 of file G4DNAMoleculeEncounterStepper.hh.

Referenced by CalculateStep().

fpReactionTable

const G4ITReactionTable* G4VITTimeStepComputer::fpReactionTable

protectedinherited

Definition at line 112 of file G4VITTimeStepComputer.hh.

Referenced by G4VITTimeStepComputer::G4VITTimeStepComputer(), G4VITTimeStepComputer::GetReactionTable(), and G4VITTimeStepComputer::SetReactionTable().

fpTrackContainer

G4ITTrackHolder* G4DNAMoleculeEncounterStepper::fpTrackContainer

private

Definition at line 102 of file G4DNAMoleculeEncounterStepper.hh.

Referenced by CalculateMinTimeStep(), and G4DNAMoleculeEncounterStepper().

fReactants

G4TrackVectorHandle G4VITTimeStepComputer::fReactants

protectedinherited

Definition at line 110 of file G4VITTimeStepComputer.hh.

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateStep(), CalculateStep(), G4DNAIndependentReactionTimeStepper::CalculateStep(), G4DNAIRTMoleculeEncounterStepper::CheckAndRecordResults(), CheckAndRecordResults(), G4DNAIndependentReactionTimeStepper::CheckAndRecordResults(), G4VITTimeStepComputer::G4VITTimeStepComputer(), G4VITTimeStepComputer::GetReactants(), G4DNAIndependentReactionTimeStepper::InitializeForNewTrack(), G4DNAIRTMoleculeEncounterStepper::InitializeForNewTrack(), InitializeForNewTrack(), G4VITTimeStepComputer::Prepare(), and G4VITTimeStepComputer::ResetReactants().

fReactionModel

G4VDNAReactionModel* G4DNAMoleculeEncounterStepper::fReactionModel

private

Definition at line 101 of file G4DNAMoleculeEncounterStepper.hh.

Referenced by CalculateStep(), GetReactionModel(), and SetReactionModel().

fReactionSet

G4ITReactionSet* G4DNAMoleculeEncounterStepper::fReactionSet

private

Definition at line 103 of file G4DNAMoleculeEncounterStepper.hh.

Referenced by CalculateMinTimeStep(), and G4DNAMoleculeEncounterStepper().

fSampledMinTimeStep

G4double G4VITTimeStepComputer::fSampledMinTimeStep

protectedinherited

Definition at line 109 of file G4VITTimeStepComputer.hh.

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIRTMoleculeEncounterStepper::CalculateStep(), CalculateStep(), G4DNAIndependentReactionTimeStepper::CalculateStep(), G4VITTimeStepComputer::G4VITTimeStepComputer(), G4VITTimeStepComputer::GetSampledMinTimeStep(), G4DNAIndependentReactionTimeStepper::InitializeForNewTrack(), G4DNAIRTMoleculeEncounterStepper::InitializeForNewTrack(), InitializeForNewTrack(), and G4DNAIRTMoleculeEncounterStepper::Prepare().

fUserMinTimeStep

G4ThreadLocal G4double G4VITTimeStepComputer::fUserMinTimeStep = -1

staticprotectedinherited

Definition at line 107 of file G4VITTimeStepComputer.hh.

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIRTMoleculeEncounterStepper::CalculateStep(), CalculateStep(), G4DNAIndependentReactionTimeStepper::CalculateStep(), and G4VITTimeStepComputer::SetTimes().

fVerbose

G4int G4DNAMoleculeEncounterStepper::fVerbose

private

Definition at line 104 of file G4DNAMoleculeEncounterStepper.hh.

Referenced by CalculateStep(), CheckAndRecordResults(), and SetVerbose().

---

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

• source/processes/electromagnetic/dna/models/include/G4DNAMoleculeEncounterStepper.hh
• source/processes/electromagnetic/dna/models/src/G4DNAMoleculeEncounterStepper.cc