G4UIcontrolMessenger Class Reference

#include <G4UIcontrolMessenger.hh>

Inheritance diagram for G4UIcontrolMessenger:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const
	G4UIcontrolMessenger ()
G4String	GetCurrentValue (G4UIcommand *command)
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	operator== (const G4UImessenger &messenger) const
void	SetNewValue (G4UIcommand *command, G4String newValue)
	~G4UIcontrolMessenger ()

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
G4UIcommand *	addCommand = nullptr
G4UIcommand *	aliasCommand = nullptr
G4UIdirectory *	controlDirectory = nullptr
G4UIcommand *	divideCommand = nullptr
G4UIcmdWithAString *	doifBatchCommand = nullptr
G4UIcommand *	doifCommand = nullptr
G4UIcmdWithAString *	doifInteractiveCommand = nullptr
G4UIcmdWithABool *	doublePrecCommand = nullptr
G4UIcmdWithAString *	echoCmd = nullptr
G4UIcmdWithAString *	ExecuteCommand = nullptr
G4UIcommand *	foreachCommand = nullptr
G4UIcmdWithAString *	getEnvCmd = nullptr
G4UIcommand *	getValCmd = nullptr
G4UIcmdWithAString *	historyCommand = nullptr
G4UIcmdWithAString *	HTMLCommand = nullptr
G4UIcmdWithAString *	ifBatchCommand = nullptr
G4UIcommand *	ifCommand = nullptr
G4UIcmdWithAString *	ifInteractiveCommand = nullptr
G4UIcmdWithoutParameter *	listAliasCommand = nullptr
G4UIcommand *	loopCommand = nullptr
G4UIcmdWithAString *	macroPathCommand = nullptr
G4UIcmdWithAString *	ManualCommand = nullptr
G4UIcmdWithAnInteger *	maxStoredHistCommand = nullptr
G4UIcommand *	multiplyCommand = nullptr
G4UIcommand *	remainderCommand = nullptr
G4UIcmdWithAString *	shellCommand = nullptr
G4UIcmdWithoutParameter *	stopStoreHistoryCommand = nullptr
G4UIcommand *	strdoifCommand = nullptr
G4UIcommand *	strifCommand = nullptr
G4UIcommand *	subtractCommand = nullptr
G4UIcmdWithAnInteger *	suppressAbortionCommand = nullptr
G4UIcmdWithAString *	unaliasCommand = nullptr
G4UIcmdWithAnInteger *	verboseCommand = nullptr

Detailed Description

Definition at line 80 of file G4UIcontrolMessenger.hh.

Constructor & Destructor Documentation

G4UIcontrolMessenger()

G4UIcontrolMessenger::G4UIcontrolMessenger

(

)

Definition at line 49 of file G4UIcontrolMessenger.cc.

