G4EmLowEParametersMessenger Class Reference

#include <G4EmLowEParametersMessenger.hh>

Inheritance diagram for G4EmLowEParametersMessenger:

Public Member Functions
	G4EmLowEParametersMessenger (G4EmLowEParameters *)
	~G4EmLowEParametersMessenger () override
void	SetNewValue (G4UIcommand *, G4String) override
G4EmLowEParametersMessenger &	operator= (const G4EmLowEParametersMessenger &right)=delete
	G4EmLowEParametersMessenger (const G4EmLowEParametersMessenger &)=delete
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	LtoS (G4long l)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (const G4String &s)
G4long	StoL (const G4String &s)
G4double	StoD (const G4String &s)
G4bool	StoB (const 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 = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 64 of file G4EmLowEParametersMessenger.hh.

Constructor & Destructor Documentation

G4EmLowEParametersMessenger() [1/2]

G4EmLowEParametersMessenger::G4EmLowEParametersMessenger ( G4EmLowEParameters * ptr )

explicit

Definition at line 58 of file G4EmLowEParametersMessenger.cc.

  : theParameters(ptr)
{
  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_Init,G4State_Idle);
  deCmd->SetToBeBroadcasted(false);
 
  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,G4State_Init);
  dirFluoCmd->SetToBeBroadcasted(false);
 
  dirFluoCmd1 = new G4UIcmdWithABool("/process/em/fluoANSTO",this);
  dirFluoCmd1->SetGuidance("Enable/disable usage of ANSTO fluorescence files");
  dirFluoCmd1->SetParameterName("fluoANSTOFlag",true);
  dirFluoCmd1->SetDefaultValue(false);
  dirFluoCmd1->AvailableForStates(G4State_PreInit,G4State_Init);
  dirFluoCmd1->SetToBeBroadcasted(false);
 
  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_Init,G4State_Idle);
  auCmd->SetToBeBroadcasted(false);
 
  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_Init,G4State_Idle);
  auCascadeCmd->SetToBeBroadcasted(false);
 
  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_Init,G4State_Idle);
  pixeCmd->SetToBeBroadcasted(false);
 
  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_Init,G4State_Idle);
  dcutCmd->SetToBeBroadcasted(false);
 
  dnafCmd = new G4UIcmdWithABool("/process/dna/UseDNAFast",this);
  dnafCmd->SetGuidance("Enable usage of fast sampling for DNA models");
  dnafCmd->SetParameterName("dnaf",true);
  dnafCmd->SetDefaultValue(false);
  dnafCmd->AvailableForStates(G4State_PreInit);
  dnafCmd->SetToBeBroadcasted(false);
 
  dnasCmd = new G4UIcmdWithABool("/process/dna/UseDNAStationary",this);
  dnasCmd->SetGuidance("Enable usage of Stationary option for DNA models");
  dnasCmd->SetParameterName("dnas",true);
  dnasCmd->SetDefaultValue(false);
  dnasCmd->AvailableForStates(G4State_PreInit);
  dnasCmd->SetToBeBroadcasted(false);
 
  dnamscCmd = new G4UIcmdWithABool("/process/dna/UseDNAElectronMsc",this);
  dnamscCmd->SetGuidance("Enable usage of e- msc for DNA");
  dnamscCmd->SetParameterName("dnamsc",true);
  dnamscCmd->SetDefaultValue(false);
  dnamscCmd->AvailableForStates(G4State_PreInit);
  dnamscCmd->SetToBeBroadcasted(false);
 
  direFluoCmd = new G4UIcmdWithAString("/process/em/fluoDirectory",this);
  direFluoCmd->SetGuidance("The name of PIXE cross section");
  direFluoCmd->SetParameterName("fluoDirectory",true);
  direFluoCmd->SetCandidates("Default Bearden ANSTO XDB_EADL");
  direFluoCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  direFluoCmd->SetToBeBroadcasted(false);
 
  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 ECPSSR_ANSTO");
  pixeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  pixeXsCmd->SetToBeBroadcasted(false);
 
  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);
  pixeeXsCmd->SetToBeBroadcasted(false);
 
  livCmd = new G4UIcmdWithAString("/process/em/LivermoreData",this);
  livCmd->SetGuidance("The name of Livermore data directory");
  livCmd->SetParameterName("livDir",true);
  livCmd->SetCandidates("livermore epics_2017");
  livCmd->AvailableForStates(G4State_PreInit);
  livCmd->SetToBeBroadcasted(false);
 
  dnaSolCmd = new G4UIcmdWithAString("/process/dna/e-SolvationSubType",this);
  dnaSolCmd->SetGuidance("The name of e- solvation DNA model");
  dnaSolCmd->SetParameterName("dnaSol",true);
  dnaSolCmd->SetCandidates("Ritchie1994 Terrisol1990 Meesungnoen2002 Kreipl2009 Meesungnoen2002_amorphous");
  dnaSolCmd->AvailableForStates(G4State_PreInit);
  dnaSolCmd->SetToBeBroadcasted(false);
 
  dnaChemModel = new G4UIcmdWithAString("/process/chem/TimeStepModel",this);
  dnaChemModel->SetGuidance("The name of DNA chemistry time step model");
  dnaChemModel->SetParameterName("TimeStepModel",true);
  dnaChemModel->SetCandidates("SBS IRT IRT_syn");
  dnaChemModel->AvailableForStates(G4State_PreInit);
  dnaChemModel->SetToBeBroadcasted(false);
 
  meCmd = new G4UIcmdWithAString("/process/em/AddMicroElecRegion",this);
  meCmd->SetGuidance("Activate MicroElec model in the G4Region");
  meCmd->SetParameterName("MicroElec",true);
  meCmd->AvailableForStates(G4State_PreInit);
  meCmd->SetToBeBroadcasted(false);
 
  dnaCmd = new G4UIcommand("/process/em/AddDNARegion",this);
  dnaCmd->SetGuidance("Activate DNA in a G4Region.");
  dnaCmd->SetGuidance("  regName   : G4Region name");
  dnaCmd->SetGuidance("  dnaType   : DNA_opt0, DNA_Opt2, DNA_Opt4, DNA_Opt4a, DNA_Opt6, DNA_Opt6a, DNA_Opt7");
  dnaCmd->AvailableForStates(G4State_PreInit);
  dnaCmd->SetToBeBroadcasted(false);
 
  auto regName = new G4UIparameter("regName",'s',false);
  dnaCmd->SetParameter(regName);
 
  auto type = new G4UIparameter("dnaType",'s',false);
  dnaCmd->SetParameter(type);
  type->SetParameterCandidates("DNA_Opt0 DNA_Opt2 DNA_Opt4 DNA_Opt4a DNA_Opt6 DNA_Opt6a DNA_Opt7");
 
  deexCmd = new G4UIcommand("/process/em/deexcitation",this);
  deexCmd->SetGuidance("Set deexcitation flags per G4Region.");
  deexCmd->SetGuidance("  regName   : G4Region name");
  deexCmd->SetGuidance("  flagFluo  : Fluorescence");
  deexCmd->SetGuidance("  flagAuger : Auger");
  deexCmd->SetGuidance("  flagPIXE  : PIXE");
  deexCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
  deexCmd->SetToBeBroadcasted(false);
 
  auto regNameD = new G4UIparameter("regName",'s',false);
  deexCmd->SetParameter(regNameD);
 
  auto flagFluo = new G4UIparameter("flagFluo",'s',false);
  deexCmd->SetParameter(flagFluo);
 
  auto flagAuger = new G4UIparameter("flagAuger",'s',false);
  deexCmd->SetParameter(flagAuger);
 
  auto flagPIXE = new G4UIparameter("flagPIXE",'s',false);
  deexCmd->SetParameter(flagPIXE);
 
}

