#include <G4Scheduler.hh>

Inheritance diagram for G4Scheduler:

Public Member Functions
void	AddTimeStep (G4double, G4double)

void	AddWatchedTime (G4double time)

G4bool	AreDefaultTimeStepsUsed ()

void	Clear ()

void	ClearList ()

void	EndTracking ()

void	ForceReinitialization ()

void	GetCollisionType (G4String &interactionType)

G4double	GetEndTime () const

G4double	GetGlobalTime () const

G4ITGun *	GetGun ()

G4ITTrackingInteractivity *	GetInteractivity ()

G4double	GetLimitingTimeStep () const

G4int	GetMaxNbSteps () const

G4double	GetMaxTimeStep () const

G4int	GetMaxZeroTimeAllowed () const

G4ITModelHandler *	GetModelHandler ()

G4int	GetNbSteps () const

G4double	GetNextWatchedTime () const

virtual size_t	GetNTracks ()

G4double	GetPreviousTimeStep () const

G4VScavengerMaterial *	GetScavengerMaterial () const

G4double	GetStartTime () const

G4ITStepStatus	GetStatus () const

virtual G4double	GetTimeStep () const

G4double	GetTimeTolerance () const

G4UserTimeStepAction *	GetUserTimeStepAction () const

G4int	GetVerbose () const

void	Initialize ()

G4bool	IsInitialized ()

G4bool	IsRunning ()

virtual G4bool	Notify (G4ApplicationState requestedState)

G4bool	operator!= (const G4VStateDependent &right) const

G4bool	operator== (const G4VStateDependent &right) const

void	Process ()

virtual void	RegisterModel (G4VITStepModel *, G4double)

void	Reset ()

void	ResetScavenger (bool)

void	SetDefaultTimeStep (G4double)

void	SetEndTime (const G4double)

void	SetGun (G4ITGun *)

void	SetInteractivity (G4ITTrackingInteractivity *)

void	SetMaxNbSteps (G4int)

void	SetMaxTimeStep (G4double maxTimeStep)

void	SetMaxZeroTimeAllowed (G4int)

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

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

void	SetTimeTolerance (G4double)

void	SetUserAction (G4UserTimeStepAction *)

void	SetVerbose (G4int)

void	Stop ()

void	UseDefaultTimeSteps (G4bool)

void	WhyDoYouStop ()

Static Public Member Functions
static void	DeleteInstance ()

static G4Scheduler *	Instance ()

Protected Member Functions
G4bool	CanICarryOn ()

void	DoProcess ()

void	FindUserPreDefinedTimeStep ()

void	PrintWhyDoYouStop ()

void	Stepping ()

void	SynchronizeTracks ()

virtual	~G4Scheduler ()

Private Member Functions
void	Create ()

	G4Scheduler ()

	G4Scheduler (const G4Scheduler &)

G4Scheduler &	operator= (const G4Scheduler &)

Private Attributes
G4bool	fContinue

G4double	fDefaultMinTimeStep

G4double	fDefinedMinTimeStep

G4double	fEndTime

G4double	fGlobalTime

G4double	fILTimeStep

G4bool	fInitialized

G4bool	fInteractionStep

G4ITStepStatus	fITStepStatus

G4int	fMaxNZeroTimeStepsAllowed

G4int	fMaxSteps

G4double	fMaxTimeStep

G4int	fNbSteps

G4ITGun *	fpGun

G4SchedulerMessenger *	fpMessenger

G4ITModelHandler *	fpModelHandler

G4ITModelProcessor *	fpModelProcessor

G4double	fPreviousTimeStep

G4ITStepProcessor *	fpStepProcessor

G4ITTrackingInteractivity *	fpTrackingInteractivity

G4ITTrackingManager *	fpTrackingManager

std::unique_ptr< G4VScavengerMaterial >	fpUserScavenger

G4UserTimeStepAction *	fpUserTimeStepAction

std::map< G4double, G4double > *	fpUserTimeSteps

G4bool	fReachedUserTimeLimit

G4ITReactionSet *	fReactionSet

bool	fResetScavenger

G4bool	fRunning

G4double	fStartTime

G4double	fStopTime

G4double	fTimeStep

G4double	fTimeTolerance

G4double	fTmpGlobalTime

G4ITTrackHolder &	fTrackContainer

G4double	fTSTimeStep

