G4SchedulerMessenger Class Reference

#include <G4SchedulerMessenger.hh>

Inheritance diagram for G4SchedulerMessenger:

Public Member Functions
	G4SchedulerMessenger (G4Scheduler *runMgr)
	~G4SchedulerMessenger ()
void	SetNewValue (G4UIcommand *command, G4String newValues)
G4String	GetCurrentValue (G4UIcommand *command)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
virtual void	SetNewValue (G4UIcommand *command, G4String newValue)
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (const G4String &s)
G4long	StoL (const G4String &s)
G4double	StoD (const G4String &s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 65 of file G4SchedulerMessenger.hh.

Constructor & Destructor Documentation

G4SchedulerMessenger()

G4SchedulerMessenger::G4SchedulerMessenger ( G4Scheduler *  runMgr )

explicit

Definition at line 45 of file G4SchedulerMessenger.cc.

  : fScheduler(stepMgr)
{
  fITDirectory = std::make_unique<G4UIdirectory>("/scheduler/");
  fITDirectory->SetGuidance("Control commands for the time scheduler "
                            "(dna chemistry applications).");
 
  // Set end time
  fEndTime = std::make_unique<G4UIcmdWithADoubleAndUnit>("/scheduler/endTime", this);
  fEndTime->SetGuidance("Set time at which the simulation must stop.");
  fEndTime->AvailableForStates(G4State_PreInit, G4State_Idle);
  fEndTime->SetUnitCategory("Time");
  fEndTime->SetDefaultUnit("picosecond");
  fEndTime->SetDefaultValue(1);
 
  // Set time tolerance
  fTimeTolerance = std::make_unique<G4UIcmdWithADoubleAndUnit>("/scheduler/timeTolerance", this);
  fTimeTolerance->SetGuidance(
    "This command aims at resolving issues related to"
    " floating points. If two time events are separated by less than the "
    "selected tolerance, they are assumed to belong to the same time step.");
  fTimeTolerance->AvailableForStates(G4State_PreInit, G4State_Idle);
  fTimeTolerance->SetUnitCategory("Time");
  fTimeTolerance->SetDefaultUnit("picosecond");
  fTimeTolerance->SetDefaultValue(1);
 
  // Initialize
  fInitCmd = std::make_unique<G4UIcmdWithoutParameter>("/scheduler/initialize", this);
  fInitCmd->SetGuidance("Initialize G4Scheduler. This is done "
                        "for standalone application only (no physics).");
  fInitCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  // Set Max Null time Step
  fMaxNULLTimeSteps = std::make_unique<G4UIcmdWithAnInteger>("/scheduler/maxNullTimeSteps", this);
  fMaxNULLTimeSteps->SetGuidance(
    "Set maximum allowed zero time steps. After this "
    "threshold, the simulation is stopped.");
  fMaxNULLTimeSteps->SetParameterName("numberOfNullTimeSteps", true);
  fMaxNULLTimeSteps->SetDefaultValue(10000);
  fMaxNULLTimeSteps->SetRange("numberOfNullTimeSteps >=0 ");
 
  fMaxStepNumber = std::make_unique<G4UIcmdWithAnInteger>("/scheduler/maxStepNumber", this);
  fMaxStepNumber->SetGuidance(
    "Set the maximum number of time steps. After this "
    "threshold, the simulation is stopped.");
  fMaxStepNumber->SetParameterName("maximumNumberOfSteps", true);
  fMaxStepNumber->SetDefaultValue(-1);
 
  // Beam On
  fProcessCmd = std::make_unique<G4UIcmdWithoutParameter>("/scheduler/process", this);
  fProcessCmd->SetGuidance(
    "Process stacked tracks in G4Scheduler. This is done "
    "for standalone application only (no physics).");
  fProcessCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  // Verbose
  fVerboseCmd = std::make_unique<G4UIcmdWithAnInteger>("/scheduler/verbose", this);
  fVerboseCmd->SetGuidance("Set the Verbose level of G4Scheduler.");
  fVerboseCmd->SetGuidance(" 0 : Silent (default)");
  fVerboseCmd->SetGuidance(" 1 : Display reactions");
  fVerboseCmd->SetGuidance(" 2 ");
  fVerboseCmd->SetParameterName("level", true);
  fVerboseCmd->SetDefaultValue(1);
 
  fWhyDoYouStop = std::make_unique<G4UIcmdWithoutParameter>("/scheduler/whyDoYouStop", this);
  fWhyDoYouStop->SetGuidance("Will print information on why the scheduler is "
                             "stopping the process");
 
  fUseDefaultTimeSteps = std::make_unique<G4UIcmdWithABool>("/scheduler/useDefaultTimeSteps", this);
  fUseDefaultTimeSteps->SetGuidance(
    "Let the G4 processes decided for the next "
    "time step interval. This command would be interesting if no reaction has "
    "been set and if one will want to track down Brownian objects. "
    "NB: This command gets in conflicts with the declaration of time steps.");
 
  fResetScavenger = std::make_unique<G4UIcmdWithABool>("/scheduler/ResetScavengerForEachBeamOn", this);
  fResetScavenger->SetGuidance(
    "Reset Scavenger information apres each BeamOn.");
  fResetScavenger->SetDefaultValue(true);
 
}

~G4SchedulerMessenger()

G4SchedulerMessenger::~G4SchedulerMessenger ( )

default

Member Function Documentation

GetCurrentValue()

G4String G4SchedulerMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 175 of file G4SchedulerMessenger.cc.

{
  G4String cv;
 
  if(command == fVerboseCmd.get())
  {
    cv = fVerboseCmd->ConvertToString(fScheduler->GetVerbose());
  }
  else if(command == fEndTime.get())
  {
    cv = fEndTime->ConvertToString(fScheduler->GetEndTime());
  }
  else if(command == fTimeTolerance.get())
  {
    cv = fTimeTolerance->ConvertToString(fScheduler->GetTimeTolerance());
  }
  else if(command == fInitCmd.get())
  {
    cv = fInitCmd->ConvertToString(fScheduler->IsInitialized());
  }
  else if(command == fMaxNULLTimeSteps.get())
  {
    cv =
      fMaxNULLTimeSteps->ConvertToString(fScheduler->GetMaxZeroTimeAllowed());
  }
  else if(command == fMaxStepNumber.get())
  {
    cv = fMaxStepNumber->ConvertToString(fScheduler->GetMaxNbSteps());
  }
  else if(command == fUseDefaultTimeSteps.get())
  {
    cv = fUseDefaultTimeSteps->ConvertToString(
      fScheduler->AreDefaultTimeStepsUsed());
  }
  return cv;
}

SetNewValue()

void G4SchedulerMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValues  )