Referenced by G4EmLowEParametersMessenger(), and operator=().

~G4EmLowEParametersMessenger()

G4EmLowEParametersMessenger::~G4EmLowEParametersMessenger ( )

override

Definition at line 218 of file G4EmLowEParametersMessenger.cc.

{
  delete deCmd;
  delete dirFluoCmd;
  delete dirFluoCmd1;
  delete auCmd;
  delete auCascadeCmd;
  delete pixeCmd;
  delete dcutCmd;
  delete dnafCmd;
  delete dnasCmd;
  delete dnamscCmd;
  delete pixeXsCmd;
  delete pixeeXsCmd;
  delete livCmd;
  delete dnaSolCmd;
  delete dnaChemModel;
  delete direFluoCmd;
  delete meCmd;
  delete dnaCmd;
  delete deexCmd;
}

G4EmLowEParametersMessenger() [2/2]

G4EmLowEParametersMessenger::G4EmLowEParametersMessenger ( const G4EmLowEParametersMessenger & )

delete

Member Function Documentation

operator=()

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

delete

SetNewValue()

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

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 243 of file G4EmLowEParametersMessenger.cc.

{
  G4bool physicsModified = false;
  if (command == deCmd) {
    theParameters->SetFluo(deCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == dirFluoCmd) {
    theParameters->SetBeardenFluoDir(dirFluoCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == dirFluoCmd1) {
    theParameters->SetANSTOFluoDir(dirFluoCmd1->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == auCmd) {
    theParameters->SetAuger(auCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == auCascadeCmd) {
    theParameters->SetAuger(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 == dnafCmd) {
    theParameters->SetDNAFast(dnafCmd->GetNewBoolValue(newValue));
  } else if (command == dnasCmd) {
    theParameters->SetDNAStationary(dnasCmd->GetNewBoolValue(newValue));
  } else if (command == dnamscCmd) {
    theParameters->SetDNAElectronMsc(dnamscCmd->GetNewBoolValue(newValue));
  } else if (command == dnaSolCmd) {
    G4DNAModelSubType ttt = fDNAUnknownModel;
    if(newValue == "Ritchie1994") { 
      ttt = fRitchie1994eSolvation; 
    } else if(newValue == "Terrisol1990") { 
      ttt = fTerrisol1990eSolvation; 
    } else if (newValue == "Meesungnoen2002") { 
      ttt = fMeesungnoen2002eSolvation;
    } else if (newValue == "Meesungnoen2002_amorphous") {
      ttt = fMeesungnoensolid2002eSolvation;
    } else if (newValue == "Kreipl2009") {
      ttt = fKreipl2009eSolvation;
    }
    theParameters->SetDNAeSolvationSubType(ttt);
  } else if (command == dnaChemModel) {
    G4ChemTimeStepModel stepM = G4ChemTimeStepModel::Unknown;
    if(newValue == "IRT") {
      stepM = G4ChemTimeStepModel::IRT;
    } else if(newValue == "SBS") {
      stepM = G4ChemTimeStepModel::SBS;
    } else if (newValue == "IRT_syn") {
      stepM = G4ChemTimeStepModel::IRT_syn;
    }
    theParameters->SetChemTimeStepModel(stepM);
  } else if (command == direFluoCmd) {
    G4EmFluoDirectory ttt = fluoDefault;
    if(newValue == "Bearden") { ttt = fluoBearden; }
    else if(newValue == "ANSTO") { ttt = fluoANSTO; }
    else if(newValue == "XDB_EADL") { ttt = fluoXDB_EADL; }
    theParameters->SetFluoDirectory(ttt);
  } else if (command == pixeXsCmd) {
    theParameters->SetPIXECrossSectionModel(newValue);
    physicsModified = true;
  } else if (command == pixeeXsCmd) {
    theParameters->SetPIXEElectronCrossSectionModel(newValue);
    physicsModified = true;
  } else if (command == livCmd) {
    theParameters->SetLivermoreDataDir(newValue);
  } 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 == deexCmd) {
    G4String s1 (""), s2(""), s3(""), s4("");
    G4bool b2(false), b3(false), b4(false);
    std::istringstream is(newValue);
    is >> s1 >> s2 >> s3 >> s4;
    if(s2 == "true") { b2 = true; }
    if(s3 == "true") { b3 = true; }
    if(s4 == "true") { b4 = true; }
    theParameters->SetDeexActiveRegion(s1,b2,b3,b4);
    physicsModified = true;
  }
  
  if(physicsModified) {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }
}

---

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

• G4EmLowEParametersMessenger.hh
• G4EmLowEParametersMessenger.cc