G4bool	fUseDefaultTimeSteps

G4bool	fUsePreDefinedTimeSteps

G4double	fUserUpperTimeLimit

G4int	fVerbose

std::set< G4double >	fWatchedTimes

G4bool	fWhyDoYouStop

G4int	fZeroTimeCount

Static Private Attributes
static G4ThreadLocal G4Scheduler *	fgScheduler

static G4ThreadLocal G4VScheduler *	fpInstance

Detailed Description

G4Scheduler synchronizes (in time) track stepping

Definition at line 88 of file G4Scheduler.hh.

Constructor & Destructor Documentation

◆ ~G4Scheduler()

G4Scheduler::~G4Scheduler ( )

protectedvirtual

Definition at line 203 of file G4Scheduler.cc.

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

References Clear(), fgScheduler, and fpMessenger.

◆ G4Scheduler() [1/2]

G4Scheduler::G4Scheduler ( )

private

Definition at line 132 of file G4Scheduler.cc.

                         :
    G4VScheduler(), G4VStateDependent(),
    fTrackContainer((G4ITTrackHolder&) *G4ITTrackHolder::Instance())
{
  Create();
}

References Create().

Referenced by Instance().

◆ G4Scheduler() [2/2]

G4Scheduler::G4Scheduler ( const G4Scheduler & )

private

Definition at line 1135 of file G4Scheduler.cc.

                                           :
    G4VScheduler(), G4VStateDependent(),
    fTrackContainer((G4ITTrackHolder&) *G4ITTrackHolder::Instance())
 
{
  Create();
}

References Create().

Member Function Documentation

◆ AddTimeStep()

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

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 318 of file G4Scheduler.hh.

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

References fpUserTimeSteps, and fUsePreDefinedTimeSteps.

◆ AddWatchedTime()

void G4Scheduler::AddWatchedTime ( G4double time )

inline

Definition at line 177 of file G4Scheduler.hh.

  {
    fWatchedTimes.insert(time);
  }

References fWatchedTimes.

◆ AreDefaultTimeStepsUsed()

G4bool G4Scheduler::AreDefaultTimeStepsUsed ( )

inline

Definition at line 451 of file G4Scheduler.hh.

{
  return (fUseDefaultTimeSteps == false && fUsePreDefinedTimeSteps == false);
}

References fUseDefaultTimeSteps, and fUsePreDefinedTimeSteps.

Referenced by G4SchedulerMessenger::GetCurrentValue().

◆ CanICarryOn()

G4bool G4Scheduler::CanICarryOn ( )

protected

Definition at line 564 of file G4Scheduler.cc.

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

References fContinue, fEndTime, fGlobalTime, fMaxSteps, and fNbSteps.

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)
  {
    delete fpMessenger;
    fpMessenger = 0;
  }
  if(fpStepProcessor)
  {
    delete fpStepProcessor;
    fpStepProcessor = 0;
  }
  if(fpModelProcessor)
  {
    delete fpModelProcessor;
    fpModelProcessor = 0;
  }
 
  G4ITTypeManager::Instance()->ReleaseRessource();
  ClearList();
  if(fpTrackingManager)
  {
    delete fpTrackingManager;
    fpTrackingManager = 0;
  }
 
  if(fReactionSet)
  {
    delete fReactionSet;
    fReactionSet = 0;
  }
 
  if(fpModelHandler)
  {
    delete fpModelHandler;
    fpModelHandler = 0;
  }
 
   //* DEBUG
   //* assert(G4StateManager::GetStateManager()->
   //* DeregisterDependent(this) == true);
 
}

References ClearList(), fpMessenger, fpModelHandler, fpModelProcessor, fpStepProcessor, fpTrackingManager, fReactionSet, G4ITTypeManager::Instance(), and G4ITTypeManager::ReleaseRessource().

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();
}

References G4ITTrackHolder::Clear(), G4AllITFinder::DeleteInstance(), and fTrackContainer.

Referenced by Clear(), and Process().

◆ Create()

void G4Scheduler::Create ( )

private

Definition at line 139 of file G4Scheduler.cc.

