G4Scheduler Class Reference

#include <G4Scheduler.hh>

Inheritance diagram for G4Scheduler:

Public Member Functions
virtual G4bool	Notify (G4ApplicationState requestedState)
virtual void	RegisterModel (G4VITStepModel *, G4double)
void	Initialize ()
void	ForceReinitialization ()
G4bool	IsInitialized ()
G4bool	IsRunning ()
void	Reset ()
void	Process ()
void	ClearList ()
void	SetGun (G4ITGun *)
G4ITGun *	GetGun ()
void	Stop ()
void	Clear ()
void	EndTracking ()
void	SetEndTime (const G4double)
void	SetTimeTolerance (G4double)
G4double	GetTimeTolerance () const
void	SetMaxZeroTimeAllowed (G4int)
G4int	GetMaxZeroTimeAllowed () const
G4ITModelHandler *	GetModelHandler ()
void	SetTimeSteps (std::map< G4double, G4double > *)
void	AddTimeStep (G4double, G4double)
void	SetDefaultTimeStep (G4double)
G4double	GetLimitingTimeStep () const
G4int	GetNbSteps () const
void	SetMaxNbSteps (G4int)
G4int	GetMaxNbSteps () const
G4double	GetStartTime () const
G4double	GetEndTime () const
virtual G4double	GetTimeStep () const
G4double	GetPreviousTimeStep () const
G4double	GetGlobalTime () const
void	SetUserAction (G4UserTimeStepAction *)
G4UserTimeStepAction *	GetUserTimeStepAction () const
void	UseDefaultTimeSteps (G4bool)
G4bool	AreDefaultTimeStepsUsed ()
G4ITStepStatus	GetStatus () const
void	SetVerbose (G4int)
G4int	GetVerbose () const
void	WhyDoYouStop ()
void	SetInteractivity (G4ITTrackingInteractivity *)
G4ITTrackingInteractivity *	GetInteractivity ()
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)
virtual void	Initialize ()
virtual void	Reset ()
virtual void	SetVerbose (int)
virtual void	SetGun (G4ITGun *)
virtual void	Process ()
virtual G4bool	IsRunning ()
virtual G4ITModelHandler *	GetModelHandler ()
virtual void	RegisterModel (G4VITStepModel *, double)
virtual void	SetEndTime (const double)
virtual void	SetTimeTolerance (double)
virtual double	GetTimeTolerance () const
virtual void	SetMaxZeroTimeAllowed (int)
virtual int	GetMaxZeroTimeAllowed () const
virtual void	SetTimeSteps (std::map< double, double > *)
virtual void	AddTimeStep (double, double)
virtual void	SetDefaultTimeStep (double)
virtual double	GetLimitingTimeStep () const
virtual G4int	GetNbSteps () const
virtual void	SetMaxNbSteps (G4int)
virtual G4int	GetMaxNbSteps () const
virtual G4double	GetStartTime () const
virtual G4double	GetEndTime () const
virtual G4double	GetTimeStep () const
virtual G4double	GetPreviousTimeStep () const
virtual G4double	GetGlobalTime () const
virtual void	SetUserAction (G4UserTimeStepAction *)
virtual G4UserTimeStepAction *	GetUserTimeStepAction () const
virtual void	SetInteractivity (G4ITTrackingInteractivity *)
virtual G4ITTrackingInteractivity *	GetInteractivity ()
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 G4bool	Notify (G4ApplicationState requestedState)=0

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

Protected Member Functions
virtual	~G4Scheduler ()
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 ( )

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

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

AddWatchedTime()

void G4Scheduler::AddWatchedTime ( G4double  time )

inline

Definition at line 177 of file G4Scheduler.hh.

  {
    fWatchedTimes.insert(time);
  }

AreDefaultTimeStepsUsed()

G4bool G4Scheduler::AreDefaultTimeStepsUsed ( )

inline

Definition at line 451 of file G4Scheduler.hh.

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

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

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

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.

{
  if(fgScheduler)
  {
    delete 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
}

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

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

ForceReinitialization()

void G4Scheduler::ForceReinitialization

(

)

Definition at line 1128 of file G4Scheduler.cc.

{
  fInitialized = false;
  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;
  }
}

Referenced by Stepping().

GetEndTime()

G4double G4Scheduler::GetEndTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 349 of file G4Scheduler.hh.

{
  return fEndTime;
}

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

GetGlobalTime()

G4double G4Scheduler::GetGlobalTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 364 of file G4Scheduler.hh.

{
  return fGlobalTime;
}

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

GetGun()

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 436 of file G4Scheduler.hh.

{
  return fpGun;
}

GetInteractivity()

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 426 of file G4Scheduler.hh.

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

