G4ScoreQuantityMessenger Class Reference

#include <G4ScoreQuantityMessenger.hh>

Inheritance diagram for G4ScoreQuantityMessenger:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const
	G4ScoreQuantityMessenger (G4ScoringManager *SManager)
G4String	GetCurrentValue (G4UIcommand *)
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	operator== (const G4UImessenger &messenger) const
void	SetNewValue (G4UIcommand *command, G4String newValues)
	~G4ScoreQuantityMessenger ()

Protected Member Functions
void	AddUIcommand (G4UIcommand *newCommand)
G4String	BtoS (G4bool b)
G4bool	CheckMeshPS (G4VScoringMesh *mesh, G4String &psname, G4UIcommand *command)
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)
void	FillTokenVec (G4String newValues, G4TokenVec &token)
void	FParticleCommand (G4VScoringMesh *mesh, G4TokenVec &token)
void	FParticleWithEnergyCommand (G4VScoringMesh *mesh, G4TokenVec &token)
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
void	FilterCommands ()
void	QuantityCommands ()

Private Attributes
G4UIcmdWithAString *	fchargedCmd
G4UIdirectory *	filterDir
G4UIcommand *	fkinECmd
G4UIcmdWithAString *	fneutralCmd
G4UIcommand *	fparticleCmd
G4UIcommand *	fparticleKinECmd
G4ScoringManager *	fSMan
G4UIcommand *	qCellChgCmd
G4UIcommand *	qCellFluxCmd
G4UIcommand *	qdoseDepCmd
G4UIcommand *	qeDepCmd
G4UIcommand *	qFlatSurfCurrCmd
G4UIcommand *	qFlatSurfFluxCmd
G4UIcmdWithoutParameter *	qGetUnitCmd
G4UIcommand *	qMinKinEAtGeneCmd
G4UIcommand *	qNofCollisionCmd
G4UIcommand *	qnOfSecondaryCmd
G4UIcommand *	qnOfStepCmd
G4UIcommand *	qPassCellCurrCmd
G4UIcommand *	qPassCellFluxCmd
G4UIcommand *	qPassTrackLengthCmd
G4UIcommand *	qPopulationCmd
G4UIcmdWithAString *	qSetUnitCmd
G4UIcommand *	qStepCheckerCmd
G4UIcommand *	qTerminationCmd
G4UIcmdWithAString *	qTouchCmd
G4UIcommand *	qTrackCountCmd
G4UIcommand *	qTrackLengthCmd
G4UIdirectory *	quantityDir
G4UIcommand *	qVolFluxCmd

Detailed Description

Definition at line 57 of file G4ScoreQuantityMessenger.hh.

Constructor & Destructor Documentation

G4ScoreQuantityMessenger()

G4ScoreQuantityMessenger::G4ScoreQuantityMessenger

(

G4ScoringManager *

SManager

)

Definition at line 117 of file G4ScoreQuantityMessenger.cc.

  : fSMan(SManager)
{
  QuantityCommands();
  FilterCommands();
}

References FilterCommands(), and QuantityCommands().

~G4ScoreQuantityMessenger()

G4ScoreQuantityMessenger::~G4ScoreQuantityMessenger

(

)

Definition at line 207 of file G4ScoreQuantityMessenger.cc.

{
  delete quantityDir;
  delete qTouchCmd;
  delete qGetUnitCmd;
  delete qSetUnitCmd;
 
  //
  delete qCellChgCmd;
  delete qCellFluxCmd;
  delete qPassCellFluxCmd;
  delete qeDepCmd;
  delete qdoseDepCmd;
  delete qnOfStepCmd;
  delete qnOfSecondaryCmd;
  //
  delete qTrackLengthCmd;
  delete qPassCellCurrCmd;
  delete qPassTrackLengthCmd;
  delete qFlatSurfCurrCmd;
  delete qFlatSurfFluxCmd;
  delete qVolFluxCmd;
  //    delete          qSphereSurfCurrCmd;
  //    delete          qSphereSurfFluxCmd;
  //    delete          qCylSurfCurrCmd;
  //    delete          qCylSurfFluxCmd;
  delete qNofCollisionCmd;
  delete qPopulationCmd;
  delete qTrackCountCmd;
  delete qTerminationCmd;
  delete qMinKinEAtGeneCmd;
  //
  delete qStepCheckerCmd;
  //
  delete filterDir;
  delete fchargedCmd;
  delete fneutralCmd;
  delete fkinECmd;
  delete fparticleCmd;
  delete fparticleKinECmd;
}

References fchargedCmd, filterDir, fkinECmd, fneutralCmd, fparticleCmd, fparticleKinECmd, qCellChgCmd, qCellFluxCmd, qdoseDepCmd, qeDepCmd, qFlatSurfCurrCmd, qFlatSurfFluxCmd, qGetUnitCmd, qMinKinEAtGeneCmd, qNofCollisionCmd, qnOfSecondaryCmd, qnOfStepCmd, qPassCellCurrCmd, qPassCellFluxCmd, qPassTrackLengthCmd, qPopulationCmd, qSetUnitCmd, qStepCheckerCmd, qTerminationCmd, qTouchCmd, qTrackCountCmd, qTrackLengthCmd, quantityDir, and qVolFluxCmd.

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;
}

CheckMeshPS()

G4bool G4ScoreQuantityMessenger::CheckMeshPS ( G4VScoringMesh *  mesh, G4String &  psname, G4UIcommand *  command  )

protected

Definition at line 860 of file G4ScoreQuantityMessenger.cc.

{
  if(!mesh->FindPrimitiveScorer(psname))
  {
    return true;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << "WARNING[" << qTouchCmd->GetCommandPath() << "] : Quantity name, \""
       << psname << "\", is already existing.";
    command->CommandFailed(ed);
    mesh->SetNullToCurrentPrimitiveScorer();
    return false;
  }
}

References G4UIcommand::CommandFailed(), G4VScoringMesh::FindPrimitiveScorer(), G4UIcommand::GetCommandPath(), qTouchCmd, and G4VScoringMesh::SetNullToCurrentPrimitiveScorer().

Referenced by SetNewValue().

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 FilterCommands(), and G4UIcontrolMessenger::SetNewValue().

FillTokenVec()

void G4ScoreQuantityMessenger::FillTokenVec ( G4String  newValues, G4TokenVec &  token  )

protected

Definition at line 815 of file G4ScoreQuantityMessenger.cc.

{
  G4Tokenizer next(newValues);
  G4String val;
  while(!(val = next()).empty())
  {  // Loop checking 12.18.2015 M.Asai
    token.push_back(val);
  }
}

References anonymous_namespace{G4MTcoutDestination.cc}::empty.

Referenced by SetNewValue().

FilterCommands()

void G4ScoreQuantityMessenger::FilterCommands ( )

private

Definition at line 124 of file G4ScoreQuantityMessenger.cc.