{
  fUseDefaultTimeSteps = true;
  fUserUpperTimeLimit = -1;
  fpGun = 0;
  fContinue = true;
//  fpMainList = 0;
//  fpWaitingList = 0;
  fpTrackingInteractivity = 0;
 
  fITStepStatus = eUndefined;
 
  fpUserTimeSteps = 0;
 
  fTimeStep = DBL_MAX;
  fTSTimeStep = DBL_MAX;
  fILTimeStep = DBL_MAX;
  fPreviousTimeStep = DBL_MAX;
 
  fZeroTimeCount = 0;
  fMaxNZeroTimeStepsAllowed = 10000;
 
  fStartTime = 0;
  fTimeTolerance = 1 * picosecond;
  fEndTime = 1 * microsecond;
  fGlobalTime = -1;
  fInteractionStep = true;
  fUsePreDefinedTimeSteps = false;
 
  fDefaultMinTimeStep = 1 * picosecond;
 
  fpStepProcessor = 0;
  fpModelProcessor = 0;
 
  fNbSteps = 0;
  fMaxSteps = -1;
 
  fRunning = false;
  fInitialized = false;
 
  fpUserTimeStepAction = 0;
  fpModelHandler = new G4ITModelHandler();
  fpTrackingManager = new G4ITTrackingManager();
 
  fVerbose = 0;
  fWhyDoYouStop = false;
  fDefinedMinTimeStep = -1.;
  fReachedUserTimeLimit = false;
  fStopTime = -1.;
  fTmpGlobalTime = -1.;
 
  fpMessenger = new G4SchedulerMessenger(this);
 
  fReactionSet = G4ITReactionSet::Instance();
  fMaxTimeStep = DBL_MAX;
 
  //hoang add
    fResetScavenger = true;//true by default
 
  G4ITTypeManager::Instance()->ReserveRessource();
}

References DBL_MAX, eUndefined, fContinue, fDefaultMinTimeStep, fDefinedMinTimeStep, fEndTime, fGlobalTime, fILTimeStep, fInitialized, fInteractionStep, fITStepStatus, fMaxNZeroTimeStepsAllowed, fMaxSteps, fMaxTimeStep, fNbSteps, fpGun, fpMessenger, fpModelHandler, fpModelProcessor, fPreviousTimeStep, fpStepProcessor, fpTrackingInteractivity, fpTrackingManager, fpUserTimeStepAction, fpUserTimeSteps, fReachedUserTimeLimit, fReactionSet, fResetScavenger, fRunning, fStartTime, fStopTime, fTimeStep, fTimeTolerance, fTmpGlobalTime, fTSTimeStep, fUseDefaultTimeSteps, fUsePreDefinedTimeSteps, fUserUpperTimeLimit, fVerbose, fWhyDoYouStop, fZeroTimeCount, G4ITReactionSet::Instance(), G4ITTypeManager::Instance(), microsecond, picosecond, and G4ITTypeManager::ReserveRessource().

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

◆ DeleteInstance()

void G4Scheduler::DeleteInstance ( )

static

DeleteInstance should be used instead of the destructor

Definition at line 123 of file G4Scheduler.cc.

{
  if(fgScheduler)
  {
    delete fgScheduler;
  }
}

References fgScheduler.

◆ DoProcess()

void G4Scheduler::DoProcess ( )

protected

Definition at line 616 of file G4Scheduler.cc.

{
  if(fpUserTimeStepAction) 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 == true)
  {
//    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
}

References fContinue, fGlobalTime, fMaxSteps, fNbSteps, fpUserTimeStepAction, fStopTime, fTrackContainer, fVerbose, G4BestUnit, G4cout, G4endl, G4ITTrackHolder::MainListsNOTEmpty(), G4MemStat::MemoryUsage(), G4UserTimeStepAction::NewStage(), PrintWhyDoYouStop(), and Stepping().

Referenced by SynchronizeTracks().

◆ EndTracking()

void G4Scheduler::EndTracking ( )

Definition at line 1074 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);
    }
  }
}

References G4ManyFastLists< OBJECT >::begin(), G4ManyFastLists< OBJECT >::end(), G4ITTrackingManager::EndTrackingWOKill(), FatalErrorInArgument, fpTrackingManager, fRunning, fTrackContainer, G4endl, G4Exception(), G4ITTrackHolder::GetMainList(), G4ITTrackHolder::GetSecondariesList(), G4ITTrackHolder::MainListsNOTEmpty(), G4ITTrackHolder::MergeSecondariesWithMainList(), and G4ITTrackHolder::SecondaryListsNOTEmpty().

