#include <G4RunMessenger.hh>

Inheritance diagram for G4RunMessenger:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const

	G4RunMessenger (G4RunManager *runMgr)

G4String	GetCurrentValue (G4UIcommand *command)

G4bool	operator!= (const G4UImessenger &messenger) const

G4bool	operator== (const G4UImessenger &messenger) const

void	SetNewValue (G4UIcommand *command, G4String newValues)

	~G4RunMessenger ()

Protected Member Functions
void	AddUIcommand (G4UIcommand *newCommand)

G4String	BtoS (G4bool b)

template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

G4String	DtoS (G4double a)

G4String	ItoS (G4int i)

G4bool	StoB (G4String s)

G4double	StoD (G4String s)

G4int	StoI (G4String s)

G4long	StoL (G4String s)

Protected Attributes
G4UIdirectory *	baseDir = nullptr

G4String	baseDirName = ""

G4bool	commandsShouldBeInMaster = false

Private Attributes
G4UIcmdWithABool *	abortCmd = nullptr

G4UIcmdWithoutParameter *	abortEventCmd = nullptr

G4UIcommand *	beamOnCmd = nullptr

G4UIcmdWithABool *	brkBoECmd = nullptr

G4UIcmdWithABool *	brkEoECmd = nullptr

G4UIcmdWithoutParameter *	constScoreCmd = nullptr

G4UIcmdWithoutParameter *	dumpCoupleCmd = nullptr

G4UIcmdWithAString *	dumpRegCmd = nullptr

G4UIcommand *	evModCmd = nullptr

G4UIcmdWithoutParameter *	geomCmd = nullptr

G4UIcmdWithABool *	geomRebCmd = nullptr

G4UIcmdWithoutParameter *	initCmd = nullptr

G4String	macroFileName = "*NULL*"

G4MaterialScanner *	materialScanner = nullptr

G4UIcmdWithoutParameter *	maxThreadsCmd = nullptr

G4UIcmdWithAnInteger *	nThreadsCmd = nullptr

G4UIcmdWithABool *	optCmd = nullptr

G4UIcmdWithoutParameter *	physCmd = nullptr

G4UIcmdWithAnInteger *	pinAffinityCmd = nullptr

G4UIcmdWithAnInteger *	printProgCmd = nullptr

G4UIcommand *	procUICmds = nullptr

G4UIcmdWithAString *	randDirCmd = nullptr

G4UIcmdWithAnInteger *	randEvtCmd = nullptr

G4UIdirectory *	randomDirectory = nullptr

G4UIcmdWithAString *	restoreRandCmd = nullptr

G4UIcmdWithABool *	restoreRandCmdMT = nullptr

G4UIdirectory *	runDirectory = nullptr

G4RunManager *	runManager = nullptr

G4UIcmdWithABool *	saveEachEventCmd = nullptr

G4UIcmdWithoutParameter *	saveThisEventCmd = nullptr

G4UIcmdWithoutParameter *	saveThisRunCmd = nullptr

G4UIcmdWithABool *	savingFlagCmd = nullptr

G4UIcmdWithAString *	seedCmd = nullptr

G4UIcmdWithAnInteger *	verboseCmd = nullptr

Detailed Description

Definition at line 65 of file G4RunMessenger.hh.

Constructor & Destructor Documentation

◆ G4RunMessenger()

G4RunMessenger::G4RunMessenger ( G4RunManager * runMgr )

