G4EmParametersMessenger Class Reference

#include <G4EmParametersMessenger.hh>

Inheritance diagram for G4EmParametersMessenger:

Collaboration diagram for G4EmParametersMessenger:

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

Private Attributes
G4EmParameters *	theParameters
G4UIdirectory *	eLossDirectory
G4UIdirectory *	mscDirectory
G4UIdirectory *	emDirectory
G4UIcmdWithABool *	flucCmd
G4UIcmdWithABool *	rangeCmd
G4UIcmdWithABool *	lpmCmd
G4UIcmdWithABool *	splCmd
G4UIcmdWithABool *	rsCmd
G4UIcmdWithABool *	aplCmd
G4UIcmdWithABool *	deCmd
G4UIcmdWithABool *	dirFluoCmd
G4UIcmdWithABool *	auCmd
G4UIcmdWithABool *	auCascadeCmd
G4UIcmdWithABool *	pixeCmd
G4UIcmdWithABool *	dcutCmd
G4UIcmdWithABool *	latCmd
G4UIcmdWithABool *	mulatCmd
G4UIcmdWithABool *	catCmd
G4UIcmdWithABool *	delCmd
G4UIcmdWithABool *	mottCmd
G4UIcmdWithADouble *	minSubSecCmd
G4UIcmdWithADoubleAndUnit *	minEnCmd
G4UIcmdWithADoubleAndUnit *	maxEnCmd
G4UIcmdWithADoubleAndUnit *	cenCmd
G4UIcmdWithADoubleAndUnit *	lowEnCmd
G4UIcmdWithADoubleAndUnit *	lowhEnCmd
G4UIcmdWithADouble *	lllCmd
G4UIcmdWithADoubleAndUnit *	brCmd
G4UIcmdWithADouble *	labCmd
G4UIcmdWithADouble *	mscfCmd
G4UIcmdWithADoubleAndUnit *	angCmd
G4UIcmdWithADouble *	frCmd
G4UIcmdWithADouble *	fr1Cmd
G4UIcmdWithADouble *	fgCmd
G4UIcmdWithADouble *	skinCmd
G4UIcmdWithAnInteger *	dedxCmd
G4UIcmdWithAnInteger *	lamCmd
G4UIcmdWithAnInteger *	amCmd
G4UIcmdWithAnInteger *	verCmd
G4UIcmdWithAnInteger *	ver1Cmd
G4UIcmdWithAnInteger *	ver2Cmd
G4UIcmdWithAString *	mscCmd
G4UIcmdWithAString *	msc1Cmd
G4UIcmdWithAString *	pixeXsCmd
G4UIcmdWithAString *	pixeeXsCmd
G4UIcommand *	paiCmd
G4UIcmdWithAString *	meCmd
G4UIcommand *	dnaCmd
G4UIcommand *	dumpCmd

Additional Inherited Members
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)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir
G4String	baseDirName
G4bool	commandsShouldBeInMaster

Detailed Description

Definition at line 68 of file G4EmParametersMessenger.hh.

Constructor & Destructor Documentation

G4EmParametersMessenger()

G4EmParametersMessenger::G4EmParametersMessenger

(

G4EmParameters *

ptr

)

