G4ScoreQuantityMessenger Class Reference

#include <G4ScoreQuantityMessenger.hh>

Inheritance diagram for G4ScoreQuantityMessenger:

Collaboration diagram for G4ScoreQuantityMessenger:

Public Member Functions
	G4ScoreQuantityMessenger (G4ScoringManager *SManager)
	~G4ScoreQuantityMessenger ()
void	SetNewValue (G4UIcommand *command, G4String newValues)
G4String	GetCurrentValue (G4UIcommand *)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Protected Member Functions
void	FillTokenVec (G4String newValues, G4TokenVec &token)
void	FParticleCommand (G4VScoringMesh *mesh, G4TokenVec &token)
void	FParticleWithEnergyCommand (G4VScoringMesh *mesh, G4TokenVec &token)
G4bool	CheckMeshPS (G4VScoringMesh *mesh, G4String &psname)
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (G4String s)
G4double	StoD (G4String s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)

Private Member Functions
void	QuantityCommands ()
void	FilterCommands ()

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

Additional Inherited Members
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir
G4String	baseDirName
G4bool	commandsShouldBeInMaster

Detailed Description

Definition at line 59 of file G4ScoreQuantityMessenger.hh.

Constructor & Destructor Documentation

G4ScoreQuantityMessenger()

G4ScoreQuantityMessenger::G4ScoreQuantityMessenger

(

G4ScoringManager *

SManager

)

Definition at line 91 of file G4ScoreQuantityMessenger.cc.

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

Here is the call graph for this function:

~G4ScoreQuantityMessenger()

G4ScoreQuantityMessenger::~G4ScoreQuantityMessenger

(

)

Definition at line 174 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          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;
}

Member Function Documentation

CheckMeshPS()

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

protected

Definition at line 539 of file G4ScoreQuantityMessenger.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

FillTokenVec()

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

protected

Definition at line 501 of file G4ScoreQuantityMessenger.cc.

                                                                                {

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

Here is the caller graph for this function:

FilterCommands()

void G4ScoreQuantityMessenger::FilterCommands ( )

private

Definition at line 98 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->SetDefaultValue("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->SetDefaultValue("keV");
  fparticleKinECmd->SetParameter(param);
  param = new G4UIparameter("particlelist",'s',false);
  param->SetDefaultValue("");
  fparticleKinECmd->SetParameter(param);
  //
  //
}

Here is the call graph for this function:

Here is the caller graph for this function:

FParticleCommand()

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

protected

Definition at line 511 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));
}    

Here is the call graph for this function:

Here is the caller graph for this function:

FParticleWithEnergyCommand()

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

protected

Definition at line 526 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCurrentValue()

G4String G4ScoreQuantityMessenger::GetCurrentValue ( G4UIcommand *  )

virtual

Reimplemented from G4UImessenger.

Definition at line 494 of file G4ScoreQuantityMessenger.cc.

{
  G4String val;

  return val;
}

QuantityCommands()

void G4ScoreQuantityMessenger::QuantityCommands ( )

private

Definition at line 83 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/quantiy/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->SetDefaultValue("MeV");
  qeDepCmd->SetParameter(param);
  //
  qCellChgCmd  = new G4UIcommand("/score/quantity/cellCharge",this);
  qCellChgCmd->SetGuidance("Cell charge scorer.");
  qCellChgCmd->
  SetGuidance("[usage] /score/quantiy/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->SetDefaultValue("e+");
  qCellChgCmd->SetParameter(param);
  //
  qCellFluxCmd = new G4UIcommand("/score/quantity/cellFlux",this);
  qCellFluxCmd->SetGuidance("Cell flux scorer.");
  qCellFluxCmd->
  SetGuidance("[usage] /score/quantiy/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/quantiy/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/quantiy/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->SetDefaultValue("Gy");
  qdoseDepCmd->SetParameter(param);
  //
  qnOfStepCmd = new G4UIcommand("/score/quantity/nOfStep",this);
  qnOfStepCmd->SetGuidance("Number of step scorer.");
  qnOfStepCmd->
  SetGuidance("[usage] /score/quantiy/nOfStep qname");
  qnOfStepCmd->
  SetGuidance("[usage] /score/quantiy/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/quantiy/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/quantiy/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/quantiy/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/quantiy/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->SetDefaultValue("mm");
  qPassTrackLengthCmd->SetParameter(param);
  //
  qFlatSurfCurrCmd = new G4UIcommand("/score/quantity/flatSurfaceCurrent",this);
  qFlatSurfCurrCmd->SetGuidance("Flat surface current Scorer.");
  qFlatSurfCurrCmd->
  SetGuidance("[usage] /score/quantiy/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   :(Bool) 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/quantiy/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);
  //
//  qSphereSurfCurrCmd = new G4UIcommand("/score/quantity/sphereSurfaceCurrent",this);
//  qSphereSurfCurrCmd->SetGuidance("Sphere surface current Scorer.");
//  qSphereSurfCurrCmd->
//      SetGuidance("[usage] /score/quantiy/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/quantiy/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/quantiy/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/quantiy/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/quantiy/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/quantiy/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/quantiy/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/quantiy/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/quantiy/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->SetDefaultValue("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/quantiy/stepChecker qname");
  qStepCheckerCmd->SetGuidance("  qname  :(String) scorer name");
  param = new G4UIparameter("qname",'s',false);
  qStepCheckerCmd->SetParameter(param);

}

Here is the call graph for this function:

Here is the caller graph for this function:

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 215 of file G4ScoreQuantityMessenger.cc.

{
      //
      // Get Current Mesh
      //
      G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
      if(!mesh)
      {
        G4cerr << "ERROR : No mesh is currently open. Open/create a mesh first. Command ignored." << G4endl;
        return;
      }
      // 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]) ){
              G4PSCellCharge3D* ps = new G4PSCellCharge3D(token[0]);
              ps->SetUnit(token[1]);
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qCellFluxCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
            if( mesh->GetShape()==boxMesh ) {
              G4PSCellFlux3D* ps = new G4PSCellFlux3D(token[0]);
              ps->SetUnit(token[1]);
              mesh->SetPrimitiveScorer(ps);
            } else if( mesh->GetShape()==cylinderMesh ) {
              G4PSCellFluxForCylinder3D* ps = 
                new G4PSCellFluxForCylinder3D(token[0]);
              ps->SetUnit(token[1]);
              G4ThreeVector msize = mesh->GetSize(); // gevin in R Z N/A
              ps->SetCylinderSize(msize[0],msize[1]); // given in dr dz
              G4int nSeg[3];
              mesh->GetNumberOfSegments(nSeg);
              ps->SetNumberOfSegments(nSeg);
              mesh->SetPrimitiveScorer(ps);
            }
          }
      } else if(command== qPassCellFluxCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
            if( mesh->GetShape()==boxMesh ) {
              G4PSPassageCellFlux3D* ps = new G4PSPassageCellFlux3D(token[0]);
              ps->SetUnit(token[1]);
              mesh->SetPrimitiveScorer(ps);
            } else if( mesh->GetShape()==cylinderMesh ) {
              G4PSPassageCellFluxForCylinder3D* ps = 
                new G4PSPassageCellFluxForCylinder3D(token[0]);
              ps->SetUnit(token[1]);
              G4ThreeVector msize = mesh->GetSize();  // gevin in R Z N/A
              ps->SetCylinderSize(msize[0],msize[1]); // given in dr dz
              G4int nSeg[3];
              mesh->GetNumberOfSegments(nSeg);
              ps->SetNumberOfSegments(nSeg);
              mesh->SetPrimitiveScorer(ps);
            }
          }
      } else if(command==qeDepCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
              G4PSEnergyDeposit3D* ps =new G4PSEnergyDeposit3D(token[0]);
              ps->SetUnit(token[1]);
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qdoseDepCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
            if( mesh->GetShape()==boxMesh ) {
              G4PSDoseDeposit3D* ps = new G4PSDoseDeposit3D(token[0]);
              ps->SetUnit(token[1]);
              mesh->SetPrimitiveScorer(ps);
            } else if( mesh->GetShape()==cylinderMesh ) {
              G4PSDoseDepositForCylinder3D* ps = 
                new G4PSDoseDepositForCylinder3D(token[0]);
              ps->SetUnit(token[1]);
              G4ThreeVector msize = mesh->GetSize(); // gevin in R Z N/A
              ps->SetCylinderSize(msize[0],msize[1]); // given in dr dz
              G4int nSeg[3];
              mesh->GetNumberOfSegments(nSeg);
              ps->SetNumberOfSegments(nSeg);
              mesh->SetPrimitiveScorer(ps);
            }
          }
      } else if(command== qnOfStepCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
              G4PSNofStep3D* ps = new G4PSNofStep3D(token[0]);
              ps->SetBoundaryFlag(StoB(token[1]));
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qnOfSecondaryCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
              G4PSNofSecondary3D* ps =new G4PSNofSecondary3D(token[0]);
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qTrackLengthCmd) {
          if ( CheckMeshPS(mesh,token[0]) ){
              G4PSTrackLength3D* 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]) ) {
              G4PSPassageCellCurrent* ps = new G4PSPassageCellCurrent3D(token[0]);
              ps->Weighted(StoB(token[1]));
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qPassTrackLengthCmd){
          if( CheckMeshPS(mesh,token[0]) ) {
              G4PSPassageTrackLength* 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])) {
              G4PSFlatSurfaceCurrent3D* 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] )) {
              G4PSFlatSurfaceFlux3D* 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== qSphereSurfCurrCmd){
//        if( CheckMeshPS(mesh, token[0] )) {
//            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])) {
//            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] ) ) {
//            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] ) {
//            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])) {
              G4PSNofCollision3D* ps =new G4PSNofCollision3D(token[0]); 
              ps->Weighted(StoB(token[1]));
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qPopulationCmd){
          if( CheckMeshPS(mesh,token[0]) ) {
              G4PSPopulation3D* ps =new G4PSPopulation3D(token[0]); 
              ps->Weighted(StoB(token[1]));
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qTrackCountCmd){
          if( CheckMeshPS(mesh,token[0])) {
              G4PSTrackCounter3D* 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])) {
              G4PSTermination3D* ps =new G4PSTermination3D(token[0]); 
              ps->Weighted(StoB(token[1]));
              mesh->SetPrimitiveScorer(ps);
          }

      } else if(command== qMinKinEAtGeneCmd){
          if( CheckMeshPS(mesh,token[0]) ){
              G4PSMinKinEAtGeneration3D* ps =new G4PSMinKinEAtGeneration3D(token[0]); 
              ps->SetUnit(token[1]);
              mesh->SetPrimitiveScorer(ps);
          }
      } else if(command== qStepCheckerCmd){
          if( CheckMeshPS(mesh,token[0]) ){
              G4PSStepChecker3D* ps =new G4PSStepChecker3D(token[0]); 
              mesh->SetPrimitiveScorer(ps);
          }

            //
            // Filters 
            // 
      }else if(command== fchargedCmd){
            if(!mesh->IsCurrentPrimitiveScorerNull()) {
              mesh->SetFilter(new G4SDChargedFilter(token[0])); 
            } else {
              G4cout << "WARNING[" << fchargedCmd->GetCommandPath()
                     << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
            }
      }else if(command== fneutralCmd){
            if(!mesh->IsCurrentPrimitiveScorerNull()) {
              mesh->SetFilter(new G4SDNeutralFilter(token[0])); 
            } else {
              G4cout << "WARNING[" << fneutralCmd->GetCommandPath()
                     << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
            }
      }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 {
              G4cout << "WARNING[" << fkinECmd->GetCommandPath()
                     << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
            }
      }else if(command== fparticleKinECmd){
            if(!mesh->IsCurrentPrimitiveScorerNull()) {
              FParticleWithEnergyCommand(mesh,token); 
            } else {
              G4cout << "WARNING[" << fparticleKinECmd->GetCommandPath()
                     << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
            }
      } else if(command==fparticleCmd) {
            if(!mesh->IsCurrentPrimitiveScorerNull()) {
              FParticleCommand(mesh,token);
            } else {
              G4cout << "WARNING[" << fparticleCmd->GetCommandPath()
                     << "] : Current quantity is not set. Set or touch a quantity first." << G4endl;
            }
      }
}

