G4ProcessTableMessenger Class Reference

#include <G4ProcessTableMessenger.hh>

Inheritance diagram for G4ProcessTableMessenger:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const
	G4ProcessTableMessenger (const G4ProcessTableMessenger &)=delete
	G4ProcessTableMessenger (G4ProcessTable *pTable)
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	operator!= (const G4UImessenger &messenger) const
G4ProcessTableMessenger &	operator= (const G4ProcessTableMessenger &)=delete
G4bool	operator== (const G4UImessenger &messenger) const
virtual void	SetNewValue (G4UIcommand *command, G4String newValues)
virtual	~G4ProcessTableMessenger ()

Protected Member Functions
void	AddUIcommand (G4UIcommand *newCommand)
G4String	BtoS (G4bool b)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
G4String	DtoS (G4double a)
G4String	ItoS (G4int i)
G4bool	StoB (G4String s)
G4double	StoD (G4String s)
G4int	StoI (G4String s)
G4long	StoL (G4String s)

Protected Attributes
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Private Member Functions
	G4ProcessTableMessenger ()
G4int	GetProcessType (const G4String &aTypeName) const
G4String	GetProcessTypeName (G4ProcessType aType) const
void	SetNumberOfProcessType ()

Private Attributes
G4UIcommand *	activateCmd = nullptr
G4String	currentParticleName = "all"
G4String	currentProcessName = "all"
G4String	currentProcessTypeName = "all"
G4UIcommand *	dumpCmd = nullptr
G4UIcommand *	inactivateCmd = nullptr
G4UIcmdWithAString *	listCmd = nullptr
G4UIcommand *	procVerboseCmd = nullptr
G4ProcessTable *	theProcessTable = nullptr
G4UIdirectory *	thisDirectory = nullptr
G4UIcmdWithAnInteger *	verboseCmd = nullptr

Static Private Attributes
static G4ThreadLocal G4int	NumberOfProcessType = 10

Detailed Description

Definition at line 55 of file G4ProcessTableMessenger.hh.

Constructor & Destructor Documentation

G4ProcessTableMessenger() [1/3]

G4ProcessTableMessenger::G4ProcessTableMessenger

(

G4ProcessTable *

pTable

)