{
  controlDirectory = new G4UIdirectory("/control/");
  controlDirectory->SetGuidance("UI control commands.");
 
  macroPathCommand = new G4UIcmdWithAString("/control/macroPath", this);
  macroPathCommand->SetGuidance("Set macro search path"
                                " with colon-separated list.");
  macroPathCommand->SetParameterName("path", false);
 
  ExecuteCommand = new G4UIcmdWithAString("/control/execute", this);
  ExecuteCommand->SetGuidance("Execute a macro file.");
  ExecuteCommand->SetParameterName("fileName", false);
  ExecuteCommand->SetToBeBroadcasted(false);
 
  loopCommand = new G4UIcommand("/control/loop", this);
  loopCommand->SetGuidance("Execute a macro file more than once.");
  loopCommand->SetGuidance("Loop counter can be used as an aliased variable.");
  G4UIparameter* param1 = new G4UIparameter("macroFile", 's', false);
  loopCommand->SetParameter(param1);
  G4UIparameter* param2 = new G4UIparameter("counterName", 's', false);
  loopCommand->SetParameter(param2);
  G4UIparameter* param3 = new G4UIparameter("initialValue", 'd', false);
  loopCommand->SetParameter(param3);
  G4UIparameter* param4 = new G4UIparameter("finalValue", 'd', false);
  loopCommand->SetParameter(param4);
  G4UIparameter* param5 = new G4UIparameter("stepSize", 'd', true);
  param5->SetDefaultValue(1.0);
  loopCommand->SetParameter(param5);
  loopCommand->SetToBeBroadcasted(false);
 
  foreachCommand = new G4UIcommand("/control/foreach", this);
  foreachCommand->SetGuidance("Execute a macro file more than once.");
  foreachCommand->SetGuidance(
    "Loop counter can be used as an aliased variable.");
  foreachCommand->SetGuidance("Values must be separated by a space.");
  G4UIparameter* param6 = new G4UIparameter("macroFile", 's', false);
  foreachCommand->SetParameter(param6);
  G4UIparameter* param7 = new G4UIparameter("counterName", 's', false);
  foreachCommand->SetParameter(param7);
  G4UIparameter* param8 = new G4UIparameter("valueList", 's', false);
  foreachCommand->SetParameter(param8);
  foreachCommand->SetToBeBroadcasted(false);
 
  suppressAbortionCommand =
    new G4UIcmdWithAnInteger("/control/suppressAbortion", this);
  suppressAbortionCommand->SetGuidance(
    "Suppress the program abortion caused by G4Exception.");
  suppressAbortionCommand->SetGuidance(
    "Suppression level = 0 : no suppression");
  suppressAbortionCommand->SetGuidance(
    "                  = 1 : suppress during EventProc state");
  suppressAbortionCommand->SetGuidance(
    "                  = 2 : full suppression, i.e. no abortion by "
    "G4Exception");
  suppressAbortionCommand->SetGuidance(
    "When abortion is suppressed, you will get error messages issued by "
    "G4Exception,");
  suppressAbortionCommand->SetGuidance(
    "and there is NO guarantee for the correct result after the G4Exception "
    "error message.");
  suppressAbortionCommand->SetParameterName("level", true);
  suppressAbortionCommand->SetRange("level >= 0 && level <= 2");
  suppressAbortionCommand->SetDefaultValue(0);
 
  verboseCommand = new G4UIcmdWithAnInteger("/control/verbose", this);
  verboseCommand->SetGuidance("Applied command will also be shown on screen.");
  verboseCommand->SetGuidance("This command is useful with MACRO file.");
  verboseCommand->SetGuidance("  0 : silent");
  verboseCommand->SetGuidance("  1 : only the valid commands are shown.");
  verboseCommand->SetGuidance("  2 : comment lines are also shown (default).");
  verboseCommand->SetParameterName("switch", true);
  verboseCommand->SetRange("switch >= 0 && switch <=2");
  verboseCommand->SetDefaultValue(2);
 
  doublePrecCommand = new G4UIcmdWithABool("/control/useDoublePrecision", this);
  doublePrecCommand->SetGuidance(
    "Use double precision for printing out the current parameter value(s).");
  doublePrecCommand->SetParameterName("useDoublePrecision", true);
  doublePrecCommand->SetDefaultValue(true);
 
  historyCommand = new G4UIcmdWithAString("/control/saveHistory", this);
  historyCommand->SetGuidance("Store command history to a file.");
  historyCommand->SetGuidance("Defaul file name is G4history.macro.");
  historyCommand->SetParameterName("fileName", true);
  historyCommand->SetDefaultValue("G4History.macro");
  historyCommand->SetToBeBroadcasted(false);
 
  stopStoreHistoryCommand =
    new G4UIcmdWithoutParameter("/control/stopSavingHistory", this);
  stopStoreHistoryCommand->SetGuidance("Stop saving history file.");
  stopStoreHistoryCommand->SetToBeBroadcasted(false);
 
  aliasCommand = new G4UIcommand("/control/alias", this);
  aliasCommand->SetGuidance("Set an alias.");
  aliasCommand->SetGuidance("String can be aliased by this command.");
  aliasCommand->SetGuidance("The string may contain one or more spaces,");
  aliasCommand->SetGuidance(
    "the string must be enclosed by double quotes (\").");
  aliasCommand->SetGuidance("To use an alias, enclose the alias name with");
  aliasCommand->SetGuidance("parenthesis \"{\" and \"}\".");
  G4UIparameter* aliasNameParam = new G4UIparameter("aliasName", 's', false);
  aliasCommand->SetParameter(aliasNameParam);
  G4UIparameter* aliasValueParam = new G4UIparameter("aliasValue", 's', false);
  aliasCommand->SetParameter(aliasValueParam);
 
  unaliasCommand = new G4UIcmdWithAString("/control/unalias", this);
  unaliasCommand->SetGuidance("Remove an alias.");
  unaliasCommand->SetParameterName("aliasName", false);
 
  listAliasCommand = new G4UIcmdWithoutParameter("/control/listAlias", this);
  listAliasCommand->SetGuidance("List aliases.");
 
  getEnvCmd = new G4UIcmdWithAString("/control/getEnv", this);
  getEnvCmd->SetGuidance(
    "Get a shell environment variable and define it as an alias.");
  getEnvCmd->SetToBeBroadcasted(false);
 
  getValCmd = new G4UIcommand("/control/getVal", this);
  getValCmd->SetGuidance(
    "Get the current value of the UI command and define it as an alias.");
  getValCmd->SetGuidance(
    "Command is ignored if the UI command does not support GetCurrentValue().");
  getValCmd->SetGuidance(" Syntax : <alias_name> <UI_command> <iIdx>");
  G4UIparameter* aliName = new G4UIparameter("alias_name", 's', false);
  getValCmd->SetParameter(aliName);
  G4UIparameter* comName = new G4UIparameter("UI_command", 's', false);
  getValCmd->SetParameter(comName);
  G4UIparameter* iIdxParam = new G4UIparameter("iIdx", 'i', true);
  iIdxParam->SetDefaultValue(0);
  getValCmd->SetParameter(iIdxParam);
  getValCmd->SetToBeBroadcasted(false);
 
  echoCmd = new G4UIcmdWithAString("/control/echo", this);
  echoCmd->SetGuidance("Display the valuerameter string.");
  echoCmd->SetGuidance("If alias is contained, it is converted to the aliased value.");
 
  shellCommand = new G4UIcmdWithAString("/control/shell", this);
  shellCommand->SetGuidance("Execute a (Unix) SHELL command.");
  shellCommand->SetToBeBroadcasted(false);
 
  ManualCommand = new G4UIcmdWithAString("/control/manual", this);
  ManualCommand->SetGuidance("Display all of sub-directories and commands.");
  ManualCommand->SetGuidance("Directory path should be given by FULL-PATH.");
  ManualCommand->SetParameterName("dirPath", true);
  ManualCommand->SetDefaultValue("/");
  ManualCommand->SetToBeBroadcasted(false);
 
  HTMLCommand = new G4UIcmdWithAString("/control/createHTML", this);
  HTMLCommand->SetGuidance(
    "Generate HTML files for all of sub-directories and commands.");
  HTMLCommand->SetGuidance("Directory path should be given by FULL-PATH.");
  HTMLCommand->SetParameterName("dirPath", true);
  HTMLCommand->SetDefaultValue("/");
  HTMLCommand->SetToBeBroadcasted(false);
 
  maxStoredHistCommand =
    new G4UIcmdWithAnInteger("/control/maximumStoredHistory", this);
  maxStoredHistCommand->SetGuidance(
    "Set maximum number of stored UI commands.");
  maxStoredHistCommand->SetParameterName("max", true);
  maxStoredHistCommand->SetDefaultValue(20);
 
  ifCommand = new G4UIcommand("/control/if", this);
  ifCommand->SetGuidance("Execute a macro file if the expression is true.");
  ifCommand->SetGuidance(" Syntax : <double> <comp> <double> <macro_file>");
  G4UIparameter* leftParam = new G4UIparameter("left", 'd', false);
  ifCommand->SetParameter(leftParam);
  G4UIparameter* compParam = new G4UIparameter("comp", 's', false);
  compParam->SetParameterCandidates("> >= < <= == !=");
  ifCommand->SetParameter(compParam);
  G4UIparameter* rightParam = new G4UIparameter("right", 'd', false);
  ifCommand->SetParameter(rightParam);
  G4UIparameter* macroFileParam = new G4UIparameter("macroFile", 's', false);
  ifCommand->SetParameter(macroFileParam);
  ifCommand->SetToBeBroadcasted(false);
 
  doifCommand = new G4UIcommand("/control/doif", this);
  doifCommand->SetGuidance("Execute a UI command if the expression is true.");
  doifCommand->SetGuidance(" Syntax : <double> <comp> <double> <UI_command>");
  G4UIparameter* doleftParam = new G4UIparameter("left", 'd', false);
  doifCommand->SetParameter(doleftParam);
  G4UIparameter* docompParam = new G4UIparameter("comp", 's', false);
  docompParam->SetParameterCandidates("> >= < <= == !=");
  doifCommand->SetParameter(docompParam);
  G4UIparameter* dorightParam = new G4UIparameter("right", 'd', false);
  doifCommand->SetParameter(dorightParam);
  G4UIparameter* comParam = new G4UIparameter("UI_command", 's', false);
  doifCommand->SetParameter(comParam);
  doifCommand->SetToBeBroadcasted(false);
 
  addCommand = new G4UIcommand("/control/add", this);
  addCommand->SetGuidance("Define a new alias as the sum of two values.");
  addCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  addCommand->SetGuidance(
    " <new_alias> may be an already existing alias. If it is the case,");
  addCommand->SetGuidance(" aliased value is alternated.");
  G4UIparameter* newAlias1 = new G4UIparameter("new_alias", 's', false);
  addCommand->SetParameter(newAlias1);
  G4UIparameter* val1a = new G4UIparameter("value1", 'd', false);
  addCommand->SetParameter(val1a);
  G4UIparameter* val1b = new G4UIparameter("value2", 'd', false);
  addCommand->SetParameter(val1b);
  addCommand->SetToBeBroadcasted(false);
 
  subtractCommand = new G4UIcommand("/control/subtract", this);
  subtractCommand->SetGuidance(
    "Define a new alias as the subtraction of two values.");
  subtractCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  subtractCommand->SetGuidance(
    " <new_alias> may be an already existing alias. If it is the case,");
  subtractCommand->SetGuidance(" aliased value is alternated.");
  G4UIparameter* newAlias2 = new G4UIparameter("new_alias", 's', false);
  subtractCommand->SetParameter(newAlias2);
  G4UIparameter* val2a = new G4UIparameter("value1", 'd', false);
  subtractCommand->SetParameter(val2a);
  G4UIparameter* val2b = new G4UIparameter("value2", 'd', false);
  subtractCommand->SetParameter(val2b);
  subtractCommand->SetToBeBroadcasted(false);
 
  multiplyCommand = new G4UIcommand("/control/multiply", this);
  multiplyCommand->SetGuidance(
    "Define a new alias as the multiplication of two values.");
  multiplyCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  multiplyCommand->SetGuidance(
    " <new_alias> may be an already existing alias. If it is the case,");
  multiplyCommand->SetGuidance(" aliased value is alternated.");
  G4UIparameter* newAlias3 = new G4UIparameter("new_alias", 's', false);
  multiplyCommand->SetParameter(newAlias3);
  G4UIparameter* val3a = new G4UIparameter("value1", 'd', false);
  multiplyCommand->SetParameter(val3a);
  G4UIparameter* val3b = new G4UIparameter("value2", 'd', false);
  multiplyCommand->SetParameter(val3b);
  multiplyCommand->SetToBeBroadcasted(false);
 
  divideCommand = new G4UIcommand("/control/divide", this);
  divideCommand->SetGuidance(
    "Define a new alias as the division of two values.");
  divideCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  divideCommand->SetGuidance(
    " <new_alias> may be an already existing alias. If it is the case,");
  divideCommand->SetGuidance(" aliased value is alternated.");
  G4UIparameter* newAlias4 = new G4UIparameter("new_alias", 's', false);
  divideCommand->SetParameter(newAlias4);
  G4UIparameter* val4a = new G4UIparameter("value1", 'd', false);
  divideCommand->SetParameter(val4a);
  G4UIparameter* val4b = new G4UIparameter("value2", 'd', false);
  val4b->SetParameterRange("value2 != 0.");
  divideCommand->SetParameter(val4b);
  divideCommand->SetToBeBroadcasted(false);
 
  remainderCommand = new G4UIcommand("/control/remainder", this);
  remainderCommand->SetGuidance(
    "Define a new alias as the remainder of two values.");
  remainderCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
  remainderCommand->SetGuidance(
    " <new_alias> may be an already existing alias. If it is the case,");
  remainderCommand->SetGuidance(" aliased value is alternated.");
  G4UIparameter* newAlias5 = new G4UIparameter("new_alias", 's', false);
  remainderCommand->SetParameter(newAlias5);
  G4UIparameter* val5a = new G4UIparameter("value1", 'i', false);
  remainderCommand->SetParameter(val5a);
  G4UIparameter* val5b = new G4UIparameter("value2", 'i', false);
  val4b->SetParameterRange("value2 != 0");
  remainderCommand->SetParameter(val5b);
  remainderCommand->SetToBeBroadcasted(false);
 
  strifCommand = new G4UIcommand("/control/strif", this);
  strifCommand->SetGuidance("Execute a macro file if the expression is true.");
  strifCommand->SetGuidance(" Syntax : <string> <comp> <string> <macro_file>");
  G4UIparameter* strleftParam = new G4UIparameter("left", 's', false);
  strifCommand->SetParameter(strleftParam);
  G4UIparameter* strcompParam = new G4UIparameter("comp", 's', false);
  strcompParam->SetParameterCandidates("== !=");
  strifCommand->SetParameter(strcompParam);
  G4UIparameter* strrightParam = new G4UIparameter("right", 's', false);
  strifCommand->SetParameter(strrightParam);
  G4UIparameter* strmacroFileParam = new G4UIparameter("macroFile", 's', false);
  strifCommand->SetParameter(strmacroFileParam);
  strifCommand->SetToBeBroadcasted(false);
 
  strdoifCommand = new G4UIcommand("/control/strdoif", this);
  strdoifCommand->SetGuidance(
    "Execute a UI command if the expression is true.");
  strdoifCommand->SetGuidance(
    " Syntax : <string> <comp> <string> <UI_command>");
  G4UIparameter* strdoleftParam = new G4UIparameter("left", 's', false);
  strdoifCommand->SetParameter(strdoleftParam);
  G4UIparameter* strdocompParam = new G4UIparameter("comp", 's', false);
  strdocompParam->SetParameterCandidates("== !=");
  strdoifCommand->SetParameter(strdocompParam);
  G4UIparameter* strdorightParam = new G4UIparameter("right", 's', false);
  strdoifCommand->SetParameter(strdorightParam);
  G4UIparameter* strdomacroFileParam =
    new G4UIparameter("UI_command", 's', false);
  strdoifCommand->SetParameter(strdomacroFileParam);
  strdoifCommand->SetToBeBroadcasted(false);
 
  ifBatchCommand = new G4UIcmdWithAString("/control/ifBatch", this);
  ifBatchCommand->SetGuidance(
    "Execute a macro file if program is running in batch mode.");
  ifBatchCommand->SetParameterName("macroFile", false);
  ifBatchCommand->SetToBeBroadcasted(false);
 
  ifInteractiveCommand = new G4UIcmdWithAString("/control/ifInteractive", this);
  ifInteractiveCommand->SetGuidance(
    "Execute a macro file if program is running in interactive mode.");
  ifInteractiveCommand->SetParameterName("macroFile", false);
  ifInteractiveCommand->SetToBeBroadcasted(false);
 
  doifBatchCommand = new G4UIcmdWithAString("/control/doifBatch", this);
  doifBatchCommand->SetGuidance(
    "Execute a UI command if program is running in batch mode.");
  doifBatchCommand->SetParameterName("UIcommand", false);
  doifBatchCommand->SetToBeBroadcasted(false);
 
  doifInteractiveCommand =
    new G4UIcmdWithAString("/control/doifInteractive", this);
  doifInteractiveCommand->SetGuidance(
    "Execute a UI command if program is running in interactive mode.");
  doifInteractiveCommand->SetParameterName("UIcommand", false);
  doifInteractiveCommand->SetToBeBroadcasted(false);
}

