G4Scheduler Class Reference

#include <G4Scheduler.hh>

Inheritance diagram for G4Scheduler:

Public Member Functions
	G4Scheduler (const G4Scheduler &)=delete
G4Scheduler &	operator= (const G4Scheduler &)=delete
G4bool	Notify (G4ApplicationState requestedState) override
void	RegisterModel (G4VITStepModel *, G4double) override
void	Initialize () override
void	ForceReinitialization ()
G4bool	IsInitialized ()
G4bool	IsRunning () override
void	Reset () override
void	Process () override
void	ClearList ()
void	SetGun (G4ITGun *) override
G4ITGun *	GetGun ()
void	Stop ()
void	Clear ()
void	EndTracking ()
void	SetEndTime (const G4double) override
void	SetTimeTolerance (G4double) override
G4double	GetTimeTolerance () const override
void	SetMaxZeroTimeAllowed (G4int) override
G4int	GetMaxZeroTimeAllowed () const override
G4ITModelHandler *	GetModelHandler () override
void	SetTimeSteps (std::map< G4double, G4double > *) override
void	AddTimeStep (G4double, G4double) override
void	SetDefaultTimeStep (G4double) override
G4double	GetLimitingTimeStep () const override
G4int	GetNbSteps () const override
void	SetMaxNbSteps (G4int) override
G4int	GetMaxNbSteps () const override
G4double	GetStartTime () const override
G4double	GetEndTime () const override
G4double	GetTimeStep () const override
G4double	GetPreviousTimeStep () const override
G4double	GetGlobalTime () const override
void	SetUserAction (G4UserTimeStepAction *) override
G4UserTimeStepAction *	GetUserTimeStepAction () const override
void	UseDefaultTimeSteps (G4bool)
G4bool	AreDefaultTimeStepsUsed ()
G4ITStepStatus	GetStatus () const
void	SetVerbose (G4int) override
G4int	GetVerbose () const
void	WhyDoYouStop ()
void	SetInteractivity (G4ITTrackingInteractivity *) override
G4ITTrackingInteractivity *	GetInteractivity () override
virtual size_t	GetNTracks ()
void	GetCollisionType (G4String &interactionType)
void	AddWatchedTime (G4double time)
G4double	GetNextWatchedTime () const
void	SetMaxTimeStep (G4double maxTimeStep)
G4double	GetMaxTimeStep () const
G4VScavengerMaterial *	GetScavengerMaterial () const
void	SetScavengerMaterial (std::unique_ptr< G4VScavengerMaterial > scavengerMaterial)
G4bool	IsInteractionStep ()
void	SetInteractionStep (G4bool InteractionStep)
void	ResetScavenger (bool)
Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)
virtual	~G4VStateDependent ()
G4bool	operator== (const G4VStateDependent &right) const
G4bool	operator!= (const G4VStateDependent &right) const
virtual void	NotifyDeletion (const G4Event *)
virtual void	NotifyDeletion (const G4Run *)

Static Public Member Functions
static G4Scheduler *	Instance ()
static void	DeleteInstance ()
Static Public Member Functions inherited from G4VScheduler
static G4VScheduler *	Instance ()

Protected Member Functions
	~G4Scheduler () override
void	DoProcess ()
void	SynchronizeTracks ()
void	Stepping ()
void	FindUserPreDefinedTimeStep ()
G4bool	CanICarryOn ()
void	PrintWhyDoYouStop ()
Protected Member Functions inherited from G4VScheduler
	G4VScheduler ()
virtual	~G4VScheduler ()

Detailed Description

G4Scheduler synchronizes (in time) track stepping

Definition at line 86 of file G4Scheduler.hh.

Constructor & Destructor Documentation

~G4Scheduler()

G4Scheduler::~G4Scheduler ( )

overrideprotected

Definition at line 169 of file G4Scheduler.cc.

{
  if (fpMessenger != nullptr)  // is used as a flag to know whether the manager was cleared
  {
    Clear();
  }
  fgScheduler = nullptr;
}

G4Scheduler()

G4Scheduler::G4Scheduler ( const G4Scheduler & )

delete

Referenced by G4Scheduler(), Instance(), and operator=().

Member Function Documentation

AddTimeStep()

void G4Scheduler::AddTimeStep ( G4double startingTime, G4double timeStep )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 308 of file G4Scheduler.hh.

{
  if (fpUserTimeSteps == nullptr) {
    fpUserTimeSteps = new std::map<G4double, G4double>();
    fUsePreDefinedTimeSteps = true;
  }
 
  (*fpUserTimeSteps)[startingTime] = timeStep;
}

AddWatchedTime()

void G4Scheduler::AddWatchedTime ( G4double time )

inline

Definition at line 176 of file G4Scheduler.hh.

{ fWatchedTimes.insert(time); }

AreDefaultTimeStepsUsed()

G4bool G4Scheduler::AreDefaultTimeStepsUsed ( )

inline