{
  G4UIparameter* param;
 
  //
  // Filter commands
  filterDir = new G4UIdirectory("/score/filter/");
  filterDir->SetGuidance("  Scoring filter commands.");
  //
  fchargedCmd = new G4UIcmdWithAString("/score/filter/charged", this);
  fchargedCmd->SetGuidance("Charged particle filter.");
  fchargedCmd->SetParameterName("fname", false);
  //
  fneutralCmd = new G4UIcmdWithAString("/score/filter/neutral", this);
  fneutralCmd->SetGuidance("Neutral particle filter.");
  fneutralCmd->SetParameterName("fname", false);
  //
  fkinECmd = new G4UIcommand("/score/filter/kineticEnergy", this);
  fkinECmd->SetGuidance("Kinetic energy filter.");
  fkinECmd->SetGuidance(
    "[usage] /score/filter/kineticEnergy fname Elow Ehigh unit");
  fkinECmd->SetGuidance("  fname     :(String) Filter Name ");
  fkinECmd->SetGuidance("  Elow      :(Double) Lower edge of kinetic energy");
  fkinECmd->SetGuidance("  Ehigh     :(Double) Higher edge of kinetic energy");
  fkinECmd->SetGuidance("  unit      :(String) unit of given kinetic energy");
  param = new G4UIparameter("fname", 's', false);
  fkinECmd->SetParameter(param);
  param = new G4UIparameter("elow", 'd', true);
  param->SetDefaultValue("0.0");
  fkinECmd->SetParameter(param);
  param = new G4UIparameter("ehigh", 'd', true);
  fkinECmd->SetParameter(param);
  G4String smax = DtoS(DBL_MAX);
  param->SetDefaultValue(smax);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("keV");
  fkinECmd->SetParameter(param);
  //
  fparticleCmd = new G4UIcommand("/score/filter/particle", this);
  fparticleCmd->SetGuidance("Particle filter.");
  fparticleCmd->SetGuidance("[usage] /score/filter/particle fname p0 .. pn");
  fparticleCmd->SetGuidance("  fname     :(String) Filter Name ");
  fparticleCmd->SetGuidance("  p0 .. pn  :(String) particle names");
  param = new G4UIparameter("fname", 's', false);
  fparticleCmd->SetParameter(param);
  param = new G4UIparameter("particlelist", 's', false);
  param->SetDefaultValue("");
  fparticleCmd->SetParameter(param);
  //
  //
  //
  fparticleKinECmd =
    new G4UIcommand("/score/filter/particleWithKineticEnergy", this);
  fparticleKinECmd->SetGuidance("Particle with kinetic energy filter.");
  fparticleKinECmd->SetGuidance(
    "[usage] /score/filter/particleWithKineticEnergy fname Elow Ehigh unit p0 "
    ".. pn");
  fparticleKinECmd->SetGuidance("  fname     :(String) Filter Name ");
  fparticleKinECmd->SetGuidance(
    "  Elow      :(Double) Lower edge of kinetic energy");
  fparticleKinECmd->SetGuidance(
    "  Ehigh     :(Double) Higher edge of kinetic energy");
  fparticleKinECmd->SetGuidance(
    "  unit      :(String) unit of given kinetic energy");
  fparticleKinECmd->SetGuidance("  p0 .. pn  :(String) particle names");
  param = new G4UIparameter("fname", 's', false);
  fparticleKinECmd->SetParameter(param);
  param = new G4UIparameter("elow", 'd', false);
  param->SetDefaultValue("0.0");
  fparticleKinECmd->SetParameter(param);
  param = new G4UIparameter("ehigh", 'd', true);
  param->SetDefaultValue(smax);
  fparticleKinECmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("keV");
  fparticleKinECmd->SetParameter(param);
  param = new G4UIparameter("particlelist", 's', false);
  param->SetDefaultValue("");
  fparticleKinECmd->SetParameter(param);
  //
  //
}

References DBL_MAX, G4UImessenger::DtoS(), fchargedCmd, filterDir, fkinECmd, fneutralCmd, fparticleCmd, fparticleKinECmd, G4UIparameter::SetDefaultUnit(), G4UIparameter::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), and G4UIcmdWithAString::SetParameterName().

Referenced by G4ScoreQuantityMessenger().

FParticleCommand()

void G4ScoreQuantityMessenger::FParticleCommand ( G4VScoringMesh *  mesh, G4TokenVec &  token  )

protected

Definition at line 826 of file G4ScoreQuantityMessenger.cc.

{
  //
  // Filter name
  G4String name = token[0];
  //
  // particle list
  std::vector<G4String> pnames;
  for(G4int i = 1; i < (G4int) token.size(); i++)
  {
    pnames.push_back(token[i]);
  }
  //
  // Attach Filter
  mesh->SetFilter(new G4SDParticleFilter(name, pnames));
}

References G4InuclParticleNames::name(), and G4VScoringMesh::SetFilter().

Referenced by SetNewValue().

FParticleWithEnergyCommand()

void G4ScoreQuantityMessenger::FParticleWithEnergyCommand ( G4VScoringMesh *  mesh, G4TokenVec &  token  )

protected

Definition at line 844 of file G4ScoreQuantityMessenger.cc.

{
  G4String& name   = token[0];
  G4double elow    = StoD(token[1]);
  G4double ehigh   = StoD(token[2]);
  G4double unitVal = G4UnitDefinition::GetValueOf(token[3]);
  G4SDParticleWithEnergyFilter* filter =
    new G4SDParticleWithEnergyFilter(name, elow * unitVal, ehigh * unitVal);
  for(G4int i = 4; i < (G4int) token.size(); i++)
  {
    filter->add(token[i]);
  }
  mesh->SetFilter(filter);
}

References G4SDParticleWithEnergyFilter::add(), G4UnitDefinition::GetValueOf(), G4InuclParticleNames::name(), G4VScoringMesh::SetFilter(), and G4UImessenger::StoD().

Referenced by SetNewValue().

GetCurrentValue()

G4String G4ScoreQuantityMessenger::GetCurrentValue ( G4UIcommand *  )

virtual

Reimplemented from G4UImessenger.

Definition at line 808 of file G4ScoreQuantityMessenger.cc.

{
  G4String val;
 
  return val;
}

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;
}

QuantityCommands()

void G4ScoreQuantityMessenger::QuantityCommands ( )

private

Definition at line 85 of file G4ScoreQuantityMessengerQCmd.cc.

