G4Scheduler Class Reference

#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
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 ()

Private Member Functions
	G4Scheduler ()
void	Create ()
	G4Scheduler (const G4Scheduler &)
G4Scheduler &	operator= (const G4Scheduler &)

Private Attributes
G4SchedulerMessenger *	fpMessenger
int	fVerbose
bool	fWhyDoYouStop
bool	fInitialized
bool	fRunning
G4bool	fContinue
int	fNbSteps
int	fMaxSteps
G4ITStepStatus	fITStepStatus
G4bool	fUseDefaultTimeSteps
double	fTimeTolerance
double	fGlobalTime
double	fTmpGlobalTime
double	fStartTime
double	fStopTime
double	fEndTime
double	fPreviousTimeStep
int	fZeroTimeCount
int	fMaxNZeroTimeStepsAllowed
double	fTimeStep
double	fMaxTimeStep
bool	fUsePreDefinedTimeSteps
double	fDefaultMinTimeStep
std::map< double, double > *	fpUserTimeSteps
double	fUserUpperTimeLimit
double	fDefinedMinTimeStep
bool	fReachedUserTimeLimit
std::set< double >	fWatchedTimes
G4UserTimeStepAction *	fpUserTimeStepAction
G4ITStepProcessor *	fpStepProcessor
G4ITModelProcessor *	fpModelProcessor
G4ITTrackingManager *	fpTrackingManager
G4ITTrackingInteractivity *	fpTrackingInteractivity
G4ITReactionSet *	fReactionSet
G4ITTrackHolder &	fTrackContainer
G4ITModelHandler *	fpModelHandler
double	fTSTimeStep
double	fILTimeStep
bool	fInteractionStep
G4ITGun *	fpGun

Static Private Attributes
static G4ThreadLocal G4Scheduler *	fgScheduler

Detailed Description

G4ITStepManager enables to synchronize in time the step of tracks.

Definition at line 94 of file G4Scheduler.hh.

Constructor & Destructor Documentation

~G4Scheduler()

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:

G4Scheduler() [1/2]

G4Scheduler::G4Scheduler ( )

private

Definition at line 133 of file G4Scheduler.cc.

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

Here is the call graph for this function:

G4Scheduler() [2/2]

G4Scheduler::G4Scheduler ( const G4Scheduler &  )

private

Definition at line 1122 of file G4Scheduler.cc.

                                           :
    G4VScheduler(), G4VStateDependent(),
    fTrackContainer((G4ITTrackHolder&) *G4ITTrackHolder::Instance())

{
  Create();
}

Here is the call graph for this function:

Member Function Documentation

AddTimeStep()

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

AddWatchedTime()

void G4Scheduler::AddWatchedTime ( double  time )

inline

Definition at line 181 of file G4Scheduler.hh.

  {
    fWatchedTimes.insert(time);
  }

AreDefaultTimeStepsUsed()

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:

CanICarryOn()

bool G4Scheduler::CanICarryOn ( )

protected

Definition at line 549 of file G4Scheduler.cc.

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

Here is the caller graph for this function:

Clear()

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:

ClearList()

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:

Create()

void G4Scheduler::Create ( )

private

Definition at line 140 of file G4Scheduler.cc.

{
  fUseDefaultTimeSteps = true;
  fUserUpperTimeLimit = -1;
  fpGun = 0;
  fContinue = true;
//  fpMainList = 0;
//  fpWaitingList = 0;
  fpTrackingInteractivity = 0;

  fITStepStatus = eUndefined;

  fpUserTimeSteps = 0;

  fTimeStep = DBL_MAX;
  fTSTimeStep = DBL_MAX;
  fILTimeStep = DBL_MAX;
  fPreviousTimeStep = DBL_MAX;

  fZeroTimeCount = 0;
  fMaxNZeroTimeStepsAllowed = 10;

  fStartTime = 0;
  fTimeTolerance = 1 * picosecond;
  fEndTime = 1 * microsecond;
  fGlobalTime = -1;
  fInteractionStep = true;
  fUsePreDefinedTimeSteps = false;

  fDefaultMinTimeStep = 1 * picosecond;

  fpStepProcessor = 0;
  fpModelProcessor = 0;

  fNbSteps = 0;
  fMaxSteps = -1;

  fRunning = false;
  fInitialized = false;

  fpUserTimeStepAction = 0;
  fpModelHandler = new G4ITModelHandler();
  fpTrackingManager = new G4ITTrackingManager();

  fVerbose = 0;
  fWhyDoYouStop = false;
  fDefinedMinTimeStep = -1.;
  fReachedUserTimeLimit = false;
  fStopTime = -1.;
  fTmpGlobalTime = -1.;

  fpMessenger = new G4SchedulerMessenger(this);

  fReactionSet = G4ITReactionSet::Instance();
  fMaxTimeStep = DBL_MAX;

  G4ITTypeManager::Instance()->ReserveRessource();
}

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteInstance()