Definition at line 438 of file G4Scheduler.hh.

{
  return (!fUseDefaultTimeSteps && !fUsePreDefinedTimeSteps);
}

CanICarryOn()

G4bool G4Scheduler::CanICarryOn ( )

protected

Definition at line 410 of file G4Scheduler.cc.

{
  return fGlobalTime < fEndTime && (fMaxSteps == -1 ? true : fNbSteps < fMaxSteps) && fContinue;
}

Referenced by SynchronizeTracks().

Clear()

void G4Scheduler::Clear

(

)

Definition at line 178 of file G4Scheduler.cc.

{
  if (fpMessenger != nullptr) {
    delete fpMessenger;
    fpMessenger = nullptr;
  }
  if (fpStepProcessor != nullptr) {
    delete fpStepProcessor;
    fpStepProcessor = nullptr;
  }
  if (fpModelProcessor != nullptr) {
    delete fpModelProcessor;
    fpModelProcessor = nullptr;
  }
 
  G4ITTypeManager::Instance()->ReleaseRessource();
  ClearList();
  if (fpTrackingManager != nullptr) {
    delete fpTrackingManager;
    fpTrackingManager = nullptr;
  }
 
  if (fReactionSet != nullptr) {
    delete fReactionSet;
    fReactionSet = nullptr;
  }
 
  if (fpModelHandler != nullptr) {
    delete fpModelHandler;
    fpModelHandler = nullptr;
  }
}

Referenced by Notify(), and ~G4Scheduler().

ClearList()

void G4Scheduler::ClearList

(

)

Definition at line 213 of file G4Scheduler.cc.

{
  fTrackContainer.Clear();
  G4AllITFinder::DeleteInstance();
}

Referenced by Clear(), and Process().

DeleteInstance()

void G4Scheduler::DeleteInstance ( )

static

DeleteInstance should be used instead of the destructor

Definition at line 110 of file G4Scheduler.cc.

{
  delete fgScheduler;
}

DoProcess()

void G4Scheduler::DoProcess ( )

protected

Definition at line 457 of file G4Scheduler.cc.

{
  if (fpUserTimeStepAction != nullptr) fpUserTimeStepAction->NewStage();
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_STEPPING)
  MemStat mem_first, mem_second, mem_diff;
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_STEPPING)
  mem_first = MemoryUsage();
#endif
 
  while (fGlobalTime < fStopTime && fTrackContainer.MainListsNOTEmpty()
         && (fMaxSteps == -1 ? true : fNbSteps < fMaxSteps) && fContinue)
  {
    Stepping();
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_STEPPING)
    mem_second = MemoryUsage();
    mem_diff = mem_second - mem_first;
    G4cout << "\t || MEM || After step " << fNbSteps << ", diff is : " << mem_diff << G4endl;
#endif
  }
 
  PrintWhyDoYouStop();
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second - mem_first;
  G4cout << "\t || MEM || After stepping, diff is : " << mem_diff << G4endl;
#endif
 
#ifdef G4VERBOSE
  if (fVerbose > 2)
    G4cout << "*** G4Scheduler has finished processing a track list at time : "
           << G4BestUnit(fGlobalTime, "Time") << G4endl;
#endif
}

Referenced by SynchronizeTracks().

EndTracking()

void G4Scheduler::EndTracking

(

)

Definition at line 821 of file G4Scheduler.cc.

{
  if (fRunning) {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "End tracking is called while G4Scheduler is still running." << G4endl;
 
    G4Exception("G4Scheduler::EndTracking", "Scheduler017", FatalErrorInArgument,
                exceptionDescription);
  }
 
  while (fTrackContainer.DelayListsNOTEmpty()) {
    auto nextTime = fTrackContainer.GetNextTime();
    fTrackContainer.MergeNextTimeToMainList(nextTime);
  }
 
  fTrackContainer.MergeSecondariesWithMainList();
 
  if (fTrackContainer.MainListsNOTEmpty()) {
    G4TrackManyList* mainList = fTrackContainer.GetMainList();
    G4TrackManyList::iterator it = mainList->begin();
    G4TrackManyList::iterator end = mainList->end();
    for (; it != end; ++it) {
      fpTrackingManager->EndTrackingWOKill(*it);
    }
  }
 
  if (fTrackContainer.SecondaryListsNOTEmpty())  // should be empty
  {
    G4TrackManyList* secondaries = fTrackContainer.GetSecondariesList();
    G4TrackManyList::iterator it = secondaries->begin();
    G4TrackManyList::iterator end = secondaries->end();
 
    for (; it != end; ++it) {
      fpTrackingManager->EndTrackingWOKill(*it);
    }
  }
}

Referenced by Process().

FindUserPreDefinedTimeStep()

void G4Scheduler::FindUserPreDefinedTimeStep ( )

protected

Definition at line 787 of file G4Scheduler.cc.