Definition at line 50 of file G4RunMessenger.cc.

  : runManager(runMgr)
{
  runDirectory = new G4UIdirectory("/run/");
  runDirectory->SetGuidance("Run control commands.");
 
  initCmd = new G4UIcmdWithoutParameter("/run/initialize", this);
  initCmd->SetGuidance("Initialize G4 kernel.");
  initCmd->AvailableForStates(G4State_PreInit, G4State_Idle),
 
    beamOnCmd = new G4UIcommand("/run/beamOn", this);
  beamOnCmd->SetGuidance("Start a Run.");
  beamOnCmd->SetGuidance(
    "If G4 kernel is not initialized, it will be initialized.");
  beamOnCmd->SetGuidance("Default number of events to be processed is 1.");
  beamOnCmd->SetGuidance("The second and third arguments can be used for");
  beamOnCmd->SetGuidance("executing a macro file at the end of each event.");
  beamOnCmd->SetGuidance("If the second argument, i.e. name of the macro");
  beamOnCmd->SetGuidance("file, is given but the third argument is not,");
  beamOnCmd->SetGuidance("the macro file will be executed for all of the");
  beamOnCmd->SetGuidance("event.");
  beamOnCmd->SetGuidance("If the third argument (nSelect) is given, the");
  beamOnCmd->SetGuidance("macro file will be executed only for the first");
  beamOnCmd->SetGuidance("nSelect events.");
  beamOnCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
  beamOnCmd->SetToBeBroadcasted(false);
  G4UIparameter* p1 = new G4UIparameter("numberOfEvent", 'i', true);
  p1->SetDefaultValue(1);
  p1->SetParameterRange("numberOfEvent >= 0");
  beamOnCmd->SetParameter(p1);
  G4UIparameter* p2 = new G4UIparameter("macroFile", 's', true);
  p2->SetDefaultValue("***NULL***");
  beamOnCmd->SetParameter(p2);
  G4UIparameter* p3 = new G4UIparameter("nSelect", 'i', true);
  p3->SetDefaultValue(-1);
  p3->SetParameterRange("nSelect>=-1");
  beamOnCmd->SetParameter(p3);
  // beamOnCmd->SetToBeBroadcasted(false);
 
  verboseCmd = new G4UIcmdWithAnInteger("/run/verbose", this);
  verboseCmd->SetGuidance("Set the Verbose level of G4RunManager.");
  verboseCmd->SetGuidance(" 0 : Silent (default)");
  verboseCmd->SetGuidance(" 1 : Display main topics");
  verboseCmd->SetGuidance(" 2 : Display main topics and run summary");
  verboseCmd->SetParameterName("level", true);
  verboseCmd->SetDefaultValue(0);
  verboseCmd->SetRange("level >=0 && level <=2");
 
  printProgCmd = new G4UIcmdWithAnInteger("/run/printProgress", this);
  printProgCmd->SetGuidance(
    "Display begin_of_event information at given frequency.");
  printProgCmd->SetGuidance(
    "If it is set to zero, only the begin_of_run is shown.");
  printProgCmd->SetGuidance("If it is set to -1, no print-out is shown.");
  printProgCmd->SetParameterName("mod", true);
  printProgCmd->SetDefaultValue(-1);
  printProgCmd->SetRange("mod>=-1");
 
  nThreadsCmd = new G4UIcmdWithAnInteger("/run/numberOfThreads", this);
  nThreadsCmd->SetGuidance("Set the number of threads to be used.");
  nThreadsCmd->SetGuidance("This command works only in PreInit state.");
  nThreadsCmd->SetGuidance(
    "This command is valid only for multi-threaded mode.");
  nThreadsCmd->SetGuidance(
    "The command is ignored if it is issued in sequential mode.");
  nThreadsCmd->SetParameterName("nThreads", true);
  nThreadsCmd->SetDefaultValue(2);
  nThreadsCmd->SetRange("nThreads >0");
  nThreadsCmd->SetToBeBroadcasted(false);
  nThreadsCmd->AvailableForStates(G4State_PreInit);
 
  maxThreadsCmd =
    new G4UIcmdWithoutParameter("/run/useMaximumLogicalCores", this);
  maxThreadsCmd->SetGuidance(
    "Set the number of threads to be the number of available logical cores.");
  maxThreadsCmd->SetGuidance("This command works only in PreInit state.");
  maxThreadsCmd->SetGuidance(
    "This command is valid only for multi-threaded mode.");
  maxThreadsCmd->SetGuidance(
    "The command is ignored if it is issued in sequential mode.");
  maxThreadsCmd->SetToBeBroadcasted(false);
  maxThreadsCmd->AvailableForStates(G4State_PreInit);
 
  pinAffinityCmd = new G4UIcmdWithAnInteger("/run/pinAffinity", this);
  pinAffinityCmd->SetGuidance(
    "Locks each thread to a specific logical core. Workers "
    "are locked in round robin to logical cores.");
  pinAffinityCmd->SetGuidance(
    "This command is valid only for multi-threaded mode.");
  pinAffinityCmd->SetGuidance("This command works only in PreInit state.");
  pinAffinityCmd->SetGuidance(
    "This command is ignored if it is issued in sequential mode.");
  pinAffinityCmd->SetGuidance(
    "If a value n>0 is provided it starts setting affinity "
    "from the n-th CPU (note: counting from 1).");
  pinAffinityCmd->SetGuidance("E.g. /run/pinAffinity 3 locks first thread on "
                              "third logical CPU (number 2).");
  pinAffinityCmd->SetGuidance(
    "If a value n<0 is provided never locks on n-th CPU.");
  pinAffinityCmd->SetParameterName("pinAffinity", true);
  pinAffinityCmd->SetDefaultValue(1);
  pinAffinityCmd->SetToBeBroadcasted(false);
  pinAffinityCmd->SetRange("pinAffinity > 0 || pinAffinity < 0");
  pinAffinityCmd->AvailableForStates(G4State_PreInit);
 
  evModCmd = new G4UIcommand("/run/eventModulo", this);
  evModCmd->SetGuidance(
    "Set the event modulo for dispatching events to worker threads");
  evModCmd->SetGuidance(
    "i.e. each worker thread is ordered to simulate N events and then");
  evModCmd->SetGuidance("comes back to G4MTRunManager for next set.");
  evModCmd->SetGuidance(
    "If it is set to zero (default value), N is roughly given by this.");
  evModCmd->SetGuidance(
    "   N = int( sqrt( number_of_events / number_of_threads ) )");
  evModCmd->SetGuidance(
    "The value N may affect on the computing performance in particular");
  evModCmd->SetGuidance(
    "if N is too small compared to the total number of events.");
  evModCmd->SetGuidance(
    "The second parameter seedOnce specifies how frequently each worker");
  evModCmd->SetGuidance(
    "thread is seeded by the random number sequence centrally managed");
  evModCmd->SetGuidance("by the master G4MTRunManager.");
  evModCmd->SetGuidance(
    " - If seedOnce is set to 0 (default), seeds that are centrally managed");
  evModCmd->SetGuidance(
    "   by G4MTRunManager are set for every event of every worker thread.");
  evModCmd->SetGuidance(
    "   This option guarantees event reproducibility regardless of number");
  evModCmd->SetGuidance("   of threads.");
  evModCmd->SetGuidance(
    " - If seedOnce is set to 1, seeds are set only once for the first");
  evModCmd->SetGuidance(
    "   event of each run of each worker thread. Event reproducibility is");
  evModCmd->SetGuidance(
    "   guaranteed only if the same number of worker threads are used.");
  evModCmd->SetGuidance(
    "   On the other hand, this option offers better computing performance");
  evModCmd->SetGuidance(
    "   in particular for applications with relatively small primary");
  evModCmd->SetGuidance("   particle energy and large number of events.");
  evModCmd->SetGuidance(
    " - If seedOnce is set to 2, seeds are set only for the first event of");
  evModCmd->SetGuidance(
    "   group of N events. This option is reserved for the future use when");
  evModCmd->SetGuidance(
    "   Geant4 allows number of threads to be dynamically changed during an");
  evModCmd->SetGuidance("   event loop.");
  evModCmd->SetGuidance("This command is valid only for multi-threaded mode.");
  evModCmd->SetGuidance(
    "This command is ignored if it is issued in sequential mode.");
  G4UIparameter* emp1 = new G4UIparameter("N", 'i', true);
  emp1->SetDefaultValue(0);
  emp1->SetParameterRange("N >= 0");
  evModCmd->SetParameter(emp1);
  G4UIparameter* emp2 = new G4UIparameter("seedOnce", 'i', true);
  emp2->SetDefaultValue(0);
  emp2->SetParameterRange("seedOnce >= 0 && seedOnce <=2");
  evModCmd->SetParameter(emp2);
  evModCmd->SetToBeBroadcasted(false);
  evModCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  dumpRegCmd = new G4UIcmdWithAString("/run/dumpRegion", this);
  dumpRegCmd->SetGuidance("Dump region information.");
  dumpRegCmd->SetGuidance(
    "In case name of a region is not given, all regions will be displayed.");
  dumpRegCmd->SetParameterName("regionName", true);
  dumpRegCmd->SetDefaultValue("**ALL**");
  dumpRegCmd->AvailableForStates(G4State_Idle);
 
  dumpCoupleCmd = new G4UIcmdWithoutParameter("/run/dumpCouples", this);
  dumpCoupleCmd->SetGuidance("Dump material-cuts-couple information.");
  dumpCoupleCmd->SetGuidance(
    "Note that material-cuts-couple information is updated");
  dumpCoupleCmd->SetGuidance("after BeamOn has started.");
  dumpCoupleCmd->AvailableForStates(G4State_Idle);
 
  optCmd = new G4UIcmdWithABool("/run/optimizeGeometry", this);
  optCmd->SetGuidance("Set the optimization flag for geometry.");
  optCmd->SetGuidance("If it is set to TRUE, G4GeometryManager will optimize");
  optCmd->SetGuidance("the geometry definitions.");
  optCmd->SetGuidance("GEANT4 is initialized with this flag as TRUE.");
  optCmd->SetParameterName("optimizeFlag", true);
  optCmd->SetDefaultValue(true);
  optCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  brkBoECmd = new G4UIcmdWithABool("/run/breakAtBeginOfEvent", this);
  brkBoECmd->SetGuidance("Set a break point at the beginning of every event.");
  brkBoECmd->SetParameterName("flag", true);
  brkBoECmd->SetDefaultValue(true);
 
  brkEoECmd = new G4UIcmdWithABool("/run/breakAtEndOfEvent", this);
  brkEoECmd->SetGuidance("Set a break point at the end of every event.");
  brkEoECmd->SetParameterName("flag", true);
  brkEoECmd->SetDefaultValue(true);
 
  abortCmd = new G4UIcmdWithABool("/run/abort", this);
  abortCmd->SetGuidance("Abort current run processing.");
  abortCmd->SetGuidance(
    "If softAbort is false (default), currently processing event "
    "will be immediately aborted,");
  abortCmd->SetGuidance("while softAbort is true, abortion occurs after "
                        "processing the current event.");
  abortCmd->AvailableForStates(G4State_GeomClosed, G4State_EventProc);
  abortCmd->SetParameterName("softAbort", true);
  abortCmd->SetDefaultValue(false);
 
  abortEventCmd = new G4UIcmdWithoutParameter("/run/abortCurrentEvent", this);
  abortEventCmd->SetGuidance("Abort currently processing event.");
  abortEventCmd->AvailableForStates(G4State_EventProc);
 
  geomCmd = new G4UIcmdWithoutParameter("/run/geometryModified", this);
  geomCmd->SetGuidance("Force geometry to be closed (re-voxellized) again.");
  geomCmd->SetGuidance(
    "This command must be applied if geometry has been modified");
  geomCmd->SetGuidance(" after the first initialization (or BeamOn).");
  geomCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  geomRebCmd = new G4UIcmdWithABool("/run/reinitializeGeometry", this);
  geomRebCmd->SetGuidance("Force geometry to be rebuilt once again.");
  geomRebCmd->SetGuidance(
    "This command must be applied if the user needs his/her");
  geomRebCmd->SetGuidance(" detector construction to be reinvoked.");
  geomRebCmd->SetGuidance(
    "/run/geometryModified is automatically issued with this command.");
  geomRebCmd->SetParameterName("destroyFirst", true);
  geomRebCmd->SetDefaultValue(false);
  geomRebCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  physCmd = new G4UIcmdWithoutParameter("/run/physicsModified", this);
  physCmd->SetGuidance("Force all physics tables recalculated again.");
  physCmd->SetGuidance("This command must be applied");
  physCmd->SetGuidance(" if physics process has been modified after the");
  physCmd->SetGuidance(" first initialization (or BeamOn).");
  physCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  constScoreCmd =
    new G4UIcmdWithoutParameter("/run/constructScoringWorlds", this);
  constScoreCmd->SetGuidance("Construct scoring parallel world(s) if defined.");
  constScoreCmd->SetGuidance("This command is not mandatory, but automatically "
                             "called when a run starts.");
  constScoreCmd->SetGuidance(
    "But the user may use this to visualize the scoring "
    "world(s) before a run to start.");
  constScoreCmd->AvailableForStates(G4State_Idle);
 
  materialScanner = new G4MaterialScanner();
 
  randomDirectory = new G4UIdirectory("/random/");
  randomDirectory->SetGuidance("Random number status control commands.");
 
  seedCmd = new G4UIcmdWithAString("/random/setSeeds", this);
  seedCmd->SetGuidance(
    "Initialize the random number generator with integer seed stream.");
  seedCmd->SetGuidance("Number of integers should be more than 1.");
  seedCmd->SetGuidance(
    "Actual number of integers to be used depends on the individual "
    "random number engine.");
#ifdef G4MULTITHREADED
  seedCmd->SetGuidance("This command sets the seeds for the master thread.");
#endif
  seedCmd->SetParameterName("IntArray", false);
  seedCmd->AvailableForStates(G4State_PreInit, G4State_Idle,
                              G4State_GeomClosed);
  seedCmd->SetToBeBroadcasted(false);
 
  randDirCmd = new G4UIcmdWithAString("/random/setDirectoryName", this);
  randDirCmd->SetGuidance(
    "Define the directory name of the rndm status files.");
  randDirCmd->SetGuidance("Directory will be created if it does not exist.");
  randDirCmd->SetParameterName("fileName", true);
  randDirCmd->SetDefaultValue("./");
  randDirCmd->AvailableForStates(G4State_PreInit, G4State_Idle,
                                 G4State_GeomClosed);
 
  savingFlagCmd = new G4UIcmdWithABool("/random/setSavingFlag", this);
  savingFlagCmd->SetGuidance("The randomNumberStatus will be saved at :");
  savingFlagCmd->SetGuidance("beginning of run (currentRun.rndm) and "
                             "beginning of event (currentEvent.rndm) ");
  savingFlagCmd->SetParameterName("flag", true);
  savingFlagCmd->SetDefaultValue(true);
 
  saveThisRunCmd = new G4UIcmdWithoutParameter("/random/saveThisRun", this);
  saveThisRunCmd->SetGuidance("copy currentRun.rndm to runXXX.rndm");
  saveThisRunCmd->AvailableForStates(G4State_Idle, G4State_GeomClosed,
                                     G4State_EventProc);
 
  saveThisEventCmd = new G4UIcmdWithoutParameter("/random/saveThisEvent", this);
  saveThisEventCmd->SetGuidance("copy currentEvent.rndm to runXXXevtYYY.rndm");
  saveThisEventCmd->AvailableForStates(G4State_EventProc);
 
  restoreRandCmd = new G4UIcmdWithAString("/random/resetEngineFrom", this);
  restoreRandCmd->SetGuidance(
    "Reset the status of the rndm engine from a file.");
  restoreRandCmd->SetGuidance("See CLHEP manual for detail.");
  restoreRandCmd->SetGuidance("The engine status must be stored beforehand.");
  restoreRandCmd->SetGuidance("Directory of the status file should be set by"
                              " /random/setDirectoryName.");
  restoreRandCmd->SetParameterName("fileName", true);
  restoreRandCmd->SetDefaultValue("currentRun.rndm");
  restoreRandCmd->AvailableForStates(G4State_PreInit, G4State_Idle,
                                     G4State_GeomClosed);
  restoreRandCmd->SetToBeBroadcasted(false);
 
  restoreRandCmdMT =
    new G4UIcmdWithABool("/random/resetEngineFromEachEvent", this);
  restoreRandCmdMT->SetGuidance(
    "Reset the status of the rndm engine from a file at each event.");
  restoreRandCmdMT->SetGuidance(
    "Note that the file must follow the following naming convention:");
  restoreRandCmdMT->SetGuidance("run{#1}evt{#2}.rndm ; where #1 is the run "
                                "number and #2 is the event number.");
  restoreRandCmdMT->SetGuidance(
    "For example to re-seed the first event of the first "
    "run the file should be called run0evt0.rndm.");
  restoreRandCmdMT->SetGuidance(
    "If for a specific run/event the file is not found, "
    "the standard re-seeding strategy is used.");
  restoreRandCmdMT->SetGuidance("This command has meaning only in MT mode for "
                                "strong reproducibility studies.");
  restoreRandCmdMT->SetGuidance("Directory of the status file should be set by"
                                " /random/setDirectoryName.");
  restoreRandCmdMT->SetDefaultValue(false);
  restoreRandCmdMT->AvailableForStates(G4State_PreInit, G4State_Idle,
                                       G4State_GeomClosed);
 
  saveEachEventCmd = new G4UIcmdWithABool("/random/saveEachEventFlag", this);
  saveEachEventCmd->SetGuidance(
    "Save random number status at beginning of each event.");
  saveEachEventCmd->SetGuidance(
    "File name contains run and event numbers: runXXXevtYYY.rndm");
  saveEachEventCmd->SetParameterName("flag", true);
  saveEachEventCmd->SetDefaultValue(true);
 
  randEvtCmd = new G4UIcmdWithAnInteger("/run/storeRndmStatToEvent", this);
  randEvtCmd->SetGuidance("Flag to store rndm status to G4Event object.");
  randEvtCmd->SetGuidance(" flag = 0 : not store (default)");
  randEvtCmd->SetGuidance(
    " flag = 1 : status before primary particle generation is stored");
  randEvtCmd->SetGuidance(
    " flag = 2 : status before event processing (after primary "
    "particle generation) is stored");
  randEvtCmd->SetGuidance(" flag = 3 : both are stored");
  randEvtCmd->SetGuidance(
    "Note: Some performance overhead may be seen by storing rndm "
    "status, in particular");
  randEvtCmd->SetGuidance(
    "for the case of simplest geometry and small number of tracks per event.");
  randEvtCmd->SetParameterName("flag", true);
  randEvtCmd->SetDefaultValue(0);
  randEvtCmd->SetRange("flag>=0 && flag<=3");
  randEvtCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  procUICmds = new G4UIcmdWithoutParameter("/run/workersProcessCmds", this);
  procUICmds->SetToBeBroadcasted(false);
  procUICmds->SetGuidance(
    "Force workers to process current stack of UI commands.");
  procUICmds->SetGuidance("This commands is meaningful only in MT mode.");
  procUICmds->AvailableForStates(G4State_PreInit, G4State_Idle,
                                 G4State_GeomClosed);
}

