G4UImanager Class Reference

#include <G4UImanager.hh>

Inheritance diagram for G4UImanager:

Public Member Functions
	~G4UImanager () override
	G4UImanager (const G4UImanager &)=delete
const G4UImanager &	operator= (const G4UImanager &)=delete
G4bool	operator== (const G4UImanager &) const =delete
G4bool	operator!= (const G4UImanager &) const =delete
G4String	GetCurrentValues (const char *aCommand)
void	AddNewCommand (G4UIcommand *newCommand)
void	RemoveCommand (G4UIcommand *aCommand)
void	ExecuteMacroFile (const char *fileName)
void	Loop (const char *macroFile, const char *variableName, G4double initialValue, G4double finalValue, G4double stepSize=1.0)
void	Foreach (const char *macroFile, const char *variableName, const char *candidates)
G4int	ApplyCommand (const char *aCommand)
G4int	ApplyCommand (const G4String &aCommand)
G4UIcommand *	FindCommand (const char *aCommand)
G4UIcommand *	FindCommand (const G4String &aCommand)
void	StoreHistory (const char *fileName="G4history.macro")
void	StoreHistory (G4bool historySwitch, const char *fileName="G4history.macro")
void	ListCommands (const char *direc)
void	SetAlias (const char *aliasLine)
void	RemoveAlias (const char *aliasName)
void	ListAlias ()
G4String	SolveAlias (const char *aCmd)
void	CreateHTML (const char *dir="/")
void	LoopS (const char *valueList)
void	ForeachS (const char *valueList)
G4bool	Notify (G4ApplicationState requestedState) override
G4String	GetCurrentStringValue (const char *aCommand, G4int parameterNumber=1, G4bool reGet=true)
G4int	GetCurrentIntValue (const char *aCommand, G4int parameterNumber=1, G4bool reGet=true)
G4double	GetCurrentDoubleValue (const char *aCommand, G4int parameterNumber=1, G4bool reGet=true)
G4String	GetCurrentStringValue (const char *aCommand, const char *aParameterName, G4bool reGet=true)
G4int	GetCurrentIntValue (const char *aCommand, const char *aParameterName, G4bool reGet=true)
G4double	GetCurrentDoubleValue (const char *aCommand, const char *aParameterName, G4bool reGet=true)
void	SetPauseAtBeginOfEvent (G4bool vl)
G4bool	GetPauseAtBeginOfEvent () const
void	SetPauseAtEndOfEvent (G4bool vl)
G4bool	GetPauseAtEndOfEvent () const
G4UIcommandTree *	GetTree () const
G4UIsession *	GetSession () const
G4UIsession *	GetG4UIWindow () const
G4UIsession *	GetBaseSession () const
void	SetSession (G4UIsession *const value)
void	SetG4UIWindow (G4UIsession *const value)
void	SetCoutDestination (G4UIsession *const value)
void	SetVerboseLevel (G4int val)
G4int	GetVerboseLevel () const
G4int	GetNumberOfHistory () const
G4String	GetPreviousCommand (G4int i) const
void	SetMaxHistSize (G4int mx)
G4int	GetMaxHistSize () const
void	SetMacroSearchPath (const G4String &path)
const G4String &	GetMacroSearchPath () const
void	ParseMacroSearchPath ()
G4String	FindMacroPath (const G4String &fname) const
void	SetMasterUIManager (G4bool val)
void	SetIgnoreCmdNotFound (G4bool val)
std::vector< G4String > *	GetCommandStack ()
void	RegisterBridge (G4UIbridge *brg)
void	SetUpForAThread (G4int tId)
void	SetUpForSpecialThread (const G4String &aPrefix)
G4int	GetThreadID () const
void	SetCoutFileName (const G4String &fileN="G4cout.txt", G4bool ifAppend=true)
void	SetCerrFileName (const G4String &fileN="G4cerr.txt", G4bool ifAppend=true)
void	SetThreadPrefixString (const G4String &prefix="W")
void	SetThreadUseBuffer (G4bool flg=true)
void	SetThreadIgnore (G4int tid=0)
void	SetThreadIgnoreInit (G4bool flg=true)
G4MTcoutDestination *	GetThreadCout ()
G4int	GetLastReturnCode () const
bool	IsLastCommandOutputTreated ()
void	SetLastCommandOutputTreated ()
void	StartRecording (G4String fn, G4bool ifAppend, G4bool ifTemp=false, G4String assocCmd="**NOCMD**")
void	RecordCommand (const G4String &aCommand)
G4int	EndRecording ()
Public Member Functions inherited from G4VStateDependent
	G4VStateDependent (G4bool bottom=false)
virtual	~G4VStateDependent ()
G4bool	operator== (const G4VStateDependent &right) const
G4bool	operator!= (const G4VStateDependent &right) const
virtual void	NotifyDeletion (const G4Event *)
virtual void	NotifyDeletion (const G4Run *)

Static Public Member Functions
static G4UImanager *	GetUIpointer ()
static G4UImanager *	GetMasterUIpointer ()
static void	UseDoublePrecisionStr (G4bool val)
static G4bool	DoublePrecisionStr ()

Protected Member Functions
	G4UImanager ()

Detailed Description

Definition at line 57 of file G4UImanager.hh.

Constructor & Destructor Documentation

~G4UImanager()

G4UImanager::~G4UImanager ( )

override

Definition at line 113 of file G4UImanager.cc.

{
  if (bridges != nullptr) {
    for (auto bridge : *bridges) {
      delete bridge;
    }
    delete bridges;
  }
  SetCoutDestination(nullptr);
  histVec.clear();
  if (saveHistory) {
    historyFile.close();
  }
  delete CoutMessenger;
  delete UnitsMessenger;
  delete UImessenger;
  delete treeTop;
  delete aliasList;
  fUImanagerHasBeenKilled() = true;
  fUImanager() = nullptr;
  if (commandStack != nullptr) {
    commandStack->clear();
    delete commandStack;
  }
  if (threadID >= 0) {
    delete threadCout;
    G4iosFinalization();
    threadID = -1;
  }
}

G4UImanager() [1/2]

G4UImanager::G4UImanager ( const G4UImanager & )

delete

Referenced by G4UImanager(), GetMasterUIpointer(), GetUIpointer(), operator!=(), operator=(), and operator==().

G4UImanager() [2/2]

G4UImanager::G4UImanager ( )

protected

Definition at line 96 of file G4UImanager.cc.

                         : G4VStateDependent(true)
{
  treeTop = new G4UIcommandTree("/");
  aliasList = new G4UIaliasList;
  SetCoutDestination(session);
  commandStack = new std::vector<G4String>;
}

Member Function Documentation

AddNewCommand()

void G4UImanager::AddNewCommand

(

G4UIcommand *

newCommand

)

Definition at line 253 of file G4UImanager.cc.