References addCommand, aliasCommand, controlDirectory, divideCommand, doifBatchCommand, doifCommand, doifInteractiveCommand, doublePrecCommand, echoCmd, ExecuteCommand, foreachCommand, getEnvCmd, getValCmd, historyCommand, HTMLCommand, ifBatchCommand, ifCommand, ifInteractiveCommand, listAliasCommand, loopCommand, macroPathCommand, ManualCommand, maxStoredHistCommand, multiplyCommand, remainderCommand, G4UIcmdWithAString::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), G4UIparameter::SetParameterCandidates(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIparameter::SetParameterRange(), G4UIcommand::SetRange(), G4UIcommand::SetToBeBroadcasted(), shellCommand, stopStoreHistoryCommand, strdoifCommand, strifCommand, subtractCommand, suppressAbortionCommand, unaliasCommand, and verboseCommand.

~G4UIcontrolMessenger()

G4UIcontrolMessenger::~G4UIcontrolMessenger

(

)

Definition at line 374 of file G4UIcontrolMessenger.cc.

{
  delete macroPathCommand;
  delete ExecuteCommand;
  delete suppressAbortionCommand;
  delete verboseCommand;
  delete doublePrecCommand;
  delete historyCommand;
  delete stopStoreHistoryCommand;
  delete ManualCommand;
  delete aliasCommand;
  delete unaliasCommand;
  delete listAliasCommand;
  delete getEnvCmd;
  delete getValCmd;
  delete echoCmd;
  delete shellCommand;
  delete loopCommand;
  delete foreachCommand;
  delete HTMLCommand;
  delete maxStoredHistCommand;
  delete ifCommand;
  delete doifCommand;
  delete addCommand;
  delete subtractCommand;
  delete multiplyCommand;
  delete divideCommand;
  delete remainderCommand;
  delete strifCommand;
  delete strdoifCommand;
  delete ifBatchCommand;
  delete ifInteractiveCommand;
  delete doifBatchCommand;
  delete doifInteractiveCommand;
  delete controlDirectory;
}

References addCommand, aliasCommand, controlDirectory, divideCommand, doifBatchCommand, doifCommand, doifInteractiveCommand, doublePrecCommand, echoCmd, ExecuteCommand, foreachCommand, getEnvCmd, getValCmd, historyCommand, HTMLCommand, ifBatchCommand, ifCommand, ifInteractiveCommand, listAliasCommand, loopCommand, macroPathCommand, ManualCommand, maxStoredHistCommand, multiplyCommand, remainderCommand, shellCommand, stopStoreHistoryCommand, strdoifCommand, strifCommand, subtractCommand, suppressAbortionCommand, unaliasCommand, and verboseCommand.

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 SetNewValue().

GetCurrentValue()

G4String G4UIcontrolMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 767 of file G4UIcontrolMessenger.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4String currentValue;
 
  if(command == macroPathCommand)
  {
    currentValue = UI->GetMacroSearchPath();
  }
  if(command == verboseCommand)
  {
    currentValue = verboseCommand->ConvertToString(UI->GetVerboseLevel());
  }
  if(command == doublePrecCommand)
  {
    currentValue =
      doublePrecCommand->ConvertToString(G4UImanager::DoublePrecisionStr());
  }
  if(command == suppressAbortionCommand)
  {
    currentValue = suppressAbortionCommand->ConvertToString(
      G4StateManager::GetStateManager()->GetSuppressAbortion());
  }
  if(command == maxStoredHistCommand)
  {
    currentValue = maxStoredHistCommand->ConvertToString(UI->GetMaxHistSize());
  }
 
  return currentValue;
}

