G4ScoringMessenger Class Reference

#include <G4ScoringMessenger.hh>

Inheritance diagram for G4ScoringMessenger:

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

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)
void	Fill1D (G4UIcommand *cmd, G4String newValues)
void	FillTokenVec (G4String newValues, G4TokenVec &token)
G4String	ItoS (G4int i)
void	MeshBinCommand (G4VScoringMesh *mesh, G4TokenVec &token)
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 Attributes
G4UIdirectory *	colorMapDir
G4UIcommand *	colorMapMinMaxCmd
G4UIcommand *	drawCmd
G4UIcommand *	drawColumnCmd
G4UIcommand *	dumpAllQtsToFileCmd
G4UIcommand *	dumpAllQtsWithFactorCmd
G4UIcmdWithoutParameter *	dumpCmd
G4UIcommand *	dumpQtyToFileCmd
G4UIcommand *	dumpQtyWithFactorCmd
G4UIcommand *	fill1DCmd
G4UIcmdWithAString *	floatMinMaxCmd
G4ScoringManager *	fSMan
G4UIcmdWithoutParameter *	listCmd
G4UIcmdWithoutParameter *	listColorMapCmd
G4UIcommand *	mBinCmd
G4UIcmdWith3VectorAndUnit *	mBoxSizeCmd
G4UIcommand *	mCylinderAngleCmd
G4UIcmdWithADoubleAndUnit *	mCylinderRMinCmd
G4UIcommand *	mCylinderSizeCmd
G4UIcmdWithAString *	meshBoxCreateCmd
G4UIcmdWithoutParameter *	meshClsCmd
G4UIdirectory *	meshCreateDir
G4UIcmdWithAString *	meshCylinderCreateCmd
G4UIdirectory *	meshDir
G4UIcmdWithAString *	meshOpnCmd
G4UIcommand *	meshRWLogVolCreateCmd
G4UIdirectory *	mRotDir
G4UIcmdWithADoubleAndUnit *	mRotXCmd
G4UIcmdWithADoubleAndUnit *	mRotYCmd
G4UIcmdWithADoubleAndUnit *	mRotZCmd
G4UIdirectory *	mTransDir
G4UIcmdWithoutParameter *	mTResetCmd
G4UIcmdWith3VectorAndUnit *	mTXyzCmd
G4UIcommand *	probeCreateCmd
G4UIdirectory *	probeDir
G4UIcmdWith3VectorAndUnit *	probeLocateCmd
G4UIcmdWithAString *	probeMatCmd
G4UIdirectory *	scoreDir
G4UIcmdWithAnInteger *	verboseCmd

Detailed Description

Definition at line 61 of file G4ScoringMessenger.hh.

Constructor & Destructor Documentation

G4ScoringMessenger()

G4ScoringMessenger::G4ScoringMessenger

(

G4ScoringManager *

SManager

)