References abortCmd, abortEventCmd, G4UIcommand::AvailableForStates(), beamOnCmd, brkBoECmd, brkEoECmd, constScoreCmd, dumpCoupleCmd, dumpRegCmd, evModCmd, G4State_EventProc, G4State_GeomClosed, G4State_Idle, G4State_PreInit, geomCmd, geomRebCmd, initCmd, materialScanner, maxThreadsCmd, nThreadsCmd, optCmd, physCmd, pinAffinityCmd, printProgCmd, procUICmds, randDirCmd, randEvtCmd, randomDirectory, restoreRandCmd, restoreRandCmdMT, runDirectory, saveEachEventCmd, saveThisEventCmd, saveThisRunCmd, savingFlagCmd, seedCmd, G4UIcmdWithAString::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIparameter::SetParameterRange(), G4UIcommand::SetRange(), G4UIcommand::SetToBeBroadcasted(), and verboseCmd.

◆ ~G4RunMessenger()

G4RunMessenger::~G4RunMessenger ( )

Definition at line 414 of file G4RunMessenger.cc.

{
  delete materialScanner;
  delete beamOnCmd;
  delete verboseCmd;
  delete printProgCmd;
  delete nThreadsCmd;
  delete maxThreadsCmd;
  delete pinAffinityCmd;
  delete evModCmd;
  delete optCmd;
  delete dumpRegCmd;
  delete dumpCoupleCmd;
  delete brkBoECmd;
  delete brkEoECmd;
  delete abortCmd;
  delete abortEventCmd;
  delete initCmd;
  delete geomCmd;
  delete geomRebCmd;
  delete physCmd;
  delete randEvtCmd;
  delete constScoreCmd;
  delete procUICmds;
 
  delete seedCmd;
  delete savingFlagCmd;
  delete saveThisRunCmd;
  delete saveThisEventCmd;
  delete restoreRandCmd;
  delete randomDirectory;
  delete saveEachEventCmd;
 
  delete randDirCmd;
  delete runDirectory;
 
  delete restoreRandCmdMT;
}

