Geant4  10.02.p01
G4UIcontrolMessenger.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4UIcontrolMessenger.cc 80641 2014-05-05 15:10:28Z gcosmo $
28 //
29 
30 #include <stdlib.h>
31 #include "G4UIcontrolMessenger.hh"
32 #include "G4UImanager.hh"
33 #include "G4UIdirectory.hh"
34 #include "G4UIcommand.hh"
35 #include "G4UIparameter.hh"
36 #include "G4UIcmdWithAString.hh"
37 #include "G4UIcmdWithAnInteger.hh"
39 #include "G4UIaliasList.hh"
40 #include "G4StateManager.hh"
41 #include "G4Tokenizer.hh"
42 
43 #include "G4ios.hh"
44 
46 {
47  controlDirectory = new G4UIdirectory("/control/");
48  controlDirectory->SetGuidance("UI control commands.");
49 
50  macroPathCommand = new G4UIcmdWithAString("/control/macroPath",this);
51  macroPathCommand->SetGuidance("Set macro search path"
52  "with colon-separated list.");
53  macroPathCommand->SetParameterName("path",false);
54 
55  ExecuteCommand = new G4UIcmdWithAString("/control/execute",this);
56  ExecuteCommand->SetGuidance("Execute a macro file.");
57  ExecuteCommand->SetParameterName("fileName",false);
59 
60  loopCommand = new G4UIcommand("/control/loop",this);
61  loopCommand->SetGuidance("Execute a macro file more than once.");
62  loopCommand->SetGuidance("Loop counter can be used as an aliased variable.");
63  G4UIparameter* param1 = new G4UIparameter("macroFile",'s',false);
64  loopCommand->SetParameter(param1);
65  G4UIparameter* param2 = new G4UIparameter("counterName",'s',false);
66  loopCommand->SetParameter(param2);
67  G4UIparameter* param3 = new G4UIparameter("initialValue",'d',false);
68  loopCommand->SetParameter(param3);
69  G4UIparameter* param4 = new G4UIparameter("finalValue",'d',false);
70  loopCommand->SetParameter(param4);
71  G4UIparameter* param5 = new G4UIparameter("stepSize",'d',true);
72  param5->SetDefaultValue(1.0);
73  loopCommand->SetParameter(param5);
75 
76  foreachCommand = new G4UIcommand("/control/foreach",this);
77  foreachCommand->SetGuidance("Execute a macro file more than once.");
78  foreachCommand->SetGuidance("Loop counter can be used as an aliased variable.");
79  foreachCommand->SetGuidance("Values must be separated by a space.");
80  G4UIparameter* param6 = new G4UIparameter("macroFile",'s',false);
82  G4UIparameter* param7 = new G4UIparameter("counterName",'s',false);
84  G4UIparameter* param8 = new G4UIparameter("valueList",'s',false);
87 
88  suppressAbortionCommand = new G4UIcmdWithAnInteger("/control/suppressAbortion",this);
89  suppressAbortionCommand->SetGuidance("Suppress the program abortion caused by G4Exception.");
90  suppressAbortionCommand->SetGuidance("Suppression level = 0 : no suppression");
91  suppressAbortionCommand->SetGuidance(" = 1 : suppress during EventProc state");
92  suppressAbortionCommand->SetGuidance(" = 2 : full suppression, i.e. no abortion by G4Exception");
93  suppressAbortionCommand->SetGuidance("When abortion is suppressed, you will get error messages issued by G4Exception,");
94  suppressAbortionCommand->SetGuidance("and there is NO guarantee for the correct result after the G4Exception error message.");
96  suppressAbortionCommand->SetRange("level >= 0 && level <= 2");
98 
99  verboseCommand = new G4UIcmdWithAnInteger("/control/verbose",this);
100  verboseCommand->SetGuidance("Applied command will also be shown on screen.");
101  verboseCommand->SetGuidance("This command is useful with MACRO file.");
102  verboseCommand->SetGuidance(" 0 : silent");
103  verboseCommand->SetGuidance(" 1 : only the valid commands are shown.");
104  verboseCommand->SetGuidance(" 2 : comment lines are also shown (default).");
105  verboseCommand->SetParameterName("switch",true);
106  verboseCommand->SetRange("switch >= 0 && switch <=2");
108 
109  historyCommand = new G4UIcmdWithAString("/control/saveHistory",this);
110  historyCommand->SetGuidance("Store command history to a file.");
111  historyCommand->SetGuidance("Defaul file name is G4history.macro.");
112  historyCommand->SetParameterName("fileName",true);
113  historyCommand->SetDefaultValue("G4History.macro");
114 
116  = new G4UIcmdWithoutParameter("/control/stopSavingHistory",this);
117  stopStoreHistoryCommand->SetGuidance("Stop saving history file.");
118 
119  aliasCommand = new G4UIcommand("/control/alias",this);
120  aliasCommand->SetGuidance("Set an alias.");
121  aliasCommand->SetGuidance("String can be aliased by this command.");
122  aliasCommand->SetGuidance("The string may contain one or more spaces,");
123  aliasCommand->SetGuidance("the string must be enclosed by double quotes (\").");
124  aliasCommand->SetGuidance("To use an alias, enclose the alias name with");
125  aliasCommand->SetGuidance("parenthis \"{\" and \"}\".");
126  G4UIparameter* aliasNameParam = new G4UIparameter("aliasName",'s',false);
127  aliasCommand->SetParameter(aliasNameParam);
128  G4UIparameter* aliasValueParam = new G4UIparameter("aliasValue",'s',false);
129  aliasCommand->SetParameter(aliasValueParam);
130 
131  unaliasCommand = new G4UIcmdWithAString("/control/unalias",this);
132  unaliasCommand->SetGuidance("Remove an alias.");
133  unaliasCommand->SetParameterName("aliasName",false);
134 
135  listAliasCommand = new G4UIcmdWithoutParameter("/control/listAlias",this);
136  listAliasCommand->SetGuidance("List aliases.");
137 
138  getEnvCmd = new G4UIcmdWithAString("/control/getEnv",this);
139  getEnvCmd->SetGuidance("Get a shell environment variable and define it as an alias.");
140 
141  getValCmd = new G4UIcommand("/control/getVal",this);
142  getValCmd->SetGuidance("Get the current value of the UI command and define it as an alias.");
143  getValCmd->SetGuidance("Command is ignored if the UI command does not support GetCurrentValue().");
144  getValCmd->SetGuidance(" Syntax : <alias_name> <UI_command>");
145  G4UIparameter* aliName = new G4UIparameter("alias_name",'s',false);
146  getValCmd->SetParameter(aliName);
147  G4UIparameter* comName = new G4UIparameter("UI_command",'s',false);
148  getValCmd->SetParameter(comName);
149 
150  echoCmd = new G4UIcmdWithAString("/control/echo",this);
151  echoCmd->SetGuidance("Display the aliased value.");
152 
153  shellCommand = new G4UIcmdWithAString("/control/shell",this);
154  shellCommand->SetGuidance("Execute a (Unix) SHELL command.");
155 
156  ManualCommand = new G4UIcmdWithAString("/control/manual",this);
157  ManualCommand->SetGuidance("Display all of sub-directories and commands.");
158  ManualCommand->SetGuidance("Directory path should be given by FULL-PATH.");
159  ManualCommand->SetParameterName("dirPath",true);
162 
163  HTMLCommand = new G4UIcmdWithAString("/control/createHTML",this);
164  HTMLCommand->SetGuidance("Generate HTML files for all of sub-directories and commands.");
165  HTMLCommand->SetGuidance("Directory path should be given by FULL-PATH.");
166  HTMLCommand->SetParameterName("dirPath",true);
169 
170  maxStoredHistCommand = new G4UIcmdWithAnInteger("/control/maximumStoredHistory",this);
171  maxStoredHistCommand->SetGuidance("Set maximum number of stored UI commands.");
174 
175  ifCommand = new G4UIcommand("/control/if",this);
176  ifCommand->SetGuidance("Execute a macro file if the expression is true.");
177  ifCommand->SetGuidance(" Syntax : <double> <comp> <double> <macro_file>");
178  G4UIparameter* leftParam = new G4UIparameter("left",'d',false);
179  ifCommand->SetParameter(leftParam);
180  G4UIparameter* compParam = new G4UIparameter("comp",'s',false);
181  compParam->SetParameterCandidates("> >= < <= == !=");
182  ifCommand->SetParameter(compParam);
183  G4UIparameter* rightParam = new G4UIparameter("right",'d',false);
184  ifCommand->SetParameter(rightParam);
185  G4UIparameter* macroFileParam = new G4UIparameter("aliasValue",'s',false);
186  ifCommand->SetParameter(macroFileParam);
188 
189  doifCommand = new G4UIcommand("/control/doif",this);
190  doifCommand->SetGuidance("Execute a macro file if the expression is true.");
191  doifCommand->SetGuidance(" Syntax : <double> <comp> <double> <UI_command>");
192  G4UIparameter* doleftParam = new G4UIparameter("left",'d',false);
193  doifCommand->SetParameter(doleftParam);
194  G4UIparameter* docompParam = new G4UIparameter("comp",'s',false);
195  docompParam->SetParameterCandidates("> >= < <= == !=");
196  doifCommand->SetParameter(docompParam);
197  G4UIparameter* dorightParam = new G4UIparameter("right",'d',false);
198  doifCommand->SetParameter(dorightParam);
199  G4UIparameter* comParam = new G4UIparameter("UI_command",'s',false);
200  doifCommand->SetParameter(comParam);
202 
203  addCommand = new G4UIcommand("/control/add",this);
204  addCommand->SetGuidance("Define a new alias as the sum of two values.");
205  addCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
206  addCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
207  addCommand->SetGuidance(" aliased value is alternated.");
208  G4UIparameter* newAlias1 = new G4UIparameter("new_alias",'s',false);
209  addCommand->SetParameter(newAlias1);
210  G4UIparameter* val1a = new G4UIparameter("value1",'d',false);
211  addCommand->SetParameter(val1a);
212  G4UIparameter* val1b = new G4UIparameter("value2",'d',false);
213  addCommand->SetParameter(val1b);
215 
216  subtractCommand = new G4UIcommand("/control/subtract",this);
217  subtractCommand->SetGuidance("Define a new alias as the subtraction of two values.");
218  subtractCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
219  subtractCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
220  subtractCommand->SetGuidance(" aliased value is alternated.");
221  G4UIparameter* newAlias2 = new G4UIparameter("new_alias",'s',false);
222  subtractCommand->SetParameter(newAlias2);
223  G4UIparameter* val2a = new G4UIparameter("value1",'d',false);
225  G4UIparameter* val2b = new G4UIparameter("value2",'d',false);
228 
229  multiplyCommand = new G4UIcommand("/control/multiply",this);
230  multiplyCommand->SetGuidance("Define a new alias as the multiplification of two values.");
231  multiplyCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
232  multiplyCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
233  multiplyCommand->SetGuidance(" aliased value is alternated.");
234  G4UIparameter* newAlias3 = new G4UIparameter("new_alias",'s',false);
235  multiplyCommand->SetParameter(newAlias3);
236  G4UIparameter* val3a = new G4UIparameter("value1",'d',false);
238  G4UIparameter* val3b = new G4UIparameter("value2",'d',false);
241 
242  divideCommand = new G4UIcommand("/control/divide",this);
243  divideCommand->SetGuidance("Define a new alias as the division of two values.");
244  divideCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
245  divideCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
246  divideCommand->SetGuidance(" aliased value is alternated.");
247  G4UIparameter* newAlias4 = new G4UIparameter("new_alias",'s',false);
248  divideCommand->SetParameter(newAlias4);
249  G4UIparameter* val4a = new G4UIparameter("value1",'d',false);
250  divideCommand->SetParameter(val4a);
251  G4UIparameter* val4b = new G4UIparameter("value2",'d',false);
252  val4b->SetParameterRange("value2 != 0.");
253  divideCommand->SetParameter(val4b);
255 
256  remainderCommand = new G4UIcommand("/control/remainder",this);
257  remainderCommand->SetGuidance("Define a new alias as the remainder of two values.");
258  remainderCommand->SetGuidance(" Syntax : <new_alias> <value1> <value2>");
259  remainderCommand->SetGuidance(" <new_alias> may be an already existing alias. If it is the case,");
260  remainderCommand->SetGuidance(" aliased value is alternated.");
261  G4UIparameter* newAlias5 = new G4UIparameter("new_alias",'s',false);
262  remainderCommand->SetParameter(newAlias5);
263  G4UIparameter* val5a = new G4UIparameter("value1",'i',false);
265  G4UIparameter* val5b = new G4UIparameter("value2",'i',false);
266  val4b->SetParameterRange("value2 != 0");
269 
270 }
271 
273 {
274  delete macroPathCommand;
275  delete ExecuteCommand;
277  delete verboseCommand;
278  delete historyCommand;
280  delete ManualCommand;
281  delete aliasCommand;
282  delete unaliasCommand;
283  delete listAliasCommand;
284  delete getEnvCmd;
285  delete getValCmd;
286  delete echoCmd;
287  delete shellCommand;
288  delete loopCommand;
289  delete foreachCommand;
290  delete HTMLCommand;
291  delete maxStoredHistCommand;
292  delete ifCommand;
293  delete doifCommand;
294  delete addCommand;
295  delete subtractCommand;
296  delete multiplyCommand;
297  delete divideCommand;
298  delete remainderCommand;
299 
300  delete controlDirectory;
301 }
302 
304 {
306 
307  if( command == macroPathCommand) {
308  UI-> SetMacroSearchPath(newValue);
309  UI-> ParseMacroSearchPath();
310  }
311  if(command==ExecuteCommand)
312  {
313  UI-> ExecuteMacroFile(UI-> FindMacroPath(newValue));
314  }
315  if(command==suppressAbortionCommand)
316  {
318  }
319  if(command==verboseCommand)
320  {
322  }
323  if(command==historyCommand)
324  {
325  UI->StoreHistory(newValue);
326  }
327  if(command==stopStoreHistoryCommand)
328  {
329  UI->StoreHistory(false);
330  }
331  if(command==ManualCommand)
332  {
333  UI->ListCommands(newValue);
334  }
335  if(command==aliasCommand)
336  {
337  UI->SetAlias(newValue);
338  }
339  if(command==unaliasCommand)
340  {
341  UI->RemoveAlias(newValue);
342  }
343  if(command==listAliasCommand)
344  {
345  UI->ListAlias();
346  }
347  if(command==getEnvCmd)
348  {
349  if(getenv(newValue))
350  {
351  G4String st = "/control/alias ";
352  st += newValue;
353  st += " ";
354  st += getenv(newValue);
355  UI->ApplyCommand(st);
356  }
357  else
358  { G4cerr << "<" << newValue << "> is not defined as a shell variable. Command ignored." << G4endl; }
359  }
360  if(command==getValCmd)
361  {
362  G4Tokenizer next(newValue);
363  G4String aliName = next();
364  G4String com = next();
365  G4String curVal = UI->GetCurrentValues(com);
366  if(!(curVal.isNull()))
367  {
368  G4String st = "/control/alias ";
369  st += aliName + " " + curVal;
370  UI->ApplyCommand(st);
371  }
372  }
373  if(command==echoCmd)
374  { G4cout << UI->SolveAlias(newValue) << G4endl; }
375  if(command==shellCommand)
376  {
377  system(newValue);
378  }
379  if(command==loopCommand)
380  {
381  UI->LoopS(newValue);
382  }
383  if(command==foreachCommand)
384  {
385  UI->ForeachS(newValue);
386  }
387  if(command==HTMLCommand)
388  {
389  UI->CreateHTML(newValue);
390  }
391  if(command==maxStoredHistCommand)
392  {
394  }
395  if(command==ifCommand)
396  {
397  G4Tokenizer next(newValue);
398  G4double l = StoD(next());
399  G4String comp = next();
400  G4double r = StoD(next());
401  G4String mac = next();
402  G4bool x = false;
403  if(comp==">") x = (l>r);
404  else if(comp==">=") x = (l>=r);
405  else if(comp=="<") x = (l<r);
406  else if(comp=="<=") x = (l<=r);
407  else if(comp=="==") x = (l==r);
408  else if(comp=="!=") x = (l!=r);
409  if(x) UI->ExecuteMacroFile(mac);
410  }
411  if(command==doifCommand)
412  {
413  G4Tokenizer next(newValue);
414  G4double l = StoD(next());
415  G4String comp = next();
416  G4double r = StoD(next());
417 
418  G4String c1 = next();
419  G4String ca;
420  while(!((ca=next()).isNull()))
421  {
422  c1 += " ";
423  c1 += ca;
424  }
425  if(c1(0)=='"')
426  {
427  G4String strippedValue;
428  if(c1(c1.length()-1)=='"')
429  { strippedValue = c1(1,c1.length()-2); }
430  else
431  { strippedValue = c1(1,c1.length()-1); }
432  c1 = strippedValue;
433  }
434 
435  G4bool x = false;
436  if(comp==">") x = (l>r);
437  else if(comp==">=") x = (l>=r);
438  else if(comp=="<") x = (l<r);
439  else if(comp=="<=") x = (l<=r);
440  else if(comp=="==") x = (l==r);
441  else if(comp=="!=") x = (l!=r);
442  if(x) UI->ApplyCommand(c1);
443  }
444  if(command==addCommand)
445  {
446  G4Tokenizer next(newValue);
447  G4String newA = next();
448  G4double l = StoD(next());
449  G4double r = StoD(next());
450  G4String st = "/control/alias ";
451  st += newA;
452  st += " ";
453  st += DtoS(l+r);
454  UI->ApplyCommand(st);
455  }
456  if(command==subtractCommand)
457  {
458  G4Tokenizer next(newValue);
459  G4String newA = next();
460  G4double l = StoD(next());
461  G4double r = StoD(next());
462  G4String st = "/control/alias ";
463  st += newA;
464  st += " ";
465  st += DtoS(l-r);
466  UI->ApplyCommand(st);
467  }
468  if(command==multiplyCommand)
469  {
470  G4Tokenizer next(newValue);
471  G4String newA = next();
472  G4double l = StoD(next());
473  G4double r = StoD(next());
474  G4String st = "/control/alias ";
475  st += newA;
476  st += " ";
477  st += DtoS(l*r);
478  UI->ApplyCommand(st);
479  }
480  if(command==divideCommand)
481  {
482  G4Tokenizer next(newValue);
483  G4String newA = next();
484  G4double l = StoD(next());
485  G4double r = StoD(next());
486  G4String st = "/control/alias ";
487  st += newA;
488  st += " ";
489  st += DtoS(l/r);
490  UI->ApplyCommand(st);
491  }
492  if(command==remainderCommand)
493  {
494  G4Tokenizer next(newValue);
495  G4String newA = next();
496  G4int l = StoI(next());
497  G4int r = StoI(next());
498  G4String st = "/control/alias ";
499  st += newA;
500  st += " ";
501  st += DtoS(l%r);
502  UI->ApplyCommand(st);
503  }
504 }
505 
507 {
509  G4String currentValue;
510 
511  if( command == macroPathCommand ) {
512  currentValue = UI-> GetMacroSearchPath();
513  }
514  if(command==verboseCommand)
515  {
516  currentValue = verboseCommand->ConvertToString(UI->GetVerboseLevel());
517  }
518  if(command==suppressAbortionCommand)
519  {
520  currentValue = suppressAbortionCommand->ConvertToString(G4StateManager::GetStateManager()->GetSuppressAbortion());
521  }
522  if(command==maxStoredHistCommand)
523  {
524  currentValue = maxStoredHistCommand->ConvertToString(UI->GetMaxHistSize());
525  }
526 
527  return currentValue;
528 }
529 
530 
void ForeachS(const char *valueList)
Definition: G4UImanager.cc:345
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
void ExecuteMacroFile(const char *fileName)
Definition: G4UImanager.cc:292
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152
void RemoveAlias(const char *aliasName)
Definition: G4UImanager.cc:643
G4UIcmdWithAnInteger * verboseCommand
G4UIcmdWithAString * ManualCommand
void SetAlias(const char *aliasLine)
Definition: G4UImanager.cc:624
G4UIcmdWithAString * HTMLCommand
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
static G4int GetNewIntValue(const char *paramString)
G4UIcmdWithAnInteger * suppressAbortionCommand
void SetParameterRange(const char *theRange)
void SetParameterCandidates(const char *theString)
G4UIcmdWithAnInteger * maxStoredHistCommand
void SetNewValue(G4UIcommand *command, G4String newValue)
G4UIcmdWithAString * macroPathCommand
void SetToBeBroadcasted(G4bool val)
Definition: G4UIcommand.hh:184
G4UIcmdWithAString * shellCommand
void SetDefaultValue(const char *theDefaultValue)
static G4String ConvertToString(G4bool boolVal)
Definition: G4UIcommand.cc:371
G4int GetVerboseLevel() const
Definition: G4UImanager.hh:227
int G4int
Definition: G4Types.hh:78
void SetVerboseLevel(G4int val)
Definition: G4UImanager.hh:225
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58
void SetSuppressAbortion(G4int i)
static G4StateManager * GetStateManager()
G4UIdirectory * controlDirectory
G4GLOB_DLL std::ostream G4cout
bool G4bool
Definition: G4Types.hh:79
void SetRange(const char *rs)
Definition: G4UIcommand.hh:125
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
G4UIcmdWithAString * getEnvCmd
G4UIcmdWithAString * historyCommand
G4UIcmdWithAString * echoCmd
G4String DtoS(G4double a)
static const G4double c1
G4int StoI(G4String s)
G4String GetCurrentValues(const char *aCommand)
Definition: G4UImanager.cc:170
void SetMaxHistSize(G4int mx)
Definition: G4UImanager.hh:238
void ListCommands(const char *direc)
Definition: G4UImanager.cc:551
G4String GetCurrentValue(G4UIcommand *command)
void SetDefaultValue(const char *defVal)
G4double StoD(G4String s)
G4UIcmdWithoutParameter * stopStoreHistoryCommand
const G4double x[NPOINTSGL]
G4UIcmdWithoutParameter * listAliasCommand
G4String SolveAlias(const char *aCmd)
Definition: G4UImanager.cc:391
void ListAlias()
Definition: G4UImanager.cc:650
#define G4endl
Definition: G4ios.hh:61
void LoopS(const char *valueList)
Definition: G4UImanager.cc:301
void SetDefaultValue(G4int defVal)
double G4double
Definition: G4Types.hh:76
void CreateHTML(const char *dir="/")
Definition: G4UImanager.cc:655
G4UIcmdWithAString * unaliasCommand
void StoreHistory(const char *fileName="G4history.macro")
Definition: G4UImanager.cc:526
G4bool isNull() const
G4UIcmdWithAString * ExecuteCommand
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:446
G4GLOB_DLL std::ostream G4cerr
G4int GetMaxHistSize() const
Definition: G4UImanager.hh:240