References G4UIcommand::ConvertToString(), doublePrecCommand, G4UImanager::DoublePrecisionStr(), G4UImanager::GetMacroSearchPath(), G4UImanager::GetMaxHistSize(), G4StateManager::GetStateManager(), G4UImanager::GetUIpointer(), G4UImanager::GetVerboseLevel(), macroPathCommand, maxStoredHistCommand, suppressAbortionCommand, and verboseCommand.

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 G4UIcontrolMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValue  )

virtual

Reimplemented from G4UImessenger.

Definition at line 412 of file G4UIcontrolMessenger.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
 
  if(command == macroPathCommand)
  {
    UI->SetMacroSearchPath(newValue);
    UI->ParseMacroSearchPath();
  }
  if(command == ExecuteCommand)
  {
    command->ResetFailure();
    UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
    if(UI->GetLastReturnCode() != 0)
    {
      G4ExceptionDescription ed;
      ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
      command->CommandFailed(UI->GetLastReturnCode(), ed);
    }
  }
  if(command == suppressAbortionCommand)
  {
    G4StateManager::GetStateManager()->SetSuppressAbortion(
      suppressAbortionCommand->GetNewIntValue(newValue));
  }
  if(command == verboseCommand)
  {
    UI->SetVerboseLevel(verboseCommand->GetNewIntValue(newValue));
  }
  if(command == doublePrecCommand)
  {
    G4UImanager::UseDoublePrecisionStr(
      doublePrecCommand->GetNewBoolValue(newValue));
  }
  if(command == historyCommand)
  {
    UI->StoreHistory(newValue);
  }
  if(command == stopStoreHistoryCommand)
  {
    UI->StoreHistory(false);
  }
  if(command == ManualCommand)
  {
    UI->ListCommands(newValue);
  }
  if(command == aliasCommand)
  {
    UI->SetAlias(newValue);
  }
  if(command == unaliasCommand)
  {
    UI->RemoveAlias(newValue);
  }
  if(command == listAliasCommand)
  {
    UI->ListAlias();
  }
  if(command == getEnvCmd)
  {
    command->ResetFailure();
    if(std::getenv(newValue))
    {
      G4String st = newValue;
      st += " ";
      st += std::getenv(newValue);
      UI->SetAlias(st.c_str());
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "<" << newValue
         << "> is not defined as a shell variable. Command ignored.";
      command->CommandFailed(ed);
    }
  }
  if(command == getValCmd)
  {
    G4Tokenizer next(newValue);
    G4String aliName = next();
    G4String com     = next();
    G4String curVal  = UI->GetCurrentValues(com);
    if(!(curVal.empty()))
    {
      G4String theValue = curVal;
      G4String iIdx     = next();
      if(!(iIdx.empty()))
      {
        G4int idx = StoI(iIdx);
        G4Tokenizer nextVal(curVal);
        for(G4int i = 0; i <= idx; i++)
        {
          theValue = nextVal();
        }
      }
      G4String st = "/control/alias ";
      st += aliName + " " + theValue;
      UI->ApplyCommand(st);
    }
  }
  if(command == echoCmd)
  {
    G4cout << UI->SolveAlias(newValue) << G4endl;
  }
  if(command == shellCommand)
  {
    command->ResetFailure();
    int rc = system(newValue);
    if(rc < 0)
    {
      G4ExceptionDescription ed;
      ed << "<" << newValue
         << "> is not a valid shell command. Command ignored.";
      command->CommandFailed(ed);
    }
  }
  if(command == loopCommand)
  {
    command->ResetFailure();
    UI->LoopS(newValue);
    if(UI->GetLastReturnCode() != 0)
    {
      G4ExceptionDescription ed;
      ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
      command->CommandFailed(UI->GetLastReturnCode(), ed);
    }
  }
  if(command == foreachCommand)
  {
    command->ResetFailure();
    UI->ForeachS(newValue);
    if(UI->GetLastReturnCode() != 0)
    {
      G4ExceptionDescription ed;
      ed << "Command aborted (" << UI->GetLastReturnCode() << ")";
      command->CommandFailed(UI->GetLastReturnCode(), ed);
    }
  }
  if(command == HTMLCommand)
  {
    UI->CreateHTML(newValue);
  }
  if(command == maxStoredHistCommand)
  {
    UI->SetMaxHistSize(maxStoredHistCommand->GetNewIntValue(newValue));
  }
  if(command == ifCommand)
  {
    G4Tokenizer next(newValue);
    G4double l    = StoD(next());
    G4String comp = next();
    G4double r    = StoD(next());
    G4String mac  = next();
    G4bool x      = false;
    if(comp == ">")
      x = (l > r);
    else if(comp == ">=")
      x = (l >= r);
    else if(comp == "<")
      x = (l < r);
    else if(comp == "<=")
      x = (l <= r);
    else if(comp == "==")
      x = (l == r);
    else if(comp == "!=")
      x = (l != r);
    if(x)
      UI->ExecuteMacroFile(mac);
  }
  if(command == doifCommand)
  {
    G4Tokenizer next(newValue);
    G4double l    = StoD(next());
    G4String comp = next();
    G4double r    = StoD(next());
 
    G4String c1 = next();
    G4String ca;
    while(!((ca = next()).empty()))
    {
      c1 += " ";
      c1 += ca;
    }
    if(c1[0] == '"')
    {
      G4String strippedValue;
      if(c1.back() == '"')
      {
        strippedValue = c1.substr(1, c1.length() - 2);
      }
      else
      {
        strippedValue = c1.substr(1, c1.length() - 1);
      }
      c1 = strippedValue;
    }
 
    G4bool x = false;
    if(comp == ">")
      x = (l > r);
    else if(comp == ">=")
      x = (l >= r);
    else if(comp == "<")
      x = (l < r);
    else if(comp == "<=")
      x = (l <= r);
    else if(comp == "==")
      x = (l == r);
    else if(comp == "!=")
      x = (l != r);
    if(x)
      UI->ApplyCommand(c1);
  }
  if(command == addCommand)
  {
    G4Tokenizer next(newValue);
    G4String newA = next();
    G4double l    = StoD(next());
    G4double r    = StoD(next());
    G4String st   = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l + r);
    UI->ApplyCommand(st);
  }
  if(command == subtractCommand)
  {
    G4Tokenizer next(newValue);
    G4String newA = next();
    G4double l    = StoD(next());
    G4double r    = StoD(next());
    G4String st   = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l - r);
    UI->ApplyCommand(st);
  }
  if(command == multiplyCommand)
  {
    G4Tokenizer next(newValue);
    G4String newA = next();
    G4double l    = StoD(next());
    G4double r    = StoD(next());
    G4String st   = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l * r);
    UI->ApplyCommand(st);
  }
  if(command == divideCommand)
  {
    G4Tokenizer next(newValue);
    G4String newA = next();
    G4double l    = StoD(next());
    G4double r    = StoD(next());
    G4String st   = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l / r);
    UI->ApplyCommand(st);
  }
  if(command == remainderCommand)
  {
    G4Tokenizer next(newValue);
    G4String newA = next();
    G4int l       = StoI(next());
    G4int r       = StoI(next());
    G4String st   = "/control/alias ";
    st += newA;
    st += " ";
    st += DtoS(l % r);
    UI->ApplyCommand(st);
  }
  if(command == strifCommand)
  {
    G4Tokenizer next(newValue);
    G4String l    = next();
    G4String comp = next();
    G4String r    = next();
    G4String mac  = next();
    G4bool x      = false;
    if(comp == "==")
    {
      x = (l == r);
    }
    else if(comp == "!=")
    {
      x = (l != r);
    }
    if(x)
      UI->ExecuteMacroFile(mac);
  }
  if(command == strdoifCommand)
  {
    G4Tokenizer next(newValue);
    G4String l    = next();
    G4String comp = next();
    G4String r    = next();
 
    G4String c1 = next();
    G4String ca;
    while(!((ca = next()).empty()))
    {
      c1 += " ";
      c1 += ca;
    }
    if(c1[0] == '"')
    {
      G4String strippedValue;
      if(c1.back() == '"')
      {
        strippedValue = c1.substr(1, c1.length() - 2);
      }
      else
      {
        strippedValue = c1.substr(1, c1.length() - 1);
      }
      c1 = strippedValue;
    }
 
    G4bool x = false;
    if(comp == "==")
    {
      x = (l == r);
    }
    else if(comp == "!=")
    {
      x = (l != r);
    }
    if(x)
      UI->ApplyCommand(c1);
  }
  if(command == ifBatchCommand)
  {
    if(G4UIsession::InSession() == 0)
      UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
  }
  if(command == ifInteractiveCommand)
  {
    if(G4UIsession::InSession() > 0)
      UI->ExecuteMacroFile(UI->FindMacroPath(newValue));
  }
  if(command == doifBatchCommand)
  {
    if(G4UIsession::InSession() == 0)
      UI->ApplyCommand(newValue);
  }
  if(command == doifInteractiveCommand)
  {
    if(G4UIsession::InSession() > 0)
      UI->ApplyCommand(newValue);
  }
}

