#include <G4Scheduler.hh>

Inheritance diagram for G4Scheduler:

Collaboration 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

G4ITTrackingManager *	GetTrackingManager () const

Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)

virtual	~G4VStateDependent ()

G4int	operator== (const G4VStateDependent &right) const

G4int	operator!= (const G4VStateDependent &right) const

Static Public Member Functions
static G4Scheduler *	Instance ()

static void	DeleteInstance ()

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

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

Constructor & Destructor Documentation

G4Scheduler::~G4Scheduler ( )

protectedvirtual

Definition at line 201 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;
 //  }
 }

Here is the call graph for this function:

Member Function Documentation

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

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 310 of file G4Scheduler.hh.

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

void G4Scheduler::AddWatchedTime ( double time )

inline

Definition at line 177 of file G4Scheduler.hh.

   {
     fWatchedTimes.insert(time);
   }

G4bool G4Scheduler::AreDefaultTimeStepsUsed ( )

inline

Definition at line 443 of file G4Scheduler.hh.

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

Here is the caller graph for this function:

bool G4Scheduler::CanICarryOn ( )

protected

Definition at line 551 of file G4Scheduler.cc.

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

Here is the caller graph for this function:

void G4Scheduler::Clear ( )

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::ClearList ( )

Definition at line 265 of file G4Scheduler.cc.

 {
 //  if (fNbTracks == 0) return;
 
   fTrackContainer.Clear();
 
   G4AllITFinder::DeleteInstance();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::DeleteInstance ( )

static

DeleteInstance should be used instead of the destructor

Definition at line 124 of file G4Scheduler.cc.

 {
   if(fgScheduler)
   {
     delete fgScheduler;
   }
 }

void G4Scheduler::DoProcess ( )

protected

Definition at line 603 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
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::EndTracking ( )

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::FindUserPreDefinedTimeStep ( )

protected

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

Here is the call graph for this function:

void G4Scheduler::ForceReinitialization ( )

Definition at line 1116 of file G4Scheduler.cc.

 {
   fInitialized = false;
   Initialize();
 }

Here is the call graph for this function:

void G4Scheduler::GetCollisionType ( G4String & interactionType )

Definition at line 1147 of file G4Scheduler.cc.

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

Here is the caller graph for this function:

G4double G4Scheduler::GetEndTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 341 of file G4Scheduler.hh.

 {
   return fEndTime;
 }

Here is the caller graph for this function:

G4double G4Scheduler::GetGlobalTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 356 of file G4Scheduler.hh.

 {
   return fGlobalTime;
 }

Here is the caller graph for this function:

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 428 of file G4Scheduler.hh.

 {
   return fpGun;
 }

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 418 of file G4Scheduler.hh.

 {
   return fpTrackingInteractivity;
 }

double G4Scheduler::GetLimitingTimeStep ( ) const

virtual

Reimplemented from G4VScheduler.

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

Here is the caller graph for this function:

G4int G4Scheduler::GetMaxNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 331 of file G4Scheduler.hh.

 {
   return fMaxSteps;
 }

Here is the caller graph for this function:

double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 189 of file G4Scheduler.hh.

   {
     return fMaxTimeStep;
   }

int G4Scheduler::GetMaxZeroTimeAllowed ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 388 of file G4Scheduler.hh.

 {
   return fMaxNZeroTimeStepsAllowed;
 }

Here is the caller graph for this function:

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 293 of file G4Scheduler.hh.

 {
   return fpModelHandler;
 }

G4int G4Scheduler::GetNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 321 of file G4Scheduler.hh.

 {
   return fNbSteps;
 }

double G4Scheduler::GetNextWatchedTime ( ) const

Definition at line 489 of file G4Scheduler.cc.

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

Here is the caller graph for this function:

size_t G4Scheduler::GetNTracks ( )

virtual

Definition at line 1141 of file G4Scheduler.cc.

 {
   return fTrackContainer.GetNTracks();
 }

Here is the call graph for this function:

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 403 of file G4Scheduler.hh.

 {
   return fPreviousTimeStep;
 }

G4double G4Scheduler::GetStartTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 336 of file G4Scheduler.hh.

 {
   return fStartTime;
 }

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 408 of file G4Scheduler.hh.

 {
   return fITStepStatus;
 }

G4double G4Scheduler::GetTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 346 of file G4Scheduler.hh.

 {
   return fTimeStep;
 }

double G4Scheduler::GetTimeTolerance ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 398 of file G4Scheduler.hh.

 {
   return fTimeTolerance;
 }

Here is the caller graph for this function:

G4ITTrackingManager* G4Scheduler::GetTrackingManager ( ) const

inline

Definition at line 194 of file G4Scheduler.hh.

   {
     return fpTrackingManager;
   }

G4UserTimeStepAction * G4Scheduler::GetUserTimeStepAction ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 367 of file G4Scheduler.hh.

 {
   return fpUserTimeStepAction;
 }

int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 377 of file G4Scheduler.hh.

 {
   return fVerbose;
 }

Here is the caller graph for this function:

void G4Scheduler::Initialize ( )

virtual

Reimplemented from G4VScheduler.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4Scheduler * G4Scheduler::Instance ( )

static

Definition at line 102 of file G4Scheduler.cc.

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

Here is the caller graph for this function:

bool G4Scheduler::IsInitialized ( )

inline

Definition at line 288 of file G4Scheduler.hh.

 {
   return fInitialized;
 }

Here is the caller graph for this function:

bool G4Scheduler::IsRunning ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 108 of file G4Scheduler.hh.

108 {return fRunning;}

Here is the caller graph for this function:

G4bool G4Scheduler::Notify ( G4ApplicationState requestedState )

virtual

Implements G4VStateDependent.

Definition at line 109 of file G4Scheduler.cc.

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

Here is the call graph for this function:

void G4Scheduler::PrintWhyDoYouStop ( )

protected

Definition at line 559 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
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::Process ( )

virtual

Reimplemented from G4VScheduler.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Reimplemented from G4VScheduler.

Definition at line 275 of file G4Scheduler.cc.

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

Here is the call graph for this function:

void G4Scheduler::Reset ( )

virtual

Reimplemented from G4VScheduler.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::SetDefaultTimeStep ( double timeStep )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 351 of file G4Scheduler.hh.

 {
   fDefaultMinTimeStep = timeStep;
 }

void G4Scheduler::SetEndTime ( const double __endtime )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 298 of file G4Scheduler.hh.

 {
   fEndTime = __endtime;
 }

Here is the caller graph for this function:

void G4Scheduler::SetGun ( G4ITGun * gun )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 423 of file G4Scheduler.hh.

 {
   fpGun = gun;
 }

Here is the caller graph for this function:

void G4Scheduler::SetInteractivity ( G4ITTrackingInteractivity * interactivity )

virtual

Reimplemented from G4VScheduler.

Definition at line 1104 of file G4Scheduler.cc.

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

Here is the call graph for this function:

void G4Scheduler::SetMaxNbSteps ( G4int maxSteps )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 326 of file G4Scheduler.hh.

 {
   fMaxSteps = maxSteps;
 }

Here is the caller graph for this function:

void G4Scheduler::SetMaxTimeStep ( double maxTimeStep )

inline

Definition at line 184 of file G4Scheduler.hh.

   {
     fMaxTimeStep = maxTimeStep;
   }

void G4Scheduler::SetMaxZeroTimeAllowed ( int maxTimeStepAllowed )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 383 of file G4Scheduler.hh.

 {
   fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
 }

Here is the caller graph for this function:

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

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 304 of file G4Scheduler.hh.

 {
   fUsePreDefinedTimeSteps = true;
   fpUserTimeSteps = steps;
 }

void G4Scheduler::SetTimeTolerance ( double time )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 393 of file G4Scheduler.hh.

 {
   fTimeTolerance = time;
 }

Here is the caller graph for this function:

void G4Scheduler::SetUserAction ( G4UserTimeStepAction * userITAction )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 362 of file G4Scheduler.hh.

 {
   fpUserTimeStepAction = userITAction;
 }

void G4Scheduler::SetVerbose ( int verbose )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 372 of file G4Scheduler.hh.

 {
   fVerbose = verbose;
 }

Here is the caller graph for this function:

void G4Scheduler::Stepping ( )

protected

Definition at line 650 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
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::Stop ( )

inline

Definition at line 413 of file G4Scheduler.hh.

 {
   fContinue = false;
 }

void G4Scheduler::SynchronizeTracks ( )

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Scheduler::UseDefaultTimeSteps ( G4bool flag )

inline

Definition at line 438 of file G4Scheduler.hh.

 {
   fUseDefaultTimeSteps = flag;
 }

Here is the caller graph for this function:

void G4Scheduler::WhyDoYouStop ( )

inline

Definition at line 433 of file G4Scheduler.hh.

 {
   fWhyDoYouStop = true;
 }

Here is the caller graph for this function:

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

geant4.10.03.p01/source/processes/electromagnetic/dna/management/include/G4Scheduler.hh
geant4.10.03.p01/source/processes/electromagnetic/dna/management/src/G4Scheduler.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation