G4EmParametersMessenger Class Reference

#include <G4EmParametersMessenger.hh>

Inheritance diagram for G4EmParametersMessenger:

Public Member Functions
G4bool	CommandsShouldBeInMaster () const
	G4EmParametersMessenger (const G4EmParametersMessenger &)=delete
	G4EmParametersMessenger (G4EmParameters *)
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	operator!= (const G4UImessenger &messenger) const
G4EmParametersMessenger &	operator= (const G4EmParametersMessenger &right)=delete
G4bool	operator== (const G4UImessenger &messenger) const
void	SetNewValue (G4UIcommand *, G4String) override
	~G4EmParametersMessenger () override

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

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

Private Attributes
G4UIcmdWithAnInteger *	amCmd
G4UIcmdWithADoubleAndUnit *	angCmd
G4UIcmdWithABool *	aplCmd
G4UIcmdWithABool *	birksCmd
G4UIcmdWithADoubleAndUnit *	br1Cmd
G4UIcmdWithADoubleAndUnit *	brCmd
G4UIcmdWithADoubleAndUnit *	cenCmd
G4UIcmdWithABool *	delCmd
G4UIdirectory *	dnaDirectory
G4UIcommand *	dumpCmd
G4UIdirectory *	eLossDirectory
G4UIdirectory *	emDirectory
G4UIcmdWithADouble *	fgCmd
G4UIcmdWithABool *	flucCmd
G4UIcmdWithADouble *	fr1Cmd
G4UIcmdWithADouble *	frCmd
G4UIdirectory *	gconvDirectory
G4UIcmdWithABool *	icru90Cmd
G4UIcmdWithADouble *	labCmd
G4UIcmdWithABool *	lat96Cmd
G4UIcmdWithABool *	latCmd
G4UIcmdWithADoubleAndUnit *	llimCmd
G4UIcmdWithADouble *	lllCmd
G4UIcmdWithADoubleAndUnit *	lowEn3Cmd
G4UIcmdWithADoubleAndUnit *	lowEnCmd
G4UIcmdWithADoubleAndUnit *	lowhEnCmd
G4UIcmdWithABool *	lpmCmd
G4UIcmdWithADoubleAndUnit *	max5DCmd
G4UIcmdWithADoubleAndUnit *	maxEnCmd
G4UIcmdWithADoubleAndUnit *	minEnCmd
G4UIcmdWithABool *	mottCmd
G4UIcmdWithAString *	msc1Cmd
G4UIcmdWithAString *	mscCmd
G4UIdirectory *	mscDirectory
G4UIcmdWithADoubleAndUnit *	msceCmd
G4UIcmdWithADouble *	mscfCmd
G4UIcmdWithABool *	mudatCmd
G4UIcmdWithABool *	mulatCmd
G4UIcmdWithAString *	nffCmd
G4UIcmdWithADoubleAndUnit *	nielCmd
G4UIcmdWithABool *	onIsolatedCmd
G4UIcmdWithABool *	poCmd
G4UIcmdWithABool *	rangeCmd
G4UIcmdWithABool *	rsCmd
G4UIcmdWithADouble *	safCmd
G4UIcmdWithABool *	sampleTCmd
G4UIcmdWithADouble *	screCmd
G4UIcmdWithABool *	sharkCmd
G4UIcmdWithADouble *	skinCmd
G4UIcmdWithAString *	ssCmd
G4EmParameters *	theParameters
G4UIcmdWithAnInteger *	tripletCmd
G4UIcmdWithAnInteger *	ver1Cmd
G4UIcmdWithAnInteger *	ver2Cmd
G4UIcmdWithAnInteger *	verCmd

Detailed Description

Definition at line 65 of file G4EmParametersMessenger.hh.

Constructor & Destructor Documentation

G4EmParametersMessenger() [1/2]

G4EmParametersMessenger::G4EmParametersMessenger ( G4EmParameters *  ptr )

explicit