References abortCmd, abortEventCmd, beamOnCmd, brkBoECmd, brkEoECmd, constScoreCmd, dumpCoupleCmd, dumpRegCmd, evModCmd, geomCmd, geomRebCmd, initCmd, materialScanner, maxThreadsCmd, nThreadsCmd, optCmd, physCmd, pinAffinityCmd, printProgCmd, procUICmds, randDirCmd, randEvtCmd, randomDirectory, restoreRandCmd, restoreRandCmdMT, runDirectory, saveEachEventCmd, saveThisEventCmd, saveThisRunCmd, savingFlagCmd, seedCmd, and verboseCmd.

Member Function Documentation

◆ AddUIcommand()

void G4UImessenger::AddUIcommand ( G4UIcommand * newCommand )

protectedinherited

Definition at line 149 of file G4UImessenger.cc.

{
  G4cerr << "Warning : Old style definition of G4UIcommand <"
         << newCommand->GetCommandPath() << ">." << G4endl;
}

References G4cerr, G4endl, and G4UIcommand::GetCommandPath().

◆ BtoS()

G4String G4UImessenger::BtoS ( G4bool b )

protectedinherited

Definition at line 98 of file G4UImessenger.cc.

{
  G4String vl = "0";
  if(b)
    vl = "true";
  return vl;
}

