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)
void	ResetScavenger (bool)
Public Member Functions inherited from G4VScheduler
Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)
virtual	~G4VStateDependent ()
G4bool	operator== (const G4VStateDependent &right) const
G4bool	operator!= (const G4VStateDependent &right) const

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 88 of file G4Scheduler.hh.

Constructor & Destructor Documentation

~G4Scheduler()

G4Scheduler::~G4Scheduler ( )

overrideprotected

Definition at line 203 of file G4Scheduler.cc.

{
 
  if(fpMessenger != nullptr) // is used as a flag to know whether the manager was cleared
  {
    Clear();
  }
 
  fgScheduler = nullptr;
 
//  if (fVerbose >= 1)
//  {
//    G4cout << "G4Scheduler is being deleted. Bye :) !" << G4endl;
//  }
}

G4Scheduler()

G4Scheduler::G4Scheduler ( const G4Scheduler & )

delete

Member Function Documentation

AddTimeStep()

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

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 319 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 180 of file G4Scheduler.hh.

  {
    fWatchedTimes.insert(time);
  }

AreDefaultTimeStepsUsed()

G4bool G4Scheduler::AreDefaultTimeStepsUsed ( )

inline

Definition at line 452 of file G4Scheduler.hh.

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

Referenced by G4SchedulerMessenger::GetCurrentValue().

CanICarryOn()

G4bool G4Scheduler::CanICarryOn ( )

protected

Definition at line 567 of file G4Scheduler.cc.

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

Referenced by SynchronizeTracks().

Clear()

void G4Scheduler::Clear

(

)

Definition at line 219 of file G4Scheduler.cc.

{
//  if (fVerbose) G4cout << "*** G4Scheduler is being cleared ***" << G4endl;
 
  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;
  }
 
   //* DEBUG
   //* assert(G4StateManager::GetStateManager()->
   //* DeregisterDependent(this) == true);
 
}

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

ClearList()

void G4Scheduler::ClearList

(

)

Definition at line 267 of file G4Scheduler.cc.

{
//  if (fNbTracks == 0) return;
 
  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 123 of file G4Scheduler.cc.

{
  
  
    delete fgScheduler;
  
}

DoProcess()

void G4Scheduler::DoProcess ( )

protected

Definition at line 619 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)
  {
//    G4cout << "Mainlist size : " << fTrackContainer.GetMainList()->size()
//        << G4endl;
 
    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 1076 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);
  }
 
  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 1021 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);
 
  // DEBUG
  // G4cout << "fGlobalTime : " << G4BestUnit(fGlobalTime,"Time") << G4endl;
  // G4cout << "fpUserTimeSteps_i : "
  // <<"<"<<G4BestUnit(fpUserTimeSteps_i->first,"Time")<<", "
  // << G4BestUnit(fpUserTimeSteps_i->second,"Time")<<">"
  // << "\t fpUserTimeSteps_low : "
  // <<"<"<<G4BestUnit(fpUserTimeSteps_low->first,"Time")<<", "
  // << G4BestUnit(fpUserTimeSteps_low->second,"Time")<<">"
  // << G4endl;
 
  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 1130 of file G4Scheduler.cc.

{
  fInitialized = false;
  Initialize();
}

GetCollisionType()

void G4Scheduler::GetCollisionType

(

G4String &

interactionType

)

Definition at line 1142 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 350 of file G4Scheduler.hh.

{
  return fEndTime;
}

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

GetGlobalTime()

G4double G4Scheduler::GetGlobalTime ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 365 of file G4Scheduler.hh.

{
  return fGlobalTime;
}

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

GetGun()

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 437 of file G4Scheduler.hh.

{
  return fpGun;
}

GetInteractivity()

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 427 of file G4Scheduler.hh.

{
  return fpTrackingInteractivity;
}

GetLimitingTimeStep()