Referenced by Process().

◆ FindUserPreDefinedTimeStep()

void G4Scheduler::FindUserPreDefinedTimeStep ( )

protected

Definition at line 1019 of file G4Scheduler.cc.

{
 
  if(fpUserTimeSteps == 0)
  {
    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
  }
  map<G4double, G4double>::iterator fpUserTimeSteps_i =
      fpUserTimeSteps->upper_bound(fGlobalTime);
  map<G4double, G4double>::iterator 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;
}

References FatalErrorInArgument, fDefinedMinTimeStep, fGlobalTime, fpUserTimeSteps, fTimeTolerance, and G4Exception().

◆ ForceReinitialization()

void G4Scheduler::ForceReinitialization ( )

Definition at line 1128 of file G4Scheduler.cc.

{
  fInitialized = false;
  Initialize();
}

References fInitialized, and Initialize().

◆ GetCollisionType()

void G4Scheduler::GetCollisionType ( G4String & interactionType )

Definition at line 1159 of file G4Scheduler.cc.

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

References eCollisionBetweenTracks, eInteractionWithMedium, and fITStepStatus.

Referenced by Stepping().

◆ GetEndTime()

G4double G4Scheduler::GetEndTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 349 of file G4Scheduler.hh.

{
  return fEndTime;
}

References fEndTime.

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

◆ GetGlobalTime()

G4double G4Scheduler::GetGlobalTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 364 of file G4Scheduler.hh.

{
  return fGlobalTime;
}

References fGlobalTime.

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

◆ GetGun()

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 436 of file G4Scheduler.hh.

{
  return fpGun;
}

References fpGun.

◆ GetInteractivity()

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 426 of file G4Scheduler.hh.

{
  return fpTrackingInteractivity;
}

References fpTrackingInteractivity.

◆ GetLimitingTimeStep()

G4double G4Scheduler::GetLimitingTimeStep ( ) const

virtual

Reimplemented from G4VScheduler.

Definition at line 953 of file G4Scheduler.cc.

{
  if (fpUserTimeSteps == 0) return fDefaultMinTimeStep;
  if (fabs(fGlobalTime - fUserUpperTimeLimit) < fTimeTolerance)
    return fDefinedMinTimeStep;
 
  map<G4double, G4double>::const_iterator it_fpUserTimeSteps_i = fpUserTimeSteps
      ->upper_bound(fGlobalTime);
  map<G4double, G4double>::const_iterator 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;
    map<G4double, G4double>::const_iterator 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;
}

References fDefaultMinTimeStep, fDefinedMinTimeStep, fGlobalTime, fpUserTimeSteps, fStopTime, fTimeTolerance, and fUserUpperTimeLimit.

Referenced by Stepping().

◆ GetMaxNbSteps()

G4int G4Scheduler::GetMaxNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 339 of file G4Scheduler.hh.

{
  return fMaxSteps;
}

References fMaxSteps.

Referenced by G4SchedulerMessenger::GetCurrentValue().

◆ GetMaxTimeStep()

G4double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 189 of file G4Scheduler.hh.

  {
    return fMaxTimeStep;
  }

References fMaxTimeStep.

◆ GetMaxZeroTimeAllowed()

G4int G4Scheduler::GetMaxZeroTimeAllowed ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 396 of file G4Scheduler.hh.

{
  return fMaxNZeroTimeStepsAllowed;
}

References fMaxNZeroTimeStepsAllowed.

Referenced by G4SchedulerMessenger::GetCurrentValue().

◆ GetModelHandler()

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 301 of file G4Scheduler.hh.

{
  return fpModelHandler;
}

References fpModelHandler.

◆ GetNbSteps()

G4int G4Scheduler::GetNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 329 of file G4Scheduler.hh.

{
  return fNbSteps;
}

References fNbSteps.

◆ GetNextWatchedTime()

G4double G4Scheduler::GetNextWatchedTime ( ) const

Definition at line 502 of file G4Scheduler.cc.

{
  std::set<G4double>::const_iterator up = fWatchedTimes.upper_bound(fGlobalTime);
  if(up == fWatchedTimes.end()) return DBL_MAX;
  return *up;
}

References DBL_MAX, fGlobalTime, and fWatchedTimes.

Referenced by SynchronizeTracks().

◆ GetNTracks()

size_t G4Scheduler::GetNTracks ( )