{
  G4UIparameter* param;
 
  //
  // Quantity commands
  quantityDir = new G4UIdirectory("/score/quantity/");
  quantityDir->SetGuidance("Scoring quantity of the mesh.");
  //
  qTouchCmd = new G4UIcmdWithAString("/score/quantity/touch", this);
  qTouchCmd->SetGuidance(
    "Assign previously defined quantity to the current quantity.");
  qTouchCmd->SetParameterName("qname", false);
  //
  qGetUnitCmd = new G4UIcmdWithoutParameter("/score/quantity/get/unit", this);
  qGetUnitCmd->SetGuidance("Print output unit of the current quantity.");
  //
  qSetUnitCmd = new G4UIcmdWithAString("/score/quantity/set/unit", this);
  qSetUnitCmd->SetGuidance("Set output unit of the current quantity.");
  qSetUnitCmd->SetParameterName("unit", false);
 
  // Primitive Scorers
  qeDepCmd = new G4UIcommand("/score/quantity/energyDeposit", this);
  qeDepCmd->SetGuidance("Energy deposit scorer.");
  qeDepCmd->SetGuidance("[usage] /score/quantity/energyDeposit qname unit");
  qeDepCmd->SetGuidance("  qname  :(String) scorer name");
  qeDepCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qeDepCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("MeV");
  qeDepCmd->SetParameter(param);
  //
  qCellChgCmd = new G4UIcommand("/score/quantity/cellCharge", this);
  qCellChgCmd->SetGuidance("Cell charge scorer.");
  qCellChgCmd->SetGuidance("[usage] /score/quantity/cellCharge qname unit");
  qCellChgCmd->SetGuidance("  qname  :(String) scorer name");
  qCellChgCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qCellChgCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("e+");
  qCellChgCmd->SetParameter(param);
  //
  qCellFluxCmd = new G4UIcommand("/score/quantity/cellFlux", this);
  qCellFluxCmd->SetGuidance("Cell flux scorer.");
  qCellFluxCmd->SetGuidance("[usage] /score/quantity/cellFlux qname unit");
  qCellFluxCmd->SetGuidance("  qname  :(String) scorer name");
  qCellFluxCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qCellFluxCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultValue("percm2");
  qCellFluxCmd->SetParameter(param);
  //
  qPassCellFluxCmd = new G4UIcommand("/score/quantity/passageCellFlux", this);
  qPassCellFluxCmd->SetGuidance("Passage cell flux scorer");
  qPassCellFluxCmd->SetGuidance(
    "[usage] /score/quantity/passageCellFlux qname unit");
  qPassCellFluxCmd->SetGuidance("  qname  :(String) scorer name");
  qPassCellFluxCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qPassCellFluxCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultValue("percm2");
  qPassCellFluxCmd->SetParameter(param);
  //
  qdoseDepCmd = new G4UIcommand("/score/quantity/doseDeposit", this);
  qdoseDepCmd->SetGuidance("Dose deposit scorer.");
  qdoseDepCmd->SetGuidance("[usage] /score/quantity/doseDeposit qname unit");
  qdoseDepCmd->SetGuidance("  qname  :(String) scorer name");
  qdoseDepCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qdoseDepCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("Gy");
  qdoseDepCmd->SetParameter(param);
  //
  qnOfStepCmd = new G4UIcommand("/score/quantity/nOfStep", this);
  qnOfStepCmd->SetGuidance("Number of step scorer.");
  qnOfStepCmd->SetGuidance("[usage] /score/quantity/nOfStep qname");
  qnOfStepCmd->SetGuidance("[usage] /score/quantity/nOfStep qname  bflag");
  qnOfStepCmd->SetGuidance("  qname  :(String) scorer name");
  qnOfStepCmd->SetGuidance("  bflag  :(Bool) Skip zero step ");
  qnOfStepCmd->SetGuidance("          at geometry boundary if true");
  param = new G4UIparameter("qname", 's', false);
  qnOfStepCmd->SetParameter(param);
  param = new G4UIparameter("bflag", 'b', true);
  param->SetDefaultValue("false");
  qnOfStepCmd->SetParameter(param);
  //
  qnOfSecondaryCmd = new G4UIcommand("/score/quantity/nOfSecondary", this);
  qnOfSecondaryCmd->SetGuidance("Number of secondary scorer.");
  qnOfSecondaryCmd->SetGuidance("[usage] /score/quantity/nOfSecondary qname");
  qnOfSecondaryCmd->SetGuidance("  qname  :(String) scorer name");
  param = new G4UIparameter("qname", 's', false);
  qnOfSecondaryCmd->SetParameter(param);
  //
  qTrackLengthCmd = new G4UIcommand("/score/quantity/trackLength", this);
  qTrackLengthCmd->SetGuidance("Track length scorer.");
  qTrackLengthCmd->SetGuidance(
    "[usage] /score/quantity/trackLength qname wflag kflag vflag unit");
  qTrackLengthCmd->SetGuidance("  qname  :(String) scorer name");
  qTrackLengthCmd->SetGuidance("  wflag  :(Bool) weighted");
  qTrackLengthCmd->SetGuidance("  kflag  :(Bool) multiply kinetic energy");
  qTrackLengthCmd->SetGuidance("  vflag  :(Bool) divide by velocity");
  qTrackLengthCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qTrackLengthCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("false");
  qTrackLengthCmd->SetParameter(param);
  param = new G4UIparameter("kflag", 'b', true);
  param->SetDefaultValue("false");
  qTrackLengthCmd->SetParameter(param);
  param = new G4UIparameter("vflag", 'b', true);
  param->SetDefaultValue("false");
  qTrackLengthCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultValue("mm");
  qTrackLengthCmd->SetParameter(param);
  //
  qPassCellCurrCmd =
    new G4UIcommand("/score/quantity/passageCellCurrent", this);
  qPassCellCurrCmd->SetGuidance("Passage cell current scorer.");
  qPassCellCurrCmd->SetGuidance(
    "[usage] /score/quantity/passageCellCurrent qname wflag");
  qPassCellCurrCmd->SetGuidance("  qname  :(String) scorer name");
  qPassCellCurrCmd->SetGuidance("  wflag  :(Bool) weighted");
  param = new G4UIparameter("qname", 's', false);
  qPassCellCurrCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("true");
  qPassCellCurrCmd->SetParameter(param);
  //
  qPassTrackLengthCmd =
    new G4UIcommand("/score/quantity/passageTrackLength", this);
  qPassTrackLengthCmd->SetGuidance("Passage track length scorer.");
  qPassTrackLengthCmd->SetGuidance(
    "[usage] /score/quantity/passageTrackLength qname wflag unit");
  qPassTrackLengthCmd->SetGuidance("  qname  :(String) scorer name");
  qPassTrackLengthCmd->SetGuidance("  wflag  :(Bool) weighted");
  qPassTrackLengthCmd->SetGuidance("  unit   :(Bool) unit");
  param = new G4UIparameter("qname", 's', false);
  qPassTrackLengthCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("true");
  qPassTrackLengthCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("mm");
  qPassTrackLengthCmd->SetParameter(param);
  //
  qFlatSurfCurrCmd =
    new G4UIcommand("/score/quantity/flatSurfaceCurrent", this);
  qFlatSurfCurrCmd->SetGuidance("Flat surface current Scorer.");
  qFlatSurfCurrCmd->SetGuidance(
    "[usage] /score/quantity/flatSurfaceCurrent qname dflag wflag aflag unit");
  qFlatSurfCurrCmd->SetGuidance("  qname  :(String) scorer name");
  qFlatSurfCurrCmd->SetGuidance("  dflag  :(Int) direction flag");
  qFlatSurfCurrCmd->SetGuidance("         : 0 = Both In and Out");
  qFlatSurfCurrCmd->SetGuidance("         : 1 = In only");
  qFlatSurfCurrCmd->SetGuidance("         : 2 = Out only");
  qFlatSurfCurrCmd->SetGuidance("  wflag  :(Bool) weighted");
  qFlatSurfCurrCmd->SetGuidance("  aflag  :(Bool) divide by area");
  qFlatSurfCurrCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qFlatSurfCurrCmd->SetParameter(param);
  param = new G4UIparameter("dflag", 'i', true);
  param->SetDefaultValue("0");
  qFlatSurfCurrCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("true");
  qFlatSurfCurrCmd->SetParameter(param);
  param = new G4UIparameter("aflag", 'b', true);
  param->SetDefaultValue("true");
  qFlatSurfCurrCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultValue("percm2");
  qFlatSurfCurrCmd->SetParameter(param);
  //
  qFlatSurfFluxCmd = new G4UIcommand("/score/quantity/flatSurfaceFlux", this);
  qFlatSurfFluxCmd->SetGuidance("Flat surface flux scorer.");
  qFlatSurfFluxCmd->SetGuidance(
    "[usage] /score/quantity/flatSurfaceFlux qname dflag unit");
  qFlatSurfFluxCmd->SetGuidance("  qname  :(String) scorer name");
  qFlatSurfFluxCmd->SetGuidance("  dflag  :(Int) direction flag");
  qFlatSurfFluxCmd->SetGuidance("         : 0 = Both In and Out");
  qFlatSurfFluxCmd->SetGuidance("         : 1 = In only");
  qFlatSurfFluxCmd->SetGuidance("         : 2 = Out only");
  qFlatSurfFluxCmd->SetGuidance("  wflag  :(Bool) weighted");
  qFlatSurfFluxCmd->SetGuidance("  aflag  :(Bool) divide by area");
  qFlatSurfFluxCmd->SetGuidance("  unit   :(String) unit");
  param = new G4UIparameter("qname", 's', false);
  qFlatSurfFluxCmd->SetParameter(param);
  param = new G4UIparameter("dflag", 'i', true);
  param->SetDefaultValue("0");
  qFlatSurfFluxCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("true");
  qFlatSurfFluxCmd->SetParameter(param);
  param = new G4UIparameter("aflag", 'b', true);
  param->SetDefaultValue("true");
  qFlatSurfFluxCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultValue("percm2");
  qFlatSurfFluxCmd->SetParameter(param);
  //
 
  qVolFluxCmd = new G4UIcommand("/score/quantity/volumeFlux", this);
  qVolFluxCmd->SetGuidance("Volume flux scorer.");
  qVolFluxCmd->SetGuidance(
    "This scorer scores the number of particles getting into the volume "
    "without normalized by the surface area.");
  qVolFluxCmd->SetGuidance(
    "[usage] /score/quantity/volumeFlux qname divcos dflag");
  qVolFluxCmd->SetGuidance("  qname  :(String) scorer name");
  qVolFluxCmd->SetGuidance("  divcos :(Bool) divide by cos(theta), where theta "
                           "is the incident angle (default : false)");
  qVolFluxCmd->SetGuidance(
    "  dflag  :(Int) direction, 1 : inward (default), 2 : outward");
  param = new G4UIparameter("qname", 's', false);
  qVolFluxCmd->SetParameter(param);
  param = new G4UIparameter("divcos", 'b', true);
  param->SetDefaultValue(false);
  qVolFluxCmd->SetParameter(param);
  param = new G4UIparameter("dflag", 'i', true);
  param->SetParameterRange("dflag>=1 && dflag<=2");
  param->SetDefaultValue(1);
  qVolFluxCmd->SetParameter(param);
 
  //  qSphereSurfCurrCmd = new
  //  G4UIcommand("/score/quantity/sphereSurfaceCurrent",this);
  //  qSphereSurfCurrCmd->SetGuidance("Sphere surface current Scorer.");
  //  qSphereSurfCurrCmd->
  //      SetGuidance("[usage] /score/quantity/sphereSurfaceCurrent qname dflag
  //      wflag aflag unit");
  //  qSphereSurfCurrCmd->SetGuidance("  qname  :(String) scorer name");
  //  qSphereSurfCurrCmd->SetGuidance("  dflag  :(Int) direction flag");
  //  qSphereSurfCurrCmd->SetGuidance("         : 0 = Both In and Out");
  //  qSphereSurfCurrCmd->SetGuidance("         : 1 = In only");
  //  qSphereSurfCurrCmd->SetGuidance("         : 2 = Out only");
  //  qSphereSurfCurrCmd->SetGuidance("  wflag  :(Bool) Weighted");
  //  qSphereSurfCurrCmd->SetGuidance("  aflag  :(Bool) DivideByArea");
  //  qSphereSurfCurrCmd->SetGuidance("  unit   :(String) unit");
  //  param = new G4UIparameter("qname",'s',false);
  //  qSphereSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("dflag",'i',true);
  //  param->SetDefaultValue("0");
  //  qSphereSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("wflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qSphereSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("aflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qSphereSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("unit",'s',true);
  //  param->SetDefaultValue("percm2");
  //  qSphereSurfCurrCmd->SetParameter(param);
 
  //
  //  qSphereSurfFluxCmd = new
  //  G4UIcommand("/score/quantity/sphereSurfaceFlux",this);
  //  qSphereSurfFluxCmd->SetGuidance("Sphere surface Flux Scorer.");
  //  qSphereSurfFluxCmd->
  //  SetGuidance("[usage] /score/quantity/sphereSurfaceFlux qname dflag unit");
  //  qSphereSurfFluxCmd->SetGuidance("  qname  :(String) scorer name");
  //  qSphereSurfFluxCmd->SetGuidance("  dflag  :(Int) direction flag");
  //  qSphereSurfFluxCmd->SetGuidance("         : 0 = Both In and Out");
  //  qSphereSurfFluxCmd->SetGuidance("         : 1 = In only");
  //  qSphereSurfFluxCmd->SetGuidance("         : 2 = Out only");
  //  qSphereSurfFluxCmd->SetGuidance("  wflag  :(Bool) weighted");
  //  qSphereSurfFluxCmd->SetGuidance("  aflag  :(Bool) divide by area");
  //  qSphereSurfFluxCmd->SetGuidance("  unit   :(String) unit");
  //  param = new G4UIparameter("qname",'s',false);
  //  qSphereSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("dflag",'i',true);
  //  param->SetDefaultValue("0");
  //  qSphereSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("wflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qSphereSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("aflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qSphereSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("unit",'s',true);
  //  param->SetDefaultValue("percm2");
  //  qSphereSurfFluxCmd->SetParameter(param);
 
  //
  //  qCylSurfCurrCmd = new
  //  G4UIcommand("/score/quantity/cylinderSurfaceCurrent",this);
  //  qCylSurfCurrCmd->SetGuidance("Cylinder surface current Scorer.");
  //  qCylSurfCurrCmd->
  //  SetGuidance("[usage] /score/quantity/cylinderSurfaceCurrent qname dflag
  //  wflag aflag unit"); qCylSurfCurrCmd->SetGuidance("  qname  :(String)
  //  scorer name"); qCylSurfCurrCmd->SetGuidance("  dflag  :(Int) direction
  //  flag"); qCylSurfCurrCmd->SetGuidance("         : 0 = Both In and Out");
  //  qCylSurfCurrCmd->SetGuidance("         : 1 = In only");
  //  qCylSurfCurrCmd->SetGuidance("         : 2 = Out only");
  //  qCylSurfCurrCmd->SetGuidance("  wflag  :(Bool) Weighted");
  //  qCylSurfCurrCmd->SetGuidance("  aflag  :(Bool) DivideByArea");
  //  qCylSurfCurrCmd->SetGuidance("  unit   :(String) unit");
  //  param = new G4UIparameter("qname",'s',false);
  //  qCylSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("dflag",'i',true);
  //  param->SetDefaultValue("0");
  //  qCylSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("wflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qCylSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("aflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qCylSurfCurrCmd->SetParameter(param);
  //  param = new G4UIparameter("unit",'s',true);
  //  param->SetDefaultValue("percm2");
  //  qCylSurfCurrCmd->SetParameter(param);
  //
  //  qCylSurfFluxCmd = new
  //  G4UIcommand("/score/quantity/cylinderSurfaceFlux",this);
  //  qCylSurfFluxCmd->SetGuidance("Cylinder surface Flux Scorer.");
  //  qCylSurfFluxCmd->
  //  SetGuidance("[usage] /score/quantity/cylinderSurfaceFlux qname dflag
  //  unit"); qCylSurfFluxCmd->SetGuidance("  qname  :(String) scorer name");
  //  qCylSurfFluxCmd->SetGuidance("  dflag  :(Int) direction flag");
  //  qCylSurfFluxCmd->SetGuidance("         : 0 = Both In and Out");
  //  qCylSurfFluxCmd->SetGuidance("         : 1 = In only");
  //  qCylSurfFluxCmd->SetGuidance("         : 2 = Out only");
  //  qCylSurfFluxCmd->SetGuidance("  wflag  :(Bool) weighted");
  //  qCylSurfFluxCmd->SetGuidance("  aflag  :(Bool) divide by area");
  //  qCylSurfFluxCmd->SetGuidance("  unit   :(String) unit");
  //  param = new G4UIparameter("qname",'s',false);
  //  qCylSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("dflag",'i',true);
  //  param->SetDefaultValue("0");
  //  qCylSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("wflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qCylSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("aflag",'b',true);
  //  param->SetDefaultValue("true");
  //  qCylSurfFluxCmd->SetParameter(param);
  //  param = new G4UIparameter("unit",'s',true);
  //  param->SetDefaultValue("percm2");
  //  qCylSurfFluxCmd->SetParameter(param);
  //
  //
  qNofCollisionCmd = new G4UIcommand("/score/quantity/nOfCollision", this);
  qNofCollisionCmd->SetGuidance("Number of collision scorer.");
  qNofCollisionCmd->SetGuidance(
    "[usage] /score/quantity/nOfCollision qname wflag");
  qNofCollisionCmd->SetGuidance("  qname  :(String) scorer name");
  param = new G4UIparameter("qname", 's', false);
  qNofCollisionCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("false");
  qNofCollisionCmd->SetParameter(param);
  //
  qPopulationCmd = new G4UIcommand("/score/quantity/population", this);
  qPopulationCmd->SetGuidance("Population scorer.");
  qPopulationCmd->SetGuidance("[usage] /score/quantity/population qname wflag");
  qPopulationCmd->SetGuidance("  qname  :(String) scorer name");
  qPopulationCmd->SetGuidance("  wflag  :(Bool) weighted");
  param = new G4UIparameter("qname", 's', false);
  qPopulationCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("false");
  qPopulationCmd->SetParameter(param);
 
  //
  qTrackCountCmd = new G4UIcommand("/score/quantity/nOfTrack", this);
  qTrackCountCmd->SetGuidance("Number of track scorer.");
  qTrackCountCmd->SetGuidance(
    "[usage] /score/quantity/nOfTrack qname dflag wflag");
  qTrackCountCmd->SetGuidance("  qname  :(String) scorer name");
  qTrackCountCmd->SetGuidance("  dflag  :(Int) direction");
  qTrackCountCmd->SetGuidance("         : 0 = Both In and Out");
  qTrackCountCmd->SetGuidance("         : 1 = In only");
  qTrackCountCmd->SetGuidance("         : 2 = Out only");
  qTrackCountCmd->SetGuidance("  wflag  :(Bool) weighted");
  param = new G4UIparameter("qname", 's', false);
  qTrackCountCmd->SetParameter(param);
  param = new G4UIparameter("dflag", 'i', true);
  param->SetDefaultValue("0");
  qTrackCountCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("false");
  qTrackCountCmd->SetParameter(param);
 
  //
  qTerminationCmd = new G4UIcommand("/score/quantity/nOfTerminatedTrack", this);
  qTerminationCmd->SetGuidance("Number of terminated tracks scorer.");
  qTerminationCmd->SetGuidance(
    "[usage] /score/quantity/nOfTerminatedTrack qname wflag");
  qTerminationCmd->SetGuidance("  qname  :(String) scorer name");
  qTerminationCmd->SetGuidance("  wflag  :(Bool) weighted");
  param = new G4UIparameter("qname", 's', false);
  qTerminationCmd->SetParameter(param);
  param = new G4UIparameter("wflag", 'b', true);
  param->SetDefaultValue("false");
  qTerminationCmd->SetParameter(param);
 
  //
  qMinKinEAtGeneCmd =
    new G4UIcommand("/score/quantity/minKinEAtGeneration", this);
  qMinKinEAtGeneCmd->SetGuidance("Min Kinetic Energy at Generation");
  qMinKinEAtGeneCmd->SetGuidance(
    "[usage] /score/quantity/minKinEAtGeneration qname unit");
  qMinKinEAtGeneCmd->SetGuidance("  qname  :(String) scorer name");
  qMinKinEAtGeneCmd->SetGuidance("  unit   :(String) unit name");
  param = new G4UIparameter("qname", 's', false);
  qMinKinEAtGeneCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("MeV");
  qMinKinEAtGeneCmd->SetParameter(param);
  //
  qStepCheckerCmd = new G4UIcommand("/score/quantity/stepChecker", this);
  qStepCheckerCmd->SetGuidance("Display a comment when this PS is invoked");
  qStepCheckerCmd->SetGuidance("[usage] /score/quantity/stepChecker qname");
  qStepCheckerCmd->SetGuidance("  qname  :(String) scorer name");
  param = new G4UIparameter("qname", 's', false);
  qStepCheckerCmd->SetParameter(param);
}