Definition at line 52 of file G4ProcessTableMessenger.cc.

  : theProcessTable(pTable)
{ 
  // Command   /particle/process
  thisDirectory = new G4UIdirectory("/process/");
  thisDirectory->SetGuidance("Process Table control commands.");
 
  // Command   /particle/process/list
  listCmd = new G4UIcmdWithAString("/process/list",this);
  listCmd->SetGuidance("List up process names");
  listCmd->SetGuidance("  list [type] ");
  listCmd->SetGuidance("    type: process type [all:for all processes]");
  listCmd->SetParameterName("type", true);
  listCmd->SetDefaultValue("all");
  SetNumberOfProcessType();
 
  G4String candidates("all");
  for (G4int idx = 0; idx < NumberOfProcessType ; ++idx )
  {
    candidates += " " + G4VProcess::GetProcessTypeName(G4ProcessType(idx));
  }
  listCmd->SetCandidates((const char*)(candidates));
 
  // Command   /particle/process/verbose
  verboseCmd = new G4UIcmdWithAnInteger("/process/verbose",this);
  verboseCmd->SetGuidance("Set Verbose Level for Process Table");
  verboseCmd->SetGuidance("  verbose [level]");
  verboseCmd->SetGuidance("   level: verbose level");
  verboseCmd->SetParameterName("verbose", true);
  verboseCmd->SetDefaultValue(1);
  verboseCmd->SetRange("verbose >=0");
  verboseCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
 
  // Command   /particle/process/setVerbose
  procVerboseCmd = new G4UIcommand("/process/setVerbose",this);
  procVerboseCmd->SetGuidance("Set verbose level for processes");
  procVerboseCmd->SetGuidance("  setVerbose level [type or name] ");
  procVerboseCmd->SetGuidance("    level: verbose level ");
  procVerboseCmd->SetGuidance("    name : process name ");
  procVerboseCmd->SetGuidance("    type : process type ");
  procVerboseCmd->SetGuidance("       [all] for all processes ");
  G4UIparameter* param = new G4UIparameter("verbose",'i',false);
  procVerboseCmd->SetParameter(param);
  param = new G4UIparameter("type",'s',true);
  param->SetDefaultValue("all");
  procVerboseCmd->SetParameter(param);
  procVerboseCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
 
  // Command   /particle/process/dump
  dumpCmd = new G4UIcommand("/process/dump",this);
  dumpCmd->SetGuidance("Dump process information");
  dumpCmd->SetGuidance(" dump name [particle]");
  dumpCmd->SetGuidance("   name:     process name or type name");
  dumpCmd->SetGuidance("   particle: particle name [all: for all particles]");
  param = new G4UIparameter("procName",'s',false);
  dumpCmd->SetParameter(param);
  param = new G4UIparameter("particle",'s',true);
  param->SetDefaultValue("all");
  dumpCmd->SetParameter(param);
  dumpCmd->AvailableForStates(G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
 
  // Command   /process/activate
  activateCmd = new G4UIcommand("/process/activate",this);
  activateCmd->SetGuidance("Activate processes  ");
  activateCmd->SetGuidance(" Activate  name [particle]");
  activateCmd->SetGuidance("   name:     process name or type name");
  activateCmd->SetGuidance("   particle: particle name [all: for all particles]");
  param = new G4UIparameter("procName",'s',false);
  activateCmd->SetParameter(param);
  param = new G4UIparameter("particle",'s',true);
  param->SetDefaultValue("all");
  activateCmd->SetParameter(param);
  activateCmd->AvailableForStates(G4State_Idle);
  
  // Command   /process/inactivate
  inactivateCmd = new G4UIcommand("/process/inactivate",this);
  inactivateCmd->SetGuidance("Inactivate process  ");
  inactivateCmd->SetGuidance("Inactivate processes  ");
  inactivateCmd->SetGuidance(" Inactivate  name [particle]");
  inactivateCmd->SetGuidance("   name:     process name or type name");
  inactivateCmd->SetGuidance("   particle: particle name [all: for all particles]");
  param = new G4UIparameter("procName",'s',false);
  inactivateCmd->SetParameter(param);
  param = new G4UIparameter("particle",'s',true);
  param->SetDefaultValue("all");
  inactivateCmd->SetParameter(param);
  inactivateCmd->AvailableForStates(G4State_Idle);
}

References activateCmd, G4UIcommand::AvailableForStates(), dumpCmd, G4State_EventProc, G4State_GeomClosed, G4State_Idle, G4State_Init, G4State_PreInit, G4VProcess::GetProcessTypeName(), inactivateCmd, listCmd, NumberOfProcessType, procVerboseCmd, G4UIcmdWithAString::SetCandidates(), G4UIcmdWithAString::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), SetNumberOfProcessType(), G4UIcommand::SetParameter(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcommand::SetRange(), thisDirectory, and verboseCmd.

~G4ProcessTableMessenger()

G4ProcessTableMessenger::~G4ProcessTableMessenger ( )

virtual

Definition at line 142 of file G4ProcessTableMessenger.cc.

{
  delete activateCmd; 
  delete inactivateCmd; 
  delete verboseCmd;
  delete dumpCmd;
  delete listCmd;
  delete procVerboseCmd;
  delete thisDirectory;
}

References activateCmd, dumpCmd, inactivateCmd, listCmd, procVerboseCmd, thisDirectory, and verboseCmd.

G4ProcessTableMessenger() [2/3]

G4ProcessTableMessenger::G4ProcessTableMessenger ( const G4ProcessTableMessenger &  )

delete

G4ProcessTableMessenger() [3/3]

G4ProcessTableMessenger::G4ProcessTableMessenger ( )

inlineprivate

Definition at line 70 of file G4ProcessTableMessenger.hh.

{}

Member Function Documentation

AddUIcommand()

void G4UImessenger::AddUIcommand ( G4UIcommand *  newCommand )

protectedinherited

Definition at line 149 of file G4UImessenger.cc.

{
  G4cerr << "Warning : Old style definition of G4UIcommand <"
         << newCommand->GetCommandPath() << ">." << G4endl;
}

References G4cerr, G4endl, and G4UIcommand::GetCommandPath().

BtoS()

G4String G4UImessenger::BtoS ( G4bool  b )

protectedinherited

Definition at line 98 of file G4UImessenger.cc.

{
  G4String vl = "0";
  if(b)
    vl = "true";
  return vl;
}

CommandsShouldBeInMaster()

G4bool G4UImessenger::CommandsShouldBeInMaster ( ) const

inlineinherited

Definition at line 77 of file G4UImessenger.hh.

    {
      return commandsShouldBeInMaster;
    }

References G4UImessenger::commandsShouldBeInMaster.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode().

CreateCommand()

template<typename T >

T * G4UImessenger::CreateCommand ( const G4String &  cname, const G4String &  dsc  )

protectedinherited

Definition at line 110 of file G4UImessenger.hh.

{
  G4String path;
  if(cname[0] != '/')
  {
    path = baseDirName + cname;
    if(path[0] != '/')
      path = "/" + path;
  }
 
  T* command = new T(path.c_str(), this);
  command->SetGuidance(dsc.c_str());
 
  return command;
}

References G4UImessenger::baseDirName.

CreateDirectory()

void G4UImessenger::CreateDirectory ( const G4String &  path, const G4String &  dsc, G4bool  commandsToBeBroadcasted = true  )

protectedinherited

Definition at line 156 of file G4UImessenger.cc.

{
  G4UImanager* ui = G4UImanager::GetUIpointer();
 
  G4String fullpath = path;
  if(fullpath.back() != '/')
    fullpath.append("/");
 
  G4UIcommandTree* tree = ui->GetTree()->FindCommandTree(fullpath.c_str());
  if(tree != nullptr)
  {
    baseDirName = tree->GetPathName();
  }
  else
  {
    baseDir     = new G4UIdirectory(fullpath.c_str(), commandsToBeBroadcasted);
    baseDirName = fullpath;
    baseDir->SetGuidance(dsc.c_str());
  }
}

References G4UImessenger::baseDir, G4UImessenger::baseDirName, G4UIcommandTree::FindCommandTree(), G4UIcommandTree::GetPathName(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), and G4UIcommand::SetGuidance().

Referenced by G4MoleculeShootMessenger::G4MoleculeShootMessenger(), and G4UImessenger::G4UImessenger().

DtoS()

G4String G4UImessenger::DtoS ( G4double  a )

protectedinherited

Definition at line 90 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << a;
  return G4String(os.str());
}