Referenced by Stepping().

GetMaxNbSteps()

G4int G4Scheduler::GetMaxNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 339 of file G4Scheduler.hh.

{
  return fMaxSteps;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

GetMaxTimeStep()

G4double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 189 of file G4Scheduler.hh.

  {
    return fMaxTimeStep;
  }

GetMaxZeroTimeAllowed()

G4int G4Scheduler::GetMaxZeroTimeAllowed ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 396 of file G4Scheduler.hh.

{
  return fMaxNZeroTimeStepsAllowed;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

GetModelHandler()

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 301 of file G4Scheduler.hh.

{
  return fpModelHandler;
}

GetNbSteps()

G4int G4Scheduler::GetNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 329 of file G4Scheduler.hh.

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

Referenced by SynchronizeTracks().

GetNTracks()

size_t G4Scheduler::GetNTracks ( )

virtual

Definition at line 1153 of file G4Scheduler.cc.

{
  return fTrackContainer.GetNTracks();
}

GetPreviousTimeStep()

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 411 of file G4Scheduler.hh.

{
  return fPreviousTimeStep;
}

GetScavengerMaterial()

G4VScavengerMaterial * G4Scheduler::GetScavengerMaterial ( ) const

inline

Definition at line 194 of file G4Scheduler.hh.

  {
      return fpUserScavenger.get();
  }

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

GetStartTime()

G4double G4Scheduler::GetStartTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 344 of file G4Scheduler.hh.

{
  return fStartTime;
}

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

GetStatus()

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 416 of file G4Scheduler.hh.

{
  return fITStepStatus;
}

GetTimeStep()

G4double G4Scheduler::GetTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 354 of file G4Scheduler.hh.

{
  return fTimeStep;
}

GetTimeTolerance()

G4double G4Scheduler::GetTimeTolerance ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 406 of file G4Scheduler.hh.

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

GetVerbose()

G4int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 385 of file G4Scheduler.hh.

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

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

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

{
  return fInitialized;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

IsRunning()

G4bool G4Scheduler::IsRunning ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 108 of file G4Scheduler.hh.

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

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
}

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

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

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

Referenced by Process().

ResetScavenger()

void G4Scheduler::ResetScavenger ( bool  value )

inline

Definition at line 456 of file G4Scheduler.hh.

{
    fResetScavenger = value;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetDefaultTimeStep()

void G4Scheduler::SetDefaultTimeStep ( G4double  timeStep )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 359 of file G4Scheduler.hh.

{
  fDefaultMinTimeStep = timeStep;
}

SetEndTime()

void G4Scheduler::SetEndTime ( const G4double  __endtime )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 306 of file G4Scheduler.hh.

{
  fEndTime = __endtime;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetGun()

void G4Scheduler::SetGun ( G4ITGun *  gun )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 431 of file G4Scheduler.hh.

{
  fpGun = gun;
}

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

SetMaxNbSteps()

void G4Scheduler::SetMaxNbSteps ( G4int  maxSteps )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 334 of file G4Scheduler.hh.

{
  fMaxSteps = maxSteps;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetMaxTimeStep()

void G4Scheduler::SetMaxTimeStep ( G4double  maxTimeStep )

inline

Definition at line 184 of file G4Scheduler.hh.

  {
    fMaxTimeStep = maxTimeStep;
  }

SetMaxZeroTimeAllowed()

void G4Scheduler::SetMaxZeroTimeAllowed ( G4int  maxTimeStepAllowed )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 391 of file G4Scheduler.hh.

{
  fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
}

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

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

SetTimeTolerance()

void G4Scheduler::SetTimeTolerance ( G4double  time )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 401 of file G4Scheduler.hh.

{
  fTimeTolerance = time;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetUserAction()

void G4Scheduler::SetUserAction ( G4UserTimeStepAction *  userITAction )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 370 of file G4Scheduler.hh.

{
  fpUserTimeStepAction = userITAction;
}

SetVerbose()

void G4Scheduler::SetVerbose ( G4int  verbose )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 380 of file G4Scheduler.hh.

{
  fVerbose = verbose;
}

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
 
}

Referenced by DoProcess().

Stop()

void G4Scheduler::Stop ( )

inline

Definition at line 421 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)
  {
//    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();
    }
  }
}

Referenced by Process().

UseDefaultTimeSteps()

void G4Scheduler::UseDefaultTimeSteps ( G4bool  flag )

inline

Definition at line 446 of file G4Scheduler.hh.

{
  fUseDefaultTimeSteps = flag;
}

Referenced by G4SchedulerMessenger::SetNewValue().

WhyDoYouStop()

void G4Scheduler::WhyDoYouStop ( )

inline

Definition at line 441 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