G4Scheduler Class Reference

#include <G4Scheduler.hh>

Inheritance diagram for G4Scheduler:

Public Member Functions
virtual G4bool	Notify (G4ApplicationState requestedState)
virtual void	RegisterModel (G4VITStepModel *, double)
void	Initialize ()
void	ForceReinitialization ()
bool	IsInitialized ()
bool	IsRunning ()
void	Reset ()
void	Process ()
void	ClearList ()
void	SetGun (G4ITGun *)
G4ITGun *	GetGun ()
void	Stop ()
void	Clear ()
void	EndTracking ()
void	SetEndTime (const double)
void	SetTimeTolerance (double)
double	GetTimeTolerance () const
void	SetMaxZeroTimeAllowed (int)
int	GetMaxZeroTimeAllowed () const
G4ITModelHandler *	GetModelHandler ()
void	SetTimeSteps (std::map< double, double > *)
void	AddTimeStep (double, double)
void	SetDefaultTimeStep (double)
double	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 (int)
int	GetVerbose () const
void	WhyDoYouStop ()
void	SetInteractivity (G4ITTrackingInteractivity *)
G4ITTrackingInteractivity *	GetInteractivity ()
virtual size_t	GetNTracks ()
void	GetCollisionType (G4String &interactionType)
void	AddWatchedTime (double time)
double	GetNextWatchedTime () const
void	SetMaxTimeStep (double maxTimeStep)
double	GetMaxTimeStep () const
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 ()
bool	CanICarryOn ()
void	PrintWhyDoYouStop ()
Protected Member Functions inherited from G4VScheduler
	G4VScheduler ()
virtual	~G4VScheduler ()

Detailed Description

G4Scheduler synchronizes (in time) track stepping

Definition at line 87 of file G4Scheduler.hh.

Constructor & Destructor Documentation

~G4Scheduler()

G4Scheduler::~G4Scheduler ( )

protectedvirtual

Definition at line 200 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 ( double  startingTime, double  timeStep  )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 304 of file G4Scheduler.hh.

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

AddWatchedTime()

void G4Scheduler::AddWatchedTime ( double  time )

inline

Definition at line 176 of file G4Scheduler.hh.

  {
    fWatchedTimes.insert(time);
  }

AreDefaultTimeStepsUsed()

G4bool G4Scheduler::AreDefaultTimeStepsUsed ( )

inline

Definition at line 437 of file G4Scheduler.hh.

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

Referenced by G4SchedulerMessenger::GetCurrentValue().

CanICarryOn()

bool G4Scheduler::CanICarryOn ( )

protected

Definition at line 550 of file G4Scheduler.cc.

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

Referenced by SynchronizeTracks().

Clear()

void G4Scheduler::Clear

(

)

Definition at line 216 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 264 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 602 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 1061 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 1006 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<double, double>::iterator fpUserTimeSteps_i =
      fpUserTimeSteps->upper_bound(fGlobalTime);
  map<double, double>::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 1115 of file G4Scheduler.cc.

{
  fInitialized = false;
  Initialize();
}

GetCollisionType()

void G4Scheduler::GetCollisionType

(

G4String &

interactionType

)

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

{
  return fGlobalTime;
}

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

GetGun()

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 422 of file G4Scheduler.hh.

{
  return fpGun;
}

GetInteractivity()

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 412 of file G4Scheduler.hh.

{
  return fpTrackingInteractivity;
}

GetLimitingTimeStep()

double G4Scheduler::GetLimitingTimeStep ( ) const

virtual

Reimplemented from G4VScheduler.

Definition at line 940 of file G4Scheduler.cc.