{
  treeTop->AddNewCommand(newCommand);
  if (fMasterUImanager() != nullptr && G4Threading::G4GetThreadId() == 0) {
    fMasterUImanager()->AddWorkerCommand(newCommand);
  }
}

ApplyCommand() [1/2]

G4int G4UImanager::ApplyCommand

(

const char *

aCommand

)

Definition at line 448 of file G4UImanager.cc.

{
  G4String aCommand = aCmd;
  if(fRecordDepth<0)
  {
    // while recording a command to a macro file, skip solving and record the command as-is
    aCommand = SolveAlias(aCmd);
    if (aCommand.empty()) {
      return fAliasNotFound;
    }
  }
  if (verboseLevel != 0) {
    if (G4Threading::IsMasterThread()) {
      fLastCommandOutputTreated = false;
    }
    G4cout << aCommand << G4endl;
  }
  G4String commandString;
  G4String commandParameter;
 
  std::size_t iAt = aCommand.find('@');
  if (iAt != std::string::npos) {
    G4String commandStr1 = aCommand.substr(0,iAt);
    G4String commandStr2 = aCommand.substr(iAt+1,aCommand.length() - (iAt + 1));
    std::size_t iAt2 = commandStr2.find('@');
    G4String tmpFileName;
    G4bool tmpFile = false;
    if (iAt2 != std::string::npos) {
      if(iAt2 == 0) {
        // Two '@'s are connected. temporal file will be created
        tmpFileName = "tmptmp_";
        tmpFileName += G4UIcommand::ConvertToString(fRecordDepth+1);
        tmpFileName += ".tmpmac";
        tmpFile = true;
      } else {
        tmpFileName = commandStr2.substr(0,iAt2);
      }
    } else {
      return fAliasNotFound;
    }
    G4String commandStr3 = commandStr2.substr(iAt2+1,commandStr2.length()-(iAt2+1));
    G4String revisedCommand = commandStr1;
    revisedCommand += " ";
    revisedCommand += tmpFileName;
    revisedCommand += " ";
    revisedCommand += commandStr3;
    StartRecording(tmpFileName,false,tmpFile,revisedCommand);
    return fCommandSucceeded;
  }  
    
  std::size_t i = aCommand.find(' ');
  if (i != std::string::npos) {
    commandString = aCommand.substr(0, i);
    commandParameter = aCommand.substr(i + 1, aCommand.length() - (i + 1));
  }
  else {
    commandString = aCommand;
  }
 
  // remove doubled slash
  std::size_t len = commandString.length();
  std::size_t ll = 0;
  G4String a1;
  G4String a2;
  while (ll < len - 1) {
    if (commandString.substr(ll, 2) == "//") {
      if (ll == 0) {
        // Safe because index argument always 0
        commandString.erase(ll, 1);
      }
      else {
        a1 = commandString.substr(0, ll);
        a2 = commandString.substr(ll + 1, len - ll - 1);
        commandString = a1 + a2;
      }
      --len;
    }
    else {
      ++ll;
    }
  }
 
  if (isMaster && bridges != nullptr) {
    for (auto bridge : *bridges) {
      G4int leng = bridge->DirLength();
      if (commandString.substr(0, leng) == bridge->DirName()) {
        return bridge->LocalUI()->ApplyCommand(commandString + " " + commandParameter);
      }
    }
  }
 
  G4UIcommand* targetCommand = treeTop->FindPath(commandString);
  if (targetCommand == nullptr) {
    if (ignoreCmdNotFound) {
      if (stackCommandsForBroadcast) {
        commandStack->push_back(commandString + " " + commandParameter);
      }
      return fCommandSucceeded;
    }
 
    return fCommandNotFound;
  }
 
  if (stackCommandsForBroadcast && targetCommand->ToBeBroadcasted()) {
    commandStack->push_back(commandString + " " + commandParameter);
  }
 
  if (!(targetCommand->IsAvailable())) {
    return fIllegalApplicationState;
  }
 
  if (saveHistory) {
    historyFile << aCommand << G4endl;
  }
  if (G4int(histVec.size()) >= maxHistSize) {
    histVec.erase(histVec.begin());
  }
  histVec.push_back(aCommand);
 
  if(fRecordDepth>=0) {
    if(aCommand == "/control/endRecord") {
      EndRecording();
      return fCommandSucceeded;
    } else if(commandString != "/control/recordToMacro") {
      RecordCommand(aCommand);
      return fCommandSucceeded;
    }
  }
 
  targetCommand->ResetFailure();
  G4int commandFailureCode = targetCommand->DoIt(commandParameter);
  if (commandFailureCode == 0) {
    G4int additionalFailureCode = targetCommand->IfCommandFailed();
    if (additionalFailureCode > 0) {
      G4ExceptionDescription msg;
      msg << targetCommand->GetFailureDescription() << "\n"
          << "Error code : " << additionalFailureCode;
      G4Exception("G4UImanager::ApplyCommand", "UIMAN0123", JustWarning, msg);
      commandFailureCode += additionalFailureCode;
    }
  }
  return commandFailureCode;
}