{
  if (fpUserTimeSteps == nullptr) {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "You are asking to use user defined steps but you did not give any.";
    G4Exception("G4Scheduler::FindUserPreDefinedTimeStep", "Scheduler004", FatalErrorInArgument,
                exceptionDescription);
    return;  // makes coverity happy
  }
  auto fpUserTimeSteps_i = fpUserTimeSteps->upper_bound(fGlobalTime);
  auto fpUserTimeSteps_low = fpUserTimeSteps->lower_bound(fGlobalTime);
 
  if (fpUserTimeSteps_i == fpUserTimeSteps->end()) {
    fpUserTimeSteps_i--;
  }
  else if (fabs(fGlobalTime - fpUserTimeSteps_low->first) < fTimeTolerance) {
    // Case : fGlobalTime = X picosecond
    // and fpUserTimeSteps_low->first = X picosecond
    // but the precision is not good enough
    fpUserTimeSteps_i = fpUserTimeSteps_low;
  }
  else if (fpUserTimeSteps_i == fpUserTimeSteps_low) {
    // "Normal" cases
    fpUserTimeSteps_i--;
  }
  else {
    fpUserTimeSteps_i = fpUserTimeSteps_low;
  }
 
  fDefinedMinTimeStep = fpUserTimeSteps_i->second;
}

ForceReinitialization()

void G4Scheduler::ForceReinitialization

(

)

Definition at line 869 of file G4Scheduler.cc.

{
  fInitialized = false;
  Initialize();
}

GetCollisionType()

void G4Scheduler::GetCollisionType

(

G4String &

interactionType

)

Definition at line 881 of file G4Scheduler.cc.

{
  switch (fITStepStatus) {
    case eInteractionWithMedium:
      interactionType = "eInteractionWithMedium";
      break;
    case eCollisionBetweenTracks:
      interactionType = "eCollisionBetweenTracks";
      break;
    default:
      interactionType = "eCollisionBetweenTracks";
      break;
  }
}

Referenced by Stepping().

GetEndTime()

G4double G4Scheduler::GetEndTime ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 338 of file G4Scheduler.hh.

{
  return fEndTime;
}

Referenced by G4DNAIRT::G4DNAIRT(), and G4DNAIRT::Initialize().

GetGlobalTime()

G4double G4Scheduler::GetGlobalTime ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 353 of file G4Scheduler.hh.

{
  return fGlobalTime;
}

Referenced by G4ITTrackHolder::_PushTrack(), G4DNAIRT::MakeReaction(), and G4DNAIRT::Sampling().

GetGun()

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 423 of file G4Scheduler.hh.

{
  return fpGun;
}

GetInteractivity()

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 413 of file G4Scheduler.hh.

{
  return fpTrackingInteractivity;
}

GetLimitingTimeStep()

G4double G4Scheduler::GetLimitingTimeStep ( ) const

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 751 of file G4Scheduler.cc.

{
  if (fpUserTimeSteps == nullptr) return fDefaultMinTimeStep;
  if (fabs(fGlobalTime - fUserUpperTimeLimit) < fTimeTolerance) return fDefinedMinTimeStep;
 
  auto it_fpUserTimeSteps_i = fpUserTimeSteps->upper_bound(fGlobalTime);
  auto it_fpUserTimeSteps_low = fpUserTimeSteps->lower_bound(fGlobalTime);
 
  if (it_fpUserTimeSteps_i == fpUserTimeSteps->end()) {
    it_fpUserTimeSteps_i--;
    fUserUpperTimeLimit = fStopTime;
  }
  else if (fabs(fGlobalTime - it_fpUserTimeSteps_low->first) < fTimeTolerance) {
    it_fpUserTimeSteps_i = it_fpUserTimeSteps_low;
    auto tmp_it = it_fpUserTimeSteps_low;
    ++tmp_it;
    if (tmp_it == fpUserTimeSteps->end()) {
      fUserUpperTimeLimit = fStopTime;
    }
    else {
      fUserUpperTimeLimit = tmp_it->first;
    }
  }
  else if (it_fpUserTimeSteps_i == it_fpUserTimeSteps_low) {
    fUserUpperTimeLimit = it_fpUserTimeSteps_i->first;
    if (it_fpUserTimeSteps_i != fpUserTimeSteps->begin()) it_fpUserTimeSteps_i--;
  }
  else {
    fUserUpperTimeLimit = it_fpUserTimeSteps_i->first;
    it_fpUserTimeSteps_i = it_fpUserTimeSteps_low;
  }
  return it_fpUserTimeSteps_i->second;
}

Referenced by Stepping().

GetMaxNbSteps()

G4int G4Scheduler::GetMaxNbSteps ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 328 of file G4Scheduler.hh.

{
  return fMaxSteps;
}

GetMaxTimeStep()

G4double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 182 of file G4Scheduler.hh.

{ return fMaxTimeStep; }

GetMaxZeroTimeAllowed()

G4int G4Scheduler::GetMaxZeroTimeAllowed ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 383 of file G4Scheduler.hh.