{
  if (fpUserTimeSteps == 0) return fDefaultMinTimeStep;
  if (fabs(fGlobalTime - fUserUpperTimeLimit) < fTimeTolerance)
    return fDefinedMinTimeStep;
 
  map<double, double>::const_iterator it_fpUserTimeSteps_i = fpUserTimeSteps
      ->upper_bound(fGlobalTime);
  map<double, double>::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<double, double>::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 325 of file G4Scheduler.hh.

{
  return fMaxSteps;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

GetMaxTimeStep()

double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 188 of file G4Scheduler.hh.

  {
    return fMaxTimeStep;
  }

GetMaxZeroTimeAllowed()

int G4Scheduler::GetMaxZeroTimeAllowed ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 382 of file G4Scheduler.hh.

{
  return fMaxNZeroTimeStepsAllowed;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

GetModelHandler()

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 287 of file G4Scheduler.hh.

{
  return fpModelHandler;
}

GetNbSteps()

G4int G4Scheduler::GetNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 315 of file G4Scheduler.hh.

{
  return fNbSteps;
}

GetNextWatchedTime()

double G4Scheduler::GetNextWatchedTime

(

)

const

Definition at line 488 of file G4Scheduler.cc.

{
  std::set<double>::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 1140 of file G4Scheduler.cc.

{
  return fTrackContainer.GetNTracks();
}

GetPreviousTimeStep()

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 397 of file G4Scheduler.hh.

{
  return fPreviousTimeStep;
}

GetStartTime()

G4double G4Scheduler::GetStartTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 330 of file G4Scheduler.hh.

{
  return fStartTime;
}

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

GetStatus()

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 402 of file G4Scheduler.hh.

{
  return fITStepStatus;
}

GetTimeStep()

G4double G4Scheduler::GetTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 340 of file G4Scheduler.hh.

{
  return fTimeStep;
}

GetTimeTolerance()

double G4Scheduler::GetTimeTolerance ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

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

{
  return fpUserTimeStepAction;
}

GetVerbose()

int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 371 of file G4Scheduler.hh.

{
  return fVerbose;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

Initialize()

void G4Scheduler::Initialize ( )

virtual

Reimplemented from G4VScheduler.

Definition at line 281 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(), G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIRT::G4DNAIRT(), G4DNAIRT::Initialize(), G4DNAChemistryManager::InitializeMaster(), G4DNAChemistryManager::InitializeThread(), G4VScheduler::Instance(), G4DNAIRT::MakeReaction(), G4DNAIRTMoleculeEncounterStepper::Prepare(), G4MoleculeCounter::RemoveAMoleculeAtTime(), G4DNAChemistryManager::Run(), G4DNAIRT::Sampling(), and G4DNAChemistryManager::SetGun().

IsInitialized()

bool G4Scheduler::IsInitialized ( )

inline

Definition at line 282 of file G4Scheduler.hh.

{
  return fInitialized;
}

Referenced by G4SchedulerMessenger::GetCurrentValue().

IsRunning()

bool G4Scheduler::IsRunning ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 107 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 558 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 376 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();
 
  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, double  time  )

virtual

Reimplemented from G4VScheduler.

Definition at line 274 of file G4Scheduler.cc.

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

Reset()

void G4Scheduler::Reset ( )

virtual

Reimplemented from G4VScheduler.

Definition at line 356 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().

SetDefaultTimeStep()

void G4Scheduler::SetDefaultTimeStep ( double  timeStep )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 345 of file G4Scheduler.hh.

{
  fDefaultMinTimeStep = timeStep;
}

SetEndTime()

void G4Scheduler::SetEndTime ( const double  __endtime )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 292 of file G4Scheduler.hh.

{
  fEndTime = __endtime;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetGun()

void G4Scheduler::SetGun ( G4ITGun *  gun )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 417 of file G4Scheduler.hh.

{
  fpGun = gun;
}

Referenced by G4DNAChemistryManager::SetGun().

SetInteractivity()

void G4Scheduler::SetInteractivity ( G4ITTrackingInteractivity *  interactivity )

virtual

Reimplemented from G4VScheduler.

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

{
  fMaxSteps = maxSteps;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetMaxTimeStep()

void G4Scheduler::SetMaxTimeStep ( double  maxTimeStep )

inline

Definition at line 183 of file G4Scheduler.hh.

  {
    fMaxTimeStep = maxTimeStep;
  }

SetMaxZeroTimeAllowed()

void G4Scheduler::SetMaxZeroTimeAllowed ( int  maxTimeStepAllowed )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 377 of file G4Scheduler.hh.

{
  fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetTimeSteps()

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

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 298 of file G4Scheduler.hh.

{
  fUsePreDefinedTimeSteps = true;
  fpUserTimeSteps = steps;
}

SetTimeTolerance()

void G4Scheduler::SetTimeTolerance ( double  time )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 387 of file G4Scheduler.hh.

{
  fTimeTolerance = time;
}

Referenced by G4SchedulerMessenger::SetNewValue().

SetUserAction()

void G4Scheduler::SetUserAction ( G4UserTimeStepAction *  userITAction )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 356 of file G4Scheduler.hh.

{
  fpUserTimeStepAction = userITAction;
}

SetVerbose()

void G4Scheduler::SetVerbose ( int  verbose )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 366 of file G4Scheduler.hh.

{
  fVerbose = verbose;
}

Referenced by G4SchedulerMessenger::SetNewValue().

Stepping()

void G4Scheduler::Stepping ( )

protected

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

{
  fContinue = false;
}

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep().

SynchronizeTracks()

void G4Scheduler::SynchronizeTracks ( )

protected

Definition at line 497 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;
 
  double nextWatchedTime = -1;
  bool 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 432 of file G4Scheduler.hh.

{
  fUseDefaultTimeSteps = flag;
}

Referenced by G4SchedulerMessenger::SetNewValue().

WhyDoYouStop()

void G4Scheduler::WhyDoYouStop ( )

inline

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