virtual

Definition at line 1153 of file G4Scheduler.cc.

{
  return fTrackContainer.GetNTracks();
}

References fTrackContainer, and G4ITTrackHolder::GetNTracks().

◆ GetPreviousTimeStep()

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 411 of file G4Scheduler.hh.

{
  return fPreviousTimeStep;
}

References fPreviousTimeStep.

Referenced by G4DNAIRT_geometries::SpaceBinning().

◆ GetScavengerMaterial()

G4VScavengerMaterial * G4Scheduler::GetScavengerMaterial ( ) const

inline

Definition at line 194 of file G4Scheduler.hh.

  {
      return fpUserScavenger.get();
  }

References fpUserScavenger.

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

◆ GetStartTime()

G4double G4Scheduler::GetStartTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 344 of file G4Scheduler.hh.

{
  return fStartTime;
}

References fStartTime.

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

◆ GetStatus()

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 416 of file G4Scheduler.hh.

{
  return fITStepStatus;
}

References fITStepStatus.

◆ GetTimeStep()

G4double G4Scheduler::GetTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 354 of file G4Scheduler.hh.

{
  return fTimeStep;
}

References fTimeStep.

◆ GetTimeTolerance()

G4double G4Scheduler::GetTimeTolerance ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 406 of file G4Scheduler.hh.

{
  return fTimeTolerance;
}

References fTimeTolerance.

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

◆ GetUserTimeStepAction()

G4UserTimeStepAction * G4Scheduler::GetUserTimeStepAction ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 375 of file G4Scheduler.hh.

{
  return fpUserTimeStepAction;
}

References fpUserTimeStepAction.

◆ GetVerbose()

G4int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 385 of file G4Scheduler.hh.

{
  return fVerbose;
}

References fVerbose.

Referenced by G4SchedulerMessenger::GetCurrentValue().

◆ Initialize()

void G4Scheduler::Initialize ( )

virtual

Reimplemented from G4VScheduler.

Definition at line 284 of file G4Scheduler.cc.

{
  if(fpStepProcessor)
  {
    delete fpStepProcessor;
  }
  if(fpModelProcessor)
  {
    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 == 0) // 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;
}

References FatalErrorInArgument, fInitialized, fpModelHandler, fpModelProcessor, fpStepProcessor, fpTrackingInteractivity, fpTrackingManager, fpUserTimeSteps, fUsePreDefinedTimeSteps, G4Exception(), G4ITTrackingManager::SetInteractivity(), G4ITModelProcessor::SetModelHandler(), G4ITModelProcessor::SetTrackingManager(), and G4ITStepProcessor::SetTrackingManager().

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

◆ Instance()

G4Scheduler * G4Scheduler::Instance ( )

static

Definition at line 101 of file G4Scheduler.cc.

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

References fgScheduler, and G4Scheduler().

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

◆ IsInitialized()

G4bool G4Scheduler::IsInitialized ( )

inline

Definition at line 296 of file G4Scheduler.hh.

{
  return fInitialized;
}

References fInitialized.

Referenced by G4SchedulerMessenger::GetCurrentValue().

◆ IsRunning()

G4bool G4Scheduler::IsRunning ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 108 of file G4Scheduler.hh.

108{return fRunning;}

References fRunning.

◆ Notify()

G4bool G4Scheduler::Notify ( G4ApplicationState requestedState )

virtual

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;
}

References Clear(), fVerbose, G4cout, G4endl, and G4State_Quit.

◆ operator!=()

G4bool G4VStateDependent::operator!= ( const G4VStateDependent & right ) const

inherited

Definition at line 66 of file G4VStateDependent.cc.

{
  return (this != &right);
}

◆ operator=()

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

private

Definition at line 1144 of file G4Scheduler.cc.

{
  if(this != &right)
  {
    Create();
  }
  return *this;
}

References Create().

◆ operator==()

G4bool G4VStateDependent::operator== ( const G4VStateDependent & right ) const

inherited

Definition at line 61 of file G4VStateDependent.cc.

{
  return (this == &right);
}

◆ PrintWhyDoYouStop()

void G4Scheduler::PrintWhyDoYouStop ( )

protected

Definition at line 572 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() == false) // 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 == false)
    {
      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
}