Definition at line 50 of file G4ScoringMessenger.cc.

  : fSMan(SManager)
{
  G4UIparameter* param = nullptr;
 
  scoreDir = new G4UIdirectory("/score/");
  scoreDir->SetGuidance("Interactive scoring commands.");
 
  listCmd = new G4UIcmdWithoutParameter("/score/list", this);
  listCmd->SetGuidance("List scoring worlds.");
 
  dumpCmd = new G4UIcmdWithoutParameter("/score/dump", this);
  dumpCmd->SetGuidance("Dump results of scorers.");
 
  verboseCmd = new G4UIcmdWithAnInteger("/score/verbose", this);
  verboseCmd->SetGuidance("Verbosity.");
  verboseCmd->SetGuidance("  0) errors or warnings,");
  verboseCmd->SetGuidance("  1) information with 0)");
 
  meshCreateDir = new G4UIdirectory("/score/create/");
  meshCreateDir->SetGuidance("  Mesh creation commands.");
  //
  // Mesh commands
  meshBoxCreateCmd = new G4UIcmdWithAString("/score/create/boxMesh", this);
  meshBoxCreateCmd->SetGuidance("Create scoring box mesh.");
  meshBoxCreateCmd->SetParameterName("MeshName", false);
  //
  meshCylinderCreateCmd =
    new G4UIcmdWithAString("/score/create/cylinderMesh", this);
  meshCylinderCreateCmd->SetGuidance("Create scoring mesh.");
  meshCylinderCreateCmd->SetParameterName("MeshName", false);
  //
  //  meshSphereCreateCmd = new
  //  G4UIcmdWithAString("/score/create/sphereMesh",this);
  //  meshSphereCreateCmd->SetGuidance("Create scoring mesh.");
  //  meshSphereCreateCmd->SetParameterName("MeshName",false);
  //
  meshRWLogVolCreateCmd =
    new G4UIcommand("/score/create/realWorldLogVol", this);
  meshRWLogVolCreateCmd->SetGuidance(
    "Define scorers to a logical volume defined in the real world.");
  meshRWLogVolCreateCmd->SetGuidance(
    "  - Name of the specified logical volume is used as the mesh name.");
  meshRWLogVolCreateCmd->SetGuidance(
    "  - /score/mesh commands do not affect for this mesh.");
  meshRWLogVolCreateCmd->SetGuidance(
    "  - If copyNumberLevel is set, the copy number of that-level higher");
  meshRWLogVolCreateCmd->SetGuidance(
    "    in the geometrical hierarchy is used as the index.");
  param = new G4UIparameter("logVol", 's', false);
  meshRWLogVolCreateCmd->SetParameter(param);
  param = new G4UIparameter("copyNumberLevel", 'i', true);
  param->SetParameterRange("copyNumberLevel>=0");
  param->SetDefaultValue(0);
  meshRWLogVolCreateCmd->SetParameter(param);
  //
  probeCreateCmd = new G4UIcommand("/score/create/probe", this);
  probeCreateCmd->SetGuidance("Define scoring probe.");
  probeCreateCmd->SetGuidance(
    "  halfSize defines the half-width of the probing cube.");
  param = new G4UIparameter("pname", 's', false);
  probeCreateCmd->SetParameter(param);
  param = new G4UIparameter("halfSize", 'd', false);
  probeCreateCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("mm");
  probeCreateCmd->SetParameter(param);
  param = new G4UIparameter("checkOverlap", 'b', true);
  param->SetDefaultValue(false);
  probeCreateCmd->SetParameter(param);
  //
  meshOpnCmd = new G4UIcmdWithAString("/score/open", this);
  meshOpnCmd->SetGuidance("Open scoring mesh.");
  meshOpnCmd->SetParameterName("MeshName", false);
  //
  meshClsCmd = new G4UIcmdWithoutParameter("/score/close", this);
  meshClsCmd->SetGuidance("Close scoring mesh.");
  //
  //  meshActCmd = new G4UIcmdWithABool("/score/mesh/activate",this);
  //  meshActCmd->SetGuidance("Activate scoring mesh.");
  //  meshActCmd->SetParameterName("MeshName",false);
  //
  meshDir = new G4UIdirectory("/score/mesh/");
  meshDir->SetGuidance("    Mesh processing commands.");
  //
  mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/boxSize", this);
  mBoxSizeCmd->SetGuidance("Define size of the scoring mesh.");
  mBoxSizeCmd->SetGuidance("Dx  Dy  Dz  unit");
  mBoxSizeCmd->SetParameterName("Di", "Dj", "Dk", false, false);
  mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>0.");
  mBoxSizeCmd->SetDefaultUnit("mm");
  //
  mCylinderSizeCmd = new G4UIcommand("/score/mesh/cylinderSize", this);
  mCylinderSizeCmd->SetGuidance("Define size of the scoring mesh.");
  mCylinderSizeCmd->SetGuidance("R   Dz  unit");
  param = new G4UIparameter("R", 'd', false);
  param->SetParameterRange("R>0");
  mCylinderSizeCmd->SetParameter(param);
  param = new G4UIparameter("Dz", 'd', false);
  param->SetParameterRange("Dz>0");
  mCylinderSizeCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("mm");
  mCylinderSizeCmd->SetParameter(param);
  //
  mCylinderRMinCmd =
    new G4UIcmdWithADoubleAndUnit("/score/mesh/cylinderRMin", this);
  mCylinderRMinCmd->SetGuidance("Define the inner radius of the tube mesh.");
  mCylinderRMinCmd->SetGuidance("This command is not needed for cylinder mesh");
  mCylinderRMinCmd->SetParameterName("RMin", false, false);
  mCylinderRMinCmd->SetRange("RMin>=0.");
  mCylinderRMinCmd->SetDefaultUnit("mm");
  //
  mCylinderAngleCmd = new G4UIcommand("/score/mesh/cylinderAngles", this);
  mCylinderAngleCmd->SetGuidance(
    "Define starting angle and span for tube segment mesh.");
  mCylinderAngleCmd->SetGuidance(
    "This command is not needed for cylinder mesh");
  param = new G4UIparameter("startPhi", 'd', false);
  mCylinderAngleCmd->SetParameter(param);
  param = new G4UIparameter("deltaPhi", 'd', false);
  param->SetParameterRange("deltaPhi>0.");
  mCylinderAngleCmd->SetParameter(param);
  param = new G4UIparameter("unit", 's', true);
  param->SetDefaultUnit("deg");
  mCylinderAngleCmd->SetParameter(param);
  //
  //   Division command
  mBinCmd = new G4UIcommand("/score/mesh/nBin", this);
  mBinCmd->SetGuidance("Define segments of the scoring mesh.");
  mBinCmd->SetGuidance("[usage] /score/mesh/nBin");
  mBinCmd->SetGuidance(" In case of boxMesh, parameters are given in");
  mBinCmd->SetGuidance("   Ni  :(int) Number of bins i (in x-axis) ");
  mBinCmd->SetGuidance("   Nj  :(int) Number of bins j (in y-axis) ");
  mBinCmd->SetGuidance("   Nk  :(int) Number of bins k (in z-axis) ");
  mBinCmd->SetGuidance(" In case of cylinderMesh, parameters are given in");
  mBinCmd->SetGuidance("   Nr  :(int) Number of bins in radial axis ");
  mBinCmd->SetGuidance("   Nz  :(int) Number of bins in z axis ");
  mBinCmd->SetGuidance("   Nphi:(int) Number of bins in phi axis ");
  // mBinCmd->SetGuidance("  Axis:(int) Axis of division ");
  //  mBinCmd->SetGuidance("  P1..Pn-1  :(double) \"paramter from P1 to Pn-1 for
  //  division.\"");
  param = new G4UIparameter("Ni", 'i', false);
  param->SetDefaultValue("1");
  param->SetParameterRange("Ni>0");
  mBinCmd->SetParameter(param);
  param = new G4UIparameter("Nj", 'i', false);
  param->SetDefaultValue("1");
  param->SetParameterRange("Nj>0");
  mBinCmd->SetParameter(param);
  param = new G4UIparameter("Nk", 'i', false);
  param->SetDefaultValue("1");
  mBinCmd->SetParameter(param);
  param->SetParameterRange("Nk>0");
  // param = new G4UIparameter("Axis",'i',true);
  // param->SetDefaultValue("3");
  // mBinCmd->SetParameter(param);
  //
  //   Placement command
  mTransDir = new G4UIdirectory("/score/mesh/translate/");
  mTransDir->SetGuidance("Mesh translation commands.");
  //
  mTResetCmd = new G4UIcmdWithoutParameter("/score/mesh/translate/reset", this);
  mTResetCmd->SetGuidance("Reset translated position of the scoring mesh.");
  //
  mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/translate/xyz", this);
  mTXyzCmd->SetGuidance("Translate the scoring mesh.");
  mTXyzCmd->SetParameterName("X", "Y", "Z", false, false);
  mTXyzCmd->SetDefaultUnit("mm");
  //
  mRotDir = new G4UIdirectory("/score/mesh/rotate/");
  mRotDir->SetGuidance("Mesh rotation commands.");
  //
  // mRResetCmd = new G4UIcmdWithoutParameter("/score/mesh/rotate/reset",this);
  // mRResetCmd->SetGuidance("Reset rotation angles of the scoring mesh.");
  //
  mRotXCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateX", this);
  mRotXCmd->SetGuidance("Rotate the scoring mesh in X axis.");
  mRotXCmd->SetParameterName("Rx", false);
  mRotXCmd->SetDefaultUnit("deg");
  //
  mRotYCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateY", this);
  mRotYCmd->SetGuidance("Rotate the scoring mesh in Y axis.");
  mRotYCmd->SetParameterName("Ry", false);
  mRotYCmd->SetDefaultUnit("deg");
  //
  mRotZCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateZ", this);
  mRotZCmd->SetGuidance("Rotate the scoring mesh in Z axis.");
  mRotZCmd->SetParameterName("Rz", false);
  mRotZCmd->SetDefaultUnit("deg");
  //
  probeDir = new G4UIdirectory("/score/probe/");
  probeDir->SetGuidance("Probe commands");
 
  probeMatCmd = new G4UIcmdWithAString("/score/probe/material", this);
  probeMatCmd->SetGuidance("Specify a material to the probe cube.");
  probeMatCmd->SetGuidance("Material name has to be taken from G4NistManager.");
  probeMatCmd->SetGuidance("Once this command is used, the specified material "
                           "overlays the material in the mass geometry");
  probeMatCmd->SetGuidance("with \"Layered Mass Geometry\" mechanism so that "
                           "physics quantities such as energy deposition");
  probeMatCmd->SetGuidance("or dose will be calculated with this material.");
  probeMatCmd->SetGuidance("To switch-off this overlaying, use \"none\".");
  probeMatCmd->SetParameterName("matName", true);
  probeMatCmd->SetDefaultValue("none");
  probeMatCmd->SetToBeBroadcasted(false);
 
  probeLocateCmd = new G4UIcmdWith3VectorAndUnit("/score/probe/locate", this);
  probeLocateCmd->SetGuidance(
    "Locate a probe in the global coordinate system.");
  probeLocateCmd->SetParameterName("x", "y", "z", false);
  probeLocateCmd->SetDefaultUnit("mm");
  probeLocateCmd->SetToBeBroadcasted(false);
 
  // Draw Scoring result
  drawCmd = new G4UIcommand("/score/drawProjection", this);
  drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
  drawCmd->SetGuidance(
    "Parameter <proj> specified which projection(s) to be drawn.");
  drawCmd->SetGuidance(
    "  100 : xy-plane, 010 : yz-plane,    001 : zx-plane -- default 111");
  drawCmd->SetGuidance(
    "  100 : N/A,      010 : z_phi-plane, 001 : r_phi-plane -- default 111");
  param = new G4UIparameter("meshName", 's', false);
  drawCmd->SetParameter(param);
  param = new G4UIparameter("psName", 's', false);
  drawCmd->SetParameter(param);
  param = new G4UIparameter("colorMapName", 's', true);
  param->SetDefaultValue("defaultLinearColorMap");
  drawCmd->SetParameter(param);
  param = new G4UIparameter("proj", 'i', true);
  param->SetDefaultValue(111);
  drawCmd->SetParameter(param);
  drawCmd->SetToBeBroadcasted(false);
 
  // Draw column
  drawColumnCmd = new G4UIcommand("/score/drawColumn", this);
  drawColumnCmd->SetGuidance("Draw a cell column.");
  drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x  for box mesh");
  drawColumnCmd->SetGuidance(
    "         0 : z-phi, 1: r-phi, 2: r-z  for cylinder mesh");
  param = new G4UIparameter("meshName", 's', false);
  drawColumnCmd->SetParameter(param);
  param = new G4UIparameter("psName", 's', false);
  drawColumnCmd->SetParameter(param);
  param = new G4UIparameter("plane", 'i', false);
  param->SetParameterRange("plane>=0 && plane<=2");
  drawColumnCmd->SetParameter(param);
  param = new G4UIparameter("column", 'i', false);
  drawColumnCmd->SetParameter(param);
  param = new G4UIparameter("colorMapName", 's', true);
  param->SetDefaultValue("defaultLinearColorMap");
  drawColumnCmd->SetParameter(param);
  drawColumnCmd->SetToBeBroadcasted(false);
 
  colorMapDir = new G4UIdirectory("/score/colorMap/");
  colorMapDir->SetGuidance("Color map commands.");
 
  listColorMapCmd =
    new G4UIcmdWithoutParameter("/score/colorMap/listScoreColorMaps", this);
  listColorMapCmd->SetGuidance("List registered score color maps.");
  listColorMapCmd->SetToBeBroadcasted(false);
 
  floatMinMaxCmd = new G4UIcmdWithAString("/score/colorMap/floatMinMax", this);
  floatMinMaxCmd->SetGuidance(
    "Min/Max of the color map is calculated according to the actual scores.");
  floatMinMaxCmd->SetParameterName("colorMapName", true, false);
  floatMinMaxCmd->SetDefaultValue("defaultLinearColorMap");
  floatMinMaxCmd->SetToBeBroadcasted(false);
 
  colorMapMinMaxCmd = new G4UIcommand("/score/colorMap/setMinMax", this);
  colorMapMinMaxCmd->SetGuidance("Define min/max value of the color map.");
  param = new G4UIparameter("colorMapMame", 's', true);
  param->SetDefaultValue("defaultLinearColorMap");
  colorMapMinMaxCmd->SetParameter(param);
  param = new G4UIparameter("minValue", 'd', false);
  colorMapMinMaxCmd->SetParameter(param);
  param = new G4UIparameter("maxValue", 'd', false);
  colorMapMinMaxCmd->SetParameter(param);
  colorMapMinMaxCmd->SetToBeBroadcasted(false);
 
  /*
  chartCmd = new G4UIcommand("/score/drawChart",this);
  chartCmd->SetGuidance("Draw color chart on the screen.");
  chartCmd->SetGuidance("[usage] /score/drawChart");
  chartCmd->SetGuidance("  mesh    :(String) Mesh name.");
  chartCmd->SetGuidance("  psname  :(String) PS name.");
  chartCmd->SetGuidance("  On/Off  :(boolean) On or Off the color chart.");
  chartCmd->SetGuidance("  scale   :(String) default=linear, or log ");
  param = new G4UIparameter("meshName",'s',false);
  chartCmd->SetParameter(param);
  param = new G4UIparameter("psName",'s',false);
  chartCmd->SetParameter(param);
  param = new G4UIparameter("On",'s',true);
  param->SetDefaultValue("true");
  chartCmd->SetParameter(param);
  param = new G4UIparameter("scale",'s',true);
  param->SetDefaultValue("linear");
  chartCmd->SetParameter(param);
  */
 
  // Dump a scored quantity
  dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
  dumpQtyToFileCmd->SetGuidance("Dump one scored quantity to file.");
  param = new G4UIparameter("meshName", 's', false);
  dumpQtyToFileCmd->SetParameter(param);
  param = new G4UIparameter("psName", 's', false);
  dumpQtyToFileCmd->SetParameter(param);
  param = new G4UIparameter("fileName", 's', false);
  dumpQtyToFileCmd->SetParameter(param);
  param = new G4UIparameter("option", 's', true);
  dumpQtyToFileCmd->SetParameter(param);
  dumpQtyToFileCmd->SetToBeBroadcasted(false);
 
  dumpQtyWithFactorCmd = new G4UIcommand("/score/dumpQuantityWithFactor", this);
  dumpQtyWithFactorCmd->SetGuidance("Dump one scored quantity to file.");
  dumpQtyWithFactorCmd->SetGuidance(
    "Each value is multiplied by the specified factor.");
  param = new G4UIparameter("meshName", 's', false);
  dumpQtyWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("psName", 's', false);
  dumpQtyWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("fileName", 's', false);
  dumpQtyWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("factor", 'd', false);
  param->SetParameterRange("factor>0.");
  dumpQtyWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("option", 's', true);
  dumpQtyWithFactorCmd->SetParameter(param);
  dumpQtyWithFactorCmd->SetToBeBroadcasted(false);
 
  // Dump all scored quantities
  dumpAllQtsToFileCmd = new G4UIcommand("/score/dumpAllQuantitiesToFile", this);
  dumpAllQtsToFileCmd->SetGuidance("Dump all quantities of the mesh to file.");
  param = new G4UIparameter("meshName", 's', false);
  dumpAllQtsToFileCmd->SetParameter(param);
  param = new G4UIparameter("fileName", 's', false);
  dumpAllQtsToFileCmd->SetParameter(param);
  param = new G4UIparameter("option", 's', true);
  dumpAllQtsToFileCmd->SetParameter(param);
  dumpAllQtsToFileCmd->SetToBeBroadcasted(false);
 
  dumpAllQtsWithFactorCmd =
    new G4UIcommand("/score/dumpAllQuantitiesWithFactor", this);
  dumpAllQtsWithFactorCmd->SetGuidance(
    "Dump all quantities of the mesh to file.");
  dumpAllQtsWithFactorCmd->SetGuidance(
    "Each value is multiplied by the specified factor.");
  param = new G4UIparameter("meshName", 's', false);
  dumpAllQtsWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("fileName", 's', false);
  dumpAllQtsWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("factor", 'd', false);
  param->SetParameterRange("factor>0.");
  dumpAllQtsWithFactorCmd->SetParameter(param);
  param = new G4UIparameter("option", 's', true);
  dumpAllQtsWithFactorCmd->SetParameter(param);
  dumpAllQtsWithFactorCmd->SetToBeBroadcasted(false);
 
  fill1DCmd = new G4UIcommand("/score/fill1D", this);
  fill1DCmd->SetGuidance("Let a primitive scorer fill 1-D histogram");
  fill1DCmd->SetGuidance("Before using this command, primitive scorer must be "
                         "defined and assigned.");
  fill1DCmd->SetGuidance("Also before using this command, a histogram has to "
                         "be defined by /analysis/h1/create command.");
  fill1DCmd->SetGuidance(
    "This command is available only for real-world volume or probe.");
  fill1DCmd->SetGuidance("Please note that this command has to be applied to "
                         "each copy number of the scoring volume.");
  fill1DCmd->SetGuidance("If same histogram ID is used more than once, more "
                         "than one scorers fill that histogram.");
  param = new G4UIparameter("histID", 'i', false);
  fill1DCmd->SetParameter(param);
  param = new G4UIparameter("meshName", 's', false);
  fill1DCmd->SetParameter(param);
  param = new G4UIparameter("scorerName", 's', false);
  fill1DCmd->SetParameter(param);
  param = new G4UIparameter("copyNo", 'i', true);
  param->SetDefaultValue(0);
  fill1DCmd->SetParameter(param);
}

