#include <G4DNAIRTMoleculeEncounterStepper.hh>

Inheritance diagram for G4DNAIRTMoleculeEncounterStepper:

Data Structures
class	Utils

Public Member Functions
virtual G4double	CalculateMinTimeStep (G4double, G4double)

virtual G4double	CalculateStep (const G4Track &, const G4double &)

	G4DNAIRTMoleculeEncounterStepper ()

	G4DNAIRTMoleculeEncounterStepper (const G4DNAIRTMoleculeEncounterStepper &)=delete

G4TrackVectorHandle	GetReactants ()

G4VDNAReactionModel *	GetReactionModel ()

const G4ITReactionTable *	GetReactionTable ()

G4double	GetSampledMinTimeStep ()

virtual void	Initialize ()

G4DNAIRTMoleculeEncounterStepper &	operator= (const G4DNAIRTMoleculeEncounterStepper &)=delete

virtual void	Prepare ()

virtual void	ResetReactants ()

void	SetReactionModel (G4VDNAReactionModel *)

void	SetReactionTable (const G4ITReactionTable *)

void	SetVerbose (int)

virtual	~G4DNAIRTMoleculeEncounterStepper ()

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 G4DNAIRTMoleculeEncounterStepper 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 59 of file G4DNAIRTMoleculeEncounterStepper.hh.

Constructor & Destructor Documentation

◆ G4DNAIRTMoleculeEncounterStepper() [1/2]

G4DNAIRTMoleculeEncounterStepper::G4DNAIRTMoleculeEncounterStepper ( )

Definition at line 67 of file G4DNAIRTMoleculeEncounterStepper.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().

◆ ~G4DNAIRTMoleculeEncounterStepper()

G4DNAIRTMoleculeEncounterStepper::~G4DNAIRTMoleculeEncounterStepper ( )

virtualdefault

◆ G4DNAIRTMoleculeEncounterStepper() [2/2]

G4DNAIRTMoleculeEncounterStepper::G4DNAIRTMoleculeEncounterStepper ( const G4DNAIRTMoleculeEncounterStepper & )

delete

Member Function Documentation

◆ CalculateMinTimeStep()

G4double G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep	(	G4double	currentGlobalTime,
		G4double	definedMinTimeStep
	)

virtual

Implements G4VITTimeStepComputer.

Definition at line 431 of file G4DNAIRTMoleculeEncounterStepper.cc.

                                                                                                                      {
 
    G4bool start = true;
    G4bool active = false;
 
    fUserMinTimeStep = definedMinTimeStep;
 
    if(fReactionSet->Empty()){
        if(currentGlobalTime == G4Scheduler::Instance()->GetStartTime()){
 
            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)
                {
                    start = false;
                    continue;
                }
                active = true;
            }
 
            if(start == true){
                return -1;
            }else if(active == false){
                G4Scheduler::Instance()->Stop();
                return fSampledMinTimeStep;
            }else{
                return fSampledMinTimeStep;
            }
 
        }else{
            for (auto pTrack : *fpTrackContainer->GetMainList())
            {
                pTrack->SetGlobalTime(G4Scheduler::Instance()->GetEndTime());
            }
            return fSampledMinTimeStep;
        }
    }
 
    auto fReactionSetInTime = fReactionSet->GetReactionsPerTime();
    fSampledMinTimeStep = fReactionSetInTime.begin()->get()->GetTime() - currentGlobalTime;
 
    return fSampledMinTimeStep;
}

References G4ITReactionSet::Empty(), FatalErrorInArgument, fpTrackContainer, fReactionSet, G4VITTimeStepComputer::fSampledMinTimeStep, fStopAndKill, fStopButAlive, G4VITTimeStepComputer::fUserMinTimeStep, G4Exception(), G4ITTrackHolder::GetMainList(), G4ITReactionSet::GetReactionsPerTime(), G4Scheduler::Instance(), and G4Scheduler::Stop().

◆ CalculateStep()

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

virtual

Implements G4VITTimeStepComputer.

Definition at line 107 of file G4DNAIRTMoleculeEncounterStepper.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, G4DNAIRTMoleculeEncounterStepper::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().

◆ CheckAndRecordResults()

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

private

Definition at line 303 of file G4DNAIRTMoleculeEncounterStepper.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, G4DNAIRTMoleculeEncounterStepper::Utils::fpMoleculeA, G4DNAIRTMoleculeEncounterStepper::Utils::fpMoleculeB, G4DNAIRTMoleculeEncounterStepper::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 G4DNAMoleculeEncounterStepper::CalculateMinTimeStep(), and G4DNAIndependentReactionTimeStepper::CalculateMinTimeStep().

◆ GetReactionModel()

G4VDNAReactionModel * G4DNAIRTMoleculeEncounterStepper::GetReactionModel ( )

Definition at line 421 of file G4DNAIRTMoleculeEncounterStepper.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.

83{;}

◆ InitializeForNewTrack()

void G4DNAIRTMoleculeEncounterStepper::InitializeForNewTrack ( )

private

Definition at line 89 of file G4DNAIRTMoleculeEncounterStepper.cc.

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

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

Referenced by CalculateStep().