References fContinue, fGlobalTime, fMaxSteps, fNbSteps, fStopTime, fTrackContainer, fWhyDoYouStop, G4BestUnit, G4cout, G4endl, and G4ITTrackHolder::MainListsNOTEmpty().

Referenced by DoProcess().

◆ Process()

void G4Scheduler::Process ( )

virtual

Reimplemented from G4VScheduler.

Definition at line 379 of file G4Scheduler.cc.

{
 
#ifdef G4VERBOSE
  if(fVerbose)
  {
    G4cout << "*** G4Scheduler starts processing " << G4endl;
    if(fVerbose > 2)
    G4cout << "___________________________________________"
    "___________________________" << G4endl;
  }
#endif
 
  if (fInitialized == false) Initialize();
 
  // fpTrackingManager->Initialize();
  fpModelProcessor->Initialize();
  fpStepProcessor->Initialize();
 
  // TODO
  // fpMasterModelProcessor->Initialize();
  // fpMasterStepProcessor->Initialize();
 
  if (fpGun) fpGun->DefineTracks();
 
  if (fpTrackingInteractivity) fpTrackingInteractivity->Initialize();
 
  // ___________________
  fRunning = true;
  Reset();
 
    //hoang 7/12/2020
 
    if(fResetScavenger) {
        if (fpUserScavenger != nullptr) {
            fpUserScavenger->Reset();
        }
    }
 
  if (fpUserTimeStepAction)
  {
      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)
  {
    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) fpUserTimeStepAction->EndProcessing();
 
  // ___________________
  EndTracking();
  ClearList();
 
  Reset();
 
  if (fpTrackingInteractivity) fpTrackingInteractivity->Finalize();
}

References ClearList(), G4ITGun::DefineTracks(), G4ITTrackHolder::DelayListsNOTEmpty(), G4UserTimeStepAction::EndProcessing(), EndTracking(), fGlobalTime, G4ITTrackingInteractivity::Finalize(), fInitialized, fpGun, fpModelProcessor, fpStepProcessor, fpTrackingInteractivity, fpUserScavenger, fpUserTimeStepAction, fResetScavenger, fRunning, fStartTime, fTrackContainer, fVerbose, G4BestUnit, G4cout, G4endl, G4ITTrackHolder::GetNextTime(), G4ITModelProcessor::Initialize(), G4ITStepProcessor::Initialize(), G4ITTrackingInteractivity::Initialize(), Initialize(), Reset(), G4Timer::Start(), G4UserTimeStepAction::StartProcessing(), G4Timer::Stop(), and SynchronizeTracks().

Referenced by G4DNAChemistryManager::Run(), and G4SchedulerMessenger::SetNewValue().

◆ RegisterModel()

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

virtual

Reimplemented from G4VScheduler.

Definition at line 277 of file G4Scheduler.cc.

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

References fpModelHandler, and G4ITModelHandler::RegisterModel().

◆ Reset()

void G4Scheduler::Reset ( )

virtual

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();
}

References G4ITReactionSet::CleanAllReaction(), DBL_MAX, eUndefined, fContinue, fGlobalTime, fILTimeStep, fInteractionStep, fITStepStatus, fNbSteps, fPreviousTimeStep, fReactionSet, fStartTime, fTimeStep, fTSTimeStep, fUserUpperTimeLimit, and fZeroTimeCount.

Referenced by Process().

◆ ResetScavenger()

void G4Scheduler::ResetScavenger ( bool value )

inline

Definition at line 456 of file G4Scheduler.hh.

{
    fResetScavenger = value;
}

References fResetScavenger.

◆ SetDefaultTimeStep()

void G4Scheduler::SetDefaultTimeStep ( G4double timeStep )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 359 of file G4Scheduler.hh.

{
  fDefaultMinTimeStep = timeStep;
}

References fDefaultMinTimeStep.

◆ SetEndTime()

void G4Scheduler::SetEndTime ( const G4double __endtime )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 306 of file G4Scheduler.hh.

{
  fEndTime = __endtime;
}

References fEndTime.

Referenced by G4SchedulerMessenger::SetNewValue().

◆ SetGun()

void G4Scheduler::SetGun ( G4ITGun * gun )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 431 of file G4Scheduler.hh.

{
  fpGun = gun;
}

References fpGun.

Referenced by G4DNAChemistryManager::SetGun().

◆ SetInteractivity()