Definition at line 61 of file G4EmParametersMessenger.cc.

  : theParameters(ptr)
{
  gconvDirectory = new G4UIdirectory("/process/gconv/");
  gconvDirectory->SetGuidance("Commands for EM gamma conversion BH5D model.");
  eLossDirectory = new G4UIdirectory("/process/eLoss/");
  eLossDirectory->SetGuidance("Commands for EM processes.");
  mscDirectory = new G4UIdirectory("/process/msc/");
  mscDirectory->SetGuidance("Commands for EM scattering processes.");
  emDirectory = new G4UIdirectory("/process/em/");
  emDirectory->SetGuidance("General commands for EM processes.");
  dnaDirectory = new G4UIdirectory("/process/dna/");
  dnaDirectory->SetGuidance("Commands for DNA processes.");
 
  flucCmd = new G4UIcmdWithABool("/process/eLoss/fluct",this);
  flucCmd->SetGuidance("Enable/disable energy loss fluctuations.");
  flucCmd->SetParameterName("choice",true);
  flucCmd->SetDefaultValue(true);
  flucCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  flucCmd->SetToBeBroadcasted(false);
 
  rangeCmd = new G4UIcmdWithABool("/process/eLoss/CSDARange",this);
  rangeCmd->SetGuidance("Enable/disable CSDA range calculation");
  rangeCmd->SetParameterName("range",true);
  rangeCmd->SetDefaultValue(false);
  rangeCmd->AvailableForStates(G4State_PreInit);
  rangeCmd->SetToBeBroadcasted(false);
 
  lpmCmd = new G4UIcmdWithABool("/process/eLoss/LPM",this);
  lpmCmd->SetGuidance("Enable/disable LPM effect calculation");
  lpmCmd->SetParameterName("lpm",true);
  lpmCmd->SetDefaultValue(true);
  lpmCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  lpmCmd->SetToBeBroadcasted(false);
 
  rsCmd = new G4UIcmdWithABool("/process/eLoss/useCutAsFinalRange",this);
  rsCmd->SetGuidance("Enable/disable use of cut in range as a final range");
  rsCmd->SetParameterName("choice",true);
  rsCmd->SetDefaultValue(false);
  rsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  rsCmd->SetToBeBroadcasted(false);
 
  aplCmd = new G4UIcmdWithABool("/process/em/applyCuts",this);
  aplCmd->SetGuidance("Enable/disable applying cuts for gamma processes");
  aplCmd->SetParameterName("apl",true);
  aplCmd->SetDefaultValue(false);
  aplCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  aplCmd->SetToBeBroadcasted(false);
 
  latCmd = new G4UIcmdWithABool("/process/msc/LateralDisplacement",this);
  latCmd->SetGuidance("Enable/disable sampling of lateral displacement");
  latCmd->SetParameterName("lat",true);
  latCmd->SetDefaultValue(true);
  latCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  latCmd->SetToBeBroadcasted(false);
 
  lat96Cmd = new G4UIcmdWithABool("/process/msc/LateralDisplacementAlg96",this);
  lat96Cmd->SetGuidance("Enable/disable sampling of lateral displacement");
  lat96Cmd->SetParameterName("lat96",true);
  lat96Cmd->SetDefaultValue(false);
  lat96Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  lat96Cmd->SetToBeBroadcasted(false);
 
  mulatCmd = new G4UIcmdWithABool("/process/msc/MuHadLateralDisplacement",this);
  mulatCmd->SetGuidance("Enable/disable sampling of lateral displacement for muons and hadrons");
  mulatCmd->SetParameterName("mulat",true);
  mulatCmd->SetDefaultValue(true);
  mulatCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  mulatCmd->SetToBeBroadcasted(false);
 
  delCmd = new G4UIcmdWithABool("/process/eLoss/UseAngularGenerator",this);
  delCmd->SetGuidance("Enable usage of angular generator for ionisation");
  delCmd->SetParameterName("del",true);
  delCmd->SetDefaultValue(false);
  delCmd->AvailableForStates(G4State_PreInit);
  delCmd->SetToBeBroadcasted(false);
 
  mottCmd = new G4UIcmdWithABool("/process/msc/UseMottCorrection",this);
  mottCmd->SetGuidance("Enable usage of Mott corrections for e- elastic scattering");
  mottCmd->SetParameterName("mott",true);
  mottCmd->SetDefaultValue(false);
  mottCmd->AvailableForStates(G4State_PreInit);
  mottCmd->SetToBeBroadcasted(false);
 
  birksCmd = new G4UIcmdWithABool("/process/msc/UseG4EmSaturation",this);
  birksCmd->SetGuidance("Enable usage of built-in Birks saturation");
  birksCmd->SetParameterName("birks",true);
  birksCmd->SetDefaultValue(false);
  birksCmd->AvailableForStates(G4State_PreInit,G4State_Init);
  birksCmd->SetToBeBroadcasted(false);
 
  sharkCmd = new G4UIcmdWithABool("/process/em/UseGeneralProcess",this);
  sharkCmd->SetGuidance("Enable gamma, e+- general process");
  sharkCmd->SetParameterName("gen",true);
  sharkCmd->SetDefaultValue(false);
  sharkCmd->AvailableForStates(G4State_PreInit);
  sharkCmd->SetToBeBroadcasted(false);
 
  poCmd = new G4UIcmdWithABool("/process/em/Polarisation",this);
  poCmd->SetGuidance("Enable polarisation");
  poCmd->AvailableForStates(G4State_PreInit);
  poCmd->SetToBeBroadcasted(false);
 
  sampleTCmd = new G4UIcmdWithABool("/process/em/enableSamplingTable",this);
  sampleTCmd->SetGuidance("Enable usage of sampling table for secondary generation");
  sampleTCmd->SetParameterName("sampleT",true);
  sampleTCmd->SetDefaultValue(false);
  sampleTCmd->AvailableForStates(G4State_PreInit);
  sampleTCmd->SetToBeBroadcasted(false);
 
  icru90Cmd = new G4UIcmdWithABool("/process/eLoss/UseICRU90",this);
  icru90Cmd->SetGuidance("Enable usage of ICRU90 stopping powers");
  icru90Cmd->SetParameterName("icru90",true);
  icru90Cmd->SetDefaultValue(false);
  icru90Cmd->AvailableForStates(G4State_PreInit);
  icru90Cmd->SetToBeBroadcasted(false);
 
  mudatCmd = new G4UIcmdWithABool("/process/em/MuDataFromFile",this);
  mudatCmd->SetGuidance("Enable usage of muon data from file");
  mudatCmd->SetParameterName("mudat",true);
  mudatCmd->SetDefaultValue(false);
  mudatCmd->AvailableForStates(G4State_PreInit);
  mudatCmd->SetToBeBroadcasted(false);
 
  minEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/minKinEnergy",this);
  minEnCmd->SetGuidance("Set the min kinetic energy for EM tables");
  minEnCmd->SetParameterName("emin",true);
  minEnCmd->SetUnitCategory("Energy");
  minEnCmd->AvailableForStates(G4State_PreInit);
  minEnCmd->SetToBeBroadcasted(false);
 
  maxEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergy",this);
  maxEnCmd->SetGuidance("Set the max kinetic energy for EM tables");
  maxEnCmd->SetParameterName("emax",true);
  maxEnCmd->SetUnitCategory("Energy");
  maxEnCmd->AvailableForStates(G4State_PreInit);
  maxEnCmd->SetToBeBroadcasted(false);
 
  cenCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergyCSDA",this);
  cenCmd->SetGuidance("Set the max kinetic energy for CSDA table");
  cenCmd->SetParameterName("emaxCSDA",true);
  cenCmd->SetUnitCategory("Energy");
  cenCmd->AvailableForStates(G4State_PreInit);
  cenCmd->SetToBeBroadcasted(false);
 
  max5DCmd = new G4UIcmdWithADoubleAndUnit("/process/em/max5DMuPairEnergy",this);
  max5DCmd->SetGuidance("Set the max kinetic energy for 5D muon pair production");
  max5DCmd->SetParameterName("emax5D",true);
  max5DCmd->SetUnitCategory("Energy");
  max5DCmd->AvailableForStates(G4State_PreInit);
  max5DCmd->SetToBeBroadcasted(false);
 
  lowEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestElectronEnergy",this);
  lowEnCmd->SetGuidance("Set the lowest kinetic energy for e+-");
  lowEnCmd->SetParameterName("elow",true);
  lowEnCmd->SetUnitCategory("Energy");
  lowEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  lowEnCmd->SetToBeBroadcasted(false);
 
  lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestMuHadEnergy",this);
  lowhEnCmd->SetGuidance("Set the lowest kinetic energy for muons and hadrons");
  lowhEnCmd->SetParameterName("elowh",true);
  lowhEnCmd->SetUnitCategory("Energy");
  lowhEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  lowhEnCmd->SetToBeBroadcasted(false);
 
  lowEn3Cmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestTripletEnergy",this);
  lowEn3Cmd->SetGuidance("Set the lowest kinetic energy for triplet production");
  lowEn3Cmd->SetParameterName("elow3",true);
  lowEn3Cmd->SetUnitCategory("Energy");
  lowEn3Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  lowEn3Cmd->SetToBeBroadcasted(false);
 
  lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this);
  lllCmd->SetGuidance("Set linearLossLimit parameter");
  lllCmd->SetParameterName("linlim",true);
  lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  lllCmd->SetToBeBroadcasted(false);
 
  brCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremThreshold",this);
  brCmd->SetGuidance("Set e+- bremsstrahlung energy threshold");
  brCmd->SetParameterName("emaxBrem",true);
  brCmd->SetUnitCategory("Energy");
  brCmd->AvailableForStates(G4State_PreInit);
  brCmd->SetToBeBroadcasted(false);
 
  br1Cmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremMuHadThreshold",this);
  br1Cmd->SetGuidance("Set muon/hadron bremsstrahlung energy threshold");
  br1Cmd->SetParameterName("emaxMuHadBrem",true);
  br1Cmd->SetUnitCategory("Energy");
  br1Cmd->AvailableForStates(G4State_PreInit);
  br1Cmd->SetToBeBroadcasted(false);
 
  labCmd = new G4UIcmdWithADouble("/process/eLoss/LambdaFactor",this);
  labCmd->SetGuidance("Set lambdaFactor parameter for integral option");
  labCmd->SetParameterName("Fl",true);
  labCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  labCmd->SetToBeBroadcasted(false);
 
  mscfCmd = new G4UIcmdWithADouble("/process/msc/FactorForAngleLimit",this);
  mscfCmd->SetGuidance("Set factor for computation of a limit for -t (invariant transfer)");
  mscfCmd->SetParameterName("Fact",true);
  mscfCmd->SetRange("Fact>0");
  mscfCmd->SetDefaultValue(1.);
  mscfCmd->AvailableForStates(G4State_PreInit);
  mscfCmd->SetToBeBroadcasted(false);
 
  angCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/ThetaLimit",this);
  angCmd->SetGuidance("Set the limit on the polar angle for msc and single scattering");
  angCmd->SetParameterName("theta",true);
  angCmd->SetUnitCategory("Angle");
  angCmd->AvailableForStates(G4State_PreInit);
  angCmd->SetToBeBroadcasted(false);
 
  msceCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/EnergyLimit",this);
  msceCmd->SetGuidance("Set the upper energy limit for msc");
  msceCmd->SetParameterName("mscE",true);
  msceCmd->SetUnitCategory("Energy");
  msceCmd->AvailableForStates(G4State_PreInit);
  msceCmd->SetToBeBroadcasted(false);
 
  nielCmd = new G4UIcmdWithADoubleAndUnit("/process/em/MaxEnergyNIEL",this);
  nielCmd->SetGuidance("Set the upper energy limit for NIEL");
  nielCmd->SetParameterName("niel",true);
  nielCmd->SetUnitCategory("Energy");
  nielCmd->AvailableForStates(G4State_PreInit);
  nielCmd->SetToBeBroadcasted(false);
 
  frCmd = new G4UIcmdWithADouble("/process/msc/RangeFactor",this);
  frCmd->SetGuidance("Set RangeFactor for msc processes of e+-");
  frCmd->SetParameterName("Fr",true);
  frCmd->SetRange("Fr>0");
  frCmd->SetDefaultValue(0.04);
  frCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  frCmd->SetToBeBroadcasted(false);
 
  fr1Cmd = new G4UIcmdWithADouble("/process/msc/RangeFactorMuHad",this);
  fr1Cmd->SetGuidance("Set RangeFactor for msc processes of muons/hadrons");
  fr1Cmd->SetParameterName("Fr1",true);
  fr1Cmd->SetRange("Fr1>0");
  fr1Cmd->SetDefaultValue(0.2);
  fr1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  fr1Cmd->SetToBeBroadcasted(false);
 
  fgCmd = new G4UIcmdWithADouble("/process/msc/GeomFactor",this);
  fgCmd->SetGuidance("Set GeomFactor parameter for msc processes");
  fgCmd->SetParameterName("Fg",true);
  fgCmd->SetRange("Fg>0");
  fgCmd->SetDefaultValue(2.5);
  fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  fgCmd->SetToBeBroadcasted(false);
 
  skinCmd = new G4UIcmdWithADouble("/process/msc/Skin",this);
  skinCmd->SetGuidance("Set skin parameter for msc processes");
  skinCmd->SetParameterName("skin",true);
  skinCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  skinCmd->SetToBeBroadcasted(false);
 
  screCmd = new G4UIcmdWithADouble("/process/msc/ScreeningFactor",this);
  screCmd->SetGuidance("Set screening factor");
  screCmd->SetParameterName("screen",true);
  screCmd->AvailableForStates(G4State_PreInit);
  screCmd->SetToBeBroadcasted(false);
 
  safCmd = new G4UIcmdWithADouble("/process/msc/SafetyFactor",this);
  safCmd->SetGuidance("Set safety factor");
  safCmd->SetParameterName("fsafe",true);
  safCmd->AvailableForStates(G4State_PreInit);
  safCmd->SetToBeBroadcasted(false);
 
  llimCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/LambdaLimit",this);
  llimCmd->SetGuidance("Set the upper energy limit for NIEL");
  llimCmd->SetParameterName("ll",true);
  llimCmd->SetUnitCategory("Length");
  llimCmd->AvailableForStates(G4State_PreInit);
  llimCmd->SetToBeBroadcasted(false);
 
  amCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsPerDecade",this);
  amCmd->SetGuidance("Set number of bins per decade for EM tables");
  amCmd->SetParameterName("bins",true);
  amCmd->SetDefaultValue(7);
  amCmd->AvailableForStates(G4State_PreInit);
  amCmd->SetToBeBroadcasted(false);
 
  verCmd = new G4UIcmdWithAnInteger("/process/eLoss/verbose",this);
  verCmd->SetGuidance("Set verbose level for EM physics");
  verCmd->SetParameterName("verb",true);
  verCmd->SetDefaultValue(1);
  verCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  verCmd->SetToBeBroadcasted(false);
 
  ver1Cmd = new G4UIcmdWithAnInteger("/process/em/verbose",this);
  ver1Cmd->SetGuidance("Set verbose level for EM physics");
  ver1Cmd->SetParameterName("verb1",true);
  ver1Cmd->SetDefaultValue(1);
  ver1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  ver1Cmd->SetToBeBroadcasted(false);
 
  ver2Cmd = new G4UIcmdWithAnInteger("/process/em/workerVerbose",this);
  ver2Cmd->SetGuidance("Set worker verbose level for EM physics");
  ver2Cmd->SetParameterName("verb2",true);
  ver2Cmd->SetDefaultValue(0);
  ver2Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  ver2Cmd->SetToBeBroadcasted(false);
 
  mscCmd = new G4UIcmdWithAString("/process/msc/StepLimit",this);
  mscCmd->SetGuidance("Set msc step limitation type");
  mscCmd->SetParameterName("StepLim",true);
  mscCmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary");
  mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  mscCmd->SetToBeBroadcasted(false);
 
  msc1Cmd = new G4UIcmdWithAString("/process/msc/StepLimitMuHad",this);
  msc1Cmd->SetGuidance("Set msc step limitation type for muons/hadrons");
  msc1Cmd->SetParameterName("StepLim1",true);
  msc1Cmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary");
  msc1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  msc1Cmd->SetToBeBroadcasted(false);
 
  dumpCmd = new G4UIcommand("/process/em/printParameters",this);
  dumpCmd->SetGuidance("Print all EM parameters.");
  dumpCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  dumpCmd->SetToBeBroadcasted(false);
 
  nffCmd = new G4UIcmdWithAString("/process/em/setNuclearFormFactor",this);
  nffCmd->SetGuidance("Define type of nuclear form-factor");
  nffCmd->SetParameterName("NucFF",true);
  nffCmd->SetCandidates("None Exponential Gaussian Flat");
  nffCmd->AvailableForStates(G4State_PreInit);
  nffCmd->SetToBeBroadcasted(false);
 
  ssCmd = new G4UIcmdWithAString("/process/em/setSingleScattering",this);
  ssCmd->SetGuidance("Define type of e+- single scattering model");
  ssCmd->SetParameterName("SS",true);
  ssCmd->SetCandidates("WVI Mott DPWA");
  ssCmd->AvailableForStates(G4State_PreInit);
  ssCmd->SetToBeBroadcasted(false);
 
  tripletCmd = new G4UIcmdWithAnInteger("/process/gconv/conversionType",this);
  tripletCmd->SetGuidance("gamma conversion triplet/nuclear generation type:");
  tripletCmd->SetGuidance("0 - (default) both triplet and nuclear");
  tripletCmd->SetGuidance("1 - force nuclear");
  tripletCmd->SetGuidance("2 - force triplet");
  tripletCmd->SetParameterName("type",false);
  tripletCmd->SetRange("type >= 0 && type <= 2");
  tripletCmd->SetDefaultValue(0);
  tripletCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  tripletCmd->SetToBeBroadcasted(false);
 
  onIsolatedCmd = new G4UIcmdWithABool("/process/gconv/onIsolated",this);
  onIsolatedCmd->SetGuidance("Conversion on isolated charged particles");
  onIsolatedCmd->SetGuidance("false (default) : atomic electron screening");
  onIsolatedCmd->SetGuidance("true : conversion on isolated particles.");
  onIsolatedCmd->SetParameterName("flag",false);
  onIsolatedCmd->SetDefaultValue(false);
  onIsolatedCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  onIsolatedCmd->SetToBeBroadcasted(false);
}

References amCmd, angCmd, aplCmd, G4UIcommand::AvailableForStates(), birksCmd, br1Cmd, brCmd, cenCmd, delCmd, dnaDirectory, dumpCmd, eLossDirectory, emDirectory, fgCmd, flucCmd, fr1Cmd, frCmd, G4State_Idle, G4State_Init, G4State_PreInit, gconvDirectory, icru90Cmd, labCmd, lat96Cmd, latCmd, llimCmd, lllCmd, lowEn3Cmd, lowEnCmd, lowhEnCmd, lpmCmd, max5DCmd, maxEnCmd, minEnCmd, mottCmd, msc1Cmd, mscCmd, mscDirectory, msceCmd, mscfCmd, mudatCmd, mulatCmd, nffCmd, nielCmd, onIsolatedCmd, poCmd, rangeCmd, rsCmd, safCmd, sampleTCmd, screCmd, G4UIcmdWithAString::SetCandidates(), G4UIcmdWithABool::SetDefaultValue(), G4UIcmdWithADouble::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcommand::SetGuidance(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcommand::SetRange(), G4UIcommand::SetToBeBroadcasted(), G4UIcmdWithADoubleAndUnit::SetUnitCategory(), sharkCmd, skinCmd, ssCmd, tripletCmd, ver1Cmd, ver2Cmd, and verCmd.

~G4EmParametersMessenger()

G4EmParametersMessenger::~G4EmParametersMessenger ( )

override

Definition at line 422 of file G4EmParametersMessenger.cc.

{
  delete gconvDirectory;
  delete eLossDirectory;
  delete mscDirectory;
  delete emDirectory;
  delete dnaDirectory;
 
  delete flucCmd;
  delete rangeCmd;
  delete lpmCmd;
  delete rsCmd;
  delete aplCmd;
  delete latCmd;
  delete lat96Cmd;
  delete mulatCmd;
  delete delCmd;
  delete mottCmd;
  delete birksCmd;
  delete sharkCmd;
  delete onIsolatedCmd;
  delete sampleTCmd;
  delete poCmd;
  delete icru90Cmd;
  delete mudatCmd;
 
  delete minEnCmd;
  delete maxEnCmd;
  delete max5DCmd;
  delete cenCmd;
  delete lowEnCmd;
  delete lowhEnCmd;
  delete lowEn3Cmd;
  delete lllCmd;
  delete brCmd;
  delete br1Cmd;
  delete labCmd;
  delete mscfCmd;
  delete angCmd;
  delete msceCmd;
  delete nielCmd;
  delete frCmd;
  delete fr1Cmd;
  delete fgCmd;
  delete skinCmd;
  delete safCmd;
  delete llimCmd;
  delete screCmd;
 
  delete amCmd;
  delete verCmd;
  delete ver1Cmd;
  delete ver2Cmd;
  delete tripletCmd;
 
  delete mscCmd;
  delete msc1Cmd;
  delete nffCmd;
  delete ssCmd;
 
  delete dumpCmd;
}

References amCmd, angCmd, aplCmd, birksCmd, br1Cmd, brCmd, cenCmd, delCmd, dnaDirectory, dumpCmd, eLossDirectory, emDirectory, fgCmd, flucCmd, fr1Cmd, frCmd, gconvDirectory, icru90Cmd, labCmd, lat96Cmd, latCmd, llimCmd, lllCmd, lowEn3Cmd, lowEnCmd, lowhEnCmd, lpmCmd, max5DCmd, maxEnCmd, minEnCmd, mottCmd, msc1Cmd, mscCmd, mscDirectory, msceCmd, mscfCmd, mudatCmd, mulatCmd, nffCmd, nielCmd, onIsolatedCmd, poCmd, rangeCmd, rsCmd, safCmd, sampleTCmd, screCmd, sharkCmd, skinCmd, ssCmd, tripletCmd, ver1Cmd, ver2Cmd, and verCmd.

G4EmParametersMessenger() [2/2]

G4EmParametersMessenger::G4EmParametersMessenger ( const G4EmParametersMessenger &  )

delete

Member Function Documentation

AddUIcommand()

void G4UImessenger::AddUIcommand ( G4UIcommand *  newCommand )

protectedinherited

Definition at line 149 of file G4UImessenger.cc.

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

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

BtoS()

G4String G4UImessenger::BtoS ( G4bool  b )

protectedinherited

Definition at line 98 of file G4UImessenger.cc.

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

CommandsShouldBeInMaster()

G4bool G4UImessenger::CommandsShouldBeInMaster ( ) const

inlineinherited

Definition at line 77 of file G4UImessenger.hh.

    {
      return commandsShouldBeInMaster;
    }

References G4UImessenger::commandsShouldBeInMaster.

Referenced by G4UIcommand::G4UIcommandCommonConstructorCode().

CreateCommand()

template<typename T >

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

protectedinherited

Definition at line 110 of file G4UImessenger.hh.

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

References G4UImessenger::baseDirName.

CreateDirectory()

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

protectedinherited

Definition at line 156 of file G4UImessenger.cc.

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

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

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

DtoS()

G4String G4UImessenger::DtoS ( G4double  a )

protectedinherited

Definition at line 90 of file G4UImessenger.cc.

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

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

GetCurrentValue()

G4String G4UImessenger::GetCurrentValue ( G4UIcommand *  command )

virtualinherited

Reimplemented in G4ScoreQuantityMessenger, G4VisCommandModelCreate< Factory >, G4VisCommandListManagerList< Manager >, G4VisCommandListManagerSelect< Manager >, G4VisCommandManagerMode< Manager >, G4ToolsAnalysisMessenger, G4ScoringMessenger, G4EvManMessenger, G4GeneralParticleSourceMessenger, G4ParticleGunMessenger, G4GeometryMessenger, G4GenericMessenger, G4UIcontrolMessenger, GFlashShowerModelMessenger, G4DecayTableMessenger, G4ParticleMessenger, G4ParticlePropertyMessenger, G4tgrMessenger, G4PersistencyCenterMessenger, G4ProductionCutsTableMessenger, G4SchedulerMessenger, G4VITSteppingVerbose, G4MoleculeShootMessenger, G4MoleculeGunMessenger, G4ProcessManagerMessenger, G4ProcessTableMessenger, G4MatScanMessenger, G4RunMessenger, G4UserPhysicsListMessenger, G4TrackingMessenger, G4GMocrenMessenger, G4HepRepMessenger, G4VisCommandAbortReviewKeptEvents, G4VisCommandDrawOnlyToBeKeptEvents, G4VisCommandEnable, G4VisCommandList, G4VisCommandReviewKeptEvents, G4VisCommandVerbose, G4VisCommandGeometryList, G4VisCommandGeometryRestore, G4VisCommandGeometrySetColour, G4VisCommandGeometrySetDaughtersInvisible, G4VisCommandGeometrySetForceAuxEdgeVisible, G4VisCommandGeometrySetForceCloud, G4VisCommandGeometrySetForceSolid, G4VisCommandGeometrySetForceLineSegmentsPerCircle, G4VisCommandGeometrySetForceWireframe, G4VisCommandGeometrySetLineStyle, G4VisCommandGeometrySetLineWidth, G4VisCommandGeometrySetVisibility, G4VisCommandSceneActivateModel, G4VisCommandSceneCreate, G4VisCommandSceneEndOfEventAction, G4VisCommandSceneEndOfRunAction, G4VisCommandSceneList, G4VisCommandSceneNotifyHandlers, G4VisCommandSceneRemoveModel, G4VisCommandSceneSelect, G4VisCommandSceneShowExtents, G4VisCommandSceneAddArrow, G4VisCommandSceneAddArrow2D, G4VisCommandSceneAddAxes, G4VisCommandSceneAddDate, G4VisCommandSceneAddDigis, G4VisCommandSceneAddEventID, G4VisCommandSceneAddExtent, G4VisCommandSceneAddElectricField, G4VisCommandSceneAddFrame, G4VisCommandSceneAddGPS, G4VisCommandSceneAddGhosts, G4VisCommandSceneAddHits, G4VisCommandSceneAddLine, G4VisCommandSceneAddLine2D, G4VisCommandSceneAddLocalAxes, G4VisCommandSceneAddLogicalVolume, G4VisCommandSceneAddLogo, G4VisCommandSceneAddLogo2D, G4VisCommandSceneAddMagneticField, G4VisCommandSceneAddPSHits, G4VisCommandSceneAddScale, G4VisCommandSceneAddText, G4VisCommandSceneAddText2D, G4VisCommandSceneAddTrajectories, G4VisCommandSceneAddUserAction, G4VisCommandSceneAddVolume, G4VisCommandSceneAddPlotter, G4VisCommandSceneHandlerAttach, G4VisCommandSceneHandlerCreate, G4VisCommandSceneHandlerList, G4VisCommandSceneHandlerSelect, G4VisCommandSetArrow3DLineSegmentsPerCircle, G4VisCommandSetColour, G4VisCommandSetExtentForField, G4VisCommandSetLineWidth, G4VisCommandSetTextColour, G4VisCommandSetTextLayout, G4VisCommandSetTextSize, G4VisCommandSetTouchable, G4VisCommandSetVolumeForField, G4VisCommandsTouchable, G4VisCommandsTouchableSet, G4VisCommandViewerAddCutawayPlane, G4VisCommandViewerCentreOn, G4VisCommandViewerChangeCutawayPlane, G4VisCommandViewerClear, G4VisCommandViewerClearCutawayPlanes, G4VisCommandViewerClearTransients, G4VisCommandViewerClearVisAttributesModifiers, G4VisCommandViewerClone, G4VisCommandViewerColourByDensity, G4VisCommandViewerCopyViewFrom, G4VisCommandViewerCreate, G4VisCommandViewerDolly, G4VisCommandViewerFlush, G4VisCommandViewerInterpolate, G4VisCommandViewerList, G4VisCommandViewerPan, G4VisCommandViewerReset, G4VisCommandViewerRefresh, G4VisCommandViewerRebuild, G4VisCommandViewerSave, G4VisCommandViewerScale, G4VisCommandViewerSelect, G4VisCommandViewerUpdate, G4VisCommandViewerZoom, G4VisCommandViewerDefaultHiddenEdge, G4VisCommandViewerDefaultStyle, G4VisCommandsViewerSet, G4VModelCommand< T >, G4VModelCommand< M >, G4RTMessenger, G4ASCIITreeMessenger, G4VtkMessenger, G4PolarizationMessenger, and G4DNAChemistryManager.

Definition at line 58 of file G4UImessenger.cc.

{
  G4String nullString;
  return nullString;
}

Referenced by G4UIcommand::DoIt(), and G4UIcommand::GetCurrentValue().

ItoS()

G4String G4UImessenger::ItoS ( G4int  i )

protectedinherited

Definition at line 82 of file G4UImessenger.cc.

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

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

operator!=()

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

inherited

Definition at line 76 of file G4UImessenger.cc.

{
  return this != &messenger;
}

operator=()

G4EmParametersMessenger & G4EmParametersMessenger::operator= ( const G4EmParametersMessenger &  right )

delete

operator==()

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

inherited

Definition at line 70 of file G4UImessenger.cc.

{
  return this == &messenger;
}

SetNewValue()

void G4EmParametersMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValue  )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 487 of file G4EmParametersMessenger.cc.

{
  G4bool physicsModified = false;
  if (command == flucCmd) {
    theParameters->SetLossFluctuations(flucCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == rangeCmd) {
    theParameters->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue));
  } else if (command == lpmCmd) {
    theParameters->SetLPM(lpmCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == rsCmd) {
    theParameters->SetUseCutAsFinalRange(rsCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == aplCmd) {
    theParameters->SetApplyCuts(aplCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == latCmd) {
    theParameters->SetLateralDisplacement(latCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == lat96Cmd) {
    theParameters->SetLateralDisplacementAlg96(lat96Cmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == mulatCmd) {
    theParameters->SetMuHadLateralDisplacement(mulatCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == delCmd) {
    theParameters->ActivateAngularGeneratorForIonisation(delCmd->GetNewBoolValue(newValue));
  } else if (command == mottCmd) {
    theParameters->SetUseMottCorrection(mottCmd->GetNewBoolValue(newValue));
  } else if (command == birksCmd) {
    theParameters->SetBirksActive(birksCmd->GetNewBoolValue(newValue));
  } else if (command == icru90Cmd) {
    theParameters->SetUseICRU90Data(icru90Cmd->GetNewBoolValue(newValue));
  } else if (command == sharkCmd) {
    theParameters->SetGeneralProcessActive(sharkCmd->GetNewBoolValue(newValue));
  } else if (command == poCmd) {
    theParameters->SetEnablePolarisation(poCmd->GetNewBoolValue(newValue));
  } else if (command == sampleTCmd) {
    theParameters->SetEnableSamplingTable(sampleTCmd->GetNewBoolValue(newValue));
  } else if (command == mudatCmd) {
    theParameters->SetRetrieveMuDataFromFile(mudatCmd->GetNewBoolValue(newValue));
 
  } else if (command == minEnCmd) {
    theParameters->SetMinEnergy(minEnCmd->GetNewDoubleValue(newValue));
  } else if (command == maxEnCmd) { 
    theParameters->SetMaxEnergy(maxEnCmd->GetNewDoubleValue(newValue));
  } else if (command == max5DCmd) { 
    theParameters->SetMaxEnergyFor5DMuPair(max5DCmd->GetNewDoubleValue(newValue));
  } else if (command == cenCmd) { 
    theParameters->SetMaxEnergyForCSDARange(cenCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == lowEnCmd) { 
    theParameters->SetLowestElectronEnergy(lowEnCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == lowEn3Cmd) { 
    theParameters->SetLowestTripletEnergy(lowEn3Cmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == lowhEnCmd) { 
    theParameters->SetLowestMuHadEnergy(lowhEnCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == lllCmd) { 
    theParameters->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == brCmd) { 
    theParameters->SetBremsstrahlungTh(brCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == br1Cmd) { 
    theParameters->SetMuHadBremsstrahlungTh(br1Cmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == labCmd) {
    theParameters->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == mscfCmd) {
    theParameters->SetFactorForAngleLimit(mscfCmd->GetNewDoubleValue(newValue));
  } else if (command == angCmd) { 
    theParameters->SetMscThetaLimit(angCmd->GetNewDoubleValue(newValue));
  } else if (command == msceCmd) { 
    theParameters->SetMscEnergyLimit(msceCmd->GetNewDoubleValue(newValue));
  } else if (command == nielCmd) { 
    theParameters->SetMaxNIELEnergy(nielCmd->GetNewDoubleValue(newValue));
  } else if (command == frCmd) {
    theParameters->SetMscRangeFactor(frCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == fr1Cmd) {
    theParameters->SetMscMuHadRangeFactor(fr1Cmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == fgCmd) {
    theParameters->SetMscGeomFactor(fgCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == skinCmd) { 
    theParameters->SetMscSkin(skinCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == safCmd) { 
    theParameters->SetMscSafetyFactor(safCmd->GetNewDoubleValue(newValue));
  } else if (command == llimCmd) { 
    theParameters->SetMscLambdaLimit(llimCmd->GetNewDoubleValue(newValue));
  } else if (command == screCmd) { 
    theParameters->SetScreeningFactor(screCmd->GetNewDoubleValue(newValue));
  } else if (command == verCmd) {
    theParameters->SetVerbose(verCmd->GetNewIntValue(newValue));
  } else if (command == ver1Cmd) {
    theParameters->SetVerbose(ver1Cmd->GetNewIntValue(newValue));
  } else if (command == ver2Cmd) {
    theParameters->SetWorkerVerbose(ver2Cmd->GetNewIntValue(newValue));
  } else if (command == dumpCmd) {
    theParameters->SetIsPrintedFlag(false);
    theParameters->Dump();
  } else if (command == mscCmd || command == msc1Cmd) {
    G4MscStepLimitType msctype = fUseSafety;
    if(newValue == "Minimal") { 
      msctype = fMinimal;  
    } else if(newValue == "UseDistanceToBoundary") { 
      msctype = fUseDistanceToBoundary;
    } else if(newValue == "UseSafety") { 
      msctype = fUseSafety; 
    } else if(newValue == "UseSafetyPlus") {
      msctype = fUseSafetyPlus; 
    } else {
      G4ExceptionDescription ed;
      ed << " StepLimit type <" << newValue << "> unknown!"; 
      G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
      return;
    }
    if (command == mscCmd) {
      theParameters->SetMscStepLimitType(msctype);
    } else {
      theParameters->SetMscMuHadStepLimitType(msctype);
    }
    physicsModified = true;
  } else if (command == nffCmd) {
    G4NuclearFormfactorType x = fNoneNF;
    if(newValue == "Exponential") { x = fExponentialNF; }
    else if(newValue == "Gaussian") { x = fGaussianNF; }
    else if(newValue == "Flat") { x = fFlatNF; }
    else if(newValue != "None") { 
      G4ExceptionDescription ed;
      ed << " NuclearFormFactor type <" << newValue << "> unknown!"; 
      G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
      return; 
    }
    theParameters->SetNuclearFormfactorType(x);
  } else if (command == ssCmd) {
    G4eSingleScatteringType x = fWVI;
    if(newValue == "DPWA") { x = fDPWA; }
    else if(newValue == "Mott") { x = fMott; }
    else if(newValue != "WVI") { 
      G4ExceptionDescription ed;
      ed << " G4eSingleScatteringType type <" << newValue << "> unknown!"; 
      G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
      return; 
    }
    theParameters->SetSingleScatteringType(x);
  } else if ( command==tripletCmd ) {
    theParameters->SetConversionType(tripletCmd->GetNewIntValue(newValue));
  } else if ( command==onIsolatedCmd ) {
    theParameters->SetOnIsolated(onIsolatedCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  }
  
  if(physicsModified) {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }
}

References G4EmParameters::ActivateAngularGeneratorForIonisation(), angCmd, aplCmd, G4UImanager::ApplyCommand(), birksCmd, br1Cmd, brCmd, cenCmd, delCmd, G4EmParameters::Dump(), dumpCmd, fDPWA, fExponentialNF, fFlatNF, fGaussianNF, fgCmd, flucCmd, fMinimal, fMott, fNoneNF, fr1Cmd, frCmd, fUseDistanceToBoundary, fUseSafety, fUseSafetyPlus, fWVI, G4Exception(), G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithADouble::GetNewDoubleValue(), G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(), G4UIcmdWithAnInteger::GetNewIntValue(), G4UImanager::GetUIpointer(), icru90Cmd, JustWarning, labCmd, lat96Cmd, latCmd, llimCmd, lllCmd, lowEn3Cmd, lowEnCmd, lowhEnCmd, lpmCmd, max5DCmd, maxEnCmd, minEnCmd, mottCmd, msc1Cmd, mscCmd, msceCmd, mscfCmd, mudatCmd, mulatCmd, nffCmd, nielCmd, onIsolatedCmd, poCmd, rangeCmd, rsCmd, safCmd, sampleTCmd, screCmd, G4EmParameters::SetApplyCuts(), G4EmParameters::SetBirksActive(), G4EmParameters::SetBremsstrahlungTh(), G4EmParameters::SetBuildCSDARange(), G4EmParameters::SetConversionType(), G4EmParameters::SetEnablePolarisation(), G4EmParameters::SetEnableSamplingTable(), G4EmParameters::SetFactorForAngleLimit(), G4EmParameters::SetGeneralProcessActive(), G4EmParameters::SetIsPrintedFlag(), G4EmParameters::SetLambdaFactor(), G4EmParameters::SetLateralDisplacement(), G4EmParameters::SetLateralDisplacementAlg96(), G4EmParameters::SetLinearLossLimit(), G4EmParameters::SetLossFluctuations(), G4EmParameters::SetLowestElectronEnergy(), G4EmParameters::SetLowestMuHadEnergy(), G4EmParameters::SetLowestTripletEnergy(), G4EmParameters::SetLPM(), G4EmParameters::SetMaxEnergy(), G4EmParameters::SetMaxEnergyFor5DMuPair(), G4EmParameters::SetMaxEnergyForCSDARange(), G4EmParameters::SetMaxNIELEnergy(), G4EmParameters::SetMinEnergy(), G4EmParameters::SetMscEnergyLimit(), G4EmParameters::SetMscGeomFactor(), G4EmParameters::SetMscLambdaLimit(), G4EmParameters::SetMscMuHadRangeFactor(), G4EmParameters::SetMscMuHadStepLimitType(), G4EmParameters::SetMscRangeFactor(), G4EmParameters::SetMscSafetyFactor(), G4EmParameters::SetMscSkin(), G4EmParameters::SetMscStepLimitType(), G4EmParameters::SetMscThetaLimit(), G4EmParameters::SetMuHadBremsstrahlungTh(), G4EmParameters::SetMuHadLateralDisplacement(), G4EmParameters::SetNuclearFormfactorType(), G4EmParameters::SetOnIsolated(), G4EmParameters::SetRetrieveMuDataFromFile(), G4EmParameters::SetScreeningFactor(), G4EmParameters::SetSingleScatteringType(), G4EmParameters::SetUseCutAsFinalRange(), G4EmParameters::SetUseICRU90Data(), G4EmParameters::SetUseMottCorrection(), G4EmParameters::SetVerbose(), G4EmParameters::SetWorkerVerbose(), sharkCmd, skinCmd, ssCmd, theParameters, tripletCmd, ver1Cmd, ver2Cmd, and verCmd.

StoB()

G4bool G4UImessenger::StoB ( G4String  s )

protectedinherited

Definition at line 137 of file G4UImessenger.cc.

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

References G4StrUtil::to_upper_copy().

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

StoD()

G4double G4UImessenger::StoD ( G4String  s )

protectedinherited

Definition at line 127 of file G4UImessenger.cc.

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

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

StoI()

G4int G4UImessenger::StoI ( G4String  s )

protectedinherited

Definition at line 107 of file G4UImessenger.cc.

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

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

StoL()

G4long G4UImessenger::StoL ( G4String  s )

protectedinherited

Definition at line 117 of file G4UImessenger.cc.

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

Referenced by G4RunMessenger::SetNewValue().

Field Documentation

amCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::amCmd

private

Definition at line 129 of file G4EmParametersMessenger.hh.

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

angCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::angCmd

private

Definition at line 118 of file G4EmParametersMessenger.hh.

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

aplCmd

G4UIcmdWithABool* G4EmParametersMessenger::aplCmd

private

Definition at line 92 of file G4EmParametersMessenger.hh.

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

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

birksCmd

G4UIcmdWithABool* G4EmParametersMessenger::birksCmd

private

Definition at line 98 of file G4EmParametersMessenger.hh.

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

br1Cmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::br1Cmd

private

Definition at line 115 of file G4EmParametersMessenger.hh.

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

brCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::brCmd

private

Definition at line 114 of file G4EmParametersMessenger.hh.

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

cenCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::cenCmd

private

Definition at line 109 of file G4EmParametersMessenger.hh.

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

commandsShouldBeInMaster

G4bool G4UImessenger::commandsShouldBeInMaster = false

protectedinherited

Definition at line 104 of file G4UImessenger.hh.

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

delCmd

G4UIcmdWithABool* G4EmParametersMessenger::delCmd

private

Definition at line 96 of file G4EmParametersMessenger.hh.

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

dnaDirectory

G4UIdirectory* G4EmParametersMessenger::dnaDirectory

private

Definition at line 86 of file G4EmParametersMessenger.hh.

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

dumpCmd

G4UIcommand* G4EmParametersMessenger::dumpCmd

private

Definition at line 140 of file G4EmParametersMessenger.hh.

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

eLossDirectory

G4UIdirectory* G4EmParametersMessenger::eLossDirectory

private

Definition at line 83 of file G4EmParametersMessenger.hh.

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

emDirectory

G4UIdirectory* G4EmParametersMessenger::emDirectory

private

Definition at line 85 of file G4EmParametersMessenger.hh.

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

fgCmd

G4UIcmdWithADouble* G4EmParametersMessenger::fgCmd

private

Definition at line 123 of file G4EmParametersMessenger.hh.

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

flucCmd

G4UIcmdWithABool* G4EmParametersMessenger::flucCmd

private

Definition at line 88 of file G4EmParametersMessenger.hh.

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

fr1Cmd

G4UIcmdWithADouble* G4EmParametersMessenger::fr1Cmd

private

Definition at line 122 of file G4EmParametersMessenger.hh.

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

frCmd

G4UIcmdWithADouble* G4EmParametersMessenger::frCmd

private

Definition at line 121 of file G4EmParametersMessenger.hh.

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

gconvDirectory

G4UIdirectory* G4EmParametersMessenger::gconvDirectory

private

Definition at line 82 of file G4EmParametersMessenger.hh.

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

icru90Cmd

G4UIcmdWithABool* G4EmParametersMessenger::icru90Cmd

private

Definition at line 103 of file G4EmParametersMessenger.hh.

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

labCmd

G4UIcmdWithADouble* G4EmParametersMessenger::labCmd

private

Definition at line 116 of file G4EmParametersMessenger.hh.

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

lat96Cmd

G4UIcmdWithABool* G4EmParametersMessenger::lat96Cmd

private

Definition at line 94 of file G4EmParametersMessenger.hh.

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

latCmd

G4UIcmdWithABool* G4EmParametersMessenger::latCmd

private

Definition at line 93 of file G4EmParametersMessenger.hh.

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

llimCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::llimCmd

private

Definition at line 125 of file G4EmParametersMessenger.hh.

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

lllCmd

G4UIcmdWithADouble* G4EmParametersMessenger::lllCmd

private

Definition at line 113 of file G4EmParametersMessenger.hh.

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

lowEn3Cmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::lowEn3Cmd

private

Definition at line 111 of file G4EmParametersMessenger.hh.

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

lowEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::lowEnCmd

private

Definition at line 110 of file G4EmParametersMessenger.hh.

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

lowhEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::lowhEnCmd

private

Definition at line 112 of file G4EmParametersMessenger.hh.

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

lpmCmd

G4UIcmdWithABool* G4EmParametersMessenger::lpmCmd

private

Definition at line 90 of file G4EmParametersMessenger.hh.

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

max5DCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::max5DCmd

private

Definition at line 108 of file G4EmParametersMessenger.hh.

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

maxEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::maxEnCmd

private

Definition at line 107 of file G4EmParametersMessenger.hh.

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

minEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::minEnCmd

private

Definition at line 106 of file G4EmParametersMessenger.hh.

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

mottCmd

G4UIcmdWithABool* G4EmParametersMessenger::mottCmd

private

Definition at line 97 of file G4EmParametersMessenger.hh.

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

msc1Cmd

G4UIcmdWithAString* G4EmParametersMessenger::msc1Cmd

private

Definition at line 136 of file G4EmParametersMessenger.hh.

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

mscCmd

G4UIcmdWithAString* G4EmParametersMessenger::mscCmd

private

Definition at line 135 of file G4EmParametersMessenger.hh.

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

mscDirectory

G4UIdirectory* G4EmParametersMessenger::mscDirectory

private

Definition at line 84 of file G4EmParametersMessenger.hh.

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

msceCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::msceCmd

private

Definition at line 119 of file G4EmParametersMessenger.hh.

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

mscfCmd

G4UIcmdWithADouble* G4EmParametersMessenger::mscfCmd

private

Definition at line 117 of file G4EmParametersMessenger.hh.

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

mudatCmd

G4UIcmdWithABool* G4EmParametersMessenger::mudatCmd

private

Definition at line 104 of file G4EmParametersMessenger.hh.

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

mulatCmd

G4UIcmdWithABool* G4EmParametersMessenger::mulatCmd

private

Definition at line 95 of file G4EmParametersMessenger.hh.

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

nffCmd

G4UIcmdWithAString* G4EmParametersMessenger::nffCmd

private

Definition at line 137 of file G4EmParametersMessenger.hh.

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

nielCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::nielCmd

private

Definition at line 120 of file G4EmParametersMessenger.hh.

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

onIsolatedCmd

G4UIcmdWithABool* G4EmParametersMessenger::onIsolatedCmd

private

Definition at line 101 of file G4EmParametersMessenger.hh.

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

poCmd

G4UIcmdWithABool* G4EmParametersMessenger::poCmd

private

Definition at line 100 of file G4EmParametersMessenger.hh.

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

rangeCmd

G4UIcmdWithABool* G4EmParametersMessenger::rangeCmd

private

Definition at line 89 of file G4EmParametersMessenger.hh.

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

rsCmd

G4UIcmdWithABool* G4EmParametersMessenger::rsCmd

private

Definition at line 91 of file G4EmParametersMessenger.hh.

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

safCmd

G4UIcmdWithADouble* G4EmParametersMessenger::safCmd

private

Definition at line 124 of file G4EmParametersMessenger.hh.

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

sampleTCmd

G4UIcmdWithABool* G4EmParametersMessenger::sampleTCmd

private

Definition at line 102 of file G4EmParametersMessenger.hh.

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

screCmd

G4UIcmdWithADouble* G4EmParametersMessenger::screCmd

private

Definition at line 127 of file G4EmParametersMessenger.hh.

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

sharkCmd

G4UIcmdWithABool* G4EmParametersMessenger::sharkCmd

private

Definition at line 99 of file G4EmParametersMessenger.hh.

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

skinCmd

G4UIcmdWithADouble* G4EmParametersMessenger::skinCmd

private

Definition at line 126 of file G4EmParametersMessenger.hh.

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

ssCmd

G4UIcmdWithAString* G4EmParametersMessenger::ssCmd

private

Definition at line 138 of file G4EmParametersMessenger.hh.

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

theParameters

G4EmParameters* G4EmParametersMessenger::theParameters

private

Definition at line 80 of file G4EmParametersMessenger.hh.

Referenced by SetNewValue().

tripletCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::tripletCmd

private

Definition at line 133 of file G4EmParametersMessenger.hh.

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

ver1Cmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::ver1Cmd

private

Definition at line 131 of file G4EmParametersMessenger.hh.

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

ver2Cmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::ver2Cmd

private

Definition at line 132 of file G4EmParametersMessenger.hh.

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

verCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::verCmd

private

Definition at line 130 of file G4EmParametersMessenger.hh.

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

---

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

• source/processes/electromagnetic/utils/include/G4EmParametersMessenger.hh
• source/processes/electromagnetic/utils/src/G4EmParametersMessenger.cc