◆ CommandsShouldBeInMaster()

G4bool G4UImessenger::CommandsShouldBeInMaster ( ) const

inlineinherited

Definition at line 77 of file G4UImessenger.hh.

    {
      return commandsShouldBeInMaster;
    }

References G4UImessenger::commandsShouldBeInMaster.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode().

◆ CreateCommand()

template<typename T >

T * G4UImessenger::CreateCommand	(	const G4String &	cname,
		const G4String &	dsc
	)

protectedinherited

Definition at line 110 of file G4UImessenger.hh.

{
  G4String path;
  if(cname[0] != '/')
  {
    path = baseDirName + cname;
    if(path[0] != '/')
      path = "/" + path;
  }
 
  T* command = new T(path.c_str(), this);
  command->SetGuidance(dsc.c_str());
 
  return command;
}

References G4UImessenger::baseDirName.

◆ CreateDirectory()

void G4UImessenger::CreateDirectory	(	const G4String &	path,
		const G4String &	dsc,
		G4bool	commandsToBeBroadcasted = `true`
	)

protectedinherited

Definition at line 156 of file G4UImessenger.cc.

{
  G4UImanager* ui = G4UImanager::GetUIpointer();
 
  G4String fullpath = path;
  if(fullpath.back() != '/')
    fullpath.append("/");
 
  G4UIcommandTree* tree = ui->GetTree()->FindCommandTree(fullpath.c_str());
  if(tree != nullptr)
  {
    baseDirName = tree->GetPathName();
  }
  else
  {
    baseDir     = new G4UIdirectory(fullpath.c_str(), commandsToBeBroadcasted);
    baseDirName = fullpath;
    baseDir->SetGuidance(dsc.c_str());
  }
}

References G4UImessenger::baseDir, G4UImessenger::baseDirName, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::GetPathName(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and G4UIcommand::SetGuidance().

Referenced by G4MoleculeShootMessenger::G4MoleculeShootMessenger(), and G4UImessenger::G4UImessenger().

◆ DtoS()

G4String G4UImessenger::DtoS ( G4double a )

protectedinherited

Definition at line 90 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << a;
  return G4String(os.str());
}

Referenced by G4ScoreQuantityMessenger::FilterCommands(), and G4UIcontrolMessenger::SetNewValue().

◆ GetCurrentValue()

G4String G4RunMessenger::GetCurrentValue ( G4UIcommand * command )

virtual

Reimplemented from G4UImessenger.

Definition at line 711 of file G4RunMessenger.cc.

{
  G4String cv;
 
  if(command == verboseCmd)
  {
    cv = verboseCmd->ConvertToString(runManager->GetVerboseLevel());
  }
  else if(command == printProgCmd)
  {
    cv = printProgCmd->ConvertToString(runManager->GetPrintProgress());
  }
  else if(command == randDirCmd)
  {
    cv = runManager->GetRandomNumberStoreDir();
  }
  else if(command == randEvtCmd)
  {
    cv = randEvtCmd->ConvertToString(
      runManager->GetFlagRandomNumberStatusToG4Event());
  }
  else if(command == nThreadsCmd)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      cv = nThreadsCmd->ConvertToString(
        static_cast<G4MTRunManager*>(runManager)->GetNumberOfThreads());
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      cv = "0";
    }
  }
  else if(command == evModCmd)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      cv =
        evModCmd->ConvertToString(
          static_cast<G4MTRunManager*>(runManager)->GetEventModulo()) +
        " " +
        evModCmd->ConvertToString(G4MTRunManager::SeedOncePerCommunication());
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      G4cout << "*** /run/eventModulo command is valid only in MT mode."
             << G4endl;
    }
  }
 
  return cv;
}

References G4UIcommand::ConvertToString(), evModCmd, G4cout, G4endl, G4RunManager::GetFlagRandomNumberStatusToG4Event(), G4RunManager::GetPrintProgress(), G4RunManager::GetRandomNumberStoreDir(), G4RunManager::GetRunManagerType(), G4RunManager::GetVerboseLevel(), G4RunManager::masterRM, nThreadsCmd, printProgCmd, randDirCmd, randEvtCmd, runManager, G4MTRunManager::SeedOncePerCommunication(), G4RunManager::sequentialRM, and verboseCmd.

◆ ItoS()

G4String G4UImessenger::ItoS ( G4int i )

protectedinherited

Definition at line 82 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << i;
  return G4String(os.str());
}

Referenced by G4GenericMessenger::DeclareMethod(), and G4ParticleGunMessenger::GetCurrentValue().

◆ operator!=()