void G4Scheduler::SetInteractivity ( G4ITTrackingInteractivity * interactivity )

virtual

Reimplemented from G4VScheduler.

Definition at line 1116 of file G4Scheduler.cc.

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

References fpTrackingInteractivity, fpTrackingManager, and G4ITTrackingManager::SetInteractivity().

◆ SetMaxNbSteps()

void G4Scheduler::SetMaxNbSteps ( G4int maxSteps )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 334 of file G4Scheduler.hh.

{
  fMaxSteps = maxSteps;
}

References fMaxSteps.

Referenced by G4SchedulerMessenger::SetNewValue().

◆ SetMaxTimeStep()

void G4Scheduler::SetMaxTimeStep ( G4double maxTimeStep )

inline

Definition at line 184 of file G4Scheduler.hh.

  {
    fMaxTimeStep = maxTimeStep;
  }

References fMaxTimeStep.

◆ SetMaxZeroTimeAllowed()

void G4Scheduler::SetMaxZeroTimeAllowed ( G4int maxTimeStepAllowed )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 391 of file G4Scheduler.hh.

{
  fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
}

References fMaxNZeroTimeStepsAllowed.

Referenced by G4SchedulerMessenger::SetNewValue().

◆ SetScavengerMaterial()

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

inline

Definition at line 198 of file G4Scheduler.hh.

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

References fpUserScavenger.

◆ SetTimeSteps()

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

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 312 of file G4Scheduler.hh.

{
  fUsePreDefinedTimeSteps = true;
  fpUserTimeSteps = steps;
}

References fpUserTimeSteps, and fUsePreDefinedTimeSteps.

◆ SetTimeTolerance()

void G4Scheduler::SetTimeTolerance ( G4double time )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 401 of file G4Scheduler.hh.

{
  fTimeTolerance = time;
}

References fTimeTolerance.

Referenced by G4SchedulerMessenger::SetNewValue().

◆ SetUserAction()

void G4Scheduler::SetUserAction ( G4UserTimeStepAction * userITAction )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 370 of file G4Scheduler.hh.

{
  fpUserTimeStepAction = userITAction;
}

References fpUserTimeStepAction.

◆ SetVerbose()

void G4Scheduler::SetVerbose ( G4int verbose )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 380 of file G4Scheduler.hh.

{
  fVerbose = verbose;
}

References fVerbose.

Referenced by G4SchedulerMessenger::SetNewValue().

◆ Stepping()

void G4Scheduler::Stepping ( )

protected

Definition at line 663 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)) ?
          true : false;
 
  if (fpUserTimeStepAction) 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)
  {
    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
 
}

References G4ITModelProcessor::CalculateMinTimeStep(), G4ITReactionSet::CleanAllReaction(), G4ITStepProcessor::ComputeInteractionLength(), G4ITModelProcessor::ComputeTrackReaction(), DBL_MAX, G4ITStepProcessor::DoIt(), eCollisionBetweenTracks, eInteractionWithMedium, eUndefined, FatalErrorInArgument, fDefinedMinTimeStep, fGlobalTime, fILTimeStep, fInteractionStep, fITStepStatus, fMaxNZeroTimeStepsAllowed, fMaxTimeStep, fNbSteps, fpModelProcessor, fPreviousTimeStep, fpStepProcessor, fpUserTimeStepAction, fReachedUserTimeLimit, fReactionSet, fStopTime, fTimeStep, fTimeTolerance, fTSTimeStep, fUseDefaultTimeSteps, fUsePreDefinedTimeSteps, fVerbose, fZeroTimeCount, G4BestUnit, G4cout, G4endl, G4Exception(), GetCollisionType(), G4ITModelProcessor::GetComputeTimeStep(), GetLimitingTimeStep(), LIGHT_RED, G4MemStat::MemoryUsage(), G4ITStepProcessor::PrepareLeadingTracks(), RESET_COLOR, G4ITStepProcessor::ResetLeadingTracks(), G4UserTimeStepAction::UserPostTimeStepAction(), and G4UserTimeStepAction::UserPreTimeStepAction().

Referenced by DoProcess().

◆ Stop()

void G4Scheduler::Stop ( )

inline

Definition at line 421 of file G4Scheduler.hh.

{
  fContinue = false;
}

References fContinue.

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)
  {
//    assert(tmpGlobalTime == fGlobalTime);
    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();
    }
  }
}