References qCellChgCmd, qCellFluxCmd, qdoseDepCmd, qeDepCmd, qFlatSurfCurrCmd, qFlatSurfFluxCmd, qGetUnitCmd, qMinKinEAtGeneCmd, qNofCollisionCmd, qnOfSecondaryCmd, qnOfStepCmd, qPassCellCurrCmd, qPassCellFluxCmd, qPassTrackLengthCmd, qPopulationCmd, qSetUnitCmd, qStepCheckerCmd, qTerminationCmd, qTouchCmd, qTrackCountCmd, qTrackLengthCmd, quantityDir, qVolFluxCmd, G4UIparameter::SetDefaultUnit(), G4UIparameter::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), G4UIcmdWithAString::SetParameterName(), and G4UIparameter::SetParameterRange().

Referenced by G4ScoreQuantityMessenger().

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 249 of file G4ScoreQuantityMessenger.cc.

{
  using MeshShape = G4VScoringMesh::MeshShape;
 
  G4ExceptionDescription ed;
 
  //
  // Get Current Mesh
  //
  G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
  if(!mesh)
  {
    ed << "ERROR : No mesh is currently open. Open/create a mesh first. "
          "Command ignored.";
    command->CommandFailed(ed);
    return;
  }
  // Mesh type
  auto shape = mesh->GetShape();
  // Tokens
  G4TokenVec token;
  FillTokenVec(newVal, token);
  //
  // Commands for Current Mesh
  if(command == qTouchCmd)
  {
    mesh->SetCurrentPrimitiveScorer(newVal);
  }
  else if(command == qGetUnitCmd)
  {
    G4cout << "Unit:  " << mesh->GetCurrentPSUnit() << G4endl;
  }
  else if(command == qSetUnitCmd)
  {
    mesh->SetCurrentPSUnit(newVal);
  }
  else if(command == qCellChgCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSCellCharge* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSCellCharge(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSCellCharge3D(token[0]);
      }
      ps->SetUnit(token[1]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qCellFluxCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSCellFlux* ps = nullptr;
      if(shape == MeshShape::box)
      {
        ps = new G4PSCellFlux3D(token[0]);
      }
      else if(shape == MeshShape::cylinder)
      {
        G4PSCellFluxForCylinder3D* pps =
          new G4PSCellFluxForCylinder3D(token[0]);
        pps->SetCylinderSize(mesh->GetSize(),mesh->GetStartAngle(),mesh->GetAngleSpan());   
        G4int nSeg[3];
        mesh->GetNumberOfSegments(nSeg);
        pps->SetNumberOfSegments(nSeg);
        ps = pps;
      }
      else if(shape == MeshShape::realWorldLogVol)
      {
        ed << "Cell flux for real world volume is not yet supported. Command "
              "ignored.";
        command->CommandFailed(ed);
        return;
      }
      else if(shape == MeshShape::probe)
      {
        ps = new G4PSCellFlux(token[0]);
      }
      ps->SetUnit(token[1]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qPassCellFluxCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSPassageCellFlux* ps = nullptr;
      if(shape == MeshShape::box)
      {
        ps = new G4PSPassageCellFlux3D(token[0]);
      }
      else if(shape == MeshShape::cylinder)
      {
        G4PSPassageCellFluxForCylinder3D* pps =
          new G4PSPassageCellFluxForCylinder3D(token[0]);
        pps->SetCylinderSize(mesh->GetSize(),mesh->GetStartAngle(),mesh->GetAngleSpan());   
        G4int nSeg[3];
        mesh->GetNumberOfSegments(nSeg);
        pps->SetNumberOfSegments(nSeg);
        ps = pps;
      }
      else if(shape == MeshShape::realWorldLogVol)
      {
        ed << "Passing cell flux for real world volume is not yet supported. "
              "Command ignored.";
        command->CommandFailed(ed);
        return;
      }
      else if(shape == MeshShape::probe)
      {
        ps = new G4PSPassageCellFlux(token[0]);
      }
      ps->SetUnit(token[1]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qeDepCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSEnergyDeposit* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSEnergyDeposit(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSEnergyDeposit3D(token[0]);
      }
      ps->SetUnit(token[1]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qdoseDepCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSDoseDeposit* ps = nullptr;
      if(shape == MeshShape::box)
      {
        ps = new G4PSDoseDeposit3D(token[0]);
      }
      else if(shape == MeshShape::cylinder)
      {
        G4PSDoseDepositForCylinder3D* pps =
          new G4PSDoseDepositForCylinder3D(token[0]);
        pps->SetUnit(token[1]);
        pps->SetCylinderSize(mesh->GetSize(),mesh->GetStartAngle(),mesh->GetAngleSpan());   
        G4int nSeg[3];
        mesh->GetNumberOfSegments(nSeg);
        pps->SetNumberOfSegments(nSeg);
        ps = pps;
      }
      else if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSDoseDeposit(token[0], mesh->GetCopyNumberLevel());
      }
      ps->SetUnit(token[1]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qnOfStepCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSNofStep* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSNofStep(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSNofStep3D(token[0]);
      }
      ps->SetBoundaryFlag(StoB(token[1]));
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qnOfSecondaryCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSNofSecondary* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSNofSecondary(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSNofSecondary3D(token[0]);
      }
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qTrackLengthCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSTrackLength* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSTrackLength(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSTrackLength3D(token[0]);
      }
      ps->Weighted(StoB(token[1]));
      ps->MultiplyKineticEnergy(StoB(token[2]));
      ps->DivideByVelocity(StoB(token[3]));
      ps->SetUnit(token[4]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qPassCellCurrCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSPassageCellCurrent* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSPassageCellCurrent(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSPassageCellCurrent3D(token[0]);
      }
      ps->Weighted(StoB(token[1]));
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qPassTrackLengthCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSPassageTrackLength* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSPassageTrackLength(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSPassageTrackLength3D(token[0]);
      }
      ps->Weighted(StoB(token[1]));
      ps->SetUnit(token[2]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qFlatSurfCurrCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSFlatSurfaceCurrent* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSFlatSurfaceCurrent(token[0], StoI(token[1]),
                                        mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSFlatSurfaceCurrent3D(token[0], StoI(token[1]));
      }
      ps->Weighted(StoB(token[2]));
      ps->DivideByArea(StoB(token[3]));
      if(StoB(token[3]))
      {
        ps->SetUnit(token[4]);
      }
      else
      {
        ps->SetUnit("");
      }
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qFlatSurfFluxCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSFlatSurfaceFlux* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSFlatSurfaceFlux(token[0], StoI(token[1]),
                                     mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSFlatSurfaceFlux3D(token[0], StoI(token[1]));
      }
      ps->Weighted(StoB(token[2]));
      ps->DivideByArea(StoB(token[3]));
      if(StoB(token[3]))
      {
        ps->SetUnit(token[4]);
      }
      else
      {
        ps->SetUnit("");
      }
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qVolFluxCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSVolumeFlux* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSVolumeFlux(token[0], StoI(token[2]),
                                mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSVolumeFlux3D(token[0], StoI(token[2]));
      }
      ps->SetDivCos(StoI(token[1]));
      mesh->SetPrimitiveScorer(ps);
    }
 
    //    } else if(command== qSphereSurfCurrCmd){
    //        if( CheckMeshPS(mesh, token[0],command )) {
    //            G4PSSphereSurfaceCurrent3D* ps =
    //              new G4PSSphereSurfaceCurrent3D(token[0],StoI(token[1]));
    //            ps->Weighted(StoB(token[2]));
    //            ps->DivideByArea(StoB(token[3]));
    //            if ( StoB(token[3]) ){
    //              ps->SetUnit(token[4]);
    //            }else{
    //              ps->SetUnit("");
    //            }
    //            mesh->SetPrimitiveScorer(ps);
    //        }
    //   } else if(command== qSphereSurfFluxCmd){
    //        if( CheckMeshPS(mesh,token[0],command)) {
    //            G4PSSphereSurfaceFlux3D* ps = new
    //            G4PSSphereSurfaceFlux3D(token[0], StoI(token[1]));
    //            ps->Weighted(StoB(token[2]));
    //            ps->DivideByArea(StoB(token[3]));
    //            if ( StoB(token[3]) ){
    //              ps->SetUnit(token[4]);
    //            }else{
    //              ps->SetUnit("");
    //            }
    //            mesh->SetPrimitiveScorer(ps);
    //        }
    //   } else if(command== qCylSurfCurrCmd){
    //        if( CheckMeshPS(mesh, token[0],command ) ) {
    //            G4PSCylinderSurfaceCurrent3D* ps =
    //              new G4PSCylinderSurfaceCurrent3D(token[0],StoI(token[1]));
    //            ps->Weighted(StoB(token[2]));
    //            ps->DivideByArea(StoB(token[3]));
    //            if ( StoB(token[3]) ){
    //              ps->SetUnit(token[4]);
    //            }else{
    //              ps->SetUnit("");
    //            }
    //            ps->SetUnit(token[4]);
    //            mesh->SetPrimitiveScorer(ps);
    //        }
    //   } else if(command== qCylSurfFluxCmd){
    //        if( CheckMeshPS(mesh, token[0],command ) {
    //            G4PSCylinerSurfaceFlux3D* ps =new
    //            G4PSCylinderSurfaceFlux3D(token[0], StoI(token[1]));
    //            ps->Weighted(StoB(token[2]));
    //            ps->DivideByArea(StoB(token[3]));
    //            if ( StoB(token[3]) ){
    //              ps->SetUnit(token[4]);
    //            }else{
    //              ps->SetUnit("");
    //            }
    //            mesh->SetPrimitiveScorer(ps);
    //        }
  }
  else if(command == qNofCollisionCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSNofCollision* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSNofCollision3D(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSNofCollision3D(token[0]);
      }
      ps->Weighted(StoB(token[1]));
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qPopulationCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSPopulation* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSPopulation(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSPopulation3D(token[0]);
      }
      ps->Weighted(StoB(token[1]));
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qTrackCountCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSTrackCounter* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSTrackCounter(token[0], StoI(token[1]),
                                  mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSTrackCounter3D(token[0], StoI(token[1]));
      }
      ps->Weighted(StoB(token[2]));
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qTerminationCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSTermination* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSTermination(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSTermination3D(token[0]);
      }
      ps->Weighted(StoB(token[1]));
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qMinKinEAtGeneCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSMinKinEAtGeneration* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSMinKinEAtGeneration(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSMinKinEAtGeneration3D(token[0]);
      }
      ps->SetUnit(token[1]);
      mesh->SetPrimitiveScorer(ps);
    }
  }
  else if(command == qStepCheckerCmd)
  {
    if(CheckMeshPS(mesh, token[0], command))
    {
      G4PSStepChecker* ps = nullptr;
      if(shape == MeshShape::realWorldLogVol || shape == MeshShape::probe)
      {
        ps = new G4PSStepChecker(token[0], mesh->GetCopyNumberLevel());
      }
      else
      {
        ps = new G4PSStepChecker3D(token[0]);
      }
      mesh->SetPrimitiveScorer(ps);
    }
 
    //
    // Filters
    //
  }
  else if(command == fchargedCmd)
  {
    if(!mesh->IsCurrentPrimitiveScorerNull())
    {
      mesh->SetFilter(new G4SDChargedFilter(token[0]));
    }
    else
    {
      ed << "WARNING[" << fchargedCmd->GetCommandPath()
         << "] : Current quantity is not set. Set or touch a quantity first.";
      command->CommandFailed(ed);
    }
  }
  else if(command == fneutralCmd)
  {
    if(!mesh->IsCurrentPrimitiveScorerNull())
    {
      mesh->SetFilter(new G4SDNeutralFilter(token[0]));
    }
    else
    {
      ed << "WARNING[" << fneutralCmd->GetCommandPath()
         << "] : Current quantity is not set. Set or touch a quantity first.";
      command->CommandFailed(ed);
    }
  }
  else if(command == fkinECmd)
  {
    if(!mesh->IsCurrentPrimitiveScorerNull())
    {
      G4String& name   = token[0];
      G4double elow    = StoD(token[1]);
      G4double ehigh   = StoD(token[2]);
      G4double unitVal = G4UnitDefinition::GetValueOf(token[3]);
      mesh->SetFilter(
        new G4SDKineticEnergyFilter(name, elow * unitVal, ehigh * unitVal));
    }
    else
    {
      ed << "WARNING[" << fkinECmd->GetCommandPath()
         << "] : Current quantity is not set. Set or touch a quantity first.";
      command->CommandFailed(ed);
    }
  }
  else if(command == fparticleKinECmd)
  {
    if(!mesh->IsCurrentPrimitiveScorerNull())
    {
      FParticleWithEnergyCommand(mesh, token);
    }
    else
    {
      ed << "WARNING[" << fparticleKinECmd->GetCommandPath()
         << "] : Current quantity is not set. Set or touch a quantity first.";
      command->CommandFailed(ed);
    }
  }
  else if(command == fparticleCmd)
  {
    if(!mesh->IsCurrentPrimitiveScorerNull())
    {
      FParticleCommand(mesh, token);
    }
    else
    {
      ed << "WARNING[" << fparticleCmd->GetCommandPath()
         << "] : Current quantity is not set. Set or touch a quantity first.";
      command->CommandFailed(ed);
    }
  }
}

References CheckMeshPS(), G4UIcommand::CommandFailed(), fchargedCmd, FillTokenVec(), fkinECmd, fneutralCmd, fparticleCmd, FParticleCommand(), fparticleKinECmd, FParticleWithEnergyCommand(), fSMan, G4cout, G4endl, G4VScoringMesh::GetAngleSpan(), G4UIcommand::GetCommandPath(), G4VScoringMesh::GetCopyNumberLevel(), G4ScoringManager::GetCurrentMesh(), G4VScoringMesh::GetCurrentPSUnit(), G4VScoringMesh::GetNumberOfSegments(), G4VScoringMesh::GetShape(), G4VScoringMesh::GetSize(), G4VScoringMesh::GetStartAngle(), G4UnitDefinition::GetValueOf(), G4VScoringMesh::IsCurrentPrimitiveScorerNull(), G4InuclParticleNames::name(), ps, qCellChgCmd, qCellFluxCmd, qdoseDepCmd, qeDepCmd, qFlatSurfCurrCmd, qFlatSurfFluxCmd, qGetUnitCmd, qMinKinEAtGeneCmd, qNofCollisionCmd, qnOfSecondaryCmd, qnOfStepCmd, qPassCellCurrCmd, qPassCellFluxCmd, qPassTrackLengthCmd, qPopulationCmd, qSetUnitCmd, qStepCheckerCmd, qTerminationCmd, qTouchCmd, qTrackCountCmd, qTrackLengthCmd, qVolFluxCmd, G4VScoringMesh::SetCurrentPrimitiveScorer(), G4VScoringMesh::SetCurrentPSUnit(), G4PSCellFluxForCylinder3D::SetCylinderSize(), G4PSDoseDepositForCylinder3D::SetCylinderSize(), G4PSPassageCellFluxForCylinder3D::SetCylinderSize(), G4VScoringMesh::SetFilter(), G4PSCellFluxForCylinder3D::SetNumberOfSegments(), G4PSDoseDepositForCylinder3D::SetNumberOfSegments(), G4PSPassageCellFluxForCylinder3D::SetNumberOfSegments(), G4VScoringMesh::SetPrimitiveScorer(), G4PSDoseDeposit::SetUnit(), G4UImessenger::StoB(), G4UImessenger::StoD(), and G4UImessenger::StoI().

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(), 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 FParticleWithEnergyCommand(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), 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(), 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

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

fchargedCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::fchargedCmd

private

Definition at line 119 of file G4ScoreQuantityMessenger.hh.

Referenced by FilterCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

filterDir

G4UIdirectory* G4ScoreQuantityMessenger::filterDir

private

Definition at line 118 of file G4ScoreQuantityMessenger.hh.

Referenced by FilterCommands(), and ~G4ScoreQuantityMessenger().

fkinECmd

G4UIcommand* G4ScoreQuantityMessenger::fkinECmd

private

Definition at line 121 of file G4ScoreQuantityMessenger.hh.

Referenced by FilterCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

fneutralCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::fneutralCmd

private

Definition at line 120 of file G4ScoreQuantityMessenger.hh.

Referenced by FilterCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

fparticleCmd

G4UIcommand* G4ScoreQuantityMessenger::fparticleCmd

private

Definition at line 122 of file G4ScoreQuantityMessenger.hh.

Referenced by FilterCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

fparticleKinECmd

G4UIcommand* G4ScoreQuantityMessenger::fparticleKinECmd

private

Definition at line 123 of file G4ScoreQuantityMessenger.hh.

Referenced by FilterCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

fSMan

G4ScoringManager* G4ScoreQuantityMessenger::fSMan

private

Definition at line 82 of file G4ScoreQuantityMessenger.hh.

Referenced by SetNewValue().

qCellChgCmd

G4UIcommand* G4ScoreQuantityMessenger::qCellChgCmd

private

Definition at line 90 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qCellFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qCellFluxCmd

private

Definition at line 91 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qdoseDepCmd

G4UIcommand* G4ScoreQuantityMessenger::qdoseDepCmd

private

Definition at line 94 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qeDepCmd

G4UIcommand* G4ScoreQuantityMessenger::qeDepCmd

private

Definition at line 93 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qFlatSurfCurrCmd

G4UIcommand* G4ScoreQuantityMessenger::qFlatSurfCurrCmd

private

Definition at line 101 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qFlatSurfFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qFlatSurfFluxCmd

private

Definition at line 102 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qGetUnitCmd

G4UIcmdWithoutParameter* G4ScoreQuantityMessenger::qGetUnitCmd

private

Definition at line 87 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qMinKinEAtGeneCmd

G4UIcommand* G4ScoreQuantityMessenger::qMinKinEAtGeneCmd

private

Definition at line 112 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qNofCollisionCmd

G4UIcommand* G4ScoreQuantityMessenger::qNofCollisionCmd

private

Definition at line 108 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qnOfSecondaryCmd

G4UIcommand* G4ScoreQuantityMessenger::qnOfSecondaryCmd

private

Definition at line 96 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qnOfStepCmd

G4UIcommand* G4ScoreQuantityMessenger::qnOfStepCmd

private

Definition at line 95 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qPassCellCurrCmd

G4UIcommand* G4ScoreQuantityMessenger::qPassCellCurrCmd

private

Definition at line 99 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qPassCellFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qPassCellFluxCmd

private

Definition at line 92 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qPassTrackLengthCmd

G4UIcommand* G4ScoreQuantityMessenger::qPassTrackLengthCmd

private

Definition at line 100 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qPopulationCmd

G4UIcommand* G4ScoreQuantityMessenger::qPopulationCmd

private

Definition at line 109 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qSetUnitCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::qSetUnitCmd

private

Definition at line 88 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qStepCheckerCmd

G4UIcommand* G4ScoreQuantityMessenger::qStepCheckerCmd

private

Definition at line 114 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qTerminationCmd

G4UIcommand* G4ScoreQuantityMessenger::qTerminationCmd

private

Definition at line 111 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qTouchCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::qTouchCmd

private

Definition at line 86 of file G4ScoreQuantityMessenger.hh.

Referenced by CheckMeshPS(), QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qTrackCountCmd

G4UIcommand* G4ScoreQuantityMessenger::qTrackCountCmd

private

Definition at line 110 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

qTrackLengthCmd

G4UIcommand* G4ScoreQuantityMessenger::qTrackLengthCmd

private

Definition at line 98 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

quantityDir

G4UIdirectory* G4ScoreQuantityMessenger::quantityDir

private

Definition at line 85 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), and ~G4ScoreQuantityMessenger().

qVolFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qVolFluxCmd

private

Definition at line 103 of file G4ScoreQuantityMessenger.hh.

Referenced by QuantityCommands(), SetNewValue(), and ~G4ScoreQuantityMessenger().

---

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

• source/digits_hits/utils/include/G4ScoreQuantityMessenger.hh
• source/digits_hits/utils/src/G4ScoreQuantityMessenger.cc
• source/digits_hits/utils/src/G4ScoreQuantityMessengerQCmd.cc