G4bool G4UImessenger::operator!= ( const G4UImessenger & messenger ) const

inherited

Definition at line 76 of file G4UImessenger.cc.

{
  return this != &messenger;
}

◆ operator==()

G4bool G4UImessenger::operator== ( const G4UImessenger & messenger ) const

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

◆ SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 454 of file G4RunMessenger.cc.

{
  if(command == beamOnCmd)
  {
    G4int nev;
    G4int nst;
    const char* nv = (const char*) newValue;
    std::istringstream is(nv);
    is >> nev >> macroFileName >> nst;
    if(macroFileName == "***NULL***")
    {
      runManager->BeamOn(nev);
    }
    else
    {
      runManager->BeamOn(nev, macroFileName, nst);
    }
  }
  else if(command == verboseCmd)
  {
    runManager->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue));
  }
  else if(command == printProgCmd)
  {
    runManager->SetPrintProgress(printProgCmd->GetNewIntValue(newValue));
  }
  else if(command == nThreadsCmd)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      static_cast<G4MTRunManager*>(runManager)
        ->SetNumberOfThreads(nThreadsCmd->GetNewIntValue(newValue));
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      G4cout << "*** /run/numberOfThreads command is issued in sequential mode."
             << "\nCommand is ignored." << G4endl;
    }
    else
    {
      G4Exception("G4RunMessenger::ApplyNewCommand", "Run0901", FatalException,
                  "/run/numberOfThreads command is issued to local thread.");
    }
  }
  else if(command == maxThreadsCmd)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      static_cast<G4MTRunManager*>(runManager)
        ->SetNumberOfThreads(G4Threading::G4GetNumberOfCores());
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      G4cout << "*** /run/useMaximumLogicalCores command is issued in "
                "sequential mode."
             << "\nCommand is ignored." << G4endl;
    }
    else
    {
      G4Exception(
        "G4RunMessenger::ApplyNewCommand", "Run0901", FatalException,
        "/run/useMaximumLogicalCores command is issued to local thread.");
    }
  }
  else if(command == pinAffinityCmd)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      static_cast<G4MTRunManager*>(runManager)
        ->SetPinAffinity(pinAffinityCmd->GetNewIntValue(newValue));
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      G4cout << "*** /run/pinAffinity command is issued in sequential mode."
             << "\nCommand is ignored." << G4endl;
    }
    else
    {
      G4Exception("G4RunMessenger::ApplyNewCommand", "Run0901", FatalException,
                  "/run/pinAffinity command is issued to local thread.");
    }
  }
  else if(command == evModCmd)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      G4int nevMod   = 0;
      G4int sOnce    = 0;
      const char* nv = (const char*) newValue;
      std::istringstream is(nv);
      is >> nevMod >> sOnce;
      static_cast<G4MTRunManager*>(runManager)->SetEventModulo(nevMod);
      G4MTRunManager::SetSeedOncePerCommunication(sOnce);
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      G4cout << "*** /run/eventModulo command is issued in sequential mode."
             << "\nCommand is ignored." << G4endl;
    }
    else
    {
      G4Exception("G4RunMessenger::ApplyNewCommand", "Run0902", FatalException,
                  "/run/eventModulo command is issued to local thread.");
    }
  }
  else if(command == dumpRegCmd)
  {
    if(newValue == "**ALL**")
    {
      runManager->DumpRegion();
    }
    else
    {
      runManager->DumpRegion(newValue);
    }
  }
  else if(command == dumpCoupleCmd)
  {
    G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
  }
  else if(command == optCmd)
  {
    runManager->SetGeometryToBeOptimized(optCmd->GetNewBoolValue(newValue));
  }
  else if(command == brkBoECmd)
  {
    G4UImanager::GetUIpointer()->SetPauseAtBeginOfEvent(
      brkBoECmd->GetNewBoolValue(newValue));
  }
  else if(command == brkEoECmd)
  {
    G4UImanager::GetUIpointer()->SetPauseAtEndOfEvent(
      brkEoECmd->GetNewBoolValue(newValue));
  }
  else if(command == abortCmd)
  {
    runManager->AbortRun(abortCmd->GetNewBoolValue(newValue));
  }
  else if(command == abortEventCmd)
  {
    runManager->AbortEvent();
  }
  else if(command == initCmd)
  {
    runManager->Initialize();
  }
  else if(command == geomCmd)
  {
    runManager->GeometryHasBeenModified(false);
  }
  else if(command == geomRebCmd)
  {
    runManager->ReinitializeGeometry(geomRebCmd->GetNewBoolValue(newValue),
                                     false);
  }
  else if(command == physCmd)
  {
    runManager->PhysicsHasBeenModified();
  }
  else if(command == seedCmd)
  {
    G4Tokenizer next(newValue);
    G4int idx = 0;
    G4long seeds[100];
    G4String vl;
    while(!(vl = next()).empty())
    {
      seeds[idx] = StoL(vl);
      ++idx;
    }
    if(idx < 2)
    {
      G4cerr << "/random/setSeeds should have at least two values. "
                "Command ignored."
             << G4endl;
    }
    else
    {
      seeds[idx] = 0;
      G4Random::setTheSeeds(seeds);
    }
  }
  else if(command == randDirCmd)
  {
    runManager->SetRandomNumberStoreDir(newValue);
  }
  else if(command == savingFlagCmd)
  {
    runManager->SetRandomNumberStore(savingFlagCmd->GetNewBoolValue(newValue));
  }
  else if(command == saveThisRunCmd)
  {
    runManager->rndmSaveThisRun();
  }
  else if(command == saveThisEventCmd)
  {
    runManager->rndmSaveThisEvent();
  }
  else if(command == restoreRandCmd)
  {
    runManager->RestoreRandomNumberStatus(newValue);
  }
  else if(command == randEvtCmd)
  {
    runManager->StoreRandomNumberStatusToG4Event(
      randEvtCmd->GetNewIntValue(newValue));
  }
  else if(command == saveEachEventCmd)
  {
    runManager->SetRandomNumberStorePerEvent(
      saveEachEventCmd->GetNewBoolValue(newValue));
  }
  else if(command == constScoreCmd)
  {
    runManager->ConstructScoringWorlds();
  }
  else if(command == restoreRandCmdMT)
  {
    runManager->RestoreRndmEachEvent(
      restoreRandCmdMT->GetNewBoolValue(newValue));
  }
  else if(command == procUICmds)
  {
    G4RunManager::RMType rmType = runManager->GetRunManagerType();
    if(rmType == G4RunManager::masterRM)
    {
      auto rm = dynamic_cast<G4MTRunManager*>(runManager);
      if(rm != nullptr)
      {
        rm->RequestWorkersProcessCommandsStack();
      }
      else
      {
        G4Exception("G4RunManager::ApplyNewCommand", "Run0128", FatalException,
                    "/run/workersProcessCmds command issued on a "
                    "non-G4MTRunManager class instance.");
      }
    }
    else if(rmType == G4RunManager::sequentialRM)
    {
      G4cout
        << "*** /run/workersProcessCmds command is issued in sequential mode."
        << "\nCommand is ignored." << G4endl;
    }
    else
    {
      G4Exception("G4RunMessenger::ApplyNewCommand", "Run0129", FatalException,
                  "/run/workersProcessCmds command is issued to local thread.");
    }
  }
}