Definition at line 64 of file G4EmParametersMessenger.cc.

  : theParameters(ptr)
{
  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.");

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

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

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

  splCmd = new G4UIcmdWithABool("/process/em/spline",this);
  splCmd->SetGuidance("Enable/disable usage spline for Physics Vectors");
  splCmd->SetParameterName("spl",true);
  splCmd->SetDefaultValue(false);
  splCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

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

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

  deCmd = new G4UIcmdWithABool("/process/em/fluo",this);
  deCmd->SetGuidance("Enable/disable atomic deexcitation");
  deCmd->SetParameterName("fluoFlag",true);
  deCmd->SetDefaultValue(false);
  deCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  dirFluoCmd = new G4UIcmdWithABool("/process/em/fluoBearden",this);
  dirFluoCmd->SetGuidance("Enable/disable usage of Bearden fluorescence files");
  dirFluoCmd->SetParameterName("fluoBeardenFlag",true);
  dirFluoCmd->SetDefaultValue(false);
  dirFluoCmd->AvailableForStates(G4State_PreInit);

  auCmd = new G4UIcmdWithABool("/process/em/auger",this);
  auCmd->SetGuidance("Enable/disable Auger electrons production");
  auCmd->SetParameterName("augerFlag",true);
  auCmd->SetDefaultValue(false);
  auCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  auCascadeCmd = new G4UIcmdWithABool("/process/em/augerCascade",this);
  auCascadeCmd->SetGuidance("Enable/disable simulation of cascade of Auger electrons");
  auCascadeCmd->SetParameterName("augerCascadeFlag",true);
  auCascadeCmd->SetDefaultValue(false);
  auCascadeCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  pixeCmd = new G4UIcmdWithABool("/process/em/pixe",this);
  pixeCmd->SetGuidance("Enable/disable PIXE simulation");
  pixeCmd->SetParameterName("pixeFlag",true);
  pixeCmd->SetDefaultValue(false);
  pixeCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  dcutCmd = new G4UIcmdWithABool("/process/em/deexcitationIgnoreCut",this);
  dcutCmd->SetGuidance("Enable/Disable usage of cuts in de-excitation module");
  dcutCmd->SetParameterName("deexcut",true);
  dcutCmd->SetDefaultValue(false);
  dcutCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

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

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

  catCmd = new G4UIcmdWithABool("/process/msc/DisplacementBeyondSafety",this);
  catCmd->SetGuidance("Enable/disable displacement at geometry boundary");
  catCmd->SetParameterName("cat",true);
  catCmd->SetDefaultValue(false);
  catCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  delCmd = new G4UIcmdWithABool("/process/eLoss/UseAngularGenerator",this);
  delCmd->SetGuidance("Enable usage of angular generator");
  delCmd->SetParameterName("del",true);
  delCmd->SetDefaultValue(false);
  delCmd->AvailableForStates(G4State_PreInit);

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

  minSubSecCmd = new G4UIcmdWithADouble("/process/eLoss/minsubsec",this);
  minSubSecCmd->SetGuidance("Set the ratio subcut/cut ");
  minSubSecCmd->SetParameterName("rcmin",true);
  minSubSecCmd->AvailableForStates(G4State_PreInit);

  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,G4State_Idle);

  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,G4State_Idle);

  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,G4State_Idle);

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

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

  lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this);
  lllCmd->SetGuidance("Set linearLossLimit parameter");
  lllCmd->SetParameterName("linlim",true);
  lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  brCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremThreshold",this);
  brCmd->SetGuidance("Set bremsstrahlung energy threshold");
  brCmd->SetParameterName("emaxBrem",true);
  brCmd->SetUnitCategory("Energy");
  brCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

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

  mscfCmd = new G4UIcmdWithADouble("/process/msc/FactorForAngleLimit",this);
  mscfCmd->SetGuidance("Set factor for computation of a limit for -t (invariant trasfer)");
  mscfCmd->SetParameterName("Fact",true);
  mscfCmd->SetRange("Fact>0");
  mscfCmd->SetDefaultValue(1.);
  mscfCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  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,G4State_Idle);

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

  fr1Cmd = new G4UIcmdWithADouble("/process/msc/RangeFactorMuHad",this);
  fr1Cmd->SetGuidance("Set RangeFactor for msc processes of muons/hadrons");
  fr1Cmd->SetParameterName("Fr1",true);
  fr1Cmd->SetRange("Fr>0");
  fr1Cmd->SetDefaultValue(0.2);
  fr1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  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(3.5);
  fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
  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);

  dedxCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsDEDX",this);
  dedxCmd->SetGuidance("Set number of bins for EM tables");
  dedxCmd->SetParameterName("binsDEDX",true);
  dedxCmd->SetDefaultValue(77);
  dedxCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  lamCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsLambda",this);
  lamCmd->SetGuidance("Set number of bins for EM tables");
  lamCmd->SetParameterName("binsL",true);
  lamCmd->SetDefaultValue(77);
  lamCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  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,G4State_Idle);

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

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

  ver2Cmd = new G4UIcmdWithAnInteger("/process/em/workerVerbose",this);
  ver2Cmd->SetGuidance("Set worker verbose level for EM physics");
  ver2Cmd->SetParameterName("verb2",true);
  ver2Cmd->SetDefaultValue(1);
  ver2Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);

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

  msc1Cmd = new G4UIcmdWithAString("/process/msc/StepLimitMuHad",this);
  msc1Cmd->SetGuidance("Set msc step limitation type for muons/hadrons");
  msc1Cmd->SetParameterName("StepLim1",true);
  msc1Cmd->SetCandidates("fMinimal fUseSafety fUseSafetyPlus fUseDistanceToBoundary");
  msc1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  pixeXsCmd = new G4UIcmdWithAString("/process/em/pixeXSmodel",this);
  pixeXsCmd->SetGuidance("The name of PIXE cross section");
  pixeXsCmd->SetParameterName("pixeXS",true);
  pixeXsCmd->SetCandidates("ECPSSR_Analytical Empirical ECPSSR_FormFactor");
  pixeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  pixeeXsCmd = new G4UIcmdWithAString("/process/em/pixeElecXSmodel",this);
  pixeeXsCmd->SetGuidance("The name of PIXE cross section for electron");
  pixeeXsCmd->SetParameterName("pixeEXS",true);
  pixeeXsCmd->SetCandidates("ECPSSR_Analytical Empirical Livermore Penelope");
  pixeeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  paiCmd = new G4UIcommand("/process/em/AddPAIRegion",this);
  paiCmd->SetGuidance("Activate PAI in the G4Region.");
  paiCmd->SetGuidance("  partName  : particle name (default - all)");
  paiCmd->SetGuidance("  regName   : G4Region name");
  paiCmd->SetGuidance("  paiType   : PAI, PAIphoton");

  G4UIparameter* part = new G4UIparameter("partName",'s',false);
  paiCmd->SetParameter(part);

  G4UIparameter* pregName = new G4UIparameter("regName",'s',false);
  paiCmd->SetParameter(pregName);

  G4UIparameter* ptype = new G4UIparameter("type",'s',false);
  paiCmd->SetParameter(ptype);

  meCmd = new G4UIcmdWithAString("/process/em/AddMicroElecRegion",this);
  meCmd->SetGuidance("Activate MicroElec model in the G4Region");
  meCmd->SetParameterName("MicroElec",true);
  meCmd->AvailableForStates(G4State_PreInit);

  dnaCmd = new G4UIcommand("/process/em/AddDNARegion",this);
  dnaCmd->SetGuidance("Activate DNA in the G4Region.");
  dnaCmd->SetGuidance("  regName   : G4Region name");
  dnaCmd->SetGuidance("  dnaType   : opt0, opt1, opt2");

  G4UIparameter* regName = new G4UIparameter("regName",'s',false);
  dnaCmd->SetParameter(regName);

  G4UIparameter* type = new G4UIparameter("type",'s',false);
  dnaCmd->SetParameter(type);

  dumpCmd = new G4UIcommand("/process/em/printParameters",this);
  dumpCmd->SetGuidance("Print all EM parameters.");

}