Referenced by G4ScoreQuantityMessenger::FilterCommands(), and G4UIcontrolMessenger::SetNewValue().

GetCurrentValue()

G4String G4ProcessTableMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 369 of file G4ProcessTableMessenger.cc.

{
  if( command==verboseCmd )
  {
    // Command   /process/verbose
    return verboseCmd->ConvertToString(theProcessTable->GetVerboseLevel());
  }
  else if ( command==listCmd )
  {
    // Command   /process/list
    return currentProcessTypeName;
  }
  else
  {
    // Command   /process/dump, activate, inactivate
    return   (currentProcessName + " " + currentParticleName);
  }
 
  return "";
}

References G4UIcommand::ConvertToString(), currentParticleName, currentProcessName, currentProcessTypeName, G4ProcessTable::GetVerboseLevel(), listCmd, theProcessTable, and verboseCmd.

GetProcessType()

G4int G4ProcessTableMessenger::GetProcessType ( const G4String &  aTypeName ) const

private

Definition at line 397 of file G4ProcessTableMessenger.cc.

{
  G4int type = -1;
  for (G4int idx = 0; idx < NumberOfProcessType ; ++idx )
  {
    if (aTypeName == G4VProcess::GetProcessTypeName(G4ProcessType(idx)) )
    {
      type = idx;
      break;
    }
  }
  return type;
}

References G4VProcess::GetProcessTypeName(), and NumberOfProcessType.

Referenced by SetNewValue().

GetProcessTypeName()

G4String G4ProcessTableMessenger::GetProcessTypeName ( G4ProcessType  aType ) const

private

Definition at line 391 of file G4ProcessTableMessenger.cc.

{
  return G4VProcess::GetProcessTypeName(aType);
}

References G4VProcess::GetProcessTypeName().

ItoS()

G4String G4UImessenger::ItoS ( G4int  i )