◆ operator=()

G4DNAIRTMoleculeEncounterStepper & G4DNAIRTMoleculeEncounterStepper::operator= ( const G4DNAIRTMoleculeEncounterStepper & )

delete

◆ Prepare()

void G4DNAIRTMoleculeEncounterStepper::Prepare ( )

virtual

Reimplemented from G4VITTimeStepComputer.

Definition at line 80 of file G4DNAIRTMoleculeEncounterStepper.cc.

{
    fSampledMinTimeStep = DBL_MAX;
    if(G4Scheduler::Instance()->GetGlobalTime() == G4Scheduler::Instance()->GetStartTime()){
        G4VITTimeStepComputer::Prepare();
        G4MoleculeFinder::Instance()->UpdatePositionMap();
    }
}

References DBL_MAX, G4VITTimeStepComputer::fSampledMinTimeStep, G4ITFinder< T >::Instance(), G4Scheduler::Instance(), G4VITTimeStepComputer::Prepare(), and G4ITFinder< T >::UpdatePositionMap().

◆ ResetReactants()

virtual void G4VITTimeStepComputer::ResetReactants ( )

inlinevirtualinherited

Definition at line 94 of file G4VITTimeStepComputer.hh.

96 {fReactants.reset();}

References G4VITTimeStepComputer::fReactants.

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

◆ SetReactionModel()

void G4DNAIRTMoleculeEncounterStepper::SetReactionModel ( G4VDNAReactionModel * pReactionModel )

Definition at line 416 of file G4DNAIRTMoleculeEncounterStepper.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 G4DNAIRTMoleculeEncounterStepper::SetVerbose ( int flag )

Definition at line 426 of file G4DNAIRTMoleculeEncounterStepper.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 G4DNAIRTMoleculeEncounterStepper::fHasAlreadyReachedNullTime

private

Definition at line 88 of file G4DNAIRTMoleculeEncounterStepper.hh.

Referenced by CalculateStep(), and InitializeForNewTrack().

◆ fMolecularReactionTable

const G4DNAMolecularReactionTable*& G4DNAIRTMoleculeEncounterStepper::fMolecularReactionTable

private

Definition at line 90 of file G4DNAIRTMoleculeEncounterStepper.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* G4DNAIRTMoleculeEncounterStepper::fpTrackContainer

private

Definition at line 93 of file G4DNAIRTMoleculeEncounterStepper.hh.

Referenced by CalculateMinTimeStep(), and G4DNAIRTMoleculeEncounterStepper().

◆ fReactants

G4TrackVectorHandle G4VITTimeStepComputer::fReactants

protectedinherited

Definition at line 110 of file G4VITTimeStepComputer.hh.

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

◆ fReactionModel

G4VDNAReactionModel* G4DNAIRTMoleculeEncounterStepper::fReactionModel

private

Definition at line 91 of file G4DNAIRTMoleculeEncounterStepper.hh.

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

◆ fReactionSet

G4ITReactionSet* G4DNAIRTMoleculeEncounterStepper::fReactionSet

private

Definition at line 92 of file G4DNAIRTMoleculeEncounterStepper.hh.

Referenced by CalculateMinTimeStep(), and G4DNAIRTMoleculeEncounterStepper().

◆ fSampledMinTimeStep

G4double G4VITTimeStepComputer::fSampledMinTimeStep

protectedinherited

Definition at line 109 of file G4VITTimeStepComputer.hh.

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

◆ fUserMinTimeStep

G4ThreadLocal G4double G4VITTimeStepComputer::fUserMinTimeStep = -1

staticprotectedinherited

Definition at line 107 of file G4VITTimeStepComputer.hh.

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

◆ fVerbose

G4int G4DNAIRTMoleculeEncounterStepper::fVerbose

private

Definition at line 94 of file G4DNAIRTMoleculeEncounterStepper.hh.

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

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

source/processes/electromagnetic/dna/models/include/G4DNAIRTMoleculeEncounterStepper.hh
source/processes/electromagnetic/dna/models/src/G4DNAIRTMoleculeEncounterStepper.cc

Data Structures

Public Member Functions

Static Public Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4DNAIRTMoleculeEncounterStepper() [1/2]

◆ ~G4DNAIRTMoleculeEncounterStepper()

◆ G4DNAIRTMoleculeEncounterStepper() [2/2]

Member Function Documentation

◆ CalculateMinTimeStep()

◆ CalculateStep()

◆ CheckAndRecordResults()

◆ GetReactants()

◆ GetReactionModel()

◆ GetReactionTable()

◆ GetSampledMinTimeStep()

◆ Initialize()

◆ InitializeForNewTrack()

◆ operator=()

◆ Prepare()

◆ ResetReactants()

◆ SetReactionModel()

◆ SetReactionTable()

◆ SetTimes()

◆ SetVerbose()

Field Documentation

◆ fCurrentGlobalTime

◆ fHasAlreadyReachedNullTime

◆ fMolecularReactionTable

◆ fpReactionTable

◆ fpTrackContainer

◆ fReactants

◆ fReactionModel

◆ fReactionSet

◆ fSampledMinTimeStep

◆ fUserMinTimeStep

◆ fVerbose