References colorMapDir, colorMapMinMaxCmd, drawCmd, drawColumnCmd, dumpAllQtsToFileCmd, dumpAllQtsWithFactorCmd, dumpCmd, dumpQtyToFileCmd, dumpQtyWithFactorCmd, fill1DCmd, floatMinMaxCmd, listCmd, listColorMapCmd, mBinCmd, mBoxSizeCmd, mCylinderAngleCmd, mCylinderRMinCmd, mCylinderSizeCmd, meshBoxCreateCmd, meshClsCmd, meshCreateDir, meshCylinderCreateCmd, meshDir, meshOpnCmd, meshRWLogVolCreateCmd, mRotDir, mRotXCmd, mRotYCmd, mRotZCmd, mTransDir, mTResetCmd, mTXyzCmd, probeCreateCmd, probeDir, probeLocateCmd, probeMatCmd, scoreDir, G4UIcmdWith3VectorAndUnit::SetDefaultUnit(), G4UIcmdWithADoubleAndUnit::SetDefaultUnit(), G4UIparameter::SetDefaultUnit(), G4UIcmdWithAString::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWith3VectorAndUnit::SetParameterName(), G4UIparameter::SetParameterRange(), G4UIcommand::SetRange(), G4UIcommand::SetToBeBroadcasted(), and verboseCmd.