References abortCmd, G4RunManager::AbortEvent(), abortEventCmd, G4RunManager::AbortRun(), G4RunManager::BeamOn(), beamOnCmd, brkBoECmd, brkEoECmd, G4RunManager::ConstructScoringWorlds(), constScoreCmd, dumpCoupleCmd, G4ProductionCutsTable::DumpCouples(), dumpRegCmd, G4RunManager::DumpRegion(), anonymous_namespace{G4MTcoutDestination.cc}::empty, evModCmd, FatalException, G4cerr, G4cout, G4endl, G4Exception(), G4Threading::G4GetNumberOfCores(), geomCmd, G4RunManager::GeometryHasBeenModified(), geomRebCmd, G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithAnInteger::GetNewIntValue(), G4ProductionCutsTable::GetProductionCutsTable(), G4RunManager::GetRunManagerType(), G4UImanager::GetUIpointer(), initCmd, G4RunManager::Initialize(), macroFileName, G4RunManager::masterRM, maxThreadsCmd, nThreadsCmd, optCmd, physCmd, G4RunManager::PhysicsHasBeenModified(), pinAffinityCmd, printProgCmd, procUICmds, randDirCmd, randEvtCmd, G4RunManager::ReinitializeGeometry(), G4MTRunManager::RequestWorkersProcessCommandsStack(), restoreRandCmd, restoreRandCmdMT, G4RunManager::RestoreRandomNumberStatus(), G4RunManager::RestoreRndmEachEvent(), G4RunManager::rndmSaveThisEvent(), G4RunManager::rndmSaveThisRun(), runManager, saveEachEventCmd, saveThisEventCmd, saveThisRunCmd, savingFlagCmd, seedCmd, G4RunManager::sequentialRM, G4RunManager::SetGeometryToBeOptimized(), G4UImanager::SetPauseAtBeginOfEvent(), G4UImanager::SetPauseAtEndOfEvent(), PTL::Threading::SetPinAffinity(), G4RunManager::SetPrintProgress(), G4RunManager::SetRandomNumberStore(), G4RunManager::SetRandomNumberStoreDir(), G4RunManager::SetRandomNumberStorePerEvent(), G4MTRunManager::SetSeedOncePerCommunication(), G4RunManager::SetVerboseLevel(), G4UImessenger::StoL(), G4RunManager::StoreRandomNumberStatusToG4Event(), and verboseCmd.

◆ StoB()

G4bool G4UImessenger::StoB ( G4String s )

protectedinherited

Definition at line 137 of file G4UImessenger.cc.

{
  G4String v = G4StrUtil::to_upper_copy(str);
  G4bool vl = false;
  if(v == "Y" || v == "YES" || v == "1" || v == "T" || v == "TRUE")
  {
    vl = true;
  }
  return vl;
}

References G4StrUtil::to_upper_copy().

Referenced by G4LocalThreadCoutMessenger::SetNewValue(), G4CascadeParamMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoD()

G4double G4UImessenger::StoD ( G4String s )

protectedinherited

Definition at line 127 of file G4UImessenger.cc.

{
  G4double vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), G4ScoringMessenger::SetNewValue(), and G4PolarizationMessenger::SetNewValue().

◆ StoI()

G4int G4UImessenger::StoI ( G4String s )

protectedinherited

Definition at line 107 of file G4UImessenger.cc.

{
  G4int vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoringMessenger::Fill1D(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4ParticleGunMessenger::IonLevelCommand(), G4GeneralParticleSourceMessenger::IonLvlCommand(), G4ScoringMessenger::MeshBinCommand(), G4LocalThreadCoutMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4GMocrenMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ StoL()

G4long G4UImessenger::StoL ( G4String s )

protectedinherited

Definition at line 117 of file G4UImessenger.cc.

{
  G4long vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by SetNewValue().

Field Documentation

◆ abortCmd

G4UIcmdWithABool* G4RunMessenger::abortCmd = nullptr

private

Definition at line 93 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ abortEventCmd

G4UIcmdWithoutParameter* G4RunMessenger::abortEventCmd = nullptr

private

Definition at line 94 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ baseDir

G4UIdirectory* G4UImessenger::baseDir = nullptr

protectedinherited

Definition at line 102 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateDirectory(), and G4UImessenger::~G4UImessenger().

◆ baseDirName

G4String G4UImessenger::baseDirName = ""

protectedinherited

Definition at line 103 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateCommand(), and G4UImessenger::CreateDirectory().

◆ beamOnCmd

G4UIcommand* G4RunMessenger::beamOnCmd = nullptr

private

Definition at line 81 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ brkBoECmd

G4UIcmdWithABool* G4RunMessenger::brkBoECmd = nullptr

private

Definition at line 91 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ brkEoECmd

G4UIcmdWithABool* G4RunMessenger::brkEoECmd = nullptr

private

Definition at line 92 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

Referenced by G4UImessenger::CommandsShouldBeInMaster(), and G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger().

◆ constScoreCmd

G4UIcmdWithoutParameter* G4RunMessenger::constScoreCmd = nullptr

private

Definition at line 112 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ dumpCoupleCmd

G4UIcmdWithoutParameter* G4RunMessenger::dumpCoupleCmd = nullptr

private

Definition at line 89 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ dumpRegCmd

G4UIcmdWithAString* G4RunMessenger::dumpRegCmd = nullptr

private

Definition at line 88 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ evModCmd

G4UIcommand* G4RunMessenger::evModCmd = nullptr

private

Definition at line 87 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), GetCurrentValue(), SetNewValue(), and ~G4RunMessenger().

◆ geomCmd

G4UIcmdWithoutParameter* G4RunMessenger::geomCmd = nullptr

private

Definition at line 96 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ geomRebCmd

G4UIcmdWithABool* G4RunMessenger::geomRebCmd = nullptr

private

Definition at line 97 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ initCmd

G4UIcmdWithoutParameter* G4RunMessenger::initCmd = nullptr

private

Definition at line 95 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ macroFileName

G4String G4RunMessenger::macroFileName = "***NULL***"

private

Definition at line 78 of file G4RunMessenger.hh.

Referenced by SetNewValue().

◆ materialScanner

G4MaterialScanner* G4RunMessenger::materialScanner = nullptr

private

Definition at line 114 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), and ~G4RunMessenger().

◆ maxThreadsCmd

G4UIcmdWithoutParameter* G4RunMessenger::maxThreadsCmd = nullptr

private

Definition at line 85 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ nThreadsCmd

G4UIcmdWithAnInteger* G4RunMessenger::nThreadsCmd = nullptr

private

Definition at line 84 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), GetCurrentValue(), SetNewValue(), and ~G4RunMessenger().

