#include <G4DNAIndependentReactionTimeStepper.hh>

Inheritance diagram for G4DNAIndependentReactionTimeStepper:

Data Structures
class	Utils

Public Member Functions
G4double	CalculateMinTimeStep (G4double, G4double) override

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

std::unique_ptr< G4ITReactionChange >	FindReaction (G4ITReactionSet *pReactionSet, const G4double &currentStepTime=0, const G4double &previousStepTime=0, const G4bool &reachedUserStepTimeLimit=false)

	G4DNAIndependentReactionTimeStepper ()

	G4DNAIndependentReactionTimeStepper (const G4DNAIndependentReactionTimeStepper &)=delete

G4TrackVectorHandle	GetReactants ()

G4VDNAReactionModel *	GetReactionModel ()

const G4ITReactionTable *	GetReactionTable ()

G4double	GetSampledMinTimeStep ()

virtual void	Initialize ()

G4DNAIndependentReactionTimeStepper &	operator= (const G4DNAIndependentReactionTimeStepper &)=delete

void	Prepare () override

virtual void	ResetReactants ()

void	SetReactionModel (G4VDNAReactionModel *)

void	SetReactionProcess (G4VITReactionProcess *pReactionProcess)

void	SetReactionTable (const G4ITReactionTable *)

void	SetReactionTypeManager (G4VReactionTypeManager *typeManager)

void	SetVerbose (G4int)

	~G4DNAIndependentReactionTimeStepper () override=default

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 &utils)

ReactionType	GetReactionType (const G4Track &trackA, const G4Track &trackB)

G4double	GetTimeToEncounter (const G4Track &trackA, const G4Track &trackB)

void	InitializeForNewTrack ()

Private Attributes
G4bool	fHasAlreadyReachedNullTime

const G4DNAMolecularReactionTable *&	fMolecularReactionTable

G4VITReactionProcess *	fpReactionProcess

G4ITTrackHolder *	fpTrackContainer

G4double	fRCutOff

G4VDNAReactionModel *	fReactionModel

G4ITReactionSet *	fReactionSet

G4DNAReactionTypeManager *	fReactionTypeManager

std::map< G4int, G4ThreeVector >	fSampledPositions

G4int	fVerbose

Detailed Description

Definition at line 51 of file G4DNAIndependentReactionTimeStepper.hh.

Constructor & Destructor Documentation

◆ G4DNAIndependentReactionTimeStepper() [1/2]

G4DNAIndependentReactionTimeStepper::G4DNAIndependentReactionTimeStepper ( )

Definition at line 57 of file G4DNAIndependentReactionTimeStepper.cc.

    : G4VITTimeStepComputer()
    , fHasAlreadyReachedNullTime(false)
    , fMolecularReactionTable(reference_cast<const G4DNAMolecularReactionTable*>(fpReactionTable))
    , fReactionModel(nullptr)
    , fpTrackContainer(G4ITTrackHolder::Instance())
    , fReactionSet(G4ITReactionSet::Instance())
    , fVerbose(0)
    , fRCutOff(G4IRTUtils::GetRCutOff())
    , fReactionTypeManager(nullptr)
    , fpReactionProcess(nullptr)
{
    fReactionSet->SortByTime();
}

References fReactionSet, and G4ITReactionSet::SortByTime().

◆ ~G4DNAIndependentReactionTimeStepper()

G4DNAIndependentReactionTimeStepper::~G4DNAIndependentReactionTimeStepper ( )

overridedefault

◆ G4DNAIndependentReactionTimeStepper() [2/2]

G4DNAIndependentReactionTimeStepper::G4DNAIndependentReactionTimeStepper ( const G4DNAIndependentReactionTimeStepper & )

delete

Member Function Documentation

◆ CalculateMinTimeStep()

G4double G4DNAIndependentReactionTimeStepper::CalculateMinTimeStep	(	G4double	,
		G4double	definedMinTimeStep
	)

overridevirtual

Implements G4VITTimeStepComputer.

