G4UImanager.hh

Go to the documentation of this file.

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
// G4UImanager
//
// Class description:
//
// This is a singleton class which controls the command manipulation
// and the user interface(s)
 
// Author: Makoto Asai, 1997
// --------------------------------------------------------------------
#ifndef G4UImanager_hh
#define G4UImanager_hh 1
 
#include <vector>
#include <fstream>
 
#include "globals.hh"
#include "icomsdefs.hh"
#include "G4VStateDependent.hh"
#include "G4UIcommandStatus.hh"
 
class G4UIcommandTree;
class G4UIcommand;
class G4UIsession;
class G4UIcontrolMessenger;
class G4UnitsMessenger;
class G4LocalThreadCoutMessenger;
class G4UIaliasList;
class G4MTcoutDestination;
class G4UIbridge;
class G4ProfilerMessenger;
 
class G4UImanager : public G4VStateDependent
{
  public:
 
    static G4UImanager* GetUIpointer();
    static G4UImanager* GetMasterUIpointer();
      // A static method to get the pointer to the only existing object
      // of this class
 
    ~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);
      // This method returns a string which represents the current value(s)
      // of the parameter(s) of the specified command. Null string will be
      // returned if the given command is not defined or the command does
      // not support the GetCurrentValues() method
 
    void AddNewCommand(G4UIcommand* newCommand);
      // This method register a new command
 
    void RemoveCommand(G4UIcommand* aCommand);
      // This command removes the registered command. After invokation of this
      // command, that particular command cannot be applied
 
    void ExecuteMacroFile(const char* fileName);
      // A macro file defined by the argument will be read by G4UIbatch object
 
    void Loop(const char* macroFile, const char* variableName,
              G4double initialValue, G4double finalValue,
              G4double stepSize = 1.0);
      // Execute a macro file more than once with a loop counter
 
    void Foreach(const char* macroFile, const char* variableName,
                 const char* candidates);
      // Execute a macro file more than once with an aliased variable which
      // takes a value in the candidate list
 
    G4int ApplyCommand(const char* aCommand);
    G4int ApplyCommand(const G4String& aCommand);
      // A command (and parameter(s)) given
      // by the method's argument will be applied. Zero will be returned in
      // case the command is successfully executed. Positive non-zero value
      // will be returned if the command cannot be executed. The meaning of
      // this non-zero value is the following:
      //   The returned number : xyy
      //        x00 : G4CommandStatus.hh enumeration
      //         yy : the problematic parameter (first found)
 
    G4UIcommand* FindCommand(const char* aCommand);
    G4UIcommand* FindCommand(const G4String& aCommand);
      // Find the G4UIcommand object. Null pointer is returned if command
      // is not found.
      // Please note that each thread returns different objects if this
      // method is used in multi-threaded mode.
 
    void StoreHistory(const char* fileName = "G4history.macro");
    void StoreHistory(G4bool historySwitch,
                      const char* fileName = "G4history.macro");
      // The executed commands will be stored in the defined file. If
      // "historySwitch" is false, saving will be suspended
 
    void ListCommands(const char* direc);
      // All commands registered under the given directory will be listed to
      // standard output
 
    void SetAlias(const char* aliasLine);
      // Define an alias. The first word of "aliasLine" string is the
      // alias name and the remaining word(s) is(are) string value
      // to be aliased
 
    void RemoveAlias(const char* aliasName);
      // Remove the defined alias
 
    void ListAlias();
      // Print all aliases
 
    G4String SolveAlias(const char* aCmd);
      // Convert a command string which contains alias(es)
 
    void CreateHTML(const char* dir = "/");
      // Generate HTML files for defined UI commands
 
    void LoopS(const char* valueList);
    void ForeachS(const char* valueList);
      // These methods are used by G4UIcontrolMessenger to use Loop()
      // and Foreach() methods
 
    G4bool Notify(G4ApplicationState requestedState) override;
    // This method is exclusively invoked by G4StateManager
 
    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);
      // These six methods return the current value of a parameter of the
      // given command. For the first three methods, the ordering number of
      // the parameter (1 is the first parameter) can be given, whereas,
      // other three methods can give the parameter name.
      // If "reGet" is true, actual request of returning the current value
      // will be sent to the corresponding messenger, while, if it is false,
      // the value stored in G4Umanager will be used. The later case is valid
      // for the sequential invokation for the same command
 
    inline void SetPauseAtBeginOfEvent(G4bool vl) { pauseAtBeginOfEvent = vl; }
    inline G4bool GetPauseAtBeginOfEvent() const { return pauseAtBeginOfEvent; }
    inline void SetPauseAtEndOfEvent(G4bool vl) { pauseAtEndOfEvent = vl; }
    inline G4bool GetPauseAtEndOfEvent() const { return pauseAtEndOfEvent; }
      // If the Boolean flags are true, Pause() method of G4StateManager is
      // invoked at the very beginning (before generating a G4Event object)
      // or at the end of each event. So that, in case a (G)UI session is
      // defined, the user can interact
 
    inline G4UIcommandTree* GetTree() const { return treeTop; }
    inline G4UIsession* GetSession() const { return session; }
    inline G4UIsession* GetG4UIWindow() const { return g4UIWindow; }
 
    inline void SetSession(G4UIsession* const value) { session = value; }
    inline void SetG4UIWindow(G4UIsession* const value) { g4UIWindow = value; }
      // These methods define the active (G)UI session
 
    void SetCoutDestination(G4UIsession* const value);
      // This method defines the destination of G4cout/G4cerr stream.
      // For usual cases, this method will be invoked by a concrete
      // (G)UI session class object and thus the user needs not to invoke this
 
    inline void SetVerboseLevel(G4int val) { verboseLevel = val; }
    inline G4int GetVerboseLevel() const { return verboseLevel; }
    inline G4int GetNumberOfHistory() const { return G4int(histVec.size()); }
    inline G4String GetPreviousCommand(G4int i) const
    {
      G4String st;
      if(i >= 0 && i < G4int(histVec.size()))
      {
        st = histVec[i];
      }
      return st;
    }
    inline void SetMaxHistSize(G4int mx) { maxHistSize = mx; }
    inline G4int GetMaxHistSize() const { return maxHistSize; }
 
    inline void SetMacroSearchPath(const G4String& path) { searchPath = path; }
    inline const G4String& GetMacroSearchPath() const { return searchPath; }
    void ParseMacroSearchPath();
    G4String FindMacroPath(const G4String& fname) const;
 
    inline void SetMasterUIManager(G4bool val)
    {
      isMaster = val;
      stackCommandsForBroadcast = val;
      if(val && (bridges == nullptr))
      {
        bridges            = new std::vector<G4UIbridge*>;
        fMasterUImanager() = this;
      }
    }
    inline void SetIgnoreCmdNotFound(G4bool val) { ignoreCmdNotFound = val; }
 
    std::vector<G4String>* GetCommandStack();
    void RegisterBridge(G4UIbridge* brg);
 
    void SetUpForAThread(G4int tId);
      // Setups as above but for a non-worker thread (e.g. vis)
 
    void SetUpForSpecialThread(const G4String& aPrefix);
 
    inline G4int GetThreadID() const { return threadID; }
 
    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);
    inline G4MTcoutDestination* GetThreadCout() { return threadCout; }
 
    static void UseDoublePrecisionStr(G4bool val);
    static G4bool DoublePrecisionStr();
 
    inline G4int GetLastReturnCode() const { return lastRC; }
 
    inline bool IsLastCommandOutputTreated() { return fLastCommandOutputTreated; }
    inline void SetLastCommandOutputTreated() { fLastCommandOutputTreated = true; }
 
  protected:
 
    G4UImanager();
 
  private:
 
    void AddWorkerCommand(G4UIcommand* newCommand);
    void RemoveWorkerCommand(G4UIcommand* aCommand);
 
    void PauseSession(const char* msg);
    void CreateMessenger();
    G4UIcommandTree* FindDirectory(const char* dirName);
 
  private:
 
    G4ICOMS_DLL static G4UImanager*& fUImanager();         // thread-local
    G4ICOMS_DLL static G4bool& fUImanagerHasBeenKilled();  // thread-local
    G4ICOMS_DLL static G4UImanager*& fMasterUImanager();
    G4UIcommandTree* treeTop = nullptr;
    G4UIsession* session = nullptr;
    G4UIsession* g4UIWindow = nullptr;
    G4UIcontrolMessenger* UImessenger = nullptr;
    G4UnitsMessenger* UnitsMessenger = nullptr;
    G4LocalThreadCoutMessenger* CoutMessenger = nullptr;
    G4ProfilerMessenger* ProfileMessenger     = nullptr;
    G4String savedParameters;
    G4UIcommand* savedCommand = nullptr;
    G4int verboseLevel = 0;
    std::ofstream historyFile;
    G4bool saveHistory = false;
    std::vector<G4String> histVec;
    G4UIaliasList* aliasList = nullptr;
    G4int maxHistSize = 20;
    G4bool pauseAtBeginOfEvent = false;
    G4bool pauseAtEndOfEvent = false;
    G4String searchPath = "";
    std::vector<G4String> searchDirs;
 
    G4bool isMaster = false;
    std::vector<G4UIbridge*>* bridges = nullptr;
    G4bool ignoreCmdNotFound = false;
    G4bool stackCommandsForBroadcast = false;
    std::vector<G4String>* commandStack = nullptr;
 
    G4int threadID = -1;
    G4MTcoutDestination* threadCout = nullptr;
    G4ICOMS_DLL static G4int igThreadID;
 
    G4ICOMS_DLL static G4bool doublePrecisionStr;
 
    G4int lastRC = 0;
 
    G4bool fLastCommandOutputTreated = true;
};
 
#endif