{
  return fMaxNZeroTimeStepsAllowed;
}

GetModelHandler()

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 292 of file G4Scheduler.hh.

{
  return fpModelHandler;
}

GetNbSteps()

G4int G4Scheduler::GetNbSteps ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 318 of file G4Scheduler.hh.

{
  return fNbSteps;
}

GetNextWatchedTime()

G4double G4Scheduler::GetNextWatchedTime

(

)

const

Definition at line 369 of file G4Scheduler.cc.

{
  auto up = fWatchedTimes.upper_bound(fGlobalTime);
  if (up == fWatchedTimes.end()) {
    return DBL_MAX;
  }
  return *up;
}

Referenced by SynchronizeTracks().

GetNTracks()

size_t G4Scheduler::GetNTracks ( )

virtual

Definition at line 875 of file G4Scheduler.cc.

{
  return fTrackContainer.GetNTracks();
}

Referenced by Stepping().

GetPreviousTimeStep()

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 398 of file G4Scheduler.hh.

{
  return fPreviousTimeStep;
}

GetScavengerMaterial()

G4VScavengerMaterial * G4Scheduler::GetScavengerMaterial ( ) const

inline

Definition at line 184 of file G4Scheduler.hh.

{ return fpUserScavenger.get(); }

Referenced by G4DNAScavengerProcess::BuildPhysicsTable(), G4DNAMakeReaction::G4DNAMakeReaction(), G4DNAEventScheduler::Initialize(), G4DNAGillespieDirectMethod::Initialize(), G4DNAEventScheduler::ParticleBasedCounter(), and G4DNAEventScheduler::Voxelizing().

GetStartTime()

G4double G4Scheduler::GetStartTime ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 333 of file G4Scheduler.hh.

{
  return fStartTime;
}

Referenced by G4DNAIRT::G4DNAIRT(), and G4DNAIRT::Initialize().

GetStatus()

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 403 of file G4Scheduler.hh.

{
  return fITStepStatus;
}

GetTimeStep()

G4double G4Scheduler::GetTimeStep ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 343 of file G4Scheduler.hh.

{
  return fTimeStep;
}

GetTimeTolerance()

G4double G4Scheduler::GetTimeTolerance ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 393 of file G4Scheduler.hh.

{
  return fTimeTolerance;
}

Referenced by G4ITTrackHolder::_PushTrack().

GetUserTimeStepAction()

G4UserTimeStepAction * G4Scheduler::GetUserTimeStepAction ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 363 of file G4Scheduler.hh.

{
  return fpUserTimeStepAction;
}

GetVerbose()

G4int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 373 of file G4Scheduler.hh.

{
  return fVerbose;
}

Initialize()

void G4Scheduler::Initialize ( )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 227 of file G4Scheduler.cc.

{
  delete fpStepProcessor;
  delete fpModelProcessor;
 
  fpModelProcessor = new G4ITModelProcessor();
  fpModelProcessor->SetModelHandler(fpModelHandler);
  fpModelProcessor->SetTrackingManager(fpTrackingManager);
  fpStepProcessor = new G4ITStepProcessor();
  fpStepProcessor->SetTrackingManager(fpTrackingManager);
  fpTrackingManager->SetInteractivity(fpTrackingInteractivity);
  if (fUsePreDefinedTimeSteps) {
    if (fpUserTimeSteps == nullptr)  // Extra checking, is it necessary ?
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "You are asking to use user defined steps but you did not give any.";
      G4Exception("G4Scheduler::FindUserPreDefinedTimeStep", "Scheduler004", FatalErrorInArgument,
                  exceptionDescription);
      return;  // makes coverity happy
    }
  }
 
  fInitialized = true;
}

Referenced by ForceReinitialization(), G4DNAChemistryManager::InitializeThread(), and Process().

Instance()

G4Scheduler * G4Scheduler::Instance ( )

static

Definition at line 91 of file G4Scheduler.cc.

{
  if (fgScheduler == nullptr) fgScheduler = new G4Scheduler();
  return fgScheduler;
}

Referenced by G4ITTrackHolder::_PushTrack(), G4VUserMoleculeCounter< TIndex >::AddMolecule(), G4DNAScavengerProcess::BuildPhysicsTable(), G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIndependentReactionTimeStepper::CalculateStep(), G4DNAIRT::G4DNAIRT(), G4DNAMakeReaction::G4DNAMakeReaction(), G4DNAEventScheduler::Initialize(), G4DNAGillespieDirectMethod::Initialize(), G4DNAIRT::Initialize(), G4DNAChemistryManager::InitializeMaster(), G4DNAChemistryManager::InitializeThread(), G4VScheduler::Instance(), G4DNAIRT::MakeReaction(), G4DNAEventScheduler::ParticleBasedCounter(), G4DNAScavengerProcess::PostStepDoIt(), G4DNAIndependentReactionTimeStepper::Prepare(), G4DNAIRTMoleculeEncounterStepper::Prepare(), G4VUserMoleculeReactionCounter< TIndex >::RecordReaction(), G4DNAScavengerMaterial::RemoveAMoleculeAtTime(), G4VUserMoleculeCounter< TIndex >::RemoveMolecule(), G4DNAChemistryManager::Run(), G4DNAIRT::Sampling(), G4DNAChemistryManager::SetGun(), and G4DNAEventScheduler::Voxelizing().