virtual

Reimplemented from G4UImessenger.

Definition at line 129 of file G4SchedulerMessenger.cc.

{
  if(command == fProcessCmd.get())
  {
    fScheduler->Process();
  }
  else if(command == fEndTime.get())
  {
    fScheduler->SetEndTime(fEndTime->GetNewDoubleValue(newValue));
  }
  else if(command == fTimeTolerance.get())
  {
    fScheduler->SetTimeTolerance(fTimeTolerance->GetNewDoubleValue(newValue));
  }
  else if(command == fVerboseCmd.get())
  {
    fScheduler->SetVerbose(fVerboseCmd->GetNewIntValue(newValue));
  }
  else if(command == fInitCmd.get())
  {
    fScheduler->Initialize();
  }
  else if(command == fMaxNULLTimeSteps.get())
  {
    fScheduler->SetMaxZeroTimeAllowed(
      fMaxNULLTimeSteps->GetNewIntValue(newValue));
  }
  else if(command == fMaxStepNumber.get())
  {
    fScheduler->SetMaxNbSteps(fMaxStepNumber->GetNewIntValue(newValue));
  }
  else if(command == fWhyDoYouStop.get())
  {
    fScheduler->WhyDoYouStop();
  }
  else if(command == fUseDefaultTimeSteps.get())
  {
    fScheduler->UseDefaultTimeSteps(
      fUseDefaultTimeSteps->GetNewBoolValue(newValue));
  }
  else if(command == fResetScavenger.get())
  {
    fScheduler->ResetScavenger(fResetScavenger->GetNewBoolValue(newValue));
  }
}

---

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

• G4SchedulerMessenger.hh
• G4SchedulerMessenger.cc