Here is the call graph for this function:

Member Data Documentation

fchargedCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::fchargedCmd

private

Definition at line 121 of file G4ScoreQuantityMessenger.hh.

filterDir

G4UIdirectory* G4ScoreQuantityMessenger::filterDir

private

Definition at line 120 of file G4ScoreQuantityMessenger.hh.

fkinECmd

G4UIcommand* G4ScoreQuantityMessenger::fkinECmd

private

Definition at line 123 of file G4ScoreQuantityMessenger.hh.

fneutralCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::fneutralCmd

private

Definition at line 122 of file G4ScoreQuantityMessenger.hh.

fparticleCmd

G4UIcommand* G4ScoreQuantityMessenger::fparticleCmd

private

Definition at line 124 of file G4ScoreQuantityMessenger.hh.

fparticleKinECmd

G4UIcommand* G4ScoreQuantityMessenger::fparticleKinECmd

private

Definition at line 125 of file G4ScoreQuantityMessenger.hh.

fSMan

G4ScoringManager* G4ScoreQuantityMessenger::fSMan

private

Definition at line 85 of file G4ScoreQuantityMessenger.hh.

qCellChgCmd

G4UIcommand* G4ScoreQuantityMessenger::qCellChgCmd

private

Definition at line 93 of file G4ScoreQuantityMessenger.hh.

qCellFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qCellFluxCmd

private

Definition at line 94 of file G4ScoreQuantityMessenger.hh.

qdoseDepCmd

G4UIcommand* G4ScoreQuantityMessenger::qdoseDepCmd

private

Definition at line 97 of file G4ScoreQuantityMessenger.hh.

qeDepCmd

G4UIcommand* G4ScoreQuantityMessenger::qeDepCmd

private

Definition at line 96 of file G4ScoreQuantityMessenger.hh.

qFlatSurfCurrCmd

G4UIcommand* G4ScoreQuantityMessenger::qFlatSurfCurrCmd

private

Definition at line 104 of file G4ScoreQuantityMessenger.hh.

qFlatSurfFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qFlatSurfFluxCmd

private

Definition at line 105 of file G4ScoreQuantityMessenger.hh.

qGetUnitCmd

G4UIcmdWithoutParameter* G4ScoreQuantityMessenger::qGetUnitCmd

private

Definition at line 90 of file G4ScoreQuantityMessenger.hh.

qMinKinEAtGeneCmd

G4UIcommand* G4ScoreQuantityMessenger::qMinKinEAtGeneCmd

private

Definition at line 114 of file G4ScoreQuantityMessenger.hh.

qNofCollisionCmd

G4UIcommand* G4ScoreQuantityMessenger::qNofCollisionCmd

private

Definition at line 110 of file G4ScoreQuantityMessenger.hh.

qnOfSecondaryCmd

G4UIcommand* G4ScoreQuantityMessenger::qnOfSecondaryCmd

private

Definition at line 99 of file G4ScoreQuantityMessenger.hh.

qnOfStepCmd

G4UIcommand* G4ScoreQuantityMessenger::qnOfStepCmd

private

Definition at line 98 of file G4ScoreQuantityMessenger.hh.

qPassCellCurrCmd

G4UIcommand* G4ScoreQuantityMessenger::qPassCellCurrCmd

private

Definition at line 102 of file G4ScoreQuantityMessenger.hh.

qPassCellFluxCmd

G4UIcommand* G4ScoreQuantityMessenger::qPassCellFluxCmd

private

Definition at line 95 of file G4ScoreQuantityMessenger.hh.

qPassTrackLengthCmd

G4UIcommand* G4ScoreQuantityMessenger::qPassTrackLengthCmd

private

Definition at line 103 of file G4ScoreQuantityMessenger.hh.

qPopulationCmd

G4UIcommand* G4ScoreQuantityMessenger::qPopulationCmd

private

Definition at line 111 of file G4ScoreQuantityMessenger.hh.

qSetUnitCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::qSetUnitCmd

private

Definition at line 91 of file G4ScoreQuantityMessenger.hh.

qStepCheckerCmd

G4UIcommand* G4ScoreQuantityMessenger::qStepCheckerCmd

private

Definition at line 116 of file G4ScoreQuantityMessenger.hh.

qTerminationCmd

G4UIcommand* G4ScoreQuantityMessenger::qTerminationCmd

private

Definition at line 113 of file G4ScoreQuantityMessenger.hh.

qTouchCmd

G4UIcmdWithAString* G4ScoreQuantityMessenger::qTouchCmd

private

Definition at line 89 of file G4ScoreQuantityMessenger.hh.

qTrackCountCmd

G4UIcommand* G4ScoreQuantityMessenger::qTrackCountCmd

private

Definition at line 112 of file G4ScoreQuantityMessenger.hh.

qTrackLengthCmd

G4UIcommand* G4ScoreQuantityMessenger::qTrackLengthCmd

private

Definition at line 101 of file G4ScoreQuantityMessenger.hh.

quantityDir

G4UIdirectory* G4ScoreQuantityMessenger::quantityDir

private

Definition at line 88 of file G4ScoreQuantityMessenger.hh.

---

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

• G4ScoreQuantityMessenger.hh
• G4ScoreQuantityMessenger.cc
• G4ScoreQuantityMessengerQCmd.cc