G4UserPhysicsListMessenger Class Reference

#include <G4UserPhysicsListMessenger.hh>

Inheritance diagram for G4UserPhysicsListMessenger:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const
	G4UserPhysicsListMessenger (G4VUserPhysicsList *pParticleList)
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	operator== (const G4UImessenger &messenger) const
virtual void	SetNewValue (G4UIcommand *command, G4String newValues)
virtual	~G4UserPhysicsListMessenger ()

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
G4VUserPhysicsList *	thePhysicsList = nullptr

Private Member Functions
	G4UserPhysicsListMessenger ()

Private Attributes
G4UIcmdWithAString *	addProcManCmd = nullptr
G4UIcommand *	applyCutsCmd = nullptr
G4UIcmdWithAnInteger *	asciiCmd = nullptr
G4UIcmdWithAString *	buildPTCmd = nullptr
G4UIcmdWithAString *	dumpCutValuesCmd = nullptr
G4UIcmdWithoutParameter *	dumpListCmd = nullptr
G4UIcmdWithAnInteger *	dumpOrdParamCmd = nullptr
G4UIcmdWithAString *	getCutForAGivenParticleCmd = nullptr
G4UIcmdWithAString *	retrieveCmd = nullptr
G4UIcmdWithADoubleAndUnit *	setCutCmd = nullptr
G4UIcommand *	setCutForAGivenParticleCmd = nullptr
G4UIcommand *	setCutRCmd = nullptr
G4UIcmdWithAString *	storeCmd = nullptr
G4UIdirectory *	theDirectory = nullptr
G4UIcmdWithAnInteger *	verboseCmd = nullptr

Detailed Description

Definition at line 63 of file G4UserPhysicsListMessenger.hh.

Constructor & Destructor Documentation

G4UserPhysicsListMessenger() [1/2]

G4UserPhysicsListMessenger::G4UserPhysicsListMessenger

(

G4VUserPhysicsList *

pParticleList

)