References addCommand, aliasCommand, G4UImanager::ApplyCommand(), G4UIcommand::CommandFailed(), G4UImanager::CreateHTML(), divideCommand, doifBatchCommand, doifCommand, doifInteractiveCommand, doublePrecCommand, G4UImessenger::DtoS(), echoCmd, anonymous_namespace{G4MTcoutDestination.cc}::empty, ExecuteCommand, G4UImanager::ExecuteMacroFile(), G4UImanager::FindMacroPath(), foreachCommand, G4UImanager::ForeachS(), G4cout, G4endl, G4UImanager::GetCurrentValues(), getEnvCmd, G4UImanager::GetLastReturnCode(), G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithAnInteger::GetNewIntValue(), G4StateManager::GetStateManager(), G4UImanager::GetUIpointer(), getValCmd, historyCommand, HTMLCommand, ifBatchCommand, ifCommand, ifInteractiveCommand, G4UIsession::InSession(), G4UImanager::ListAlias(), listAliasCommand, G4UImanager::ListCommands(), loopCommand, G4UImanager::LoopS(), macroPathCommand, ManualCommand, maxStoredHistCommand, multiplyCommand, G4UImanager::ParseMacroSearchPath(), remainderCommand, G4UImanager::RemoveAlias(), G4UIcommand::ResetFailure(), G4UImanager::SetAlias(), G4UImanager::SetMacroSearchPath(), G4UImanager::SetMaxHistSize(), G4StateManager::SetSuppressAbortion(), G4UImanager::SetVerboseLevel(), shellCommand, G4UImanager::SolveAlias(), G4UImessenger::StoD(), G4UImessenger::StoI(), stopStoreHistoryCommand, G4UImanager::StoreHistory(), strdoifCommand, strifCommand, subtractCommand, suppressAbortionCommand, unaliasCommand, G4UImanager::UseDoublePrecisionStr(), and verboseCommand.

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(), 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(), 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 G4RunMessenger::SetNewValue().