G4double G4Scheduler::GetLimitingTimeStep ( ) const

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 955 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);
 
  // DEBUG
  // G4cout << "fGlobalTime : " << G4BestUnit(fGlobalTime,"Time")
  //            << G4endl;
  // G4cout << "fpUserTimeSteps_i : "
  //        <<"<"<<G4BestUnit(it_fpUserTimeSteps->first,"Time")
  //        <<", "<< G4BestUnit(it_fpUserTimeSteps->second,"Time")<<">"
  //        << "\t fpUserTimeSteps_low : "
  //        <<"<"<<G4BestUnit(fpUserTimeSteps_low->first,"Time")<<", "*
  //        << G4BestUnit(fpUserTimeSteps_low->second,"Time")<<">"
  //        << G4endl;
 
  if (it_fpUserTimeSteps_i == fpUserTimeSteps->end())
  {
    it_fpUserTimeSteps_i--;
    fUserUpperTimeLimit = fStopTime;
  }
  else if (fabs(fGlobalTime - it_fpUserTimeSteps_low->first) < fTimeTolerance)
  {
    // Case : fGlobalTime = X picosecond
    // and fpUserTimeSteps_low->first = X picosecond
    // but the precision is not good enough
    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)
  {
    // "Normal" cases
    fUserUpperTimeLimit = it_fpUserTimeSteps_i->first;
//    it_fpUserTimeSteps_i++;
//    G4cout << "Global time = " << fGlobalTime << G4endl;
//    G4cout << "Is begin = "
//    << (it_fpUserTimeSteps_i == fpUserTimeSteps->begin())<< G4endl;
 
    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 340 of file G4Scheduler.hh.

{
  return fMaxSteps;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

GetMaxTimeStep()

G4double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 192 of file G4Scheduler.hh.

  {
    return fMaxTimeStep;
  }

GetMaxZeroTimeAllowed()

G4int G4Scheduler::GetMaxZeroTimeAllowed ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 397 of file G4Scheduler.hh.

{
  return fMaxNZeroTimeStepsAllowed;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

GetModelHandler()

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 302 of file G4Scheduler.hh.

{
  return fpModelHandler;
}

GetNbSteps()

G4int G4Scheduler::GetNbSteps ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 330 of file G4Scheduler.hh.

{
  return fNbSteps;
}

GetNextWatchedTime()

G4double G4Scheduler::GetNextWatchedTime

(

)

const

Definition at line 502 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 1136 of file G4Scheduler.cc.

{
  return fTrackContainer.GetNTracks();
}

GetPreviousTimeStep()

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 412 of file G4Scheduler.hh.

{
  return fPreviousTimeStep;
}

GetScavengerMaterial()

G4VScavengerMaterial * G4Scheduler::GetScavengerMaterial ( ) const

inline

Definition at line 197 of file G4Scheduler.hh.

  {
      return fpUserScavenger.get();
  }

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

GetStartTime()

G4double G4Scheduler::GetStartTime ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 345 of file G4Scheduler.hh.

{
  return fStartTime;
}

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

GetStatus()

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 417 of file G4Scheduler.hh.

{
  return fITStepStatus;
}

GetTimeStep()

G4double G4Scheduler::GetTimeStep ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 355 of file G4Scheduler.hh.

{
  return fTimeStep;
}

GetTimeTolerance()

G4double G4Scheduler::GetTimeTolerance ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 407 of file G4Scheduler.hh.

{
  return fTimeTolerance;
}

Referenced by G4ITTrackHolder::_PushTrack(), and G4SchedulerMessenger::GetCurrentValue().

GetUserTimeStepAction()

G4UserTimeStepAction * G4Scheduler::GetUserTimeStepAction ( ) const

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 376 of file G4Scheduler.hh.

{
  return fpUserTimeStepAction;
}

GetVerbose()

G4int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 386 of file G4Scheduler.hh.

{
  return fVerbose;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

Initialize()

void G4Scheduler::Initialize ( )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 284 of file G4Scheduler.cc.

{
  
  
    delete fpStepProcessor;
  
  
  
    delete fpModelProcessor;
  
  // if(fpMasterModelProcessor)
  // {
  //     delete fpMasterModelProcessor;
  // }
 
  //______________________________________________________________
 
  fpModelProcessor = new G4ITModelProcessor();
  fpModelProcessor->SetModelHandler(fpModelHandler);
  fpModelProcessor->SetTrackingManager(fpTrackingManager);
 
  // fpMasterModelProcessor = new G4ITModelProcessor();
  // fpMasterModelProcessor->SetModelHandler(fpModelHandler);
  // fpModelProcessor      = fpMasterModelProcessor;
 
  //______________________________________________________________
 
  fpStepProcessor = new G4ITStepProcessor();
  fpStepProcessor->SetTrackingManager(fpTrackingManager);
 
  fpTrackingManager->SetInteractivity(fpTrackingInteractivity);
 
  // fpMasterStepProcessor = new G4ITStepProcessor();
  // fpMasterStepProcessor->SetTrackingManager(fpTrackingManager);
  // fpStepProcessor = fpMasterStepProcessor ;
  //______________________________________________________________
 
  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
    }
  }
 
//  if (fComputeTimeStep)
//  {
//    if (fpModelProcessor == 0)
//    {
//      G4ExceptionDescription exceptionDescription;
//      exceptionDescription
//          << "There is no G4ITModelProcessor to handle IT reaction. ";
//      exceptionDescription
//          << "You probably did not initialize the G4Scheduler. ";
//      exceptionDescription
//          << "Just do G4Scheduler::Instance()->Initialize(); ";
//      exceptionDescription << " but only after initializing the run manager.";
//      G4Exception("G4Scheduler::CalculateMinStep", "ITScheduler005",
//                  FatalErrorInArgument, exceptionDescription);
//      return; // makes coverity happy
//    }
//  }
 
  fInitialized = true;
}

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

Instance()

G4Scheduler * G4Scheduler::Instance ( )

static

Definition at line 101 of file G4Scheduler.cc.

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

Referenced by G4ITTrackHolder::_PushTrack(), G4MoleculeCounter::AddAMoleculeAtTime(), G4DNAScavengerProcess::BuildPhysicsTable(), G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIndependentReactionTimeStepper::CalculateStep(), G4DNAIRT::G4DNAIRT(), G4DNAEventScheduler::Initialize(), G4DNAGillespieDirectMethod::Initialize(), G4DNAIRT::Initialize(), G4DNAChemistryManager::InitializeMaster(), G4DNAChemistryManager::InitializeThread(), G4VScheduler::Instance(), G4DNAIRT::MakeReaction(), G4DNAIRTMoleculeEncounterStepper::Prepare(), G4DNAScavengerMaterial::RemoveAMoleculeAtTime(), G4MoleculeCounter::RemoveAMoleculeAtTime(), G4DNAChemistryManager::Run(), G4DNAIRT::Sampling(), G4DNAChemistryManager::SetGun(), and G4DNAEventScheduler::Voxelizing().

IsInitialized()

G4bool G4Scheduler::IsInitialized ( )

inline

Definition at line 297 of file G4Scheduler.hh.

{
  return fInitialized;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

IsRunning()

G4bool G4Scheduler::IsRunning ( )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 111 of file G4Scheduler.hh.

{return fRunning;}

Notify()

G4bool G4Scheduler::Notify ( G4ApplicationState requestedState )

overridevirtual

Implements G4VStateDependent.

Definition at line 108 of file G4Scheduler.cc.

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

operator=()

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

delete

PrintWhyDoYouStop()

void G4Scheduler::PrintWhyDoYouStop ( )

protected

Definition at line 575 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 379 of file G4Scheduler.cc.

{
 
#ifdef G4VERBOSE
  if(fVerbose != 0)
  {
    G4cout << "*** G4Scheduler starts processing " << G4endl;
    if(fVerbose > 2)
    G4cout << "___________________________________________"
    "___________________________" << G4endl;
  }
#endif
 
  if (!fInitialized) Initialize();
 
  // fpTrackingManager->Initialize();
  fpModelProcessor->Initialize();
  fpStepProcessor->Initialize();
 
  // TODO
  // fpMasterModelProcessor->Initialize();
  // fpMasterStepProcessor->Initialize();
 
  if (fpGun != nullptr) fpGun->DefineTracks();
 
  if (fpTrackingInteractivity != nullptr) fpTrackingInteractivity->Initialize();
 
  // ___________________
  fRunning = true;
  Reset();
 
    //hoang 7/12/2020
 
    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
  }
 
//  //---------------------------------
//  // TODO: This could be removed ?
//  if(fTrackContainer.MainListsNOTEmpty()
//      && (fMaxSteps == -1 ? true : fNbSteps < fMaxSteps)
//      && fGlobalTime < fEndTime
//      && fContinue == true)
//{
//#ifdef G4VERBOSE
//    trackFound = true;
//#endif
//    DoProcess();
//}
//  //---------------------------------
 
#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(), and G4SchedulerMessenger::SetNewValue().

RegisterModel()

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

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 277 of file G4Scheduler.cc.

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

Reset()

void G4Scheduler::Reset ( )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 359 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;
  // fReactingTracks.clear();
  fReactionSet->CleanAllReaction();
}

Referenced by Process().

ResetScavenger()

void G4Scheduler::ResetScavenger ( bool value )

inline

Definition at line 457 of file G4Scheduler.hh.

{
    fResetScavenger = value;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetDefaultTimeStep()

void G4Scheduler::SetDefaultTimeStep ( G4double timeStep )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 360 of file G4Scheduler.hh.

{
  fDefaultMinTimeStep = timeStep;
}

SetEndTime()

void G4Scheduler::SetEndTime ( const G4double __endtime )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 307 of file G4Scheduler.hh.

{
  fEndTime = __endtime;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetGun()

void G4Scheduler::SetGun ( G4ITGun * gun )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 432 of file G4Scheduler.hh.

{
  fpGun = gun;
}

Referenced by G4DNAChemistryManager::SetGun().

SetInteractivity()

void G4Scheduler::SetInteractivity ( G4ITTrackingInteractivity * interactivity )

overridevirtual

Reimplemented from G4VScheduler.

Definition at line 1118 of file G4Scheduler.cc.

{
  fpTrackingInteractivity = interactivity;
  if(fpTrackingManager != nullptr)
  {
    fpTrackingManager->SetInteractivity(fpTrackingInteractivity);
  }
 
  //G4MIWorkspace::GetWorldWorkspace()->SetTrackingInteractivity(interactivity);
}

SetMaxNbSteps()

void G4Scheduler::SetMaxNbSteps ( G4int maxSteps )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 335 of file G4Scheduler.hh.

{
  fMaxSteps = maxSteps;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetMaxTimeStep()

void G4Scheduler::SetMaxTimeStep ( G4double maxTimeStep )

inline

Definition at line 187 of file G4Scheduler.hh.

  {
    fMaxTimeStep = maxTimeStep;
  }

SetMaxZeroTimeAllowed()

void G4Scheduler::SetMaxZeroTimeAllowed ( G4int maxTimeStepAllowed )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 392 of file G4Scheduler.hh.

{
  fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetScavengerMaterial()

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

inline

Definition at line 201 of file G4Scheduler.hh.

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

SetTimeSteps()

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

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 313 of file G4Scheduler.hh.

{
  fUsePreDefinedTimeSteps = true;
  fpUserTimeSteps = steps;
}

SetTimeTolerance()

void G4Scheduler::SetTimeTolerance ( G4double time )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 402 of file G4Scheduler.hh.

{
  fTimeTolerance = time;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetUserAction()

void G4Scheduler::SetUserAction ( G4UserTimeStepAction * userITAction )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 371 of file G4Scheduler.hh.

{
  fpUserTimeStepAction = userITAction;
}

SetVerbose()

void G4Scheduler::SetVerbose ( G4int verbose )

inlineoverridevirtual

Reimplemented from G4VScheduler.

Definition at line 381 of file G4Scheduler.hh.

{
  fVerbose = verbose;
}

Referenced by G4SchedulerMessenger::SetNewValue().

Stepping()

void G4Scheduler::Stepping ( )

protected

Definition at line 666 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 << " ***" << 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)
  {
    //        G4cout << "Will call DoIT" << G4endl;
    fpStepProcessor->DoIt(fTimeStep);
    //  fTrackContainer.MergeSecondariesWithMainList();
    //  fTrackContainer.KillTracks(); // remove ?
  }
  // else
  // {
  //   G4cout << "fTSTimeStep : " << fTSTimeStep << G4endl;
  //   G4cout << "fILTimeStep : " << fILTimeStep << G4endl;
  // }
 
#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 422 of file G4Scheduler.hh.

{
  fContinue = false;
}

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep().

SynchronizeTracks()

void G4Scheduler::SynchronizeTracks ( )

protected

Definition at line 511 of file G4Scheduler.cc.

{
//  if(fTrackContainer.WaitingListsNOTEmpty())
//   {
//    G4ExceptionDescription exceptionDescription;
//    exceptionDescription
//        << "There is a waiting track list (fpWaitingList != 0).";
//    exceptionDescription
//        << " When G4Scheduler::SynchronizeTracks() is called, ";
//    exceptionDescription
//        << "no more tracks should remain in the fpWaitingList.";
//    G4Exception("G4Scheduler::SynchronizeTracks", "ITScheduler002",
//                FatalErrorInArgument, exceptionDescription);
//  }
 
  // Backup main list and time feature
  // Reminder : the main list here, should
  // have the biggest global time
  //  fTrackContainer.MoveMainToWaitingList();
  // TODO: not yet supported
 
  fTmpGlobalTime = fGlobalTime;
  //fTmpEndTime = fEndTime;
 
  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 447 of file G4Scheduler.hh.

{
  fUseDefaultTimeSteps = flag;
}

Referenced by G4SchedulerMessenger::SetNewValue().

WhyDoYouStop()

void G4Scheduler::WhyDoYouStop ( )

inline

Definition at line 442 of file G4Scheduler.hh.

{
  fWhyDoYouStop = true;
}

Referenced by G4SchedulerMessenger::SetNewValue().

---

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

• G4Scheduler.hh
• G4Scheduler.cc