Definition at line 48 of file G4UserPhysicsListMessenger.cc.

  : thePhysicsList(pParticleList)
{
  G4UIparameter* param = nullptr;
  // /run/particle    directory
  theDirectory = new G4UIdirectory("/run/particle/");
  theDirectory->SetGuidance("Commands for G4VUserPhysicsList.");
 
  // /run/particle/Verbose command
  verboseCmd = new G4UIcmdWithAnInteger("/run/particle/verbose", this);
  verboseCmd->SetGuidance("Set the Verbose level of G4VUserPhysicsList.");
  verboseCmd->SetGuidance(" 0 : Silent (default)");
  verboseCmd->SetGuidance(" 1 : Display warning messages");
  verboseCmd->SetGuidance(" 2 : Display more");
  verboseCmd->SetParameterName("level", true);
  verboseCmd->SetDefaultValue(0);
  verboseCmd->SetRange("level >=0 && level <=3");
 
  // /run/setCut command
  setCutCmd = new G4UIcmdWithADoubleAndUnit("/run/setCut", this);
  setCutCmd->SetGuidance("Set default cut value ");
  setCutCmd->SetParameterName("cut", false);
  setCutCmd->SetDefaultValue(1.0);
  setCutCmd->SetRange("cut >=0.0");
  setCutCmd->SetDefaultUnit("mm");
  setCutCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  // /run/setCutForAGivenParticle command
  setCutForAGivenParticleCmd =
    new G4UIcommand("/run/setCutForAGivenParticle", this);
  setCutForAGivenParticleCmd->SetGuidance(
    "Set a cut value to a specific particle ");
  setCutForAGivenParticleCmd->SetGuidance(
    "Usage: /run/setCutForAGivenParticle  gamma  1. mm");
  param = new G4UIparameter("particleName", 's', false);
  param->SetParameterCandidates("e- e+ gamma proton");
  setCutForAGivenParticleCmd->SetParameter(param);
  param = new G4UIparameter("cut", 'd', false);
  param->SetDefaultValue("1.");
  param->SetParameterRange("cut>=0.0");
  setCutForAGivenParticleCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', false);
  param->SetDefaultUnit("mm");
  setCutForAGivenParticleCmd->SetParameter(param);
  setCutForAGivenParticleCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  // /run/getCutForAGivenParticle command
  getCutForAGivenParticleCmd =
    new G4UIcmdWithAString("/run/getCutForAGivenParticle", this);
  getCutForAGivenParticleCmd->SetGuidance(
    "Get a cut value to a specific particle ");
  getCutForAGivenParticleCmd->SetGuidance(
    "Usage: /run/getCutForAGivenParticle  gamma ");
  getCutForAGivenParticleCmd->SetParameterName("particleName", false, false);
  getCutForAGivenParticleCmd->SetCandidates("e- e+ gamma proton");
  getCutForAGivenParticleCmd->AvailableForStates(
    G4State_PreInit, G4State_Idle, G4State_GeomClosed, G4State_EventProc);
 
  // /run/setCutForRegion command
  setCutRCmd = new G4UIcommand("/run/setCutForRegion", this);
  setCutRCmd->SetGuidance("Set cut value for a region");
  param = new G4UIparameter("Region", 's', false);
  setCutRCmd->SetParameter(param);
  param = new G4UIparameter("cut", 'd', false);
  param->SetParameterRange("cut >=0.0");
  setCutRCmd->SetParameter(param);
  param = new G4UIparameter("Unit", 's', true);
  param->SetDefaultValue("mm");
  param->SetParameterCandidates(
    setCutRCmd->UnitsList(setCutRCmd->CategoryOf("mm")));
  setCutRCmd->SetParameter(param);
  setCutRCmd->AvailableForStates(G4State_Idle);
 
  // /run/particle/DumpList command
  dumpListCmd = new G4UIcmdWithoutParameter("/run/particle/dumpList", this);
  dumpListCmd->SetGuidance("Dump List of particles in G4VUserPhysicsList. ");
 
  // /run/particle/addProcManager command
  addProcManCmd = new G4UIcmdWithAString("/run/particle/addProcManager", this);
  addProcManCmd->SetToBeBroadcasted(false);
  addProcManCmd->SetGuidance("add process manager to specified particle type");
  addProcManCmd->SetParameterName("particleType", true);
  addProcManCmd->SetDefaultValue("");
  addProcManCmd->AvailableForStates(G4State_PreInit, G4State_Init, G4State_Idle,
                                    G4State_GeomClosed, G4State_EventProc);
 
  // /run/particle/buildPhysicsTable command
  buildPTCmd = new G4UIcmdWithAString("/run/particle/buildPhysicsTable", this);
  buildPTCmd->SetGuidance("build physics table of specified particle type");
  buildPTCmd->SetParameterName("particleType", true);
  buildPTCmd->SetDefaultValue("");
  buildPTCmd->AvailableForStates(G4State_Init, G4State_Idle, G4State_GeomClosed,
                                 G4State_EventProc);
 
  // /run/particle/storePhysicsTable command
  storeCmd = new G4UIcmdWithAString("/run/particle/storePhysicsTable", this);
  storeCmd->SetGuidance("Store Physics Table");
  storeCmd->SetGuidance("  Enter directory name");
  storeCmd->SetParameterName("dirName", true);
  storeCmd->SetDefaultValue("");
  storeCmd->AvailableForStates(G4State_Idle);
 
  //  /run/particle/retrievePhysicsTable command
  retrieveCmd =
    new G4UIcmdWithAString("/run/particle/retrievePhysicsTable", this);
  retrieveCmd->SetGuidance("Retrieve Physics Table");
  retrieveCmd->SetGuidance("  Enter directory name or OFF to switch off");
  retrieveCmd->SetParameterName("dirName", true);
  retrieveCmd->SetDefaultValue("");
  retrieveCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  //  /run/particle/setStoredInAscii command
  asciiCmd = new G4UIcmdWithAnInteger("/run/particle/setStoredInAscii", this);
  asciiCmd->SetGuidance(
    "Switch on/off ascii mode in store/retrieve Physics Table");
  asciiCmd->SetGuidance("  Enter 0(binary) or 1(ascii)");
  asciiCmd->SetParameterName("ascii", true);
  asciiCmd->SetDefaultValue(0);
  asciiCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
  asciiCmd->SetRange("ascii ==0 || ascii ==1");
 
  // Commnad    /run/particle/applyCuts command
  applyCutsCmd = new G4UIcommand("/run/particle/applyCuts", this);
  applyCutsCmd->SetGuidance("Set applyCuts flag for a particle.");
  applyCutsCmd->SetGuidance(
    " Some EM processes which do not have infrared divergence");
  applyCutsCmd->SetGuidance(
    "may generate gamma, e- and/or e+ with kinetic energies");
  applyCutsCmd->SetGuidance(
    "below the production threshold. By setting this flag,");
  applyCutsCmd->SetGuidance(
    "such secondaries below threshold are eliminated and");
  applyCutsCmd->SetGuidance(
    "kinetic energies of such secondaries are accumulated");
  applyCutsCmd->SetGuidance("to the energy deposition of their mother.");
  applyCutsCmd->SetGuidance(
    " Note that 'applyCuts' makes sense only for gamma,");
  applyCutsCmd->SetGuidance(
    "e- and e+. If this command is issued for other particle,");
  applyCutsCmd->SetGuidance(
    "a warning message is displayed and the command is");
  applyCutsCmd->SetGuidance("ignored.");
  applyCutsCmd->SetGuidance(
    " If particle name is 'all', this command affects on");
  applyCutsCmd->SetGuidance("gamma, e- and e+.");
  param = new G4UIparameter("Flag", 's', true);
  param->SetDefaultValue("true");
  applyCutsCmd->SetParameter(param);
  param = new G4UIparameter("Particle", 's', true);
  param->SetDefaultValue("all");
  applyCutsCmd->SetParameter(param);
  applyCutsCmd->AvailableForStates(G4State_PreInit, G4State_Init, G4State_Idle);
 
  //  /run/particle/dumpCutValues command
  dumpCutValuesCmd =
    new G4UIcmdWithAString("/run/particle/dumpCutValues", this);
  dumpCutValuesCmd->SetGuidance(
    "Dump a list of production threshold values in range and energy");
  dumpCutValuesCmd->SetGuidance("for all registered material-cuts-couples.");
  dumpCutValuesCmd->SetGuidance(
    "Dumping a list takes place when you issue 'beamOn' and");
  dumpCutValuesCmd->SetGuidance(
    "actual conversion tables from range to energy are available.");
  dumpCutValuesCmd->SetGuidance(
    "If you want a list 'immediately', use '/run/dumpRegion' for threshold");
  dumpCutValuesCmd->SetGuidance(
    "list given in range only. Also, '/run/dumpCouples' gives you the");
  dumpCutValuesCmd->SetGuidance(
    "current list if you have already issued 'run/beamOn' at least once.");
  dumpCutValuesCmd->SetParameterName("particle", true);
  dumpCutValuesCmd->SetDefaultValue("all");
  dumpCutValuesCmd->AvailableForStates(G4State_Idle);
 
  //  /run/particle/dumpCutValues command
  dumpOrdParamCmd =
    new G4UIcmdWithAnInteger("/run/particle/dumpOrderingParam", this);
  dumpOrdParamCmd->SetGuidance("Dump a list of ordering parameter ");
  dumpOrdParamCmd->SetParameterName("subtype", true);
  dumpOrdParamCmd->SetDefaultValue(-1);
  dumpOrdParamCmd->AvailableForStates(G4State_PreInit, G4State_Init,
                                      G4State_Idle);
}