Field Documentation

addCommand

G4UIcommand* G4UIcontrolMessenger::addCommand = nullptr

private

Definition at line 113 of file G4UIcontrolMessenger.hh.

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

aliasCommand

G4UIcommand* G4UIcontrolMessenger::aliasCommand = nullptr

private

Definition at line 99 of file G4UIcontrolMessenger.hh.

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

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

commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

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

controlDirectory

G4UIdirectory* G4UIcontrolMessenger::controlDirectory = nullptr

private

Definition at line 91 of file G4UIcontrolMessenger.hh.

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

divideCommand

G4UIcommand* G4UIcontrolMessenger::divideCommand = nullptr

private

Definition at line 116 of file G4UIcontrolMessenger.hh.

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

doifBatchCommand

G4UIcmdWithAString* G4UIcontrolMessenger::doifBatchCommand = nullptr

private

Definition at line 122 of file G4UIcontrolMessenger.hh.

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

doifCommand

G4UIcommand* G4UIcontrolMessenger::doifCommand = nullptr

private

Definition at line 112 of file G4UIcontrolMessenger.hh.

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

doifInteractiveCommand

G4UIcmdWithAString* G4UIcontrolMessenger::doifInteractiveCommand = nullptr

private

Definition at line 123 of file G4UIcontrolMessenger.hh.

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