IsInitialized()

G4bool G4Scheduler::IsInitialized ( )

inline

Definition at line 287 of file G4Scheduler.hh.

{
  return fInitialized;
}

IsInteractionStep()

G4bool G4Scheduler::IsInteractionStep ( )

inline

Definition at line 189 of file G4Scheduler.hh.

                                     {
      return fInteractionStep;
    }

IsRunning()

G4bool G4Scheduler::IsRunning ( )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 107 of file G4Scheduler.hh.

{ return fRunning; }

Notify()

G4bool G4Scheduler::Notify ( G4ApplicationState requestedState )

overridevirtual

Implements G4VStateDependent.

Definition at line 98 of file G4Scheduler.cc.

{
  if (requestedState == G4State_Quit) {
    if (fVerbose >= 4) {
      G4cout << "G4Scheduler received G4State_Quit" << G4endl;
    }
    Clear();
  }
  return true;
}

operator=()

G4Scheduler & G4Scheduler::operator= ( const G4Scheduler & )

delete

PrintWhyDoYouStop()

void G4Scheduler::PrintWhyDoYouStop ( )

protected

Definition at line 417 of file G4Scheduler.cc.

{
#ifdef G4VERBOSE
  if (fWhyDoYouStop) {
    G4cout << "G4Scheduler has reached a stage: it might be"
              " a transition or the end"
           << G4endl;
 
    G4bool normalStop = false;
 
    if (fGlobalTime >= fStopTime) {
      G4cout << "== G4Scheduler: I stop because I reached the stop time : "
             << G4BestUnit(fStopTime, "Time") << " ==" << G4endl;
      normalStop = true;
    }
    if (!fTrackContainer.MainListsNOTEmpty())  // is empty
    {
      G4cout << "G4Scheduler: I stop because the current main list of tracks "
                "is empty"
             << G4endl;
      normalStop = true;
    }
    if (fMaxSteps == -1 ? false : fNbSteps >= fMaxSteps) {
      G4cout << "G4Scheduler: I stop because I reached the maximum allowed "
                "number of steps="
             << fMaxSteps << G4endl;
      normalStop = true;
    }
    if (fContinue && !normalStop) {
      G4cout << "G4Scheduler: It might be that I stop because "
                "I have been told so. You may check "
                "member fContinue and usage of the method G4Scheduler::Stop()."
             << G4endl;
    }
  }
#endif
}

Referenced by DoProcess().

Process()

void G4Scheduler::Process ( )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 273 of file G4Scheduler.cc.

{
#ifdef G4VERBOSE
  if (fVerbose != 0) {
    G4cout << "*** G4Scheduler starts processing " << G4endl;
    if (fVerbose > 2)
      G4cout << "___________________________________________"
                "___________________________"
             << G4endl;
  }
#endif
 
  if (!fInitialized) {
    Initialize();
  }
  fpModelProcessor->Initialize();
  fpStepProcessor->Initialize();
 
  if (fpGun != nullptr) fpGun->DefineTracks();
 
  if (fpTrackingInteractivity != nullptr) fpTrackingInteractivity->Initialize();
 
  // ___________________
  fRunning = true;
  Reset();
 
  if (fResetScavenger) {
    if (fpUserScavenger != nullptr) {
      fpUserScavenger->Reset();
    }
  }
 
  if (fpUserTimeStepAction != nullptr) {
    fpUserTimeStepAction->StartProcessing();
  }
 
#ifdef G4VERBOSE
  G4bool trackFound = false;
  G4IosFlagsSaver iosfs(G4cout);
  G4cout.precision(5);
#endif
 
  //===========================================================================
  // By default, before the G4Scheduler is launched, the tracks are pushed to
  // the delayed lists
  //===========================================================================
 
  if (fTrackContainer.DelayListsNOTEmpty()) {
    fStartTime = fTrackContainer.GetNextTime();
#ifdef G4VERBOSE
    trackFound = true;
    G4Timer localtimer;
    if (fVerbose > 1) {
      localtimer.Start();
    }
#endif
    SynchronizeTracks();
#ifdef G4VERBOSE
    if (fVerbose > 1) {
      localtimer.Stop();
      G4cout << "G4Scheduler: process time= " << localtimer << G4endl;
    }
#endif
  }
#ifdef G4VERBOSE
  if (fVerbose != 0) {
    if (trackFound) {
      G4cout << "*** G4Scheduler ends at time : " << G4BestUnit(fGlobalTime, "Time") << G4endl;
      G4cout << "___________________________________" << G4endl;
    }
    else {
      G4cout << "*** G4Scheduler did not start because no "
                "track was found to be processed"
             << G4endl;
      G4cout << "___________________________________" << G4endl;
    }
  }
#endif
 
  fRunning = false;
 
  if (fpUserTimeStepAction != nullptr) {
    fpUserTimeStepAction->EndProcessing();
  }
  // ___________________
  EndTracking();
  ClearList();
  Reset();
 
  if (fpTrackingInteractivity != nullptr) {
    fpTrackingInteractivity->Finalize();
  }
}