~G4ScoringMessenger()

G4ScoringMessenger::~G4ScoringMessenger

(

)

Definition at line 432 of file G4ScoringMessenger.cc.

{
  delete listCmd;
  delete verboseCmd;
  //
  delete meshBoxCreateCmd;
  delete meshCylinderCreateCmd;
  delete meshRWLogVolCreateCmd;
  delete probeCreateCmd;
  delete meshCreateDir;
  //    delete           meshSphereCreateCmd;
  //
  delete meshOpnCmd;
  //
  delete meshClsCmd;
  //    delete    meshActCmd;
  delete meshDir;
  //
  delete mBoxSizeCmd;
  delete mCylinderSizeCmd;
  delete mCylinderRMinCmd;
  delete mCylinderAngleCmd;
  //    delete  mSphereSizeCmd;
  //
  delete mBinCmd;
  //
  delete mTResetCmd;
  delete mTXyzCmd;
  delete mTransDir;
  //    delete   mRResetCmd;
  delete mRotXCmd;
  delete mRotYCmd;
  delete mRotZCmd;
  delete mRotDir;
  //
  delete probeLocateCmd;
  delete probeMatCmd;
  delete probeDir;
  //
  // delete     chartCmd;
  delete dumpCmd;
  delete drawCmd;
  delete drawColumnCmd;
  delete listColorMapCmd;
  delete floatMinMaxCmd;
  delete colorMapMinMaxCmd;
  delete colorMapDir;
  delete dumpQtyToFileCmd;
  delete dumpQtyWithFactorCmd;
  delete dumpAllQtsToFileCmd;
  delete dumpAllQtsWithFactorCmd;
  delete fill1DCmd;
  //
  delete scoreDir;
}

References colorMapDir, colorMapMinMaxCmd, drawCmd, drawColumnCmd, dumpAllQtsToFileCmd, dumpAllQtsWithFactorCmd, dumpCmd, dumpQtyToFileCmd, dumpQtyWithFactorCmd, fill1DCmd, floatMinMaxCmd, listCmd, listColorMapCmd, mBinCmd, mBoxSizeCmd, mCylinderAngleCmd, mCylinderRMinCmd, mCylinderSizeCmd, meshBoxCreateCmd, meshClsCmd, meshCreateDir, meshCylinderCreateCmd, meshDir, meshOpnCmd, meshRWLogVolCreateCmd, mRotDir, mRotXCmd, mRotYCmd, mRotZCmd, mTransDir, mTResetCmd, mTXyzCmd, probeCreateCmd, probeDir, probeLocateCmd, probeMatCmd, scoreDir, and verboseCmd.

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

Fill1D()

void G4ScoringMessenger::Fill1D ( G4UIcommand *  cmd, G4String  newValues  )

protected

Definition at line 1032 of file G4ScoringMessenger.cc.

