df/dcf/_g4_u_icontrol_messenger_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * Neither the authors of this software system, nor their employing *

 // * institutes,nor the agencies providing financial support for this *

 // * work  make  any representation or  warranty, express or implied, *

 // * regarding  this  software system or assume any liability for its *

 // * use.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 //

 // $Id: G4UIcontrolMessenger.cc 68725 2013-04-05 09:27:45Z gcosmo $

 //


 #include <stdlib.h>

 #include "G4UIcontrolMessenger.hh"

 #include "G4UImanager.hh"

 #include "G4UIdirectory.hh"

 #include "G4UIcommand.hh"

 #include "G4UIparameter.hh"

 #include "G4UIcmdWithAString.hh"

 #include "G4UIcmdWithAnInteger.hh"

 #include "G4UIcmdWithoutParameter.hh"

 #include "G4UIaliasList.hh"

 #include "G4StateManager.hh"

 #include "G4Tokenizer.hh"


 #include "G4ios.hh"


 G4UIcontrolMessenger::G4UIcontrolMessenger()

 {

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


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


   stopStoreHistoryCommand

     = new G4UIcmdWithoutParameter("/control/stopSavingHistory",this);

   stopStoreHistoryCommand->SetGuidance("Stop saving history file.");


   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("parenthis \"{\" 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.");


   echoCmd = new G4UIcmdWithAString("/control/echo",this);

   echoCmd->SetGuidance("Display the aliased value.");


   shellCommand = new G4UIcmdWithAString("/control/shell",this);

   shellCommand->SetGuidance("Execute a (Unix) SHELL command.");


   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("aliasValue",'s',false);

   ifCommand->SetParameter(macroFileParam);

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


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


   multiplyCommand = new G4UIcommand("/control/multiply",this);

   multiplyCommand->SetGuidance("Define a new alias as the multiplification 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);


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


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


 }


 G4UIcontrolMessenger::~G4UIcontrolMessenger()

 {

   delete macroPathCommand;

   delete ExecuteCommand;

   delete suppressAbortionCommand;

   delete verboseCommand;

   delete historyCommand;

   delete stopStoreHistoryCommand;

   delete ManualCommand;

   delete aliasCommand;

   delete unaliasCommand;

   delete listAliasCommand;

   delete getEnvCmd;

   delete echoCmd;

   delete shellCommand;

   delete loopCommand;

   delete foreachCommand;

   delete HTMLCommand;

   delete maxStoredHistCommand;

   delete ifCommand;

   delete addCommand;

   delete subtractCommand;

   delete multiplyCommand;

   delete divideCommand;

   delete remainderCommand;


   delete controlDirectory;

 }


 void G4UIcontrolMessenger::SetNewValue(G4UIcommand * command,G4String newValue)

 {

   G4UImanager * UI = G4UImanager::GetUIpointer();


   if( command == macroPathCommand) {

     UI-> SetMacroSearchPath(newValue);

     UI-> ParseMacroSearchPath();

   }

   if(command==ExecuteCommand)

   {

     UI-> ExecuteMacroFile(UI-> FindMacroPath(newValue));

   }

   if(command==suppressAbortionCommand)

   {

     G4StateManager::GetStateManager()->SetSuppressAbortion(suppressAbortionCommand->GetNewIntValue(newValue));

   }

   if(command==verboseCommand)

   {

     UI->SetVerboseLevel(verboseCommand->GetNewIntValue(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)

   {

     if(getenv(newValue))

     {

       G4String st = "/control/alias ";

       st += newValue;

       st += " ";

       st += getenv(newValue);

       UI->ApplyCommand(st);

     }

     else

     { G4cerr << "<" << newValue << "> is not defined as a shell variable. Command ignored." << G4endl; }

   }

   if(command==echoCmd)

   { G4cout << UI->SolveAlias(newValue) << G4endl; }

   if(command==shellCommand)

   {

     system(newValue);

   }

   if(command==loopCommand)

   {

     UI->LoopS(newValue);

   }

   if(command==foreachCommand)

   {

     UI->ForeachS(newValue);

   }

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

   }

 }


 G4String G4UIcontrolMessenger::GetCurrentValue(G4UIcommand * command)

 {

   G4UImanager * UI = G4UImanager::GetUIpointer();

   G4String currentValue;


   if( command == macroPathCommand ) {

     currentValue = UI-> GetMacroSearchPath();

   }

   if(command==verboseCommand)

   {

     currentValue = verboseCommand->ConvertToString(UI->GetVerboseLevel());

   }

   if(command==suppressAbortionCommand)

   {

     currentValue = suppressAbortionCommand->ConvertToString(G4StateManager::GetStateManager()->GetSuppressAbortion());

   }

   if(command==maxStoredHistCommand)

   {

     currentValue = maxStoredHistCommand->ConvertToString(UI->GetMaxHistSize());

   }


   return currentValue;

 }


G4UImanager::ForeachS
void ForeachS(const char *valueList)
Definition: G4UImanager.cc:331

G4UIcmdWithAString::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAString.cc:42

G4UImanager::ExecuteMacroFile
void ExecuteMacroFile(const char *fileName)
Definition: G4UImanager.cc:278

G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152

G4UImanager::RemoveAlias
void RemoveAlias(const char *aliasName)
Definition: G4UImanager.cc:629

G4UIcontrolMessenger::verboseCommand
G4UIcmdWithAnInteger * verboseCommand
Definition: G4UIcontrolMessenger.hh:82

G4UIcontrolMessenger::ManualCommand
G4UIcmdWithAString * ManualCommand
Definition: G4UIcontrolMessenger.hh:93

G4UImanager::SetAlias
void SetAlias(const char *aliasLine)
Definition: G4UImanager.cc:610

G4UIcontrolMessenger::HTMLCommand
G4UIcmdWithAString * HTMLCommand
Definition: G4UIcontrolMessenger.hh:94

G4UIcontrolMessenger::~G4UIcontrolMessenger
~G4UIcontrolMessenger()
Definition: G4UIcontrolMessenger.cc:244

G4UIdirectory
Definition: G4UIdirectory.hh:41

G4UIcontrolMessenger::G4UIcontrolMessenger
G4UIcontrolMessenger()
Definition: G4UIcontrolMessenger.cc:45

G4UIdirectory.hh

G4UIcmdWithAnInteger::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAnInteger.cc:47

G4UIcmdWithAnInteger::GetNewIntValue
static G4int GetNewIntValue(const char *paramString)
Definition: G4UIcmdWithAnInteger.cc:41

G4UIcontrolMessenger::suppressAbortionCommand
G4UIcmdWithAnInteger * suppressAbortionCommand
Definition: G4UIcontrolMessenger.hh:81

G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:95

G4UIparameter::SetParameterCandidates
void SetParameterCandidates(const char *theString)
Definition: G4UIparameter.hh:113

G4UIcontrolMessenger::maxStoredHistCommand
G4UIcmdWithAnInteger * maxStoredHistCommand
Definition: G4UIcontrolMessenger.hh:95

G4UIcontrolMessenger::SetNewValue
void SetNewValue(G4UIcommand *command, G4String newValue)
Definition: G4UIcontrolMessenger.cc:273

G4UIcontrolMessenger::macroPathCommand
G4UIcmdWithAString * macroPathCommand
Definition: G4UIcontrolMessenger.hh:79

G4UIcommand::SetToBeBroadcasted
void SetToBeBroadcasted(G4bool val)
Definition: G4UIcommand.hh:184

G4UIcontrolMessenger::shellCommand
G4UIcmdWithAString * shellCommand
Definition: G4UIcontrolMessenger.hh:90

G4UIcmdWithAString.hh

G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:83

G4UIcommand::ConvertToString
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:357

G4UImanager::GetVerboseLevel
G4int GetVerboseLevel() const
Definition: G4UImanager.hh:227

G4int
int G4int
Definition: G4Types.hh:78

G4UImanager::SetVerboseLevel
void SetVerboseLevel(G4int val)
Definition: G4UImanager.hh:225

G4Tokenizer.hh

G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58

G4StateManager::SetSuppressAbortion
void SetSuppressAbortion(G4int i)

G4StateManager::GetStateManager
static G4StateManager * GetStateManager()
Definition: G4StateManager.cc:131

G4UIcommand
Definition: G4UIcommand.hh:51

G4UIcontrolMessenger::controlDirectory
G4UIdirectory * controlDirectory
Definition: G4UIcontrolMessenger.hh:78

G4cout
G4GLOB_DLL std::ostream G4cout

G4UIcommand.hh

G4UIaliasList.hh

G4bool
bool G4bool
Definition: G4Types.hh:79

G4UIcommand::SetRange
void SetRange(const char *rs)
Definition: G4UIcommand.hh:125

G4UIparameter.hh

G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161

G4UIcontrolMessenger::getEnvCmd
G4UIcmdWithAString * getEnvCmd
Definition: G4UIcontrolMessenger.hh:88

G4UIcontrolMessenger::historyCommand
G4UIcmdWithAString * historyCommand
Definition: G4UIcontrolMessenger.hh:83

G4UIcontrolMessenger::addCommand
G4UIcommand * addCommand
Definition: G4UIcontrolMessenger.hh:97

G4UIcontrolMessenger::echoCmd
G4UIcmdWithAString * echoCmd
Definition: G4UIcontrolMessenger.hh:89

G4UIcmdWithAnInteger
Definition: G4UIcmdWithAnInteger.hh:41

G4UImanager.hh

G4UImessenger::DtoS
G4String DtoS(G4double a)
Definition: G4UImessenger.cc:75

G4UIcontrolMessenger::subtractCommand
G4UIcommand * subtractCommand
Definition: G4UIcontrolMessenger.hh:98

G4UIcmdWithoutParameter
Definition: G4UIcmdWithoutParameter.hh:41

G4UImessenger::StoI
G4int StoI(G4String s)
Definition: G4UImessenger.cc:89

G4UIcontrolMessenger::multiplyCommand
G4UIcommand * multiplyCommand
Definition: G4UIcontrolMessenger.hh:99

G4UIparameter
Definition: G4UIparameter.hh:47

G4UImanager::SetMaxHistSize
void SetMaxHistSize(G4int mx)
Definition: G4UImanager.hh:238

G4UImanager::ListCommands
void ListCommands(const char *direc)
Definition: G4UImanager.cc:537

G4UIcontrolMessenger::foreachCommand
G4UIcommand * foreachCommand
Definition: G4UIcontrolMessenger.hh:92

G4UIcontrolMessenger::aliasCommand
G4UIcommand * aliasCommand
Definition: G4UIcontrolMessenger.hh:85

G4UIcontrolMessenger::GetCurrentValue
G4String GetCurrentValue(G4UIcommand *command)
Definition: G4UIcontrolMessenger.cc:430

G4UIcmdWithAString
Definition: G4UIcmdWithAString.hh:42

G4UIcontrolMessenger::ifCommand
G4UIcommand * ifCommand
Definition: G4UIcontrolMessenger.hh:96

G4UIcmdWithAString::SetDefaultValue
void SetDefaultValue(const char *defVal)
Definition: G4UIcmdWithAString.cc:57

G4UImessenger::StoD
G4double StoD(G4String s)
Definition: G4UImessenger.cc:98

G4UIcontrolMessenger::stopStoreHistoryCommand
G4UIcmdWithoutParameter * stopStoreHistoryCommand
Definition: G4UIcontrolMessenger.hh:84

G4ios.hh

G4UIcontrolMessenger::listAliasCommand
G4UIcmdWithoutParameter * listAliasCommand
Definition: G4UIcontrolMessenger.hh:87

G4UImanager::SolveAlias
G4String SolveAlias(const char *aCmd)
Definition: G4UImanager.cc:377

G4StateManager.hh

G4UIcmdWithAnInteger.hh

G4UImanager::ListAlias
void ListAlias()
Definition: G4UImanager.cc:636

G4UImanager
Definition: G4UImanager.hh:56

G4endl
#define G4endl
Definition: G4ios.hh:61

G4Tokenizer
Definition: G4Tokenizer.hh:48

G4UImanager::LoopS
void LoopS(const char *valueList)
Definition: G4UImanager.cc:287

G4UIcmdWithAnInteger::SetDefaultValue
void SetDefaultValue(G4int defVal)
Definition: G4UIcmdWithAnInteger.cc:55

G4UIcontrolMessenger::divideCommand
G4UIcommand * divideCommand
Definition: G4UIcontrolMessenger.hh:100

G4double
double G4double
Definition: G4Types.hh:76

G4UImanager::CreateHTML
void CreateHTML(const char *dir="/")
Definition: G4UImanager.cc:641

G4UIcontrolMessenger::loopCommand
G4UIcommand * loopCommand
Definition: G4UIcontrolMessenger.hh:91

G4UIcontrolMessenger::remainderCommand
G4UIcommand * remainderCommand
Definition: G4UIcontrolMessenger.hh:101

G4UIcmdWithoutParameter.hh

G4UIcontrolMessenger.hh

G4UIcontrolMessenger::unaliasCommand
G4UIcmdWithAString * unaliasCommand
Definition: G4UIcontrolMessenger.hh:86

G4UImanager::StoreHistory
void StoreHistory(const char *fileName="G4history.macro")
Definition: G4UImanager.cc:512

G4UIcontrolMessenger::ExecuteCommand
G4UIcmdWithAString * ExecuteCommand
Definition: G4UIcontrolMessenger.hh:80

G4UImanager::ApplyCommand
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:432

G4cerr
G4GLOB_DLL std::ostream G4cerr

G4UImanager::GetMaxHistSize
G4int GetMaxHistSize() const
Definition: G4UImanager.hh:240

G4String
Definition: G4String.hh:45