Referenced by G4DNAChemistryManager::Run().

RegisterModel()

void G4Scheduler::RegisterModel ( G4VITStepModel * model, G4double time )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 220 of file G4Scheduler.cc.

{
  fpModelHandler->RegisterModel(model, time);
}

Reset()

void G4Scheduler::Reset ( )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 254 of file G4Scheduler.cc.

{
  fStartTime = 0;
  fUserUpperTimeLimit = -1;
  fTimeStep = DBL_MAX;
  fTSTimeStep = DBL_MAX;
  fILTimeStep = DBL_MAX;
  fPreviousTimeStep = DBL_MAX;
  fGlobalTime = -1;
  fInteractionStep = true;
  fITStepStatus = eUndefined;
  fZeroTimeCount = 0;
 
  fNbSteps = 0;
  fContinue = true;
  fReactionSet->CleanAllReaction();
}

Referenced by Process().

ResetScavenger()

void G4Scheduler::ResetScavenger ( bool value )

inline

Definition at line 443 of file G4Scheduler.hh.

{
  fResetScavenger = value;
}

SetDefaultTimeStep()

void G4Scheduler::SetDefaultTimeStep ( G4double timeStep )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 348 of file G4Scheduler.hh.

{
  fDefaultMinTimeStep = timeStep;
}

SetEndTime()

void G4Scheduler::SetEndTime ( const G4double __endtime )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 297 of file G4Scheduler.hh.

{
  fEndTime = __endtime;
}

SetGun()

void G4Scheduler::SetGun ( G4ITGun * gun )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 418 of file G4Scheduler.hh.

{
  fpGun = gun;
}

Referenced by G4DNAChemistryManager::SetGun().

SetInteractionStep()

void G4Scheduler::SetInteractionStep ( G4bool InteractionStep )

inline

Definition at line 192 of file G4Scheduler.hh.

                                                          {
      fInteractionStep = InteractionStep;
    }

Referenced by G4DNAScavengerProcess::PostStepDoIt().

SetInteractivity()

void G4Scheduler::SetInteractivity ( G4ITTrackingInteractivity * interactivity )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 860 of file G4Scheduler.cc.

{
  fpTrackingInteractivity = interactivity;
  if (fpTrackingManager != nullptr) {
    fpTrackingManager->SetInteractivity(fpTrackingInteractivity);
  }
}

SetMaxNbSteps()

void G4Scheduler::SetMaxNbSteps ( G4int maxSteps )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 323 of file G4Scheduler.hh.

{
  fMaxSteps = maxSteps;
}

SetMaxTimeStep()

void G4Scheduler::SetMaxTimeStep ( G4double maxTimeStep )

inline

Definition at line 180 of file G4Scheduler.hh.

{ fMaxTimeStep = maxTimeStep; }

SetMaxZeroTimeAllowed()

void G4Scheduler::SetMaxZeroTimeAllowed ( G4int maxTimeStepAllowed )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 378 of file G4Scheduler.hh.

{
  fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
}

SetScavengerMaterial()

void G4Scheduler::SetScavengerMaterial ( std::unique_ptr< G4VScavengerMaterial > scavengerMaterial )

inline

Definition at line 185 of file G4Scheduler.hh.

    {
      fpUserScavenger = std::move(scavengerMaterial);
    }

SetTimeSteps()

void G4Scheduler::SetTimeSteps ( std::map< G4double, G4double > * steps )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 302 of file G4Scheduler.hh.

{
  fUsePreDefinedTimeSteps = true;
  fpUserTimeSteps = steps;
}

SetTimeTolerance()

void G4Scheduler::SetTimeTolerance ( G4double time )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 388 of file G4Scheduler.hh.

{
  fTimeTolerance = time;
}

SetUserAction()

void G4Scheduler::SetUserAction ( G4UserTimeStepAction * userITAction )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 358 of file G4Scheduler.hh.

{
  fpUserTimeStepAction = userITAction;
}

SetVerbose()

void G4Scheduler::SetVerbose ( G4int verbose )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 368 of file G4Scheduler.hh.

{
  fVerbose = verbose;
}

Stepping()

void G4Scheduler::Stepping ( )

protected

Definition at line 497 of file G4Scheduler.cc.