doublePrecCommand

G4UIcmdWithABool* G4UIcontrolMessenger::doublePrecCommand = nullptr

private

Definition at line 96 of file G4UIcontrolMessenger.hh.

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

echoCmd

G4UIcmdWithAString* G4UIcontrolMessenger::echoCmd = nullptr

private

Definition at line 104 of file G4UIcontrolMessenger.hh.

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

ExecuteCommand

G4UIcmdWithAString* G4UIcontrolMessenger::ExecuteCommand = nullptr

private

Definition at line 93 of file G4UIcontrolMessenger.hh.

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

foreachCommand

G4UIcommand* G4UIcontrolMessenger::foreachCommand = nullptr

private

Definition at line 107 of file G4UIcontrolMessenger.hh.

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

getEnvCmd

G4UIcmdWithAString* G4UIcontrolMessenger::getEnvCmd = nullptr

private

Definition at line 102 of file G4UIcontrolMessenger.hh.

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

getValCmd

G4UIcommand* G4UIcontrolMessenger::getValCmd = nullptr

private

Definition at line 103 of file G4UIcontrolMessenger.hh.

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

historyCommand

G4UIcmdWithAString* G4UIcontrolMessenger::historyCommand = nullptr

private

Definition at line 97 of file G4UIcontrolMessenger.hh.

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