protectedinherited

Definition at line 82 of file G4UImessenger.cc.

{
  std::ostringstream os;
  os << i;
  return G4String(os.str());
}

Referenced by G4GenericMessenger::DeclareMethod(), and G4ParticleGunMessenger::GetCurrentValue().

operator!=()

G4bool G4UImessenger::operator!= ( const G4UImessenger &  messenger ) const

inherited

Definition at line 76 of file G4UImessenger.cc.

{
  return this != &messenger;
}

operator=()

G4ProcessTableMessenger & G4ProcessTableMessenger::operator= ( const G4ProcessTableMessenger &  )

delete

operator==()

G4bool G4UImessenger::operator== ( const G4UImessenger &  messenger ) const

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

SetNewValue()

void G4ProcessTableMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValues  )

virtual

Reimplemented from G4UImessenger.

Definition at line 155 of file G4ProcessTableMessenger.cc.

{
  G4ProcessTable::G4ProcNameVector* procNameVector 
                         = theProcessTable->GetNameList(); 
  G4int idx;
  G4int type = -1;
  G4ExceptionDescription ed;
 
  if( command == listCmd )
  {
    // Command  /process/list
    type = -1;
    if (newValue == "all")
    {
      currentProcessTypeName = newValue;
    }
    else
    {
      type  = GetProcessType(newValue);
      if (type <0)
      {
        G4cout << " illegal type !!! " << G4endl;
      }
      else
      {
        currentProcessTypeName = newValue;
      }
    }    
    G4int counter = 0;
    idx = 0;
    for (auto itr=procNameVector->cbegin(); itr!=procNameVector->cend(); ++itr)
    {
      ++idx;
      G4ProcessVector* tmpVector = theProcessTable->FindProcesses(*itr);
      if ( (type <0) || ( ((*tmpVector)(0)->GetProcessType()) == type) )
      {
        if ( counter%4 != 0) G4cout << ",";
        G4cout << std::setw(19) << *itr;
        if ((counter++)%4 == 3)
        {
          G4cout << G4endl;
        }
      }
      delete tmpVector;
    }
    G4cout << G4endl;
  }
  else if( command==procVerboseCmd )
  {
    // Command  /process/setVerbose
    G4Tokenizer next( newValue );
 
    // check 1st argument
    G4String tmpS = G4String(next());
    //  inputstream for newValues
    const char* temp = (const char*)(tmpS);
    std::istringstream is((char*)temp);
    G4int level;
    is  >>level;
 
    // check 2nd argument
    currentProcessTypeName = G4String(next());
    if (currentProcessTypeName.empty()) currentProcessTypeName = "all";
    G4bool isProcName = false;
    G4bool isAll = false;
    type = -1;
 
    if (currentProcessTypeName == "all")
    {
      isAll = true; 
    }
    else
    {
      type  = GetProcessType(currentProcessTypeName);
      if (type<0)
      {
        isProcName = true;
        currentProcessName = currentProcessTypeName;
        currentProcessTypeName = "";
      }
    }  
    idx = 0;
    for (auto itr=procNameVector->cbegin(); itr!=procNameVector->cend(); ++itr)
    {
      ++idx;
      G4ProcessVector* tmpVector = theProcessTable->FindProcesses(*itr);
      G4VProcess* p = (*tmpVector)(0);
      if ( isAll || 
           (!isProcName && ( p->GetProcessType() == type) ) ||
           ( isProcName && ( p->GetProcessName()== currentProcessName) ) )
      {
        p->SetVerboseLevel(level);
      }
      delete tmpVector;
    }
  }
  else if( command==verboseCmd )
  {
    // Command   /process/verbose
    theProcessTable->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue));
  }
  else
  {
    G4Tokenizer next( newValue );
 
    // check 1st argument
    currentProcessName = G4String(next());
    G4bool isProcName = false; 
    for (auto itr=procNameVector->cbegin(); itr!=procNameVector->cend(); ++itr)
    {
      if ( (*itr) == currentProcessName )
      {
        isProcName = true; 
        break;
      }
    }
    if (!isProcName)
    {
      type  = GetProcessType(currentProcessName);
      if (type <0 )
      {
        // no processes with specified name
        ed << " illegal process (or type) name ["
           << currentProcessName << "]";
        command->CommandFailed(ed);
        currentProcessName = "";
        return;
      }
    }
  
    // check 2nd argument
    currentParticleName = G4String(next());
    G4bool isParticleFound = false;
    G4ParticleDefinition* currentParticle = nullptr;
    if ( currentParticleName == "all" )
    {
      isParticleFound = true;
    }
    else
    {
      isParticleFound = G4ParticleTable::GetParticleTable()
                      ->contains(currentParticleName);
      if (isParticleFound)
      {
        currentParticle = G4ParticleTable::GetParticleTable()
                        ->FindParticle(currentParticleName);
      }
    }
 
    if ( !isParticleFound )
    {
      // no particle with specified name
      ed << " illegal particle name [" << currentParticleName << "]";
      command->CommandFailed(ed);
      currentParticleName = "";
      return;
    }
        
    if( command==dumpCmd )
    {
      // process/dump
      G4ProcessVector* tmpVector;
      if (isProcName)
      {
        tmpVector = theProcessTable->FindProcesses(currentProcessName);
      }
      else
      {
        tmpVector = theProcessTable->FindProcesses(G4ProcessType(type));
      }
      for (std::size_t i=0; i<tmpVector->length(); ++i)
      {
        theProcessTable->DumpInfo( (*tmpVector)(i), currentParticle );
      }
      delete tmpVector;
    }
    else if ( (command==activateCmd) || (command==inactivateCmd))
    {
      // process/activate , inactivate
      G4bool fActive = (command==activateCmd);
      if (isProcName)
      {
        if ( currentParticle == nullptr )
        {
          theProcessTable->SetProcessActivation(currentProcessName, 
                                                fActive);
        }
        else
        {
          theProcessTable->SetProcessActivation(currentProcessName,
                                                currentParticle,
                                                fActive);
        }
      }
      else
      {
        if ( currentParticle == nullptr )
        {
          theProcessTable->SetProcessActivation(G4ProcessType(type),
                                                fActive);
        }
        else
        {
          theProcessTable->SetProcessActivation(G4ProcessType(type),
                                                currentParticle,
                                                fActive);
        }
      }
      G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
    } 
  }
}