{
  fTimeStep = fMaxTimeStep;
 
  fTSTimeStep = DBL_MAX;
  fILTimeStep = DBL_MAX;
 
  //fInteractionStep = false;
  fReachedUserTimeLimit = false;
 
  fITStepStatus = eUndefined;
 
  // Start of step
#ifdef G4VERBOSE
  if (fVerbose > 2) {
#  ifdef USE_COLOR
    G4cout << LIGHT_RED;
#  endif
    G4cout << "*** Start Of Step N°" << fNbSteps + 1 << " species number : " << GetNTracks()
           << " ***" << G4endl;
    G4cout << "Current Global time : " << G4BestUnit(fGlobalTime, "Time") << G4endl;
#  ifdef USE_COLOR
    G4cout << RESET_COLOR;
#  endif
  }
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  MemStat mem_first, mem_second, mem_diff;
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_first = MemoryUsage();
#endif
 
  fDefinedMinTimeStep = GetLimitingTimeStep();
 
  if (fUsePreDefinedTimeSteps) {
#ifdef G4VERBOSE
    if (fVerbose > 2) {
#  ifdef USE_COLOR
      G4cout << LIGHT_RED;
#  endif
      G4cout << "*** At time : " << G4BestUnit(fGlobalTime, "Time")
             << " the chosen user time step is : " << G4BestUnit(fDefinedMinTimeStep, "Time")
             << " ***" << G4endl;
#  ifdef USE_COLOR
      G4cout << RESET_COLOR;
#  endif
    }
#endif
  }
 
  if (fpModelProcessor->GetComputeTimeStep())  // fComputeTimeStep)
  {
    fTSTimeStep = fpModelProcessor->CalculateMinTimeStep(fGlobalTime, fDefinedMinTimeStep);
    // => at least N (N = nb of tracks) loops
  }
  else if (fUseDefaultTimeSteps) {
    fTSTimeStep = fDefinedMinTimeStep;
  }
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second - mem_first;
  G4cout << "|| MEM || After computing TS, diff is : " << mem_diff << G4endl;
#endif
 
#ifdef G4VERBOSE
  if (fVerbose > 2) {
#  ifdef USE_COLOR
    G4cout << LIGHT_RED;
#  endif
    G4cout << "*** Time stepper returned : " << G4BestUnit(fTSTimeStep, "Time") << " ***" << G4endl;
#  ifdef USE_COLOR
    G4cout << RESET_COLOR;
#  endif
  }
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_first = MemoryUsage();
#endif
 
  // Call IL even if fTSTimeStep == 0
  // if fILTimeStep == 0 give the priority to DoIt processes
 
  fILTimeStep = fpStepProcessor->ComputeInteractionLength(fPreviousTimeStep);
  // => at least N loops
  // All process returns the physical step of interaction
  // The transportation process calculates the corresponding
  // time step
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second - mem_first;
  G4cout << "|| MEM || After IL, diff is : " << mem_diff << G4endl;
#endif
 
#ifdef G4VERBOSE
  if (fVerbose > 2) {
#  ifdef USE_COLOR
    G4cout << LIGHT_RED;
#  endif
    G4cout << "*** The minimum time returned by the processes is : "
           << G4BestUnit(fILTimeStep, "Time") << " ***" << G4endl;
#  ifdef USE_COLOR
    G4cout << RESET_COLOR;
#  endif
  }
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_first = MemoryUsage();
#endif
 
  if (fILTimeStep <= fTSTimeStep)
  // Give the priority to the IL
  {
    fInteractionStep = true;
    //fReactionSet->CleanAllReaction();
    fTimeStep = fILTimeStep;
    fITStepStatus = eInteractionWithMedium;
    fpStepProcessor->PrepareLeadingTracks();
  }
  else {
    fInteractionStep = false;
    fpStepProcessor->ResetLeadingTracks();
    fTimeStep = fTSTimeStep;
    fITStepStatus = eCollisionBetweenTracks;
  }
 
  if (fGlobalTime + fTimeStep > fStopTime)
  // This check is done at every time step
  {
    fTimeStep = fStopTime - fGlobalTime;
    fITStepStatus = eInteractionWithMedium;  // ie: transportation
    fInteractionStep = true;
    fReactionSet->CleanAllReaction();
    fpStepProcessor->ResetLeadingTracks();
  }
 
  if (fTimeStep == 0)  // < fTimeTolerance)
  {
    ++fZeroTimeCount;
    if (fZeroTimeCount >= fMaxNZeroTimeStepsAllowed) {
      G4ExceptionDescription exceptionDescription;
 
      exceptionDescription << "Too many zero time steps were detected. ";
      exceptionDescription << "The simulation is probably stuck. ";
      exceptionDescription << "The maximum number of zero time steps is currently : "
                           << fMaxNZeroTimeStepsAllowed;
      exceptionDescription << ".";
 
      G4Exception("G4Scheduler::Stepping", "SchedulerNullTimeSteps", FatalErrorInArgument,
                  exceptionDescription);
    }
  }
  else {
    fZeroTimeCount = 0;
  }
 
  fReachedUserTimeLimit = (fTimeStep <= fDefinedMinTimeStep)
                          || ((fTimeStep > fDefinedMinTimeStep)
                              && fabs(fTimeStep - fDefinedMinTimeStep) < fTimeTolerance);
 
  if (fpUserTimeStepAction != nullptr) fpUserTimeStepAction->UserPreTimeStepAction();
    // TODO: pre/post
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second - mem_first;
  G4cout << "|| MEM || After LeadingTracks and UserPreTimeStepAction: " << mem_diff << G4endl;
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_first = MemoryUsage();
#endif
 
  fGlobalTime += fTimeStep;
 
  // if fTSTimeStep > 0 => still need to call the transportation process
  // if fILTimeStep < fTSTimeStep => call only DoIt processes, no reactions
  // if fILTimeStep == fTSTimeStep => give the priority to the DoIt processes
  if (fTSTimeStep > 0 || fILTimeStep <= fTSTimeStep) {
    fpStepProcessor->DoIt(fTimeStep);
  }
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second - mem_first;
  G4cout << "|| MEM || After DoIT, diff is : " << mem_diff << G4endl;
#endif
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_first = MemoryUsage();
#endif
 
  fpModelProcessor->ComputeTrackReaction(fITStepStatus, fGlobalTime, fTimeStep, fPreviousTimeStep,
                                         fReachedUserTimeLimit, fTimeTolerance,
                                         fpUserTimeStepAction, fVerbose);
 
  ++fNbSteps;
 
  if (fpUserTimeStepAction != nullptr) {
    fpUserTimeStepAction->UserPostTimeStepAction();
  }
 
  fPreviousTimeStep = fTimeStep;
 
#if defined(DEBUG_MEM) && defined(DEBUG_MEM_DETAILED_STEPPING)
  mem_second = MemoryUsage();
  mem_diff = mem_second - mem_first;
  G4cout << "|| MEM || After computing reactions + UserPostTimeStepAction, "
            "diff is : "
         << mem_diff << G4endl;
#endif
 
  // End of step
#ifdef G4VERBOSE
  if (fVerbose >= 2) {
#  ifdef USE_COLOR
    G4cout << LIGHT_RED;
#  endif
 
    G4String interactionType;
    GetCollisionType(interactionType);
 
    std::stringstream finalOutput;
 
    finalOutput << "*** End of step N°" << fNbSteps
                << "\t T_i= " << G4BestUnit(fGlobalTime - fTimeStep, "Time")
                << "\t dt= " << G4BestUnit(fTimeStep, "Time")
                << "\t T_f= " << G4BestUnit(fGlobalTime, "Time") << "\t " << interactionType
                << G4endl;
 
    if (fVerbose > 2) {
      if (fReachedUserTimeLimit) {
        finalOutput << "It has also reached the user time limit" << G4endl;
      }
      finalOutput << "_______________________________________________________________"
                     "_______"
                  << G4endl;
    }
 
    G4cout << finalOutput.str();
 
#  ifdef USE_COLOR
    G4cout << RESET_COLOR;
#  endif
  }
#endif
}