HTMLCommand

G4UIcmdWithAString* G4UIcontrolMessenger::HTMLCommand = nullptr

private

Definition at line 109 of file G4UIcontrolMessenger.hh.

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

ifBatchCommand

G4UIcmdWithAString* G4UIcontrolMessenger::ifBatchCommand = nullptr

private

Definition at line 120 of file G4UIcontrolMessenger.hh.

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

ifCommand

G4UIcommand* G4UIcontrolMessenger::ifCommand = nullptr

private

Definition at line 111 of file G4UIcontrolMessenger.hh.

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

ifInteractiveCommand

G4UIcmdWithAString* G4UIcontrolMessenger::ifInteractiveCommand = nullptr

private

Definition at line 121 of file G4UIcontrolMessenger.hh.

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

listAliasCommand

G4UIcmdWithoutParameter* G4UIcontrolMessenger::listAliasCommand = nullptr

private

Definition at line 101 of file G4UIcontrolMessenger.hh.

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

loopCommand

G4UIcommand* G4UIcontrolMessenger::loopCommand = nullptr

private

Definition at line 106 of file G4UIcontrolMessenger.hh.

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

macroPathCommand

G4UIcmdWithAString* G4UIcontrolMessenger::macroPathCommand = nullptr

private

Definition at line 92 of file G4UIcontrolMessenger.hh.

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

ManualCommand

G4UIcmdWithAString* G4UIcontrolMessenger::ManualCommand = nullptr

private

Definition at line 108 of file G4UIcontrolMessenger.hh.

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

maxStoredHistCommand

G4UIcmdWithAnInteger* G4UIcontrolMessenger::maxStoredHistCommand = nullptr

private

Definition at line 110 of file G4UIcontrolMessenger.hh.

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

multiplyCommand

G4UIcommand* G4UIcontrolMessenger::multiplyCommand = nullptr

private

Definition at line 115 of file G4UIcontrolMessenger.hh.

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

remainderCommand

G4UIcommand* G4UIcontrolMessenger::remainderCommand = nullptr

private

Definition at line 117 of file G4UIcontrolMessenger.hh.

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

shellCommand

G4UIcmdWithAString* G4UIcontrolMessenger::shellCommand = nullptr

private

Definition at line 105 of file G4UIcontrolMessenger.hh.

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

stopStoreHistoryCommand

G4UIcmdWithoutParameter* G4UIcontrolMessenger::stopStoreHistoryCommand = nullptr

private

Definition at line 98 of file G4UIcontrolMessenger.hh.

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

strdoifCommand

G4UIcommand* G4UIcontrolMessenger::strdoifCommand = nullptr

private

Definition at line 119 of file G4UIcontrolMessenger.hh.

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

strifCommand

G4UIcommand* G4UIcontrolMessenger::strifCommand = nullptr

private

Definition at line 118 of file G4UIcontrolMessenger.hh.

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

subtractCommand

G4UIcommand* G4UIcontrolMessenger::subtractCommand = nullptr

private

Definition at line 114 of file G4UIcontrolMessenger.hh.

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

suppressAbortionCommand

G4UIcmdWithAnInteger* G4UIcontrolMessenger::suppressAbortionCommand = nullptr

private

Definition at line 94 of file G4UIcontrolMessenger.hh.

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

unaliasCommand

G4UIcmdWithAString* G4UIcontrolMessenger::unaliasCommand = nullptr

private

Definition at line 100 of file G4UIcontrolMessenger.hh.

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

verboseCommand

G4UIcmdWithAnInteger* G4UIcontrolMessenger::verboseCommand = nullptr

private

Definition at line 95 of file G4UIcontrolMessenger.hh.

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

---

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

• source/intercoms/include/G4UIcontrolMessenger.hh
• source/intercoms/src/G4UIcontrolMessenger.cc