{
  using MeshShape = G4VScoringMesh::MeshShape;
 
  G4Tokenizer next(newVal);
  G4int histID      = StoI(next());
  G4String meshName = next();
  G4String primName = next();
  G4int copyNo      = StoI(next());
 
  auto filler = G4VScoreHistFiller::Instance();
  if(!filler)
  {
    G4ExceptionDescription ed;
    ed << "G4TScoreHistFiller is not instantiated in this application.";
    cmd->CommandFailed(ed);
    return;
  }
  //
  // To do : check the validity of histID
  //
 
  auto sm   = G4ScoringManager::GetScoringManagerIfExist();
  auto mesh = sm->FindMesh(meshName);
  if(mesh == nullptr)
  {
    G4ExceptionDescription ed;
    ed << "Mesh name <" << meshName << "> is not found.";
    cmd->CommandFailed(ed);
    return;
  }
  auto shape = mesh->GetShape();
  if(shape != MeshShape::realWorldLogVol && shape != MeshShape::probe)
  {
    G4ExceptionDescription ed;
    ed << "Mesh <" << meshName
       << "> is not real-world logical volume or probe.";
    cmd->CommandFailed(ed);
    return;
  }
 
  auto prim = mesh->GetPrimitiveScorer(primName);
  if(prim == nullptr)
  {
    G4ExceptionDescription ed;
    ed << "Primitive scorer name <" << primName << "> is not found.";
    cmd->CommandFailed(ed);
    return;
  }
  auto pp = dynamic_cast<G4VPrimitivePlotter*>(prim);
  if(pp == nullptr)
  {
    G4ExceptionDescription ed;
    ed << "Primitive scorer <" << primName
       << "> does not support direct histogram filling.";
    cmd->CommandFailed(ed);
    return;
  }
 
  pp->Plot(copyNo, histID);
}

References G4UIcommand::CommandFailed(), G4ScoringManager::GetScoringManagerIfExist(), G4VScoreHistFiller::Instance(), G4InuclParticleNames::pp, G4InuclParticleNames::sm, and G4UImessenger::StoI().

Referenced by SetNewValue().

FillTokenVec()

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

protected

Definition at line 986 of file G4ScoringMessenger.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().

GetCurrentValue()

G4String G4ScoringMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 975 of file G4ScoringMessenger.cc.

{
  G4String val;
  if(command == verboseCmd)
  {
    val = verboseCmd->ConvertToString(fSMan->GetVerboseLevel());
  }
 
  return val;
}

References G4UIcommand::ConvertToString(), fSMan, G4ScoringManager::GetVerboseLevel(), 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().

MeshBinCommand()

void G4ScoringMessenger::MeshBinCommand ( G4VScoringMesh *  mesh, G4TokenVec &  token  )

protected

Definition at line 996 of file G4ScoringMessenger.cc.

{
  G4int Ni = StoI(token[0]);
  G4int Nj = StoI(token[1]);
  G4int Nk = StoI(token[2]);
  G4int nSegment[3];
 
  if(dynamic_cast<G4ScoringBox*>(mesh))
  {
    G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox"
           << G4endl;
    nSegment[0] = Ni;
    nSegment[1] = Nj;
    nSegment[2] = Nk;
  }
  else if(dynamic_cast<G4ScoringCylinder*>(mesh))
  {
    G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder"
           << G4endl;
    nSegment[0] = Nj;
    nSegment[1] = Nk;
    nSegment[2] = Ni;
  }
  else
  {
    G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException,
                "invalid mesh type");
    return;
  }
  //
  mesh->SetNumberOfSegments(nSegment);
}

References FatalException, G4cout, G4endl, G4Exception(), G4VScoringMesh::SetNumberOfSegments(), and G4UImessenger::StoI().

Referenced by SetNewValue().

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 G4ScoringMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValues  )

virtual

Reimplemented from G4UImessenger.

Definition at line 488 of file G4ScoringMessenger.cc.