References activateCmd, G4UImanager::ApplyCommand(), G4UIcommand::CommandFailed(), G4ParticleTable::contains(), currentParticleName, currentProcessName, currentProcessTypeName, dumpCmd, G4ProcessTable::DumpInfo(), G4ParticleTable::FindParticle(), G4ProcessTable::FindProcesses(), G4cout, G4endl, G4ProcessTable::GetNameList(), G4UIcmdWithAnInteger::GetNewIntValue(), G4ParticleTable::GetParticleTable(), G4VProcess::GetProcessName(), G4VProcess::GetProcessType(), GetProcessType(), G4UImanager::GetUIpointer(), inactivateCmd, G4ProcessVector::length(), listCmd, procVerboseCmd, G4ProcessTable::SetProcessActivation(), G4ProcessTable::SetVerboseLevel(), G4VProcess::SetVerboseLevel(), theProcessTable, and verboseCmd.

SetNumberOfProcessType()

void G4ProcessTableMessenger::SetNumberOfProcessType ( )

private

Definition at line 412 of file G4ProcessTableMessenger.cc.

{
  G4bool isFoundEndMark = false;
  G4int idx;
  for (idx = 0; idx < 1000 ; ++idx )
  {
    G4String typeName = G4VProcess::GetProcessTypeName(G4ProcessType(idx));
    isFoundEndMark = G4StrUtil::contains(typeName, "---");
    if ( isFoundEndMark ) break;
  }
  if ( isFoundEndMark )
  {
    NumberOfProcessType = idx;
  }
  else
  {
    G4Exception("G4ProcessTableMessenger::SetNumberOfProcessType()",
                "ProcMan014", FatalException, "No End Mark");
  } 
}

References G4StrUtil::contains(), FatalException, G4Exception(), G4VProcess::GetProcessTypeName(), and NumberOfProcessType.

Referenced by G4ProcessTableMessenger().

StoB()

G4bool G4UImessenger::StoB ( G4String  s )

protectedinherited

Definition at line 137 of file G4UImessenger.cc.