void G4Scheduler::DeleteInstance ( )

static

DeleteInstance should be used instead of the destructor

Definition at line 124 of file G4Scheduler.cc.

{
  if(fgScheduler)
  {
    delete fgScheduler;
  }
}

DoProcess()

void G4Scheduler::DoProcess ( )

protected

Definition at line 601 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:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

ForceReinitialization()

void G4Scheduler::ForceReinitialization

(

)

Definition at line 1115 of file G4Scheduler.cc.

{
  fInitialized = false;
  Initialize();
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

GetEndTime()

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:

GetGlobalTime()

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:

GetGun()

G4ITGun * G4Scheduler::GetGun ( )

inline

Definition at line 428 of file G4Scheduler.hh.

{
  return fpGun;
}

GetInteractivity()

G4ITTrackingInteractivity * G4Scheduler::GetInteractivity ( )

inlinevirtual

Reimplemented from G4VScheduler.

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

Here is the caller graph for this function:

GetMaxNbSteps()

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:

GetMaxTimeStep()

double G4Scheduler::GetMaxTimeStep ( ) const

inline

Definition at line 194 of file G4Scheduler.hh.

  {
    return fMaxTimeStep;
  }

GetMaxZeroTimeAllowed()

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:

GetModelHandler()

G4ITModelHandler * G4Scheduler::GetModelHandler ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 293 of file G4Scheduler.hh.

{
  return fpModelHandler;
}

GetNbSteps()

G4int G4Scheduler::GetNbSteps ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 321 of file G4Scheduler.hh.

{
  return fNbSteps;
}

GetNextWatchedTime()

double G4Scheduler::GetNextWatchedTime

(

)

const

Definition at line 487 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:

GetNTracks()

size_t G4Scheduler::GetNTracks ( )

virtual

Definition at line 1140 of file G4Scheduler.cc.

{
  return fTrackContainer.GetNTracks();
}

Here is the call graph for this function:

GetPreviousTimeStep()

G4double G4Scheduler::GetPreviousTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 403 of file G4Scheduler.hh.

{
  return fPreviousTimeStep;
}

GetStartTime()

G4double G4Scheduler::GetStartTime ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 336 of file G4Scheduler.hh.

{
  return fStartTime;
}

GetStatus()

G4ITStepStatus G4Scheduler::GetStatus ( ) const

inline

Definition at line 408 of file G4Scheduler.hh.

{
  return fITStepStatus;
}

GetTimeStep()

G4double G4Scheduler::GetTimeStep ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 346 of file G4Scheduler.hh.

{
  return fTimeStep;
}

GetTimeTolerance()

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:

GetUserTimeStepAction()

G4UserTimeStepAction * G4Scheduler::GetUserTimeStepAction ( ) const

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 367 of file G4Scheduler.hh.

{
  return fpUserTimeStepAction;
}

GetVerbose()

int G4Scheduler::GetVerbose ( ) const

inline

Definition at line 377 of file G4Scheduler.hh.

{
  return fVerbose;
}

Here is the caller graph for this function:

Initialize()

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:

Instance()

G4Scheduler * G4Scheduler::Instance ( void  )

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:

IsInitialized()

bool G4Scheduler::IsInitialized ( )

inline

Definition at line 288 of file G4Scheduler.hh.

{
  return fInitialized;
}

Here is the caller graph for this function:

IsRunning()

bool G4Scheduler::IsRunning ( )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 114 of file G4Scheduler.hh.

{return fRunning;}

Here is the call graph for this function:

Here is the caller graph for this function:

Notify()

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:

operator=()

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

private

Definition at line 1131 of file G4Scheduler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

PrintWhyDoYouStop()

void G4Scheduler::PrintWhyDoYouStop ( )

protected

Definition at line 557 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:

Process()

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;
#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:

RegisterModel()

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:

Reset()

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:

SetDefaultTimeStep()

void G4Scheduler::SetDefaultTimeStep ( double  timeStep )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 351 of file G4Scheduler.hh.

{
  fDefaultMinTimeStep = timeStep;
}

SetEndTime()

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:

SetGun()

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:

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

Here is the call graph for this function:

SetMaxNbSteps()

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:

SetMaxTimeStep()

void G4Scheduler::SetMaxTimeStep ( double  maxTimeStep )

inline

Definition at line 188 of file G4Scheduler.hh.

  {
    fMaxTimeStep = maxTimeStep;
  }

SetMaxZeroTimeAllowed()

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:

SetTimeSteps()

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

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 304 of file G4Scheduler.hh.

{
  fUsePreDefinedTimeSteps = true;
  fpUserTimeSteps = steps;
}

SetTimeTolerance()

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:

SetUserAction()

void G4Scheduler::SetUserAction ( G4UserTimeStepAction *  userITAction )

inlinevirtual

Reimplemented from G4VScheduler.

Definition at line 362 of file G4Scheduler.hh.

{
  fpUserTimeStepAction = userITAction;
}

SetVerbose()

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:

Stepping()

void G4Scheduler::Stepping ( )

protected

Definition at line 648 of file G4Scheduler.cc.

{
  G4IosFlagsSaver iosfs(G4cout);
  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:

Stop()

void G4Scheduler::Stop ( )

inline

Definition at line 413 of file G4Scheduler.hh.

{
  fContinue = false;
}

SynchronizeTracks()

void G4Scheduler::SynchronizeTracks ( )

protected

Definition at line 496 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:

UseDefaultTimeSteps()

void G4Scheduler::UseDefaultTimeSteps ( G4bool  flag )

inline

Definition at line 438 of file G4Scheduler.hh.

{
  fUseDefaultTimeSteps = flag;
}

Here is the caller graph for this function:

WhyDoYouStop()

void G4Scheduler::WhyDoYouStop ( )

inline

Definition at line 433 of file G4Scheduler.hh.

{
  fWhyDoYouStop = true;
}

Here is the caller graph for this function:

Member Data Documentation

fContinue

G4bool G4Scheduler::fContinue

private

Definition at line 224 of file G4Scheduler.hh.

fDefaultMinTimeStep

double G4Scheduler::fDefaultMinTimeStep

private

Definition at line 248 of file G4Scheduler.hh.

fDefinedMinTimeStep

double G4Scheduler::fDefinedMinTimeStep

private

Definition at line 252 of file G4Scheduler.hh.

fEndTime

double G4Scheduler::fEndTime

private

Definition at line 238 of file G4Scheduler.hh.

fGlobalTime

double G4Scheduler::fGlobalTime

private

Definition at line 234 of file G4Scheduler.hh.

fgScheduler

G4ThreadLocal G4Scheduler * G4Scheduler::fgScheduler

staticprivate

Definition at line 219 of file G4Scheduler.hh.

fILTimeStep

double G4Scheduler::fILTimeStep

private

Definition at line 273 of file G4Scheduler.hh.

fInitialized

bool G4Scheduler::fInitialized

private

Definition at line 222 of file G4Scheduler.hh.

fInteractionStep

bool G4Scheduler::fInteractionStep

private

Definition at line 277 of file G4Scheduler.hh.

fITStepStatus

G4ITStepStatus G4Scheduler::fITStepStatus

private

Definition at line 229 of file G4Scheduler.hh.

fMaxNZeroTimeStepsAllowed

int G4Scheduler::fMaxNZeroTimeStepsAllowed

private

Definition at line 241 of file G4Scheduler.hh.

fMaxSteps

int G4Scheduler::fMaxSteps

private

Definition at line 227 of file G4Scheduler.hh.

fMaxTimeStep

double G4Scheduler::fMaxTimeStep

private

Definition at line 244 of file G4Scheduler.hh.

fNbSteps

int G4Scheduler::fNbSteps

private

Definition at line 226 of file G4Scheduler.hh.

fpGun

G4ITGun* G4Scheduler::fpGun

private

Definition at line 281 of file G4Scheduler.hh.

fpMessenger

G4SchedulerMessenger* G4Scheduler::fpMessenger

private

Definition at line 217 of file G4Scheduler.hh.

fpModelHandler

G4ITModelHandler* G4Scheduler::fpModelHandler

private

Definition at line 268 of file G4Scheduler.hh.

fpModelProcessor

G4ITModelProcessor* G4Scheduler::fpModelProcessor

private

Definition at line 263 of file G4Scheduler.hh.

fPreviousTimeStep

double G4Scheduler::fPreviousTimeStep

private

Definition at line 239 of file G4Scheduler.hh.

fpStepProcessor

G4ITStepProcessor* G4Scheduler::fpStepProcessor

private

Definition at line 262 of file G4Scheduler.hh.

fpTrackingInteractivity

G4ITTrackingInteractivity* G4Scheduler::fpTrackingInteractivity

private

Definition at line 265 of file G4Scheduler.hh.

fpTrackingManager

G4ITTrackingManager* G4Scheduler::fpTrackingManager

private

Definition at line 264 of file G4Scheduler.hh.

fpUserTimeStepAction

G4UserTimeStepAction* G4Scheduler::fpUserTimeStepAction

private

Definition at line 258 of file G4Scheduler.hh.

fpUserTimeSteps

std::map<double, double>* G4Scheduler::fpUserTimeSteps

private

Definition at line 249 of file G4Scheduler.hh.

fReachedUserTimeLimit

bool G4Scheduler::fReachedUserTimeLimit

private

Definition at line 254 of file G4Scheduler.hh.

fReactionSet

G4ITReactionSet* G4Scheduler::fReactionSet

private

Definition at line 266 of file G4Scheduler.hh.

fRunning

bool G4Scheduler::fRunning

private

Definition at line 223 of file G4Scheduler.hh.

fStartTime

double G4Scheduler::fStartTime

private

Definition at line 236 of file G4Scheduler.hh.

fStopTime

double G4Scheduler::fStopTime

private

Definition at line 237 of file G4Scheduler.hh.

fTimeStep

double G4Scheduler::fTimeStep

private

Definition at line 243 of file G4Scheduler.hh.

fTimeTolerance

double G4Scheduler::fTimeTolerance

private

Definition at line 233 of file G4Scheduler.hh.

fTmpGlobalTime

double G4Scheduler::fTmpGlobalTime

private

Definition at line 235 of file G4Scheduler.hh.

fTrackContainer

G4ITTrackHolder& G4Scheduler::fTrackContainer

private

Definition at line 267 of file G4Scheduler.hh.

fTSTimeStep

double G4Scheduler::fTSTimeStep

private

Definition at line 271 of file G4Scheduler.hh.

fUseDefaultTimeSteps

G4bool G4Scheduler::fUseDefaultTimeSteps

private

Definition at line 232 of file G4Scheduler.hh.

fUsePreDefinedTimeSteps

bool G4Scheduler::fUsePreDefinedTimeSteps

private

Definition at line 247 of file G4Scheduler.hh.

fUserUpperTimeLimit

double G4Scheduler::fUserUpperTimeLimit

mutableprivate

Definition at line 251 of file G4Scheduler.hh.

fVerbose

int G4Scheduler::fVerbose

private

Definition at line 220 of file G4Scheduler.hh.

fWatchedTimes

std::set<double> G4Scheduler::fWatchedTimes

private

Definition at line 256 of file G4Scheduler.hh.

fWhyDoYouStop

bool G4Scheduler::fWhyDoYouStop

private

Definition at line 221 of file G4Scheduler.hh.

fZeroTimeCount

int G4Scheduler::fZeroTimeCount

private

Definition at line 240 of file G4Scheduler.hh.

---

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

• G4Scheduler.hh
• G4Scheduler.cc