Here is the call graph for this function:

~G4EmParametersMessenger()

G4EmParametersMessenger::~G4EmParametersMessenger ( )

virtual

Definition at line 364 of file G4EmParametersMessenger.cc.

{
  delete eLossDirectory;
  delete mscDirectory;
  delete emDirectory;

  delete flucCmd;
  delete rangeCmd;
  delete lpmCmd;
  delete splCmd;
  delete rsCmd;
  delete aplCmd;
  delete deCmd;
  delete dirFluoCmd;
  delete auCmd;
  delete auCascadeCmd;
  delete pixeCmd;
  delete dcutCmd;
  delete latCmd;
  delete mulatCmd;
  delete catCmd;
  delete delCmd;
  delete mottCmd;

  delete minSubSecCmd;
  delete minEnCmd;
  delete maxEnCmd;
  delete cenCmd;
  delete lowEnCmd;
  delete lowhEnCmd;
  delete lllCmd;
  delete brCmd;
  delete labCmd;
  delete mscfCmd;
  delete angCmd;
  delete frCmd;
  delete fr1Cmd;
  delete fgCmd;
  delete skinCmd;

  delete dedxCmd;
  delete lamCmd;
  delete amCmd;
  delete verCmd;
  delete ver1Cmd;
  delete ver2Cmd;

  delete mscCmd;
  delete msc1Cmd;

  delete pixeXsCmd;
  delete pixeeXsCmd;

  delete paiCmd;
  delete meCmd;
  delete dnaCmd;
  delete dumpCmd;
}