Definition at line 439 of file G4DNAIndependentReactionTimeStepper.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 && G4bool(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 G4DNAIndependentReactionTimeStepper::CalculateStep	(	const G4Track &	trackA,
		const G4double &	userMinTimeStep
	)

overridevirtual

Implements G4VITTimeStepComputer.

Definition at line 96 of file G4DNAIndependentReactionTimeStepper.cc.

{
    auto pMoleculeA = GetMolecule(trackA);
    InitializeForNewTrack();
    fUserMinTimeStep = userMinTimeStep;
 
#ifdef G4VERBOSE
    if (fVerbose)
    {
        G4cout
            << "_______________________________________________________________________"
            << G4endl;
        G4cout << "G4DNAIndependentReactionTimeStepper::CalculateStep" << G4endl;
        G4cout << "Check done for molecule : " << pMoleculeA->GetName()
            << " (" << trackA.GetTrackID() << ") "
            << G4endl;
    }
#endif
 
    auto pMolConfA = pMoleculeA->GetMolecularConfiguration();
 
    const auto pReactantList = fMolecularReactionTable->CanReactWith(pMolConfA);
 
    if (!pReactantList)
    {
#ifdef G4VERBOSE
        if (fVerbose > 1)
        {
            G4cout << "!!!!!!!!!!!!!!!!!!!!" << G4endl;
            G4cout << "!!! WARNING" << G4endl;
            G4cout << "G4DNAIndependentReactionTimeStepper::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)
        {
            G4cout << "!!!!!!!!!!!!!!!!!!!!" << G4endl;
            G4cout << "!!! WARNING" << G4endl;
            G4cout << "G4DNAIndependentReactionTimeStepper::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);
    for (G4int i = 0; i < nbReactives; i++)
    {
        auto pMoleculeB = (*pReactantList)[i];
        G4int key = pMoleculeB->GetMoleculeID();
 
        //fRCutOff = G4IRTUtils::GetRCutOff(1 * ps);
        fRCutOff = G4IRTUtils::GetRCutOff();
        //______________________________________________________________
        // Retrieve reaction range
        const G4double Reff = fReactionModel->GetReactionRadius(i);
        std::vector<std::pair<G4TrackList::iterator,G4double>> resultIndices;
        resultIndices.clear();
        G4ChemicalMoleculeFinder::Instance()->
        FindNearestInRange(trackA,
                            key,
                            fRCutOff,
                            resultIndices);
 
        if(resultIndices.empty())
        {
            continue;
        }
        for(auto& it : resultIndices)
        {
            G4Track* pTrackB = *(std::get<0>(it));
 
            if(pTrackB == &trackA)
            {
                continue;
            }
            if(pTrackB == nullptr)
            {
                G4ExceptionDescription exceptionDescription;
                exceptionDescription << "No trackB no valid";
                G4Exception("G4DNAIndependentReactionTimeModel"
                            "::BuildReactionMap()", "NO_TRACK02",
                FatalException, exceptionDescription);
            }
            Utils utils(trackA, *pTrackB);
 
            auto pMolB = GetMolecule(pTrackB);
            auto pMolConfB = pMolB->GetMolecularConfiguration();
            G4double distance = (trackA.GetPosition() - pTrackB->GetPosition()).mag();
            if(distance * distance < Reff * Reff)
            {
                auto processTable = *(fReactionTypeManager->GetReactionTypeTable());
                auto typeOfReaction = (G4int)GetReactionType(trackA, *pTrackB);
                if(processTable[typeOfReaction]->
                GeminateRecombinationProbability(pMolConfA, pMolConfB))
                {
                    if (!fHasAlreadyReachedNullTime)
                    {
                        fReactants->clear();
                        fHasAlreadyReachedNullTime = true;
                    }
                    fSampledMinTimeStep = 0.;
                    CheckAndRecordResults(utils);
                }
            }
            else
            {
                G4double tempMinET = GetTimeToEncounter(trackA, *pTrackB);
                if(tempMinET < 0 ||
                   tempMinET > G4Scheduler::Instance()->GetEndTime())
                {
                    continue;
                }
                if (tempMinET >= fSampledMinTimeStep)
                {
                    continue;
                }
                fSampledMinTimeStep = tempMinET;
                fReactants->clear();
                CheckAndRecordResults(utils);
            }
        }
    }
 
#ifdef G4VERBOSE
    if (fVerbose)
    {
        G4cout << "G4DNAIndependentReactionTimeStepper::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
 
    for (const auto& it : *fReactants)
    {
        auto pTrackB = it;
        fSampledPositions[pTrackB->GetTrackID()] = pTrackB->GetPosition();
    }
    return fSampledMinTimeStep;
}

References G4DNAMolecularReactionTable::CanReactWith(), CheckAndRecordResults(), DBL_MAX, FatalException, fHasAlreadyReachedNullTime, fMolecularReactionTable, fRCutOff, G4VITTimeStepComputer::fReactants, fReactionModel, fReactionTypeManager, G4VITTimeStepComputer::fSampledMinTimeStep, fSampledPositions, G4VITTimeStepComputer::fUserMinTimeStep, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), GetMolecule(), G4Molecule::GetName(), G4Track::GetPosition(), G4IRTUtils::GetRCutOff(), G4VDNAReactionModel::GetReactionRadius(), GetReactionType(), G4DNAReactionTypeManager::GetReactionTypeTable(), GetTimeToEncounter(), G4Track::GetTrackID(), G4VDNAReactionModel::Initialise(), InitializeForNewTrack(), G4OctreeFinder< T, CONTAINER >::Instance(), and G4Scheduler::Instance().

Referenced by CalculateMinTimeStep().

◆ CheckAndRecordResults()

void G4DNAIndependentReactionTimeStepper::CheckAndRecordResults ( const Utils & utils )

private

Definition at line 270 of file G4DNAIndependentReactionTimeStepper.cc.

{
    if (utils.fTrackB.GetTrackStatus() != fAlive)
    {
            return;
    }
 
    if (&utils.fTrackB == &utils.fTrackA)
    {
        G4ExceptionDescription exceptionDescription;
        exceptionDescription<< "A track is reacting with itself"
                            " (which is impossible) ie fpTrackA == trackB"<< G4endl;
        exceptionDescription << "Molecule A is of type : "
                             << utils.fpMoleculeA->GetName() << " with trackID : "
                             << utils.fTrackA.GetTrackID()<<" and B : "
                             << utils.fpMoleculeB->GetName() << " with trackID : "
                             << utils.fTrackB.GetTrackID() << G4endl;
        G4Exception("G4DNAIndependentReactionTimeStepper::RetrieveResults",
                    "G4DNAIndependentReactionTimeStepper003", FatalErrorInArgument,
                    exceptionDescription);
    }
 
    if (fabs(utils.fTrackB.GetGlobalTime() - utils.fTrackA.GetGlobalTime())
    > utils.fTrackA.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.fTrackA.GetTrackID()
            << "\t Name :" << utils.fpMoleculeA->GetName()
            << "\t fpTrackA->GetGlobalTime() = "
            << G4BestUnit(utils.fTrackA.GetGlobalTime(), "Time") << G4endl;
 
        exceptionDescription << "trackB : trackID : " << utils.fTrackB.GetTrackID()
            << "\t Name :" << utils.fpMoleculeB->GetName()
            << "\t trackB->GetGlobalTime() = "
            << G4BestUnit(utils.fTrackB.GetGlobalTime(), "Time") << G4endl;
 
        G4Exception("G4DNAIndependentReactionTimeStepper::RetrieveResults",
                    "G4DNAIndependentReactionTimeStepper004", FatalErrorInArgument,
                    exceptionDescription);
    }
    fReactants->push_back(const_cast<G4Track*>(&utils.fTrackB));
}

References fAlive, FatalErrorInArgument, G4DNAIndependentReactionTimeStepper::Utils::fpMoleculeA, G4DNAIndependentReactionTimeStepper::Utils::fpMoleculeB, G4VITTimeStepComputer::fReactants, G4DNAIndependentReactionTimeStepper::Utils::fTrackA, G4DNAIndependentReactionTimeStepper::Utils::fTrackB, G4BestUnit, G4endl, G4Exception(), G4Track::GetGlobalTime(), G4Molecule::GetName(), G4Track::GetTrackID(), and G4Track::GetTrackStatus().

Referenced by CalculateStep().

◆ FindReaction()

std::unique_ptr< G4ITReactionChange > G4DNAIndependentReactionTimeStepper::FindReaction	(	G4ITReactionSet *	pReactionSet,
		const G4double &	currentStepTime = `0`,
		const G4double &	previousStepTime = `0`,
		const G4bool &	reachedUserStepTimeLimit = `false`
	)

Definition at line 320 of file G4DNAIndependentReactionTimeStepper.cc.

{
    if (pReactionSet == nullptr)
    {
        return nullptr;
    }
 
    G4ITReactionPerTime& reactionPerTime = pReactionSet->GetReactionsPerTime();
    if(reactionPerTime.empty())
    {
        return nullptr;
    }
 
    for (auto reaction_i = reactionPerTime.begin();
         reaction_i != reactionPerTime.end();
         reaction_i = reactionPerTime.begin())
    {
        G4Track* pTrackA = (*reaction_i)->GetReactants().first;
        if (pTrackA->GetTrackStatus() == fStopAndKill)
        {
            continue;
        }
        G4Track* pTrackB = (*reaction_i)->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_i);
        if(fpReactionProcess != nullptr && fpReactionProcess->TestReactibility(*pTrackA,
                                                                               *pTrackB,
                                                                               currentStepTime,
                                                                               false))
        {
            pTrackA->SetPosition(fSampledPositions[pTrackA->GetTrackID()]);
            pTrackB->SetPosition(fSampledPositions[pTrackB->GetTrackID()]);
            auto pReactionChange = fpReactionProcess->MakeReaction(*pTrackA, *pTrackB);
            if (pReactionChange == nullptr)
            {
                return nullptr;
            }
            return pReactionChange;
        }
    }
    return nullptr;
}

References FatalErrorInArgument, fpReactionProcess, fSampledPositions, fStopAndKill, G4Exception(), G4ITReactionSet::GetReactionsPerTime(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4VITReactionProcess::MakeReaction(), G4ITReactionSet::SelectThisReaction(), G4Track::SetPosition(), and G4VITReactionProcess::TestReactibility().

◆ GetReactants()

G4TrackVectorHandle G4VITTimeStepComputer::GetReactants ( )

inlineinherited

Definition at line 139 of file G4VITTimeStepComputer.hh.

{
    return  fReactants ;
}

References G4VITTimeStepComputer::fReactants.

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

◆ GetReactionModel()

G4VDNAReactionModel * G4DNAIndependentReactionTimeStepper::GetReactionModel ( )

Definition at line 386 of file G4DNAIndependentReactionTimeStepper.cc.

{
    return fReactionModel;
}

References fReactionModel.

◆ GetReactionTable()

const G4ITReactionTable * G4VITTimeStepComputer::GetReactionTable ( )

inlineinherited

Definition at line 123 of file G4VITTimeStepComputer.hh.

{
    return fpReactionTable ;
}

References G4VITTimeStepComputer::fpReactionTable.

◆ GetReactionType()

ReactionType G4DNAIndependentReactionTimeStepper::GetReactionType	(	const G4Track &	trackA,
		const G4Track &	trackB
	)

private

Definition at line 396 of file G4DNAIndependentReactionTimeStepper.cc.

{
    auto pMoleculeA = GetMolecule(trackA)->GetMolecularConfiguration();
    auto pMoleculeB = GetMolecule(trackB)->GetMolecularConfiguration();
    auto pData = fMolecularReactionTable->GetReactionData(pMoleculeA,pMoleculeB);
    G4int reactionID = pData->GetReactionID();
    return fReactionTypeManager->GetReactionTypeByID(reactionID);
}

References fMolecularReactionTable, fReactionTypeManager, G4Molecule::GetMolecularConfiguration(), GetMolecule(), G4DNAMolecularReactionTable::GetReactionData(), G4DNAMolecularReactionData::GetReactionID(), and G4DNAReactionTypeManager::GetReactionTypeByID().

Referenced by CalculateStep(), and GetTimeToEncounter().

◆ GetSampledMinTimeStep()

G4double G4VITTimeStepComputer::GetSampledMinTimeStep ( )

inlineinherited

Definition at line 134 of file G4VITTimeStepComputer.hh.

{
    return fSampledMinTimeStep ;
}

References G4VITTimeStepComputer::fSampledMinTimeStep.

◆ GetTimeToEncounter()

G4double G4DNAIndependentReactionTimeStepper::GetTimeToEncounter	(	const G4Track &	trackA,
		const G4Track &	trackB
	)

private

Definition at line 406 of file G4DNAIndependentReactionTimeStepper.cc.

{
    if(fReactionTypeManager == nullptr)
    {
        G4ExceptionDescription exceptionDescription;
        exceptionDescription << "fpProManager is not "
                                "initialized ";
        G4Exception("G4DNAIndependentReactionTimeModel::"
                    "GetIndependentReactionTime()",
                    "G4DNAIndependentReactionTimeModel002",
                    FatalErrorInArgument,exceptionDescription);
    }
    auto processTable = *(fReactionTypeManager->GetReactionTypeTable());
    ReactionType reactionType = GetReactionType(trackA,trackB);
 
#ifdef DEBUG
    G4cout<<"A: "<<GetMolecule(trackA)->GetName()<<"("<<trackA.GetTrackID()<<")"<<" + B : "
    <<GetMolecule(trackB)->GetName()<<"("<<trackB.GetTrackID()<<")"<<G4endl;
#endif
 
    return processTable[(G4int)reactionType]->GetTimeToEncounter(trackA,trackB);
}

References FatalErrorInArgument, fReactionTypeManager, G4cout, G4endl, G4Exception(), GetMolecule(), G4Molecule::GetName(), GetReactionType(), G4DNAReactionTypeManager::GetReactionTypeTable(), GetTimeToEncounter(), and G4Track::GetTrackID().

Referenced by CalculateStep(), and GetTimeToEncounter().

◆ Initialize()

virtual void G4VITTimeStepComputer::Initialize ( )

inlinevirtualinherited

This macro defined in AddClone_def

Definition at line 83 of file G4VITTimeStepComputer.hh.

83{;}

◆ InitializeForNewTrack()

void G4DNAIndependentReactionTimeStepper::InitializeForNewTrack ( )

private

Definition at line 79 of file G4DNAIndependentReactionTimeStepper.cc.

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

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

Referenced by CalculateStep().

◆ operator=()

G4DNAIndependentReactionTimeStepper & G4DNAIndependentReactionTimeStepper::operator= ( const G4DNAIndependentReactionTimeStepper & )

delete

◆ Prepare()

void G4DNAIndependentReactionTimeStepper::Prepare ( )

overridevirtual

Reimplemented from G4VITTimeStepComputer.

Definition at line 72 of file G4DNAIndependentReactionTimeStepper.cc.

{
    G4VITTimeStepComputer::Prepare();
    fSampledPositions.clear();
    BuildChemicalMoleculeFinder()
}

References BuildChemicalMoleculeFinder, fSampledPositions, and G4VITTimeStepComputer::Prepare().

◆ 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 CalculateMinTimeStep().

◆ SetReactionModel()

void G4DNAIndependentReactionTimeStepper::SetReactionModel ( G4VDNAReactionModel * pReactionModel )

Definition at line 381 of file G4DNAIndependentReactionTimeStepper.cc.

{
    fReactionModel = pReactionModel;
}

References fReactionModel.

◆ SetReactionProcess()

void G4DNAIndependentReactionTimeStepper::SetReactionProcess ( G4VITReactionProcess * pReactionProcess )

Definition at line 435 of file G4DNAIndependentReactionTimeStepper.cc.

{
    fpReactionProcess = pReactionProcess;
}

References fpReactionProcess.

◆ SetReactionTable()

void G4VITTimeStepComputer::SetReactionTable ( const G4ITReactionTable * table )

inlineinherited

Definition at line 118 of file G4VITTimeStepComputer.hh.

{
    fpReactionTable = table;
}

References G4VITTimeStepComputer::fpReactionTable.

◆ SetReactionTypeManager()

void G4DNAIndependentReactionTimeStepper::SetReactionTypeManager ( G4VReactionTypeManager * typeManager )

Definition at line 430 of file G4DNAIndependentReactionTimeStepper.cc.

{
    fReactionTypeManager = ((G4DNAReactionTypeManager*)typeManager);
}

References fReactionTypeManager.

◆ 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 G4DNAIndependentReactionTimeStepper::SetVerbose ( G4int flag )

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

private

Definition at line 87 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateStep(), and InitializeForNewTrack().

◆ fMolecularReactionTable

const G4DNAMolecularReactionTable*& G4DNAIndependentReactionTimeStepper::fMolecularReactionTable

private

Definition at line 88 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateStep(), and GetReactionType().

◆ fpReactionProcess

G4VITReactionProcess* G4DNAIndependentReactionTimeStepper::fpReactionProcess

private

Definition at line 96 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by FindReaction(), and SetReactionProcess().

◆ 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* G4DNAIndependentReactionTimeStepper::fpTrackContainer

private

Definition at line 90 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateMinTimeStep().

◆ fRCutOff

G4double G4DNAIndependentReactionTimeStepper::fRCutOff

private

Definition at line 93 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateStep().

◆ fReactants

G4TrackVectorHandle G4VITTimeStepComputer::fReactants

protectedinherited

Definition at line 110 of file G4VITTimeStepComputer.hh.

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

◆ fReactionModel

G4VDNAReactionModel* G4DNAIndependentReactionTimeStepper::fReactionModel

private

Definition at line 89 of file G4DNAIndependentReactionTimeStepper.hh.

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

◆ fReactionSet

G4ITReactionSet* G4DNAIndependentReactionTimeStepper::fReactionSet

private

Definition at line 91 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateMinTimeStep(), and G4DNAIndependentReactionTimeStepper().

◆ fReactionTypeManager

G4DNAReactionTypeManager* G4DNAIndependentReactionTimeStepper::fReactionTypeManager

private

Definition at line 94 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateStep(), GetReactionType(), GetTimeToEncounter(), and SetReactionTypeManager().

◆ fSampledMinTimeStep

G4double G4VITTimeStepComputer::fSampledMinTimeStep

protectedinherited

Definition at line 109 of file G4VITTimeStepComputer.hh.

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

◆ fSampledPositions

std::map<G4int,G4ThreeVector> G4DNAIndependentReactionTimeStepper::fSampledPositions

private

Definition at line 97 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateStep(), FindReaction(), and Prepare().

◆ fUserMinTimeStep

G4ThreadLocal G4double G4VITTimeStepComputer::fUserMinTimeStep = -1

staticprotectedinherited

Definition at line 107 of file G4VITTimeStepComputer.hh.

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

◆ fVerbose

G4int G4DNAIndependentReactionTimeStepper::fVerbose

private

Definition at line 92 of file G4DNAIndependentReactionTimeStepper.hh.

Referenced by CalculateStep(), and SetVerbose().

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

source/processes/electromagnetic/dna/models/include/G4DNAIndependentReactionTimeStepper.hh
source/processes/electromagnetic/dna/models/src/G4DNAIndependentReactionTimeStepper.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

◆ G4DNAIndependentReactionTimeStepper() [1/2]

◆ ~G4DNAIndependentReactionTimeStepper()

◆ G4DNAIndependentReactionTimeStepper() [2/2]

Member Function Documentation

◆ CalculateMinTimeStep()

◆ CalculateStep()

◆ CheckAndRecordResults()

◆ FindReaction()

◆ GetReactants()

◆ GetReactionModel()

◆ GetReactionTable()

◆ GetReactionType()

◆ GetSampledMinTimeStep()

◆ GetTimeToEncounter()

◆ Initialize()

◆ InitializeForNewTrack()

◆ operator=()

◆ Prepare()

◆ ResetReactants()

◆ SetReactionModel()

◆ SetReactionProcess()

◆ SetReactionTable()

◆ SetReactionTypeManager()

◆ SetTimes()

◆ SetVerbose()

Field Documentation

◆ fCurrentGlobalTime

◆ fHasAlreadyReachedNullTime

◆ fMolecularReactionTable

◆ fpReactionProcess

◆ fpReactionTable

◆ fpTrackContainer

◆ fRCutOff

◆ fReactants

◆ fReactionModel

◆ fReactionSet

◆ fReactionTypeManager

◆ fSampledMinTimeStep

◆ fSampledPositions

◆ fUserMinTimeStep

◆ fVerbose