{
  using MeshShape = G4VScoringMesh::MeshShape;
 
  if(command == listCmd)
  {
    fSMan->List();
  }
  else if(command == dumpCmd)
  {
    fSMan->Dump();
  }
  else if(command == drawCmd)
  {
    G4Tokenizer next(newVal);
    G4String meshName     = next();
    G4String psName       = next();
    G4String colorMapName = next();
    G4int axflg           = StoI(next());
    fSMan->DrawMesh(meshName, psName, colorMapName, axflg);
  }
  else if(command == drawColumnCmd)
  {
    G4Tokenizer next(newVal);
    G4String meshName     = next();
    G4String psName       = next();
    G4int iPlane          = StoI(next());
    G4int iColumn         = StoI(next());
    G4String colorMapName = next();
    fSMan->DrawMesh(meshName, psName, iPlane, iColumn, colorMapName);
    //  } else if(command==chartCmd ){
    //      G4Tokenizer next(newVal);
    //      G4String meshName = next();
    //      G4String psName = next();
    //      //G4bool   onFlag = StoB(next());
    //      G4String scaleOption = next();
    //      fSMan->DrawChart(meshName,psName,onFlag,scaleOption);
  }
  else if(command == dumpQtyToFileCmd)
  {
    G4Tokenizer next(newVal);
    G4String meshName = next();
    G4String psName   = next();
    G4String fileName = next();
    G4String option   = next("\n");
    auto mesh         = fSMan->FindMesh(meshName);
    if(!mesh)
    {
      G4ExceptionDescription ed;
      ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
      command->CommandFailed(ed);
      return;
    }
    fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
  }
  else if(command == dumpQtyWithFactorCmd)
  {
    G4Tokenizer next(newVal);
    G4String meshName = next();
    G4String psName   = next();
    G4String fileName = next();
    G4double fac      = StoD(next());
    G4String option   = next("\n");
    auto mesh         = fSMan->FindMesh(meshName);
    if(!mesh)
    {
      G4ExceptionDescription ed;
      ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
      command->CommandFailed(ed);
      return;
    }
    fSMan->SetFactor(fac);
    fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
    fSMan->SetFactor(1.0);
  }
  else if(command == dumpAllQtsToFileCmd)
  {
    G4Tokenizer next(newVal);
    G4String meshName = next();
    G4String fileName = next();
    G4String option   = next("\n");
    auto mesh         = fSMan->FindMesh(meshName);
    if(!mesh)
    {
      G4ExceptionDescription ed;
      ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
      command->CommandFailed(ed);
      return;
    }
    fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
  }
  else if(command == dumpAllQtsWithFactorCmd)
  {
    G4Tokenizer next(newVal);
    G4String meshName = next();
    G4String fileName = next();
    G4double fac      = StoD(next());
    G4String option   = next("\n");
    auto mesh         = fSMan->FindMesh(meshName);
    if(!mesh)
    {
      G4ExceptionDescription ed;
      ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
      command->CommandFailed(ed);
      return;
    }
    fSMan->SetFactor(fac);
    fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
    fSMan->SetFactor(1.0);
  }
  else if(command == fill1DCmd)
  {
    Fill1D(command, newVal);
  }
  else if(command == verboseCmd)
  {
    fSMan->SetVerboseLevel(verboseCmd->GetNewIntValue(newVal));
  }
  else if(command == meshBoxCreateCmd)
  {
    G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
    if(currentmesh)
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath() << "] : Mesh <"
         << currentmesh->GetWorldName()
         << "> is still open. Close it first. Command ignored.";
      command->CommandFailed(ed);
    }
    else
    {
      G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
      if(!mesh)
      {
        mesh = new G4ScoringBox(newVal);
        fSMan->RegisterScoringMesh(mesh);
      }
      else
      {
        G4ExceptionDescription ed;
        ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
           << "] : Scoring mesh <" << newVal
           << "> already exists. Command ignored.";
        command->CommandFailed(ed);
      }
    }
  }
  else if(command == meshCylinderCreateCmd)
  {
    G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
    if(currentmesh)
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath() << "] : Mesh <"
         << currentmesh->GetWorldName()
         << "> is still open. Close it first. Command ignored.";
      command->CommandFailed(ed);
    }
    else
    {
      G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
      if(!mesh)
      {
        mesh = new G4ScoringCylinder(newVal);
        fSMan->RegisterScoringMesh(mesh);
      }
      else
      {
        G4ExceptionDescription ed;
        ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
           << "] : Scoring mesh <" << newVal
           << "> already exists. Command ignored.";
        command->CommandFailed(ed);
      }
    }
  }
  else if(command == meshRWLogVolCreateCmd)
  {
    auto mesh = fSMan->GetCurrentMesh();
    if(mesh)
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath() << "] : Mesh <"
         << mesh->GetWorldName()
         << "> is still open. Close it first. Command ignored.";
      command->CommandFailed(ed);
    }
    else
    {
      G4Tokenizer next(newVal);
      G4String meshName = next();
      G4int idx         = StoI(next());
      mesh              = fSMan->FindMesh(meshName);
      if(!mesh)
      {
        mesh = new G4ScoringRealWorld(meshName);
        mesh->SetCopyNumberLevel(idx);
        fSMan->RegisterScoringMesh(mesh);
      }
      else
      {
        G4ExceptionDescription ed;
        ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath()
           << "] : Scoring mesh <" << meshName
           << "> already exists. Command ignored.";
        command->CommandFailed(ed);
      }
    }
  }
  else if(command == probeCreateCmd)
  {
    auto mesh = fSMan->GetCurrentMesh();
    if(mesh)
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath() << "] : Mesh <"
         << mesh->GetWorldName()
         << "> is still open. Close it first. Command ignored.";
      command->CommandFailed(ed);
    }
    else
    {
      G4Tokenizer next(newVal);
      G4String qname    = next();
      G4double halfSize = StoD(next());
      halfSize *= G4UIcommand::ValueOf(next());
      G4bool checkOverlap = StoB(next());
      mesh                = fSMan->FindMesh(qname);
      if(!mesh)
      {
        mesh = new G4ScoringProbe(qname, halfSize, checkOverlap);
        fSMan->RegisterScoringMesh(mesh);
      }
      else
      {
        G4ExceptionDescription ed;
        ed << "ERROR[" << probeCreateCmd->GetCommandPath() << "] : Mesh name <"
           << qname << "> already exists. Use another name.";
        command->CommandFailed(ed);
      }
    }
  }
  else if(command == probeMatCmd || command == probeLocateCmd)
  {
    auto mesh = fSMan->GetCurrentMesh();
    if(!mesh)
    {
      G4ExceptionDescription ed;
      ed << "ERROR : No mesh is currently open. Open/create a mesh first. "
            "Command ignored.";
      command->CommandFailed(ed);
      return;
    }
    if(mesh->GetShape() != MeshShape::probe)
    {
      G4ExceptionDescription ed;
      ed << "ERROR : Inconsistent mesh type. Close current mesh and open "
            "Scoring Probe.";
      command->CommandFailed(ed);
      return;
    }
 
    if(command == probeMatCmd)
    {
      G4bool succ = static_cast<G4ScoringProbe*>(mesh)->SetMaterial(newVal);
      if(!succ)
      {
        G4ExceptionDescription ed;
        ed << "Material <" << newVal
           << "> is not defind in G4NistManager. Command is ignored.\n"
           << "Use /material/nist/listMaterials command to see the available "
              "materials.";
        command->CommandFailed(ed);
        return;
      }
    }
    else if(command == probeLocateCmd)
    {
      G4ThreeVector loc = probeLocateCmd->GetNew3VectorValue(newVal);
      static_cast<G4ScoringProbe*>(mesh)->LocateProbe(loc);
    }
  }
  else if(command == listColorMapCmd)
  {
    fSMan->ListScoreColorMaps();
  }
  else if(command == floatMinMaxCmd)
  {
    G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(newVal);
    if(colorMap)
    {
      colorMap->SetFloatingMinMax(true);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << floatMinMaxCmd->GetCommandPath() << "] : color map <"
         << newVal << "> is not defined. Command ignored.";
      command->CommandFailed(ed);
    }
  }
  else if(command == colorMapMinMaxCmd)
  {
    G4Tokenizer next(newVal);
    G4String mapName           = next();
    G4double minVal            = StoD(next());
    G4double maxVal            = StoD(next());
    G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(mapName);
    if(colorMap)
    {
      colorMap->SetFloatingMinMax(false);
      colorMap->SetMinMax(minVal, maxVal);
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << colorMapMinMaxCmd->GetCommandPath() << "] : color map <"
         << newVal << "> is not defined. Command ignored." << G4endl;
      command->CommandFailed(ed);
    }
  }
  else if(command == meshOpnCmd)
  {
    G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
    if(currentmesh)
    {
      G4ExceptionDescription ed;
      ed << "ERROR[" << meshOpnCmd->GetCommandPath() << "] : Mesh <"
         << currentmesh->GetWorldName()
         << "> is still open. Close it first. Command ignored.";
      command->CommandFailed(ed);
    }
    else
    {
      G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
      if(!mesh)
      {
        G4ExceptionDescription ed;
        ed << "ERROR[" << meshOpnCmd->GetCommandPath() << "] : Scoring mesh <"
           << newVal << "> does not exist. Command ignored.";
        command->CommandFailed(ed);
      }
      else
      {
        fSMan->SetCurrentMesh(mesh);
      }
    }
  }
  else if(command == meshClsCmd)
  {
    fSMan->CloseCurrentMesh();
  }
  else
  {
    //
    // Get Current Mesh
    //
    G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
    //
    // Commands for Current Mesh
    if(mesh)
    {
      MeshShape shape = mesh->GetShape();
      if(shape == MeshShape::realWorldLogVol)
      {
        G4ExceptionDescription ed;
        ed << "ERROR[" << mBinCmd->GetCommandPath()
           << "] : Number of mesh command cannot be set for this type of mesh. "
              "Command ignored.";
        command->CommandFailed(ed);
      }
      else
      {
        // Tokens
        G4TokenVec token;
        FillTokenVec(newVal, token);
        //
        // Mesh Geometry
        //
        //    if(command==meshActCmd) {
        //        mesh->Activate(meshActCmd->GetNewBoolValue(newVal));
        //    } else
        if(command == mBoxSizeCmd)
        {
          if(shape == MeshShape::box)
          {
            G4ThreeVector size = mBoxSizeCmd->GetNew3VectorValue(newVal);
            G4double vsize[3];
            vsize[0] = size.x();
            vsize[1] = size.y();
            vsize[2] = size.z();
            mesh->SetSize(vsize);
          }
          else
          {
            G4ExceptionDescription ed;
            ed << "ERROR[" << mBoxSizeCmd->GetCommandPath()
               << "] : This mesh is not Box. Command ignored.";
            command->CommandFailed(ed);
          }
        }
        else if(command == mCylinderSizeCmd || command == mCylinderRMinCmd ||
                command == mCylinderAngleCmd)
        {
          if(shape != MeshShape::cylinder)
          {
            G4ExceptionDescription ed;
            ed << "ERROR[" << command->GetCommandPath()
               << "] : This mesh is not Cylinder. Command ignored.";
            command->CommandFailed(ed);
          }
          else
          {
            if(command == mCylinderSizeCmd)
            {
              G4double vsize[3];
              vsize[0]     = (mesh->GetSize()).x();
              vsize[1]     = StoD(token[0]);
              vsize[2]     = StoD(token[1]);
              G4double unt = mCylinderSizeCmd->ValueOf(token[2]);
              vsize[1] *= unt;
              vsize[2] *= unt;
              mesh->SetSize(vsize);
            }
            else if(command == mCylinderRMinCmd)
            {
              G4double vsize[3];
              vsize[0] = mCylinderRMinCmd->GetNewDoubleValue(newVal);
              vsize[1] = (mesh->GetSize()).y();
              vsize[2] = (mesh->GetSize()).z();
              mesh->SetSize(vsize);
            }
            else if(command == mCylinderAngleCmd)
            {
              G4double stphi = StoD(token[0]);
              G4double spphi = StoD(token[1]);
              G4double unt   = mCylinderAngleCmd->ValueOf(token[2]);
              mesh->SetAngles(stphi * unt, spphi * unt);
            }
          }
        }
        else if(command == mBinCmd)
        {
          MeshBinCommand(mesh, token);
        }
        else if(command == mTResetCmd)
        {
          G4double centerPosition[3] = { 0., 0., 0. };
          mesh->SetCenterPosition(centerPosition);
        }
        else if(command == mTXyzCmd)
        {
          G4ThreeVector xyz = mTXyzCmd->GetNew3VectorValue(newVal);
          G4double centerPosition[3];
          centerPosition[0] = xyz.x();
          centerPosition[1] = xyz.y();
          centerPosition[2] = xyz.z();
          mesh->SetCenterPosition(centerPosition);
          //      } else if(command==mRResetCmd) {
        }
        else if(command == mRotXCmd)
        {
          G4double value = mRotXCmd->GetNewDoubleValue(newVal);
          mesh->RotateX(value);
        }
        else if(command == mRotYCmd)
        {
          G4double value = mRotYCmd->GetNewDoubleValue(newVal);
          mesh->RotateY(value);
        }
        else if(command == mRotZCmd)
        {
          G4double value = mRotZCmd->GetNewDoubleValue(newVal);
          mesh->RotateZ(value);
        }
      }
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "ERROR: No mesh is currently open. Open/create a mesh first. "
            "Command ignored.";
      command->CommandFailed(ed);
    }
  }
}