Member Function Documentation

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 425 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 == splCmd) {
    theParameters->SetSpline(splCmd->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 == deCmd) {
    theParameters->SetFluo(deCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == dirFluoCmd) {
    theParameters->SetBeardenFluoDir(dirFluoCmd->GetNewBoolValue(newValue));
  } else if (command == auCmd) {
    theParameters->SetAuger(auCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == auCascadeCmd) {
    theParameters->SetAugerCascade(auCascadeCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == pixeCmd) {
    theParameters->SetPixe(pixeCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == dcutCmd) {
    theParameters->SetDeexcitationIgnoreCut(dcutCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == latCmd) {
    theParameters->SetLateralDisplacement(latCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == mulatCmd) {
    theParameters->SetMuHadLateralDisplacement(mulatCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == catCmd) {
    theParameters->SetLatDisplacementBeyondSafety(catCmd->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 == minSubSecCmd) {
    theParameters->SetMinSubRange(minSubSecCmd->GetNewDoubleValue(newValue));
  } else if (command == minEnCmd) {
    theParameters->SetMinEnergy(minEnCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == maxEnCmd) { 
    theParameters->SetMaxEnergy(maxEnCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } 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 == 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 == labCmd) {
    theParameters->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == mscfCmd) {
    theParameters->SetFactorForAngleLimit(mscfCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } else if (command == angCmd) { 
    theParameters->SetMscThetaLimit(angCmd->GetNewDoubleValue(newValue));
    physicsModified = true;
  } 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 == dedxCmd) { 
    theParameters->SetNumberOfBins(dedxCmd->GetNewIntValue(newValue));
    physicsModified = true;
  } else if (command == lamCmd) { 
    theParameters->SetNumberOfBins(lamCmd->GetNewIntValue(newValue));
    physicsModified = true;
  } else if (command == amCmd) { 
    theParameters->SetNumberOfBinsPerDecade(amCmd->GetNewIntValue(newValue));
    physicsModified = true;
  } 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 == 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 {
      G4cout << "### G4EmParametersMessenger WARNING: StepLimit type <" 
             << newValue << "> unknown!" << G4endl;
      return;
    }
    if (command == mscCmd) {
      theParameters->SetMscStepLimitType(msctype);
    } else {
      theParameters->SetMscMuHadStepLimitType(msctype);
    }
    physicsModified = true;
  } else if (command == pixeXsCmd) {
    theParameters->SetPIXECrossSectionModel(newValue);
    physicsModified = true;
  } else if (command == pixeeXsCmd) {
    theParameters->SetPIXEElectronCrossSectionModel(newValue);
    physicsModified = true;
  } else if (command == paiCmd) {
    G4String s1(""),s2(""),s3("");
    std::istringstream is(newValue);
    is >> s1 >> s2 >> s3;
    theParameters->AddPAIModel(s1, s2, s3);
  } else if (command == meCmd) {
    theParameters->AddMicroElec(newValue);
  } else if (command == dnaCmd) {
    G4String s1(""),s2("");
    std::istringstream is(newValue);
    is >> s1 >> s2;
    theParameters->AddDNA(s1, s2);
  } else if (command == dumpCmd) {
    theParameters->Dump();
  }
  if(physicsModified) {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }
}

Member Data Documentation

amCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::amCmd

private

Definition at line 121 of file G4EmParametersMessenger.hh.

angCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::angCmd

private

Definition at line 113 of file G4EmParametersMessenger.hh.

aplCmd

G4UIcmdWithABool* G4EmParametersMessenger::aplCmd

private

Definition at line 90 of file G4EmParametersMessenger.hh.

auCascadeCmd

G4UIcmdWithABool* G4EmParametersMessenger::auCascadeCmd

private

Definition at line 94 of file G4EmParametersMessenger.hh.

auCmd

G4UIcmdWithABool* G4EmParametersMessenger::auCmd

private

Definition at line 93 of file G4EmParametersMessenger.hh.

brCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::brCmd

private

Definition at line 110 of file G4EmParametersMessenger.hh.

catCmd

G4UIcmdWithABool* G4EmParametersMessenger::catCmd

private

Definition at line 99 of file G4EmParametersMessenger.hh.

cenCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::cenCmd

private

Definition at line 106 of file G4EmParametersMessenger.hh.

dcutCmd

G4UIcmdWithABool* G4EmParametersMessenger::dcutCmd

private

Definition at line 96 of file G4EmParametersMessenger.hh.

deCmd

G4UIcmdWithABool* G4EmParametersMessenger::deCmd

private

Definition at line 91 of file G4EmParametersMessenger.hh.

dedxCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::dedxCmd

private

Definition at line 119 of file G4EmParametersMessenger.hh.

delCmd

G4UIcmdWithABool* G4EmParametersMessenger::delCmd

private

Definition at line 100 of file G4EmParametersMessenger.hh.

dirFluoCmd

G4UIcmdWithABool* G4EmParametersMessenger::dirFluoCmd

private

Definition at line 92 of file G4EmParametersMessenger.hh.

dnaCmd

G4UIcommand* G4EmParametersMessenger::dnaCmd

private

Definition at line 134 of file G4EmParametersMessenger.hh.

dumpCmd

G4UIcommand* G4EmParametersMessenger::dumpCmd

private

Definition at line 135 of file G4EmParametersMessenger.hh.

eLossDirectory

G4UIdirectory* G4EmParametersMessenger::eLossDirectory

private

Definition at line 81 of file G4EmParametersMessenger.hh.

emDirectory

G4UIdirectory* G4EmParametersMessenger::emDirectory

private

Definition at line 83 of file G4EmParametersMessenger.hh.

fgCmd

G4UIcmdWithADouble* G4EmParametersMessenger::fgCmd

private

Definition at line 116 of file G4EmParametersMessenger.hh.

flucCmd

G4UIcmdWithABool* G4EmParametersMessenger::flucCmd

private

Definition at line 85 of file G4EmParametersMessenger.hh.

fr1Cmd

G4UIcmdWithADouble* G4EmParametersMessenger::fr1Cmd

private

Definition at line 115 of file G4EmParametersMessenger.hh.

frCmd

G4UIcmdWithADouble* G4EmParametersMessenger::frCmd

private

Definition at line 114 of file G4EmParametersMessenger.hh.

labCmd

G4UIcmdWithADouble* G4EmParametersMessenger::labCmd

private

Definition at line 111 of file G4EmParametersMessenger.hh.

lamCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::lamCmd

private

Definition at line 120 of file G4EmParametersMessenger.hh.

latCmd

G4UIcmdWithABool* G4EmParametersMessenger::latCmd

private

Definition at line 97 of file G4EmParametersMessenger.hh.

lllCmd

G4UIcmdWithADouble* G4EmParametersMessenger::lllCmd

private

Definition at line 109 of file G4EmParametersMessenger.hh.

lowEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::lowEnCmd

private

Definition at line 107 of file G4EmParametersMessenger.hh.

lowhEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::lowhEnCmd

private

Definition at line 108 of file G4EmParametersMessenger.hh.

lpmCmd

G4UIcmdWithABool* G4EmParametersMessenger::lpmCmd

private

Definition at line 87 of file G4EmParametersMessenger.hh.

maxEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::maxEnCmd

private

Definition at line 105 of file G4EmParametersMessenger.hh.

meCmd

G4UIcmdWithAString* G4EmParametersMessenger::meCmd

private

Definition at line 133 of file G4EmParametersMessenger.hh.

minEnCmd

G4UIcmdWithADoubleAndUnit* G4EmParametersMessenger::minEnCmd

private

Definition at line 104 of file G4EmParametersMessenger.hh.

minSubSecCmd

G4UIcmdWithADouble* G4EmParametersMessenger::minSubSecCmd

private

Definition at line 103 of file G4EmParametersMessenger.hh.

mottCmd

G4UIcmdWithABool* G4EmParametersMessenger::mottCmd

private

Definition at line 101 of file G4EmParametersMessenger.hh.

msc1Cmd

G4UIcmdWithAString* G4EmParametersMessenger::msc1Cmd

private

Definition at line 127 of file G4EmParametersMessenger.hh.

mscCmd

G4UIcmdWithAString* G4EmParametersMessenger::mscCmd

private

Definition at line 126 of file G4EmParametersMessenger.hh.

mscDirectory

G4UIdirectory* G4EmParametersMessenger::mscDirectory

private

Definition at line 82 of file G4EmParametersMessenger.hh.

mscfCmd

G4UIcmdWithADouble* G4EmParametersMessenger::mscfCmd

private

Definition at line 112 of file G4EmParametersMessenger.hh.

mulatCmd

G4UIcmdWithABool* G4EmParametersMessenger::mulatCmd

private

Definition at line 98 of file G4EmParametersMessenger.hh.

paiCmd

G4UIcommand* G4EmParametersMessenger::paiCmd

private

Definition at line 132 of file G4EmParametersMessenger.hh.

pixeCmd

G4UIcmdWithABool* G4EmParametersMessenger::pixeCmd

private

Definition at line 95 of file G4EmParametersMessenger.hh.

pixeeXsCmd

G4UIcmdWithAString* G4EmParametersMessenger::pixeeXsCmd

private

Definition at line 130 of file G4EmParametersMessenger.hh.

pixeXsCmd

G4UIcmdWithAString* G4EmParametersMessenger::pixeXsCmd

private

Definition at line 129 of file G4EmParametersMessenger.hh.

rangeCmd

G4UIcmdWithABool* G4EmParametersMessenger::rangeCmd

private

Definition at line 86 of file G4EmParametersMessenger.hh.

rsCmd

G4UIcmdWithABool* G4EmParametersMessenger::rsCmd

private

Definition at line 89 of file G4EmParametersMessenger.hh.

skinCmd

G4UIcmdWithADouble* G4EmParametersMessenger::skinCmd

private

Definition at line 117 of file G4EmParametersMessenger.hh.

splCmd

G4UIcmdWithABool* G4EmParametersMessenger::splCmd

private

Definition at line 88 of file G4EmParametersMessenger.hh.

theParameters

G4EmParameters* G4EmParametersMessenger::theParameters

private

Definition at line 79 of file G4EmParametersMessenger.hh.

ver1Cmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::ver1Cmd

private

Definition at line 123 of file G4EmParametersMessenger.hh.

ver2Cmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::ver2Cmd

private

Definition at line 124 of file G4EmParametersMessenger.hh.

verCmd

G4UIcmdWithAnInteger* G4EmParametersMessenger::verCmd

private

Definition at line 122 of file G4EmParametersMessenger.hh.

---

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

• G4EmParametersMessenger.hh
• G4EmParametersMessenger.cc