G4SchedulerMessenger Class Reference

#include <G4SchedulerMessenger.hh>

Inheritance diagram for G4SchedulerMessenger:

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

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	LtoS (G4long l)
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 (const 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 ( )

overridedefault

Member Function Documentation

GetCurrentValue()

G4String G4SchedulerMessenger::GetCurrentValue ( G4UIcommand * command )

overridevirtual

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 )

overridevirtual

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