References G4ScoringManager::CloseCurrentMesh(), colorMapMinMaxCmd, G4UIcommand::CommandFailed(), drawCmd, drawColumnCmd, G4ScoringManager::DrawMesh(), G4ScoringManager::Dump(), dumpAllQtsToFileCmd, dumpAllQtsWithFactorCmd, G4ScoringManager::DumpAllQuantitiesToFile(), dumpCmd, dumpQtyToFileCmd, dumpQtyWithFactorCmd, G4ScoringManager::DumpQuantityToFile(), fac, Fill1D(), fill1DCmd, FillTokenVec(), G4ScoringManager::FindMesh(), floatMinMaxCmd, fSMan, G4endl, G4UIcommand::GetCommandPath(), G4ScoringManager::GetCurrentMesh(), G4UIcmdWith3VectorAndUnit::GetNew3VectorValue(), G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(), G4UIcmdWithAnInteger::GetNewIntValue(), G4ScoringManager::GetScoreColorMap(), G4VScoringMesh::GetShape(), G4VScoringMesh::GetSize(), G4VScoringMesh::GetWorldName(), G4ScoringManager::List(), listCmd, listColorMapCmd, G4ScoringManager::ListScoreColorMaps(), mBinCmd, mBoxSizeCmd, mCylinderAngleCmd, mCylinderRMinCmd, mCylinderSizeCmd, MeshBinCommand(), meshBoxCreateCmd, meshClsCmd, meshCylinderCreateCmd, meshOpnCmd, meshRWLogVolCreateCmd, mRotXCmd, mRotYCmd, mRotZCmd, mTResetCmd, mTXyzCmd, probeCreateCmd, probeLocateCmd, probeMatCmd, G4ScoringManager::RegisterScoringMesh(), G4VScoringMesh::RotateX(), G4VScoringMesh::RotateY(), G4VScoringMesh::RotateZ(), G4VScoringMesh::SetAngles(), G4VScoringMesh::SetCenterPosition(), G4ScoringManager::SetCurrentMesh(), G4ScoringManager::SetFactor(), G4VScoreColorMap::SetFloatingMinMax(), EmPlot::SetMaterial(), G4VScoreColorMap::SetMinMax(), G4VScoringMesh::SetSize(), G4ScoringManager::SetVerboseLevel(), G4UImessenger::StoB(), G4UImessenger::StoD(), G4UImessenger::StoI(), G4UIcommand::ValueOf(), verboseCmd, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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 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(), 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 Fill1D(), G4ParticleGunMessenger::IonCommand(), G4GeneralParticleSourceMessenger::IonCommand(), G4ParticleGunMessenger::IonLevelCommand(), G4GeneralParticleSourceMessenger::IonLvlCommand(), MeshBinCommand(), G4LocalThreadCoutMessenger::SetNewValue(), G4UIcontrolMessenger::SetNewValue(), G4MatScanMessenger::SetNewValue(), G4GMocrenMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), and 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().

colorMapDir

G4UIdirectory* G4ScoringMessenger::colorMapDir

private

Definition at line 126 of file G4ScoringMessenger.hh.

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

colorMapMinMaxCmd