◆ optCmd

G4UIcmdWithABool* G4RunMessenger::optCmd = nullptr

private

Definition at line 90 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ physCmd

G4UIcmdWithoutParameter* G4RunMessenger::physCmd = nullptr

private

Definition at line 98 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ pinAffinityCmd

G4UIcmdWithAnInteger* G4RunMessenger::pinAffinityCmd = nullptr

private

Definition at line 86 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ printProgCmd

G4UIcmdWithAnInteger* G4RunMessenger::printProgCmd = nullptr

private

Definition at line 83 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), GetCurrentValue(), SetNewValue(), and ~G4RunMessenger().

◆ procUICmds

G4UIcommand* G4RunMessenger::procUICmds = nullptr

private

Definition at line 100 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ randDirCmd

G4UIcmdWithAString* G4RunMessenger::randDirCmd = nullptr

private

Definition at line 104 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), GetCurrentValue(), SetNewValue(), and ~G4RunMessenger().

◆ randEvtCmd

G4UIcmdWithAnInteger* G4RunMessenger::randEvtCmd = nullptr

private

Definition at line 99 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), GetCurrentValue(), SetNewValue(), and ~G4RunMessenger().

◆ randomDirectory

G4UIdirectory* G4RunMessenger::randomDirectory = nullptr

private

Definition at line 102 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), and ~G4RunMessenger().

◆ restoreRandCmd

G4UIcmdWithAString* G4RunMessenger::restoreRandCmd = nullptr

private

Definition at line 108 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ restoreRandCmdMT

G4UIcmdWithABool* G4RunMessenger::restoreRandCmdMT = nullptr

private

Definition at line 110 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ runDirectory

G4UIdirectory* G4RunMessenger::runDirectory = nullptr

private

Definition at line 80 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), and ~G4RunMessenger().

◆ runManager

G4RunManager* G4RunMessenger::runManager = nullptr

private

Definition at line 77 of file G4RunMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

◆ saveEachEventCmd

G4UIcmdWithABool* G4RunMessenger::saveEachEventCmd = nullptr

private

Definition at line 109 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ saveThisEventCmd

G4UIcmdWithoutParameter* G4RunMessenger::saveThisEventCmd = nullptr

private

Definition at line 107 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ saveThisRunCmd

G4UIcmdWithoutParameter* G4RunMessenger::saveThisRunCmd = nullptr

private

Definition at line 106 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ savingFlagCmd

G4UIcmdWithABool* G4RunMessenger::savingFlagCmd = nullptr

private

Definition at line 105 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ seedCmd

G4UIcmdWithAString* G4RunMessenger::seedCmd = nullptr

private

Definition at line 103 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), SetNewValue(), and ~G4RunMessenger().

◆ verboseCmd

G4UIcmdWithAnInteger* G4RunMessenger::verboseCmd = nullptr

private

Definition at line 82 of file G4RunMessenger.hh.

Referenced by G4RunMessenger(), GetCurrentValue(), SetNewValue(), and ~G4RunMessenger().

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

source/run/include/G4RunMessenger.hh
source/run/src/G4RunMessenger.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4RunMessenger()

◆ ~G4RunMessenger()

Member Function Documentation

◆ AddUIcommand()

◆ BtoS()

◆ CommandsShouldBeInMaster()

◆ CreateCommand()

◆ CreateDirectory()

◆ DtoS()

◆ GetCurrentValue()

◆ ItoS()

◆ operator!=()

◆ operator==()

◆ SetNewValue()

◆ StoB()

◆ StoD()

◆ StoI()

◆ StoL()

Field Documentation

◆ abortCmd

◆ abortEventCmd

◆ baseDir

◆ baseDirName

◆ beamOnCmd

◆ brkBoECmd

◆ brkEoECmd

◆ commandsShouldBeInMaster

◆ constScoreCmd

◆ dumpCoupleCmd

◆ dumpRegCmd

◆ evModCmd

◆ geomCmd

◆ geomRebCmd

◆ initCmd

◆ macroFileName

◆ materialScanner

◆ maxThreadsCmd

◆ nThreadsCmd

◆ optCmd

◆ physCmd

◆ pinAffinityCmd

◆ printProgCmd

◆ procUICmds

◆ randDirCmd

◆ randEvtCmd

◆ randomDirectory

◆ restoreRandCmd

◆ restoreRandCmdMT

◆ runDirectory

◆ runManager

◆ saveEachEventCmd

◆ saveThisEventCmd

◆ saveThisRunCmd

◆ savingFlagCmd

◆ seedCmd

◆ verboseCmd