Referenced by ApplyCommand(), G4RunManagerKernel::BuildPhysicsTables(), G4SubEvtRunManager::CreateAndStartWorkers(), G4TaskRunManager::CreateAndStartWorkers(), G4TheMTRayTracer::CreateBitMap(), G4WorkerRunManager::DoWork(), EndRecording(), G4VBasicShell::ExecuteCommand(), G4RunManager::GeometryHasBeenModified(), G4TaskRunManagerKernel::InitializeWorker(), G4VVisCommand::InterpolateViews(), G4QTabWidget::paintEvent(), G4RunManager::ProcessOneEvent(), G4SubEvtRunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), G4WorkerTaskRunManager::ProcessOneEvent(), G4WorkerSubEvtRunManager::ProcessUI(), G4WorkerTaskRunManager::ProcessUI(), G4VVisCommand::RefreshIfRequired(), G4RunManager::ReinitializeGeometry(), G4SubEvtRunManager::RequestWorkersProcessCommandsStack(), G4TaskRunManager::RequestWorkersProcessCommandsStack(), G4VVisCommandGeometrySet::Set(), G4EmExtraParametersMessenger::SetNewValue(), G4EmLowEParametersMessenger::SetNewValue(), G4EmParametersMessenger::SetNewValue(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLXmViewerMessenger::SetNewValue(), G4OpticalParametersMessenger::SetNewValue(), G4ProcessManagerMessenger::SetNewValue(), G4ProcessTableMessenger::SetNewValue(), G4TrackingMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4VisCommandDrawLogicalVolume::SetNewValue(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandDrawView::SetNewValue(), G4VisCommandDrawVolume::SetNewValue(), G4VisCommandGeometryRestore::SetNewValue(), G4VisCommandList::SetNewValue(), G4VisCommandOpen::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandSceneAddTrajectories::SetNewValue(), G4VisCommandSpecify::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandsTouchableSet::SetNewValue(), G4VisCommandViewerClone::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerFlush::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandGeometrySetVisibility::SetNewValueOnLV(), G4ToolsSGSceneHandler::SetPlotterHistograms(), G4VViewer::SetTouchable(), G4TheMTRayTracer::Trace(), and G4TheRayTracer::Trace().

ApplyCommand() [2/2]

G4int G4UImanager::ApplyCommand

(

const G4String &

aCommand

)

Definition at line 442 of file G4UImanager.cc.

{
  return ApplyCommand(aCmd.data());
}

CreateHTML()

void G4UImanager::CreateHTML

(

const char *

dir = "/"

)

Definition at line 749 of file G4UImanager.cc.

{
  G4UIcommandTree* tr = FindDirectory(dir);
  if (tr != nullptr) {
    tr->CreateHTML();
  }
  else {
    G4cerr << "Directory <" << dir << "> is not found." << G4endl;
  }
}

Referenced by G4UIcontrolMessenger::SetNewValue().

DoublePrecisionStr()

G4bool G4UImanager::DoublePrecisionStr ( )

static

Definition at line 151 of file G4UImanager.cc.

{
  return doublePrecisionStr;
}

Referenced by G4UIcommand::ConvertToString(), G4UIcommand::ConvertToString(), G4UIcommand::ConvertToString(), G4UIcommand::ConvertToString(), and G4UIcontrolMessenger::GetCurrentValue().

EndRecording()

G4int G4UImanager::EndRecording

(

)

Definition at line 969 of file G4UImanager.cc.

{
  G4int retVal = fCommandSucceeded;
  fRecordFile[fRecordDepth]->close();
  delete fRecordFile[fRecordDepth];
  fRecordFile.pop_back();
  G4String assocCmd = fAccosiatedCommand[fRecordDepth];
  fAccosiatedCommand.pop_back();
  G4cout << "G4UImanager::EndRecording [" << fRecordDepth << "] "
         << fRecordFileName[fRecordDepth].first << G4endl;
  fRecordDepth--;
  if(assocCmd!="**NOCMD**") {
    retVal = ApplyCommand(assocCmd);
  }
  if(fRecordDepth<0) {
    while(fRecordFileName.size()>0) {
      G4String fn = fRecordFileName.back().first;
      G4bool ifTemp = fRecordFileName.back().second;
      fRecordFileName.pop_back();
      if(ifTemp) {
        std::error_code ec;
        G4bool res = G4fs::remove(fn.c_str(), ec);
        if(!res) {
          G4ExceptionDescription ed;
          ed << "Error removing temporary macro file " << fn << " : " 
             << ec.message(); 
          G4Exception("G4UImanager::EndRecording()", "UIMAN0801", JustWarning, ed);
        }
      }
    }
  }
  return retVal;
}

Referenced by ApplyCommand().

ExecuteMacroFile()

void G4UImanager::ExecuteMacroFile

(

const char *

fileName

)

Definition at line 283 of file G4UImanager.cc.

{
  G4UIsession* batchSession = new G4UIbatch(fileName, session);
  session = batchSession;
  lastRC = 0;
  G4UIsession* previousSession = session->SessionStart();
  lastRC = session->GetLastReturnCode();
  delete session;
  session = previousSession;
}

Referenced by Foreach(), and G4UIcontrolMessenger::SetNewValue().

FindCommand() [1/2]

G4UIcommand * G4UImanager::FindCommand

(

const char *

aCommand

)

Definition at line 599 of file G4UImanager.cc.

{
  const G4String& aCommand = SolveAlias(aCmd);
  if (aCommand.empty()) {
    return nullptr;
  }
 
  G4String commandString;
 
  std::size_t i = aCommand.find(' ');
  if (i != std::string::npos) {
    commandString = aCommand.substr(0, i);
  }
  else {
    commandString = aCommand;
  }
 
  return treeTop->FindPath(commandString);
}

Referenced by FindCommand().

FindCommand() [2/2]

G4UIcommand * G4UImanager::FindCommand

(

const G4String &

aCommand

)

Definition at line 593 of file G4UImanager.cc.

{
  return FindCommand(aCmd.data());
}

FindMacroPath()

G4String G4UImanager::FindMacroPath

(

const G4String &

fname

)

const

Definition at line 796 of file G4UImanager.cc.

{
  G4String macrofile = fname;
 
  for (const auto& searchDir : searchDirs) {
    const G4String& fullpath = searchDir + "/" + fname;
    if (FileFound(fullpath)) {
      macrofile = fullpath;
      break;
    }
  }
  return macrofile;
}

Referenced by G4UIQt::AddIcon(), G4UIQt::AddViewerTabFromFile(), Foreach(), and G4UIcontrolMessenger::SetNewValue().

Foreach()

void G4UImanager::Foreach	(	const char *	macroFile,
		const char *	variableName,
		const char *	candidates )

Definition at line 370 of file G4UImanager.cc.

{
  G4String candidatesString = candidates;
  G4Tokenizer parameterToken(candidatesString);
  G4String cd;
  while (!((cd = parameterToken()).empty())) {
    G4String vl = variableName;
    vl += " ";
    vl += cd;
    SetAlias(vl);
    ExecuteMacroFile(FindMacroPath(macroFile));
    if (lastRC != 0) {
      G4ExceptionDescription ed;
      ed << "Loop aborted due to a command execution error - "
         << "error code " << lastRC;
      G4Exception("G4UImanager::Foreach", "UIMAN0201", JustWarning, ed);
      break;
    }
  }
}

Referenced by ForeachS(), and Loop().

ForeachS()

void G4UImanager::ForeachS

(

const char *

valueList

)

Definition at line 340 of file G4UImanager.cc.

{
  const G4String& vl = valueList;
  G4Tokenizer parameterToken(vl);
  const G4String& mf = parameterToken();
  const G4String& vn = parameterToken();
  G4String c1 = parameterToken();
  G4String ca;
  while (!((ca = parameterToken()).empty())) {
    c1 += " ";
    c1 += ca;
  }
 
  G4String aliasValue = std::move(c1);
  if (aliasValue[0] == '"') {
    G4String strippedValue;
    if (aliasValue.back() == '"') {
      strippedValue = aliasValue.substr(1, aliasValue.length() - 2);
    }
    else {
      strippedValue = aliasValue.substr(1, aliasValue.length() - 1);
    }
    aliasValue = std::move(strippedValue);
  }
 
  //  Foreach(mf,vn,c1);
  Foreach(mf, vn, aliasValue);
}

Referenced by G4UIcontrolMessenger::SetNewValue().

GetBaseSession()

G4UIsession * G4UImanager::GetBaseSession

(

)

const

Definition at line 928 of file G4UImanager.cc.

{
  // There may be no session - pure batch mode (session == nullptr)
  // If there is a session, it may be a batch session used for processing macros.
  // Find base session of this hierarchy of batch sessions.
  G4UIsession* baseSession = session;
  while (auto aBatchSession = dynamic_cast<G4UIbatch*>(baseSession)) {
    auto previousSession = aBatchSession->GetPreviousSession();
    if (previousSession == nullptr) {
      // No previouse session - aBatchSession is the desired base session
      baseSession = aBatchSession;
      break;
    }
    // There is a previous session, which may or may not be a batch.
    // If not, it will be our desired base - so record and test again.
    baseSession = previousSession;
  }
  return baseSession;
}

Referenced by G4OpenGLQt::IsUISessionCompatible(), G4OpenGLXm::IsUISessionCompatible(), G4OpenInventor::IsUISessionCompatible(), G4ToolsSGQtGLES::IsUISessionCompatible(), G4ToolsSGQtZB::IsUISessionCompatible(), and G4VtkQt::IsUISessionCompatible().

GetCommandStack()

std::vector< G4String > * G4UImanager::GetCommandStack

(

)

Definition at line 811 of file G4UImanager.cc.

{
  std::vector<G4String>* returnValue = commandStack;
  commandStack = new std::vector<G4String>;
  return returnValue;
}

Referenced by G4MTRunManager::PrepareCommandsStack().

GetCurrentDoubleValue() [1/2]

G4double G4UImanager::GetCurrentDoubleValue	(	const char *	aCommand,
		const char *	aParameterName,
		G4bool	reGet = true )

Definition at line 229 of file G4UImanager.cc.

{
  G4String targetParameter = GetCurrentStringValue(aCommand, aParameterName, reGet);
  G4double value;
  const char* t = targetParameter;
  std::istringstream is(t);
  is >> value;
  return value;
}

GetCurrentDoubleValue() [2/2]

G4double G4UImanager::GetCurrentDoubleValue	(	const char *	aCommand,
		G4int	parameterNumber = 1,
		G4bool	reGet = true )

Definition at line 241 of file G4UImanager.cc.

{
  G4String targetParameter = GetCurrentStringValue(aCommand, parameterNumber, reGet);
  G4double value;
  const char* t = targetParameter;
  std::istringstream is(t);
  is >> value;
  return value;
}

GetCurrentIntValue() [1/2]

G4int G4UImanager::GetCurrentIntValue	(	const char *	aCommand,
		const char *	aParameterName,
		G4bool	reGet = true )

Definition at line 206 of file G4UImanager.cc.

{
  G4String targetParameter = GetCurrentStringValue(aCommand, aParameterName, reGet);
  G4int value;
  const char* t = targetParameter;
  std::istringstream is(t);
  is >> value;
  return value;
}

GetCurrentIntValue() [2/2]

G4int G4UImanager::GetCurrentIntValue	(	const char *	aCommand,
		G4int	parameterNumber = 1,
		G4bool	reGet = true )

Definition at line 218 of file G4UImanager.cc.

{
  G4String targetParameter = GetCurrentStringValue(aCommand, parameterNumber, reGet);
  G4int value;
  const char* t = targetParameter;
  std::istringstream is(t);
  is >> value;
  return value;
}

Referenced by G4TheMTRayTracer::Trace(), and G4TheRayTracer::Trace().

GetCurrentStringValue() [1/2]

G4String G4UImanager::GetCurrentStringValue	(	const char *	aCommand,
		const char *	aParameterName,
		G4bool	reGet = true )

Definition at line 191 of file G4UImanager.cc.

{
  if (reGet || savedCommand == nullptr) {
    G4String parameterValues = GetCurrentValues(aCommand);
  }
  for (G4int i = 0; i < (G4int)savedCommand->GetParameterEntries(); ++i) {
    if (aParameterName == savedCommand->GetParameter(i)->GetParameterName()) {
      return GetCurrentStringValue(aCommand, i + 1, false);
    }
  }
  return G4String();
}

GetCurrentStringValue() [2/2]

G4String G4UImanager::GetCurrentStringValue	(	const char *	aCommand,
		G4int	parameterNumber = 1,
		G4bool	reGet = true )

Definition at line 169 of file G4UImanager.cc.

{
  if (reGet || savedCommand == nullptr) {
    savedParameters = GetCurrentValues(aCommand);
  }
  G4Tokenizer savedToken(savedParameters);
  G4String token;
  for (G4int i_thParameter = 0; i_thParameter < parameterNumber; ++i_thParameter) {
    token = savedToken();
    if (token.empty()) {
      return G4String();
    }
    if (token[(size_t)0] == '"') {
      token.append(" ");
      token.append(savedToken("\""));
    }
  }
  return token;
}

Referenced by GetCurrentDoubleValue(), GetCurrentDoubleValue(), GetCurrentIntValue(), GetCurrentIntValue(), and GetCurrentStringValue().

GetCurrentValues()

G4String G4UImanager::GetCurrentValues

(

const char *

aCommand

)

Definition at line 157 of file G4UImanager.cc.

{
  G4String theCommand = aCommand;
  savedCommand = treeTop->FindPath(theCommand);
  if (savedCommand == nullptr) {
    G4cerr << "command not found" << G4endl;
    return G4String();
  }
  return savedCommand->GetCurrentValue();
}

Referenced by GetCurrentStringValue(), GetCurrentStringValue(), G4UIcontrolMessenger::SetNewValue(), G4ToolsSGSceneHandler::SetPlotterHistograms(), and G4VBasicShell::ShowCurrent().

GetG4UIWindow()

G4UIsession * G4UImanager::GetG4UIWindow ( ) const

inline

Definition at line 178 of file G4UImanager.hh.

{ return g4UIWindow; }

Referenced by G4OpenGLQtViewer::CreateMainWindow(), G4VtkQtViewer::CreateMainWindow(), G4ToolsSGQtGLESViewer::Initialise(), G4ToolsSGQtZBViewer::Initialise(), G4VViewer::UpdateGUIDrawingStyle(), G4VViewer::UpdateGUIProjectionStyle(), G4VViewer::UpdateGUISceneTree(), and G4VViewer::UpdateGUITransparencySlider().

GetLastReturnCode()

G4int G4UImanager::GetLastReturnCode ( ) const

inline

Definition at line 242 of file G4UImanager.hh.

{ return lastRC; }

Referenced by G4UIcontrolMessenger::SetNewValue().

GetMacroSearchPath()

const G4String & G4UImanager::GetMacroSearchPath ( ) const

inline

Definition at line 206 of file G4UImanager.hh.

{ return searchPath; }

Referenced by G4UIcontrolMessenger::GetCurrentValue().

GetMasterUIpointer()

G4UImanager * G4UImanager::GetMasterUIpointer ( )

static

Definition at line 90 of file G4UImanager.cc.

{
  return fMasterUImanager();
}

Referenced by G4UIbridge::G4UIbridge().

GetMaxHistSize()

G4int G4UImanager::GetMaxHistSize ( ) const

inline

Definition at line 203 of file G4UImanager.hh.

{ return maxHistSize; }

Referenced by G4UIcontrolMessenger::GetCurrentValue().

GetNumberOfHistory()

G4int G4UImanager::GetNumberOfHistory ( ) const

inline

Definition at line 193 of file G4UImanager.hh.

{ return G4int(histVec.size()); }

Referenced by G4VBasicShell::ApplyShellCommand().

GetPauseAtBeginOfEvent()

G4bool G4UImanager::GetPauseAtBeginOfEvent ( ) const

inline

Definition at line 172 of file G4UImanager.hh.

{ return pauseAtBeginOfEvent; }

GetPauseAtEndOfEvent()

G4bool G4UImanager::GetPauseAtEndOfEvent ( ) const

inline

Definition at line 174 of file G4UImanager.hh.

{ return pauseAtEndOfEvent; }

GetPreviousCommand()

G4String G4UImanager::GetPreviousCommand ( G4int i ) const

inline

Definition at line 194 of file G4UImanager.hh.

    {
      G4String st;
      if (i >= 0 && i < G4int(histVec.size())) {
        st = histVec[i];
      }
      return st;
    }

Referenced by G4VBasicShell::ApplyShellCommand().

GetSession()

G4UIsession * G4UImanager::GetSession ( ) const

inline

Definition at line 177 of file G4UImanager.hh.

{ return session; }

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

GetThreadCout()

G4MTcoutDestination * G4UImanager::GetThreadCout ( )

inline

Definition at line 237 of file G4UImanager.hh.

{ return threadCout; }

GetThreadID()

G4int G4UImanager::GetThreadID ( ) const

inline

Definition at line 229 of file G4UImanager.hh.

{ return threadID; }

GetTree()

G4UIcommandTree * G4UImanager::GetTree ( ) const

inline

Definition at line 176 of file G4UImanager.hh.

{ return treeTop; }

Referenced by G4UIQt::AddButton(), G4UIQt::AddIcon(), G4VBasicShell::Complete(), G4UImessenger::CreateDirectory(), G4VBasicShell::FindCommand(), G4VBasicShell::FindDirectory(), G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandOpen::G4VisCommandOpen(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), G4VUIshell::GetCommandTree(), G4VBasicShell::TerminalHelp(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

GetUIpointer()

G4UImanager * G4UImanager::GetUIpointer ( )

static

Definition at line 78 of file G4UImanager.cc.

{
  if (fUImanager() == nullptr) {
    if (!fUImanagerHasBeenKilled()) {
      fUImanager() = new G4UImanager;
      fUImanager()->CreateMessenger();
    }
  }
  return fUImanager();
}

Referenced by G4UIQt::AddButton(), G4UIQt::AddIcon(), G4UIcommandTree::AddNewCommand(), G4UIQt::AddViewerTabFromFile(), G4OpenInventorQtExaminerViewer::afterRealizeHook(), G4VBasicShell::ApplyShellCommand(), G4RunManagerKernel::BuildPhysicsTables(), G4VVisCommand::CheckSceneAndNotifyHandlers(), G4VBasicShell::Complete(), G4SubEvtRunManager::CreateAndStartWorkers(), G4TaskRunManager::CreateAndStartWorkers(), G4TheMTRayTracer::CreateBitMap(), G4UImessenger::CreateDirectory(), G4OpenGLQtViewer::CreateMainWindow(), G4VtkQtViewer::CreateMainWindow(), G4WorkerRunManager::DoWork(), G4VBasicShell::ExecuteCommand(), G4VBasicShell::FindCommand(), G4VBasicShell::FindDirectory(), G4MTRunManager::G4MTRunManager(), G4RunManager::G4RunManager(), G4SubEvtRunManager::G4SubEvtRunManager(), G4TaskRunManager::G4TaskRunManager(), G4UIbatch::G4UIbatch(), G4UIQt::G4UIQt(), G4UIterminal::G4UIterminal(), G4UIWin32::G4UIWin32(), G4UIXm::G4UIXm(), G4VisCommandDrawLogicalVolume::G4VisCommandDrawLogicalVolume(), G4VisCommandDrawVolume::G4VisCommandDrawVolume(), G4VisCommandOpen::G4VisCommandOpen(), G4VisCommandSceneAddMagneticField::G4VisCommandSceneAddMagneticField(), G4VisManager::G4VisSubThread(), G4WorkerRunManager::G4WorkerRunManager(), G4RunManager::GeometryHasBeenModified(), G4VisManager::GeometryHasChanged(), G4VUIshell::GetCommandTree(), G4UIcontrolMessenger::GetCurrentValue(), G4RTQtScanner::GetQtWindow(), G4OpenInventorQtViewer::Initialise(), G4ToolsSGQtGLESViewer::Initialise(), G4ToolsSGQtZBViewer::Initialise(), G4TaskRunManagerKernel::InitializeWorker(), G4VVisCommand::InterpolateViews(), G4OpenGLQt::IsUISessionCompatible(), G4OpenGLXm::IsUISessionCompatible(), G4OpenInventor::IsUISessionCompatible(), G4ToolsSGQtGLES::IsUISessionCompatible(), G4ToolsSGQtZB::IsUISessionCompatible(), G4VtkQt::IsUISessionCompatible(), G4VisManager::NotifyHandlers(), G4QTabWidget::paintEvent(), G4MTRunManager::PrepareCommandsStack(), G4RunManager::ProcessOneEvent(), G4SubEvtRunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), G4WorkerTaskRunManager::ProcessOneEvent(), G4WorkerSubEvtRunManager::ProcessUI(), G4WorkerTaskRunManager::ProcessUI(), G4UIQt::ReceiveG4cout(), G4VVisCommand::RefreshIfRequired(), G4RunManager::ReinitializeGeometry(), G4SubEvtRunManager::RequestWorkersProcessCommandsStack(), G4TaskRunManager::RequestWorkersProcessCommandsStack(), G4UIbatch::SessionStart(), G4VVisCommandGeometrySet::Set(), G4EmExtraParametersMessenger::SetNewValue(), G4EmLowEParametersMessenger::SetNewValue(), G4EmParametersMessenger::SetNewValue(), G4LocalThreadCoutMessenger::SetNewValue(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLXmViewerMessenger::SetNewValue(), G4OpticalParametersMessenger::SetNewValue(), G4ProcessManagerMessenger::SetNewValue(), G4ProcessTableMessenger::SetNewValue(), G4RunMessenger::SetNewValue(), G4TrackingMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4VisCommandDrawLogicalVolume::SetNewValue(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandDrawView::SetNewValue(), G4VisCommandDrawVolume::SetNewValue(), G4VisCommandGeometryRestore::SetNewValue(), G4VisCommandList::SetNewValue(), G4VisCommandOpen::SetNewValue(), G4VisCommandPlot::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandReviewPlots::SetNewValue(), G4VisCommandSceneAddTrajectories::SetNewValue(), G4VisCommandSceneHandlerCreate::SetNewValue(), G4VisCommandSpecify::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandsTouchableSet::SetNewValue(), G4VisCommandViewerClone::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandViewerFlush::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), G4VisCommandGeometrySetVisibility::SetNewValueOnLV(), G4ToolsSGSceneHandler::SetPlotterHistograms(), G4VViewer::SetTouchable(), G4VBasicShell::ShowCurrent(), G4MTRunManagerKernel::StartThread(), G4VBasicShell::TerminalHelp(), G4TheMTRayTracer::Trace(), G4TheRayTracer::Trace(), G4VViewer::UpdateGUIDrawingStyle(), G4VViewer::UpdateGUIProjectionStyle(), G4VViewer::UpdateGUISceneTree(), G4VViewer::UpdateGUITransparencySlider(), G4OpenGLQtViewer::updateViewerPropertiesTableWidget(), G4RunManagerKernel::~G4RunManagerKernel(), G4UIcommand::~G4UIcommand(), G4UIQt::~G4UIQt(), G4UIterminal::~G4UIterminal(), G4UIWin32::~G4UIWin32(), G4UIXm::~G4UIXm(), and G4VisManager::~G4VisManager().

GetVerboseLevel()

G4int G4UImanager::GetVerboseLevel ( ) const

inline

Definition at line 192 of file G4UImanager.hh.

{ return verboseLevel; }

Referenced by G4UIQt::AddButton(), G4UIQt::AddIcon(), G4UIQt::G4UIQt(), G4UIcontrolMessenger::GetCurrentValue(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), and G4ToolsSGSceneHandler::SetPlotterHistograms().

IsLastCommandOutputTreated()

bool G4UImanager::IsLastCommandOutputTreated ( )

inline

Definition at line 244 of file G4UImanager.hh.

{ return fLastCommandOutputTreated; }

Referenced by G4UIQt::ReceiveG4cout().

ListAlias()

void G4UImanager::ListAlias

(

)

Definition at line 743 of file G4UImanager.cc.

{
  aliasList->List();
}

Referenced by G4UIcontrolMessenger::SetNewValue().

ListCommands()

void G4UImanager::ListCommands

(

const char *

direc

)

Definition at line 651 of file G4UImanager.cc.

{
  G4UIcommandTree* comTree = FindDirectory(direct);
  if (comTree != nullptr) {
    comTree->List();
  }
  else {
    G4cout << direct << " is not found." << G4endl;
  }
}

Referenced by G4UIcontrolMessenger::SetNewValue().

Loop()

void G4UImanager::Loop	(	const char *	macroFile,
		const char *	variableName,
		G4double	initialValue,
		G4double	finalValue,
		G4double	stepSize = 1.0 )

Definition at line 316 of file G4UImanager.cc.

{
  G4String cd;
  if (stepSize > 0) {
    for (G4double d = initialValue; d <= finalValue; d += stepSize) {
      std::ostringstream os;
      os << d;
      cd += os.str();
      cd += " ";
    }
  }
  else {
    for (G4double d = initialValue; d >= finalValue; d += stepSize) {
      std::ostringstream os;
      os << d;
      cd += os.str();
      cd += " ";
    }
  }
  Foreach(macroFile, variableName, cd);
}

Referenced by LoopS().

LoopS()

void G4UImanager::LoopS

(

const char *

valueList

)

Definition at line 295 of file G4UImanager.cc.

{
  G4String vl = valueList;
  G4Tokenizer parameterToken(vl);
  G4String mf = parameterToken();
  G4String vn = parameterToken();
  G4String c1 = parameterToken();
  c1 += " ";
  c1 += parameterToken();
  c1 += " ";
  c1 += parameterToken();
  const char* t1 = c1;
  std::istringstream is(t1);
  G4double d1;
  G4double d2;
  G4double d3;
  is >> d1 >> d2 >> d3;
  Loop(mf, vn, d1, d2, d3);
}

Referenced by G4UIcontrolMessenger::SetNewValue().

Notify()

G4bool G4UImanager::Notify ( G4ApplicationState requestedState )

overridevirtual

Implements G4VStateDependent.

Definition at line 688 of file G4UImanager.cc.

{
  if (pauseAtBeginOfEvent) {
    if (requestedState == G4State_EventProc
        && G4StateManager::GetStateManager()->GetPreviousState() == G4State_GeomClosed)
    {
      PauseSession("BeginOfEvent");
    }
  }
  if (pauseAtEndOfEvent) {
    if (requestedState == G4State_GeomClosed
        && G4StateManager::GetStateManager()->GetPreviousState() == G4State_EventProc)
    {
      PauseSession("EndOfEvent");
    }
  }
  return true;
}

operator!=()

G4bool G4UImanager::operator!= ( const G4UImanager & ) const

delete

operator=()

const G4UImanager & G4UImanager::operator= ( const G4UImanager & )

delete

operator==()

G4bool G4UImanager::operator== ( const G4UImanager & ) const

delete

ParseMacroSearchPath()

void G4UImanager::ParseMacroSearchPath

(

)

Definition at line 761 of file G4UImanager.cc.

{
  searchDirs.clear();
 
  std::size_t idxfirst = 0;
  std::size_t idxend = 0;
  G4String pathstring = "";
  while ((idxend = searchPath.find(':', idxfirst)) != G4String::npos) {
    pathstring = searchPath.substr(idxfirst, idxend - idxfirst);
    if (!pathstring.empty()) {
      searchDirs.push_back(pathstring);
    }
    idxfirst = idxend + 1;
  }
 
  pathstring = searchPath.substr(idxfirst, searchPath.size() - idxfirst);
  if (!pathstring.empty()) {
    searchDirs.push_back(std::move(pathstring));
  }
}

Referenced by G4UIcontrolMessenger::SetNewValue().

RecordCommand()

void G4UImanager::RecordCommand

(

const G4String &

aCommand

)

Definition at line 963 of file G4UImanager.cc.

{ 
  *(fRecordFile[fRecordDepth]) << aCommand << G4endl;
}

Referenced by ApplyCommand().

RegisterBridge()

void G4UImanager::RegisterBridge

(

G4UIbridge *

brg

)

Definition at line 819 of file G4UImanager.cc.

{
  if (brg->LocalUI() == this) {
    G4Exception("G4UImanager::RegisterBridge()", "UI7002", FatalException,
                "G4UIBridge cannot bridge between same object.");
  }
  else {
    bridges->push_back(brg);
  }
}

RemoveAlias()

void G4UImanager::RemoveAlias

(

const char *

aliasName

)

Definition at line 735 of file G4UImanager.cc.

{
  const G4String& aL = aliasName;
  G4String targetAlias = G4StrUtil::strip_copy(aL);
  aliasList->RemoveAlias(targetAlias);
}

Referenced by G4UIcontrolMessenger::SetNewValue().

RemoveCommand()

void G4UImanager::RemoveCommand

(

G4UIcommand *

aCommand

)

Definition at line 268 of file G4UImanager.cc.

{
  treeTop->RemoveCommand(aCommand);
  if (fMasterUImanager() != nullptr && G4Threading::G4GetThreadId() == 0) {
    fMasterUImanager()->RemoveWorkerCommand(aCommand);
  }
}

Referenced by G4UIcommand::~G4UIcommand().

SetAlias()

void G4UImanager::SetAlias

(

const char *

aliasLine

)

Definition at line 714 of file G4UImanager.cc.

{
  const G4String& aLine = aliasLine;
  std::size_t i = aLine.find(' ');
  const G4String& aliasName = aLine.substr(0, i);
  G4String aliasValue = aLine.substr(i + 1, aLine.length() - (i + 1));
  if (aliasValue[0] == '"') {
    G4String strippedValue;
    if (aliasValue.back() == '"') {
      strippedValue = aliasValue.substr(1, aliasValue.length() - 2);
    }
    else {
      strippedValue = aliasValue.substr(1, aliasValue.length() - 1);
    }
    aliasValue = std::move(strippedValue);
  }
 
  aliasList->ChangeAlias(aliasName, aliasValue);
}

Referenced by Foreach(), G4MTRunManager::G4MTRunManager(), G4RunManager::G4RunManager(), G4SubEvtRunManager::G4SubEvtRunManager(), and G4UIcontrolMessenger::SetNewValue().

SetCerrFileName()

void G4UImanager::SetCerrFileName	(	const G4String &	fileN = "G4cerr.txt",
		G4bool	ifAppend = true )

Definition at line 869 of file G4UImanager.cc.

{
  // for sequential mode, ignore this method.
  if (threadID < 0) {
    return;
  }
 
  if (fileN == "**Screen**") {
    threadCout->SetCerrFileName(fileN, ifAppend);
  }
  else {
    std::stringstream fn;
    fn << "G4W_" << threadID << "_" << fileN;
    threadCout->SetCerrFileName(fn.str(), ifAppend);
  }
}

Referenced by G4LocalThreadCoutMessenger::SetNewValue().

SetCoutDestination()

void G4UImanager::SetCoutDestination

(

G4UIsession *const

value

)

Definition at line 708 of file G4UImanager.cc.

{
  G4iosSetDestination(value);
}

Referenced by G4UImanager(), G4UIQt::G4UIQt(), G4UIWin32::G4UIWin32(), G4UIXm::G4UIXm(), ~G4UImanager(), G4UIQt::~G4UIQt(), G4UIWin32::~G4UIWin32(), G4UIXm::~G4UIXm(), and G4VisManager::~G4VisManager().

SetCoutFileName()

void G4UImanager::SetCoutFileName	(	const G4String &	fileN = "G4cout.txt",
		G4bool	ifAppend = true )

Definition at line 851 of file G4UImanager.cc.

{
  // for sequential mode, ignore this method.
  if (threadID < 0) {
    return;
  }
 
  if (fileN == "**Screen**") {
    threadCout->SetCoutFileName(fileN, ifAppend);
  }
  else {
    std::stringstream fn;
    fn << "G4W_" << threadID << "_" << fileN;
    threadCout->SetCoutFileName(fn.str(), ifAppend);
  }
}

Referenced by G4LocalThreadCoutMessenger::SetNewValue().

SetG4UIWindow()

void G4UImanager::SetG4UIWindow ( G4UIsession *const value )

inline

Definition at line 184 of file G4UImanager.hh.

{ g4UIWindow = value; }

Referenced by G4UIQt::G4UIQt(), G4UIWin32::G4UIWin32(), G4UIQt::~G4UIQt(), and G4UIWin32::~G4UIWin32().

SetIgnoreCmdNotFound()

void G4UImanager::SetIgnoreCmdNotFound ( G4bool val )

inline

Definition at line 219 of file G4UImanager.hh.

{ ignoreCmdNotFound = val; }

Referenced by G4WorkerRunManager::G4WorkerRunManager().

SetLastCommandOutputTreated()

void G4UImanager::SetLastCommandOutputTreated ( )

inline

Definition at line 245 of file G4UImanager.hh.

{ fLastCommandOutputTreated = true; }

Referenced by G4UIQt::ReceiveG4cout().

SetMacroSearchPath()

void G4UImanager::SetMacroSearchPath ( const G4String & path )

inline

Definition at line 205 of file G4UImanager.hh.

{ searchPath = path; }

Referenced by G4UIcontrolMessenger::SetNewValue().

SetMasterUIManager()

void G4UImanager::SetMasterUIManager ( G4bool val )

inline

Definition at line 210 of file G4UImanager.hh.

    {
      isMaster = val;
      stackCommandsForBroadcast = val;
      if (val && (bridges == nullptr)) {
        bridges = new std::vector<G4UIbridge*>;
        fMasterUImanager() = this;
      }
    }

Referenced by G4MTRunManager::G4MTRunManager(), and G4TaskRunManager::G4TaskRunManager().

SetMaxHistSize()

void G4UImanager::SetMaxHistSize ( G4int mx )

inline

Definition at line 202 of file G4UImanager.hh.

{ maxHistSize = mx; }

Referenced by G4UIcontrolMessenger::SetNewValue().

SetPauseAtBeginOfEvent()

void G4UImanager::SetPauseAtBeginOfEvent ( G4bool vl )

inline

Definition at line 171 of file G4UImanager.hh.

{ pauseAtBeginOfEvent = vl; }

Referenced by G4RunMessenger::SetNewValue().

SetPauseAtEndOfEvent()

void G4UImanager::SetPauseAtEndOfEvent ( G4bool vl )

inline

Definition at line 173 of file G4UImanager.hh.

{ pauseAtEndOfEvent = vl; }

Referenced by G4RunMessenger::SetNewValue().

SetSession()

void G4UImanager::SetSession ( G4UIsession *const value )

inline

Definition at line 183 of file G4UImanager.hh.

{ session = value; }

Referenced by G4UIQt::G4UIQt(), G4UIWin32::G4UIWin32(), G4UIXm::G4UIXm(), G4UIQt::~G4UIQt(), G4UIWin32::~G4UIWin32(), and G4UIXm::~G4UIXm().

SetThreadIgnore()

void G4UImanager::SetThreadIgnore

(

G4int

tid = 0

)

Definition at line 907 of file G4UImanager.cc.

{
  // for sequential mode, ignore this method.
  if (threadID < 0) {
    igThreadID = tid;
    return;
  }
  threadCout->SetIgnoreCout(tid);
}

Referenced by G4LocalThreadCoutMessenger::SetNewValue().

SetThreadIgnoreInit()

void G4UImanager::SetThreadIgnoreInit

(

G4bool

flg = true

)

Definition at line 918 of file G4UImanager.cc.

{
  // for sequential mode, ignore this method.
  if (threadID < 0) {
    return;
  }
  threadCout->SetIgnoreInit(flg);
}

Referenced by G4LocalThreadCoutMessenger::SetNewValue().

SetThreadPrefixString()

void G4UImanager::SetThreadPrefixString

(

const G4String &

prefix = "W"

)

Definition at line 887 of file G4UImanager.cc.

{
  // for sequential mode, ignore this method.
  if (threadID < 0) {
    return;
  }
  threadCout->SetPrefixString(s);
}

Referenced by G4LocalThreadCoutMessenger::SetNewValue().

SetThreadUseBuffer()

void G4UImanager::SetThreadUseBuffer

(

G4bool

flg = true

)

Definition at line 897 of file G4UImanager.cc.

{
  // for sequential mode, ignore this method.
  if (threadID < 0) {
    return;
  }
  threadCout->EnableBuffering(flg);
}

Referenced by G4LocalThreadCoutMessenger::SetNewValue().

SetUpForAThread()

void G4UImanager::SetUpForAThread

(

G4int

tId

)

Definition at line 831 of file G4UImanager.cc.

{
  threadID = tId;
  G4iosInitialization();
  threadCout = new G4MTcoutDestination(threadID);
  threadCout->SetIgnoreCout(igThreadID);
}

Referenced by G4TaskRunManagerKernel::InitializeWorker(), and G4MTRunManagerKernel::StartThread().

SetUpForSpecialThread()

void G4UImanager::SetUpForSpecialThread

(

const G4String &

aPrefix

)

Definition at line 840 of file G4UImanager.cc.

{
  threadID = G4Threading::GENERICTHREAD_ID;
  G4Threading::G4SetThreadId(threadID);
  G4iosInitialization();
  threadCout = new G4MTcoutDestination(threadID);
  threadCout->SetPrefixString(pref);
  threadCout->SetIgnoreCout(igThreadID);
}

Referenced by G4VisManager::G4VisSubThread().

SetVerboseLevel()

void G4UImanager::SetVerboseLevel ( G4int val )

inline

Definition at line 191 of file G4UImanager.hh.

{ verboseLevel = val; }

Referenced by G4UIcontrolMessenger::SetNewValue(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandViewerInterpolate::SetNewValue(), and G4ToolsSGSceneHandler::SetPlotterHistograms().

SolveAlias()

G4String G4UImanager::SolveAlias

(

const char *

aCmd

)

Definition at line 392 of file G4UImanager.cc.

{
  G4String aCommand = aCmd;
  std::size_t ia = aCommand.find('{');
  std::size_t iz = aCommand.find('#');
  while ((ia != std::string::npos) && ((iz == std::string::npos) || (ia < iz))) {
    G4int ibx = -1;
    while (ibx < 0) {
      std::size_t ib = aCommand.find('}');
      if (ib == std::string::npos) {
        G4cerr << aCommand << G4endl;
        for (std::size_t i = 0; i < ia; ++i) {
          G4cerr << " ";
        }
        G4cerr << "^" << G4endl;
        G4cerr << "Unmatched alias parenthesis -- command ignored" << G4endl;
        G4String nullStr;
        return nullStr;
      }
      G4String ps = aCommand.substr(ia + 1, aCommand.length() - (ia + 1));
      std::size_t ic = ps.find('{');
      std::size_t id = ps.find('}');
      if (ic != std::string::npos && ic < id) {
        ia += ic + 1;
      }
      else {
        ibx = (G4int)ib;
      }
    }
    //--- Here ia represents the position of innermost "{"
    //--- and ibx represents corresponding "}"
    G4String subs;
    if (ia > 0) {
      subs = aCommand.substr(0, ia);
    }
    G4String alis = aCommand.substr(ia + 1, ibx - ia - 1);
    G4String rems = aCommand.substr(ibx + 1, aCommand.length() - ibx);
    const G4String* alVal = aliasList->FindAlias(alis);
    if (alVal == nullptr) {
      G4cerr << "Alias <" << alis << "> not found -- command ignored" << G4endl;
      G4String nullStr;
      return nullStr;
    }
    aCommand = subs + (*alVal) + rems;
    ia = aCommand.find('{');
  }
  return aCommand;
}

Referenced by ApplyCommand(), FindCommand(), and G4UIcontrolMessenger::SetNewValue().

StartRecording()

void G4UImanager::StartRecording	(	G4String	fn,
		G4bool	ifAppend,
		G4bool	ifTemp = false,
		G4String	assocCmd = "**NOCMD**" )

Definition at line 949 of file G4UImanager.cc.

{
  fRecordDepth++;
  fRecordFileName.push_back(std::pair<G4String,G4bool>(fn,ifTemp));
  fAccosiatedCommand.push_back(assocCmd);
  G4cout << "G4UImanager::StartRecording [" << fRecordDepth << "] " << fn << G4endl;
  auto mode = std::ios_base::out;
  if(ifAppend) mode = std::ios_base::app;
  auto rf = new std::ofstream;
  rf->open(fn,mode);
  fRecordFile.push_back(rf);
}

Referenced by ApplyCommand(), and G4UIcontrolMessenger::SetNewValue().

StoreHistory() [1/2]

void G4UImanager::StoreHistory

(

const char *

fileName = "G4history.macro"

)

Definition at line 620 of file G4UImanager.cc.

{
  StoreHistory(true, fileName);
}

Referenced by G4UIcontrolMessenger::SetNewValue(), and StoreHistory().

StoreHistory() [2/2]

void G4UImanager::StoreHistory	(	G4bool	historySwitch,
		const char *	fileName = "G4history.macro" )

Definition at line 626 of file G4UImanager.cc.

{
  if (historySwitch) {
    if (saveHistory) {
      historyFile.close();
    }
    historyFile.open((char*)fileName);
    saveHistory = true;
  }
  else {
    historyFile.close();
    saveHistory = false;
  }
  saveHistory = historySwitch;
}

UseDoublePrecisionStr()

void G4UImanager::UseDoublePrecisionStr ( G4bool val )

static

Definition at line 145 of file G4UImanager.cc.

{
  doublePrecisionStr = val;
}

Referenced by G4UIcontrolMessenger::SetNewValue().

---

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

• G4UImanager.hh
• G4UImanager.cc