References addProcManCmd, applyCutsCmd, asciiCmd, G4UIcommand::AvailableForStates(), buildPTCmd, G4UIcommand::CategoryOf(), dumpCutValuesCmd, dumpListCmd, dumpOrdParamCmd, G4State_EventProc, G4State_GeomClosed, G4State_Idle, G4State_Init, G4State_PreInit, getCutForAGivenParticleCmd, retrieveCmd, G4UIcmdWithAString::SetCandidates(), setCutCmd, setCutForAGivenParticleCmd, setCutRCmd, G4UIcmdWithADoubleAndUnit::SetDefaultUnit(), G4UIparameter::SetDefaultUnit(), G4UIcmdWithAString::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIcmdWithADoubleAndUnit::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), G4UIparameter::SetParameterCandidates(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIparameter::SetParameterRange(), G4UIcommand::SetRange(), G4UIcommand::SetToBeBroadcasted(), storeCmd, theDirectory, G4UIcommand::UnitsList(), and verboseCmd.

~G4UserPhysicsListMessenger()

G4UserPhysicsListMessenger::~G4UserPhysicsListMessenger ( )

virtual

Definition at line 233 of file G4UserPhysicsListMessenger.cc.

{
  delete setCutCmd;
  delete setCutRCmd;
  delete setCutForAGivenParticleCmd;
  delete getCutForAGivenParticleCmd;
  delete verboseCmd;
  delete dumpListCmd;
  delete addProcManCmd;
  delete buildPTCmd;
  delete storeCmd;
  delete retrieveCmd;
  delete asciiCmd;
  delete applyCutsCmd;
  delete dumpCutValuesCmd;
  delete dumpOrdParamCmd;
  delete theDirectory;
}

References addProcManCmd, applyCutsCmd, asciiCmd, buildPTCmd, dumpCutValuesCmd, dumpListCmd, dumpOrdParamCmd, getCutForAGivenParticleCmd, retrieveCmd, setCutCmd, setCutForAGivenParticleCmd, setCutRCmd, storeCmd, theDirectory, and verboseCmd.

G4UserPhysicsListMessenger() [2/2]

G4UserPhysicsListMessenger::G4UserPhysicsListMessenger ( )

inlineprivate

Definition at line 79 of file G4UserPhysicsListMessenger.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 G4UserPhysicsListMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 382 of file G4UserPhysicsListMessenger.cc.

{
  G4String cv;
  G4String candidates("none");
  auto piter = G4ParticleTable::GetParticleTable()->GetIterator();
 
  if(command == setCutCmd)
  {
    cv = setCutCmd->ConvertToString(thePhysicsList->GetDefaultCutValue(), "mm");
  }
  else if(command == verboseCmd)
  {
    cv = verboseCmd->ConvertToString(thePhysicsList->GetVerboseLevel());
  }
  else if(command == addProcManCmd)
  {
    // set candidate list
    piter->reset();
    while((*piter)())
    {
      G4ParticleDefinition* particle = piter->value();
      candidates += " " + particle->GetParticleName();
    }
    addProcManCmd->SetCandidates(candidates);
    cv = "";
  }
  else if(command == buildPTCmd)
  {
    // set candidate list
    piter->reset();
    while((*piter)())
    {
      G4ParticleDefinition* particle = piter->value();
      candidates += " " + particle->GetParticleName();
    }
    addProcManCmd->SetCandidates(candidates);
    cv = "";
  }
  else if(command == storeCmd)
  {
    cv = thePhysicsList->GetPhysicsTableDirectory();
  }
  else if(command == retrieveCmd)
  {
    if(thePhysicsList->IsPhysicsTableRetrieved())
    {
      cv = thePhysicsList->GetPhysicsTableDirectory();
    }
    else
    {
      cv = "OFF";
    }
  }
  else if(command == asciiCmd)
  {
    if(thePhysicsList->IsStoredInAscii())
    {
      cv = "1";
    }
    else
    {
      cv = "0";
    }
  }
 
  return cv;
}

References addProcManCmd, asciiCmd, buildPTCmd, G4UIcommand::ConvertToString(), G4VUserPhysicsList::GetDefaultCutValue(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4VUserPhysicsList::GetPhysicsTableDirectory(), G4VUserPhysicsList::GetVerboseLevel(), G4VUserPhysicsList::IsPhysicsTableRetrieved(), G4VUserPhysicsList::IsStoredInAscii(), retrieveCmd, G4UIcmdWithAString::SetCandidates(), setCutCmd, storeCmd, thePhysicsList, and verboseCmd.

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

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

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 253 of file G4UserPhysicsListMessenger.cc.

{
  G4ExceptionDescription ed;
  if(command == setCutCmd)
  {
    G4double newCut = setCutCmd->GetNewDoubleValue(newValue);
    thePhysicsList->SetDefaultCutValue(newCut);
    thePhysicsList->SetCuts();
  }
  else if(command == setCutForAGivenParticleCmd)
  {
    G4String particleName, unit;
    G4double cut;
    std::istringstream str(newValue);
    str >> particleName >> cut >> unit;
    thePhysicsList->SetCutValue(cut * G4UIcommand::ValueOf(unit), particleName);
  }
  else if(command == getCutForAGivenParticleCmd)
  {
    G4cout << thePhysicsList->GetCutValue(newValue) / mm << "[mm]" << G4endl;
  }
  else if(command == setCutRCmd)
  {
    std::istringstream is(newValue);
    G4String regName;
    G4String uniName;
    G4double cVal = -1.0;
    is >> regName >> cVal >> uniName;
    if(is.fail())
    {
      ed << "illegal arguments : " << newValue;
      command->CommandFailed(ed);
      return;
    }
    thePhysicsList->SetCutsForRegion(cVal * (setCutRCmd->ValueOf(uniName)),
                                     regName);
  }
  else if(command == verboseCmd)
  {
    thePhysicsList->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue));
  }
  else if(command == dumpListCmd)
  {
    thePhysicsList->DumpList();
  }
  else if(command == dumpOrdParamCmd)
  {
    G4int stype = dumpOrdParamCmd->GetNewIntValue(newValue);
    G4PhysicsListHelper::GetPhysicsListHelper()->DumpOrdingParameterTable(
      stype);
  }
  else if(command == addProcManCmd)
  {
    G4ParticleDefinition* particle =
      (G4ParticleTable::GetParticleTable())->FindParticle(newValue);
    if(particle == nullptr)
    {
      ed << " Particle is not found : " << newValue;
      command->CommandFailed(ed);
      return;
    }
    else if(particle->GetProcessManager() != nullptr)
    {
      ed << " Particle is not initialized : " << newValue;
      command->CommandFailed(ed);
      return;
    }
    thePhysicsList->AddProcessManager(particle);
  }
  else if(command == buildPTCmd)
  {
    G4ParticleDefinition* particle =
      (G4ParticleTable::GetParticleTable())->FindParticle(newValue);
    if(particle == nullptr)
    {
      ed << " Particle is not found : " << newValue;
      command->CommandFailed(ed);
      return;
    }
    thePhysicsList->PreparePhysicsTable(particle);
    thePhysicsList->BuildPhysicsTable(particle);
  }
  else if(command == storeCmd)
  {
    thePhysicsList->StorePhysicsTable(newValue);
  }
  else if(command == retrieveCmd)
  {
    if((newValue == "OFF") || (newValue == "off"))
    {
      thePhysicsList->ResetPhysicsTableRetrieved();
    }
    else
    {
      thePhysicsList->SetPhysicsTableRetrieved(newValue);
    }
  }
  else if(command == asciiCmd)
  {
    if(asciiCmd->GetNewIntValue(newValue) == 0)
    {
      thePhysicsList->ResetStoredInAscii();
    }
    else
    {
      thePhysicsList->SetStoredInAscii();
    }
  }
  else if(command == applyCutsCmd)
  {
    G4Tokenizer next(newValue);
 
    // check 1st argument
    G4String temp = G4String(next());
    G4bool flag   = (temp == "true" || temp == "TRUE");
 
    // check 2nd argument
    G4String name = G4String(next());
 
    thePhysicsList->SetApplyCuts(flag, name);
  }
  else if(command == dumpCutValuesCmd)
  {
    thePhysicsList->DumpCutValuesTable(1);
  }
}