G4UIcommand* G4ScoringMessenger::colorMapMinMaxCmd

private

Definition at line 129 of file G4ScoringMessenger.hh.

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

commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

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

drawCmd

G4UIcommand* G4ScoringMessenger::drawCmd

private

Definition at line 124 of file G4ScoringMessenger.hh.

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

drawColumnCmd

G4UIcommand* G4ScoringMessenger::drawColumnCmd

private

Definition at line 125 of file G4ScoringMessenger.hh.

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

dumpAllQtsToFileCmd

G4UIcommand* G4ScoringMessenger::dumpAllQtsToFileCmd

private

Definition at line 134 of file G4ScoringMessenger.hh.

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

dumpAllQtsWithFactorCmd

G4UIcommand* G4ScoringMessenger::dumpAllQtsWithFactorCmd

private

Definition at line 136 of file G4ScoringMessenger.hh.

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

dumpCmd

G4UIcmdWithoutParameter* G4ScoringMessenger::dumpCmd

private

Definition at line 81 of file G4ScoringMessenger.hh.

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

dumpQtyToFileCmd

G4UIcommand* G4ScoringMessenger::dumpQtyToFileCmd

private

Definition at line 133 of file G4ScoringMessenger.hh.

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

dumpQtyWithFactorCmd

G4UIcommand* G4ScoringMessenger::dumpQtyWithFactorCmd

private

Definition at line 135 of file G4ScoringMessenger.hh.

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

fill1DCmd

G4UIcommand* G4ScoringMessenger::fill1DCmd

private

Definition at line 139 of file G4ScoringMessenger.hh.

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

floatMinMaxCmd

G4UIcmdWithAString* G4ScoringMessenger::floatMinMaxCmd

private

Definition at line 128 of file G4ScoringMessenger.hh.

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

fSMan

G4ScoringManager* G4ScoringMessenger::fSMan

private

Definition at line 78 of file G4ScoringMessenger.hh.

Referenced by GetCurrentValue(), and SetNewValue().

listCmd

G4UIcmdWithoutParameter* G4ScoringMessenger::listCmd

private

Definition at line 80 of file G4ScoringMessenger.hh.

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

listColorMapCmd

G4UIcmdWithoutParameter* G4ScoringMessenger::listColorMapCmd

private

Definition at line 127 of file G4ScoringMessenger.hh.

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

mBinCmd

G4UIcommand* G4ScoringMessenger::mBinCmd

private

Definition at line 106 of file G4ScoringMessenger.hh.

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

mBoxSizeCmd

G4UIcmdWith3VectorAndUnit* G4ScoringMessenger::mBoxSizeCmd

private

Definition at line 99 of file G4ScoringMessenger.hh.

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

mCylinderAngleCmd

G4UIcommand* G4ScoringMessenger::mCylinderAngleCmd

private

Definition at line 102 of file G4ScoringMessenger.hh.

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

mCylinderRMinCmd

G4UIcmdWithADoubleAndUnit* G4ScoringMessenger::mCylinderRMinCmd

private

Definition at line 101 of file G4ScoringMessenger.hh.

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

mCylinderSizeCmd

G4UIcommand* G4ScoringMessenger::mCylinderSizeCmd

private

Definition at line 100 of file G4ScoringMessenger.hh.

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

meshBoxCreateCmd

G4UIcmdWithAString* G4ScoringMessenger::meshBoxCreateCmd

private

Definition at line 85 of file G4ScoringMessenger.hh.

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

meshClsCmd

G4UIcmdWithoutParameter* G4ScoringMessenger::meshClsCmd

private

Definition at line 95 of file G4ScoringMessenger.hh.

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

meshCreateDir

G4UIdirectory* G4ScoringMessenger::meshCreateDir

private

Definition at line 84 of file G4ScoringMessenger.hh.

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

meshCylinderCreateCmd

G4UIcmdWithAString* G4ScoringMessenger::meshCylinderCreateCmd

private

Definition at line 86 of file G4ScoringMessenger.hh.

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

meshDir

G4UIdirectory* G4ScoringMessenger::meshDir

private

Definition at line 92 of file G4ScoringMessenger.hh.

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

meshOpnCmd

G4UIcmdWithAString* G4ScoringMessenger::meshOpnCmd

private

Definition at line 93 of file G4ScoringMessenger.hh.

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

meshRWLogVolCreateCmd

G4UIcommand* G4ScoringMessenger::meshRWLogVolCreateCmd

private

Definition at line 88 of file G4ScoringMessenger.hh.

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

mRotDir

G4UIdirectory* G4ScoringMessenger::mRotDir

private

Definition at line 112 of file G4ScoringMessenger.hh.

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

mRotXCmd

G4UIcmdWithADoubleAndUnit* G4ScoringMessenger::mRotXCmd

private

Definition at line 114 of file G4ScoringMessenger.hh.

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

mRotYCmd

G4UIcmdWithADoubleAndUnit* G4ScoringMessenger::mRotYCmd

private

Definition at line 115 of file G4ScoringMessenger.hh.

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

mRotZCmd

G4UIcmdWithADoubleAndUnit* G4ScoringMessenger::mRotZCmd

private

Definition at line 116 of file G4ScoringMessenger.hh.

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

mTransDir

G4UIdirectory* G4ScoringMessenger::mTransDir

private

Definition at line 109 of file G4ScoringMessenger.hh.

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

mTResetCmd

G4UIcmdWithoutParameter* G4ScoringMessenger::mTResetCmd

private

Definition at line 110 of file G4ScoringMessenger.hh.

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

mTXyzCmd

G4UIcmdWith3VectorAndUnit* G4ScoringMessenger::mTXyzCmd

private

Definition at line 111 of file G4ScoringMessenger.hh.

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

probeCreateCmd

G4UIcommand* G4ScoringMessenger::probeCreateCmd

private

Definition at line 89 of file G4ScoringMessenger.hh.

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

probeDir

G4UIdirectory* G4ScoringMessenger::probeDir

private

Definition at line 119 of file G4ScoringMessenger.hh.

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

probeLocateCmd

G4UIcmdWith3VectorAndUnit* G4ScoringMessenger::probeLocateCmd

private

Definition at line 121 of file G4ScoringMessenger.hh.

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

probeMatCmd

G4UIcmdWithAString* G4ScoringMessenger::probeMatCmd

private

Definition at line 120 of file G4ScoringMessenger.hh.

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

scoreDir

G4UIdirectory* G4ScoringMessenger::scoreDir

private

Definition at line 79 of file G4ScoringMessenger.hh.

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

verboseCmd

G4UIcmdWithAnInteger* G4ScoringMessenger::verboseCmd

private

Definition at line 82 of file G4ScoringMessenger.hh.

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

---

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

• source/digits_hits/utils/include/G4ScoringMessenger.hh
• source/digits_hits/utils/src/G4ScoringMessenger.cc