{
  G4String v = G4StrUtil::to_upper_copy(str);
  G4bool vl = false;
  if(v == "Y" || v == "YES" || v == "1" || v == "T" || v == "TRUE")
  {
    vl = true;
  }
  return vl;
}

References G4StrUtil::to_upper_copy().

Referenced by G4LocalThreadCoutMessenger::SetNewValue(), G4CascadeParamMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

StoD()

G4double G4UImessenger::StoD ( G4String  s )

protectedinherited

Definition at line 127 of file G4UImessenger.cc.

{
  G4double vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), G4ScoringMessenger::SetNewValue(), and G4PolarizationMessenger::SetNewValue().

StoI()

G4int G4UImessenger::StoI ( G4String  s )

protectedinherited

Definition at line 107 of file G4UImessenger.cc.

{
  G4int vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4ScoringMessenger::Fill1D(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4ParticleGunMessenger::IonLevelCommand(), G4GeneralParticleSourceMessenger::IonLvlCommand(), G4ScoringMessenger::MeshBinCommand(), G4LocalThreadCoutMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4GMocrenMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

StoL()

G4long G4UImessenger::StoL ( G4String  s )

protectedinherited

Definition at line 117 of file G4UImessenger.cc.

{
  G4long vl;
  const char* t = str;
  std::istringstream is(t);
  is >> vl;
  return vl;
}

Referenced by G4RunMessenger::SetNewValue().

Field Documentation

activateCmd

G4UIcommand* G4ProcessTableMessenger::activateCmd = nullptr

private

Definition at line 85 of file G4ProcessTableMessenger.hh.

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

baseDir

G4UIdirectory* G4UImessenger::baseDir = nullptr

protectedinherited

Definition at line 102 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateDirectory(), and G4UImessenger::~G4UImessenger().

baseDirName

G4String G4UImessenger::baseDirName = ""

protectedinherited

Definition at line 103 of file G4UImessenger.hh.

Referenced by G4UImessenger::CreateCommand(), and G4UImessenger::CreateDirectory().

commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

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

currentParticleName

G4String G4ProcessTableMessenger::currentParticleName = "all"

private

Definition at line 91 of file G4ProcessTableMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

currentProcessName

G4String G4ProcessTableMessenger::currentProcessName = "all"

private

Definition at line 90 of file G4ProcessTableMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

currentProcessTypeName

G4String G4ProcessTableMessenger::currentProcessTypeName = "all"

private

Definition at line 89 of file G4ProcessTableMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

dumpCmd

G4UIcommand* G4ProcessTableMessenger::dumpCmd = nullptr

private

Definition at line 84 of file G4ProcessTableMessenger.hh.

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

inactivateCmd

G4UIcommand* G4ProcessTableMessenger::inactivateCmd = nullptr

private

Definition at line 86 of file G4ProcessTableMessenger.hh.

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

listCmd

G4UIcmdWithAString* G4ProcessTableMessenger::listCmd = nullptr

private

Definition at line 83 of file G4ProcessTableMessenger.hh.

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

NumberOfProcessType

G4ThreadLocal G4int G4ProcessTableMessenger::NumberOfProcessType = 10

staticprivate

Definition at line 74 of file G4ProcessTableMessenger.hh.

Referenced by G4ProcessTableMessenger(), GetProcessType(), and SetNumberOfProcessType().

procVerboseCmd

G4UIcommand* G4ProcessTableMessenger::procVerboseCmd = nullptr

private

Definition at line 87 of file G4ProcessTableMessenger.hh.

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

theProcessTable

G4ProcessTable* G4ProcessTableMessenger::theProcessTable = nullptr

private

Definition at line 79 of file G4ProcessTableMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

thisDirectory

G4UIdirectory* G4ProcessTableMessenger::thisDirectory = nullptr

private

Definition at line 81 of file G4ProcessTableMessenger.hh.

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

verboseCmd

G4UIcmdWithAnInteger* G4ProcessTableMessenger::verboseCmd = nullptr

private

Definition at line 82 of file G4ProcessTableMessenger.hh.

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

---

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

• source/processes/management/include/G4ProcessTableMessenger.hh
• source/processes/management/src/G4ProcessTableMessenger.cc