References G4VUserPhysicsList::AddProcessManager(), addProcManCmd, applyCutsCmd, asciiCmd, G4VUserPhysicsList::BuildPhysicsTable(), buildPTCmd, G4UIcommand::CommandFailed(), dumpCutValuesCmd, G4VUserPhysicsList::DumpCutValuesTable(), G4VUserPhysicsList::DumpList(), dumpListCmd, G4PhysicsListHelper::DumpOrdingParameterTable(), dumpOrdParamCmd, G4cout, G4endl, getCutForAGivenParticleCmd, G4VUserPhysicsList::GetCutValue(), G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(), G4UIcmdWithAnInteger::GetNewIntValue(), G4ParticleTable::GetParticleTable(), G4PhysicsListHelper::GetPhysicsListHelper(), G4ParticleDefinition::GetProcessManager(), mm, G4InuclParticleNames::name(), G4VUserPhysicsList::PreparePhysicsTable(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), G4VUserPhysicsList::ResetStoredInAscii(), retrieveCmd, G4VUserPhysicsList::SetApplyCuts(), setCutCmd, setCutForAGivenParticleCmd, setCutRCmd, G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetCutsForRegion(), G4VUserPhysicsList::SetCutValue(), G4VUserPhysicsList::SetDefaultCutValue(), G4VUserPhysicsList::SetPhysicsTableRetrieved(), G4VUserPhysicsList::SetStoredInAscii(), G4VUserPhysicsList::SetVerboseLevel(), storeCmd, G4VUserPhysicsList::StorePhysicsTable(), thePhysicsList, G4UIcommand::ValueOf(), and verboseCmd.

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