Referenced by DoProcess().

Stop()

void G4Scheduler::Stop ( )

inline

Definition at line 408 of file G4Scheduler.hh.

{
  fContinue = false;
}

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep().

SynchronizeTracks()

void G4Scheduler::SynchronizeTracks ( )

protected

Definition at line 380 of file G4Scheduler.cc.

{
  fTmpGlobalTime = fGlobalTime;
  fGlobalTime = fTrackContainer.GetNextTime();
  G4double tmpGlobalTime = fGlobalTime;
  G4double nextWatchedTime = -1;
  G4bool carryOn = true;
  while (fTrackContainer.MergeNextTimeToMainList(tmpGlobalTime) && carryOn) {
    if (tmpGlobalTime != fGlobalTime) {
      fGlobalTime = tmpGlobalTime;
    };
    fStopTime = min(fTrackContainer.GetNextTime(), fEndTime);
    while ((nextWatchedTime = GetNextWatchedTime()) < fTrackContainer.GetNextTime()
           && (carryOn = CanICarryOn()))
    {
      fStopTime = min(nextWatchedTime, fEndTime);
      DoProcess();
    }
 
    carryOn = CanICarryOn();
 
    if (nextWatchedTime > fEndTime && carryOn) {
      fStopTime = min(fTrackContainer.GetNextTime(), fEndTime);
      DoProcess();
    }
  }
}

Referenced by Process().

UseDefaultTimeSteps()

void G4Scheduler::UseDefaultTimeSteps ( G4bool flag )

inline

Definition at line 433 of file G4Scheduler.hh.

{
  fUseDefaultTimeSteps = flag;
}

WhyDoYouStop()

void G4Scheduler::WhyDoYouStop ( )

inline

Definition at line 428 of file G4Scheduler.hh.

{
  fWhyDoYouStop = true;
}

---

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

• G4Scheduler.hh
• G4Scheduler.cc