addProcManCmd

G4UIcmdWithAString* G4UserPhysicsListMessenger::addProcManCmd = nullptr

private

Definition at line 89 of file G4UserPhysicsListMessenger.hh.

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

applyCutsCmd

G4UIcommand* G4UserPhysicsListMessenger::applyCutsCmd = nullptr

private

Definition at line 94 of file G4UserPhysicsListMessenger.hh.

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

asciiCmd

G4UIcmdWithAnInteger* G4UserPhysicsListMessenger::asciiCmd = nullptr

private

Definition at line 93 of file G4UserPhysicsListMessenger.hh.

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

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().

buildPTCmd

G4UIcmdWithAString* G4UserPhysicsListMessenger::buildPTCmd = nullptr

private

Definition at line 90 of file G4UserPhysicsListMessenger.hh.

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

commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

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

dumpCutValuesCmd

G4UIcmdWithAString* G4UserPhysicsListMessenger::dumpCutValuesCmd = nullptr

private

Definition at line 95 of file G4UserPhysicsListMessenger.hh.

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

dumpListCmd

G4UIcmdWithoutParameter* G4UserPhysicsListMessenger::dumpListCmd = nullptr

private

Definition at line 88 of file G4UserPhysicsListMessenger.hh.

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

dumpOrdParamCmd

G4UIcmdWithAnInteger* G4UserPhysicsListMessenger::dumpOrdParamCmd = nullptr

private

Definition at line 96 of file G4UserPhysicsListMessenger.hh.

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

getCutForAGivenParticleCmd

G4UIcmdWithAString* G4UserPhysicsListMessenger::getCutForAGivenParticleCmd = nullptr

private

Definition at line 86 of file G4UserPhysicsListMessenger.hh.

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

retrieveCmd

G4UIcmdWithAString* G4UserPhysicsListMessenger::retrieveCmd = nullptr

private

Definition at line 92 of file G4UserPhysicsListMessenger.hh.

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

setCutCmd

G4UIcmdWithADoubleAndUnit* G4UserPhysicsListMessenger::setCutCmd = nullptr

private

Definition at line 83 of file G4UserPhysicsListMessenger.hh.

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

setCutForAGivenParticleCmd

G4UIcommand* G4UserPhysicsListMessenger::setCutForAGivenParticleCmd = nullptr

private

Definition at line 85 of file G4UserPhysicsListMessenger.hh.

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

setCutRCmd

G4UIcommand* G4UserPhysicsListMessenger::setCutRCmd = nullptr

private

Definition at line 84 of file G4UserPhysicsListMessenger.hh.

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

storeCmd

G4UIcmdWithAString* G4UserPhysicsListMessenger::storeCmd = nullptr

private

Definition at line 91 of file G4UserPhysicsListMessenger.hh.

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

theDirectory

G4UIdirectory* G4UserPhysicsListMessenger::theDirectory = nullptr

private

Definition at line 82 of file G4UserPhysicsListMessenger.hh.

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

thePhysicsList

G4VUserPhysicsList* G4UserPhysicsListMessenger::thePhysicsList = nullptr

protected

Definition at line 75 of file G4UserPhysicsListMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

verboseCmd

G4UIcmdWithAnInteger* G4UserPhysicsListMessenger::verboseCmd = nullptr

private

Definition at line 87 of file G4UserPhysicsListMessenger.hh.

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

---

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

• source/run/include/G4UserPhysicsListMessenger.hh
• source/run/src/G4UserPhysicsListMessenger.cc