G4EmExtraParametersMessenger Class Reference

#include <G4EmExtraParametersMessenger.hh>

Inheritance diagram for G4EmExtraParametersMessenger:

Public Member Functions
	G4EmExtraParametersMessenger (G4EmExtraParameters *)
	~G4EmExtraParametersMessenger () override
void	SetNewValue (G4UIcommand *, G4String) override
G4EmExtraParametersMessenger &	operator= (const G4EmExtraParametersMessenger &right)=delete
	G4EmExtraParametersMessenger (const G4EmExtraParametersMessenger &)=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)
virtual void	SetNewValue (G4UIcommand *command, G4String newValue)
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
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 (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 G4EmExtraParametersMessenger.hh.

Constructor & Destructor Documentation

G4EmExtraParametersMessenger() [1/2]

G4EmExtraParametersMessenger::G4EmExtraParametersMessenger ( G4EmExtraParameters *  ptr )

explicit

Definition at line 58 of file G4EmExtraParametersMessenger.cc.

  : theParameters(ptr)
{
  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");
  paiCmd->AvailableForStates(G4State_PreInit);
  paiCmd->SetToBeBroadcasted(false);
 
  auto part = new G4UIparameter("partName",'s',false);
  paiCmd->SetParameter(part);
 
  auto pregName = new G4UIparameter("regName",'s',false);
  paiCmd->SetParameter(pregName);
 
  auto ptype = new G4UIparameter("type",'s',false);
  paiCmd->SetParameter(ptype);
  ptype->SetParameterCandidates("pai PAI PAIphoton");
 
  mscoCmd = new G4UIcommand("/process/em/AddEmRegion",this);
  mscoCmd->SetGuidance("Add optional EM configuration for a G4Region.");
  mscoCmd->SetGuidance("  regName  : G4Region name");
  mscoCmd->SetGuidance("  emType   : G4EmStandard, G4EmStandard_opt1, ...");
  mscoCmd->AvailableForStates(G4State_PreInit);
 
  auto mregName = new G4UIparameter("regName",'s',false);
  mscoCmd->SetParameter(mregName);
 
  auto mtype = new G4UIparameter("mscType",'s',false);
  mscoCmd->SetParameter(mtype);
  mtype->SetParameterCandidates("G4EmStandard G4EmStandard_opt1 G4EmStandard_opt2 G4EmStandard_opt3 G4EmStandard_opt4 G4EmStandardGS G4EmStandardSS G4EmLivermore G4EmPenelope G4RadioactiveDecay");
 
  SubSecCmd = new G4UIcmdWithAString("/process/eLoss/subsecRegion",this);
  SubSecCmd->SetGuidance("Enable subcut generation per region.");
  SubSecCmd->SetGuidance("  Region   : region name");
  SubSecCmd->AvailableForStates(G4State_PreInit);
  SubSecCmd->SetToBeBroadcasted(false);
 
  StepFuncCmd = new G4UIcommand("/process/eLoss/StepFunction",this);
  StepFuncCmd->SetGuidance("Set the energy loss step limitation parameters for e+-.");
  StepFuncCmd->SetGuidance("  dRoverR   : max Range variation per step");
  StepFuncCmd->SetGuidance("  finalRange: range for final step");
  StepFuncCmd->SetGuidance("  unit      : unit of finalRange");
  StepFuncCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  StepFuncCmd->SetToBeBroadcasted(false);
 
  auto dRoverRPrm = new G4UIparameter("dRoverR",'d',false);
  dRoverRPrm->SetParameterRange("dRoverR>0. && dRoverR<=1.");
  StepFuncCmd->SetParameter(dRoverRPrm);
 
  auto finalRangePrm = new G4UIparameter("finalRange",'d',false);
  finalRangePrm->SetParameterRange("finalRange>0.");
  StepFuncCmd->SetParameter(finalRangePrm);
 
  auto unitPrm = new G4UIparameter("unit",'s',true);
  unitPrm->SetDefaultUnit("mm");
  StepFuncCmd->SetParameter(unitPrm);
 
  StepFuncCmd1 = new G4UIcommand("/process/eLoss/StepFunctionMuHad",this);
  StepFuncCmd1->SetGuidance("Set the energy loss step limitation parameters for muon/hadron.");
  StepFuncCmd1->SetGuidance("  dRoverR   : max Range variation per step");
  StepFuncCmd1->SetGuidance("  finalRange: range for final step");
  StepFuncCmd1->AvailableForStates(G4State_PreInit,G4State_Idle);
  StepFuncCmd1->SetToBeBroadcasted(false);
 
  auto dRoverRPrm1 = new G4UIparameter("dRoverRMuHad",'d',false);
  dRoverRPrm1->SetParameterRange("dRoverRMuHad>0. && dRoverRMuHad<=1.");
  StepFuncCmd1->SetParameter(dRoverRPrm1);
 
  auto finalRangePrm1 = new G4UIparameter("finalRangeMuHad",'d',false);
  finalRangePrm1->SetParameterRange("finalRangeMuHad>0.");
  StepFuncCmd1->SetParameter(finalRangePrm1);
 
  auto unitPrm1 = new G4UIparameter("unit",'s',true);
  unitPrm1->SetDefaultValue("mm");
  StepFuncCmd1->SetParameter(unitPrm1);
 
  StepFuncCmd2 = new G4UIcommand("/process/eLoss/StepFunctionLightIons",this);
  StepFuncCmd2->SetGuidance("Set the energy loss step limitation parameters for light ions.");
  StepFuncCmd2->SetGuidance("  dRoverR   : max Range variation per step");
  StepFuncCmd2->SetGuidance("  finalRange: range for final step");
  StepFuncCmd2->AvailableForStates(G4State_PreInit,G4State_Idle);
  StepFuncCmd2->SetToBeBroadcasted(false);
 
  auto dRoverRPrm2 = new G4UIparameter("dRoverRLIons",'d',false);
  dRoverRPrm2->SetParameterRange("dRoverRLIons>0. && dRoverRLIons<=1.");
  StepFuncCmd2->SetParameter(dRoverRPrm2);
 
  auto finalRangePrm2 = new G4UIparameter("finalRangeLIons",'d',false);
  finalRangePrm2->SetParameterRange("finalRangeLIons>0.");
  StepFuncCmd2->SetParameter(finalRangePrm2);
 
  auto unitPrm2 = new G4UIparameter("unit",'s',true);
  unitPrm2->SetDefaultValue("mm");
  StepFuncCmd2->SetParameter(unitPrm2);
 
  StepFuncCmd3 = new G4UIcommand("/process/eLoss/StepFunctionIons",this);
  StepFuncCmd3->SetGuidance("Set the energy loss step limitation parameters for ions.");
  StepFuncCmd3->SetGuidance("  dRoverR   : max Range variation per step");
  StepFuncCmd3->SetGuidance("  finalRange: range for final step");
  StepFuncCmd3->AvailableForStates(G4State_PreInit,G4State_Idle);
  StepFuncCmd3->SetToBeBroadcasted(false);
 
  auto dRoverRPrm3 = new G4UIparameter("dRoverRIons",'d',false);
  dRoverRPrm3->SetParameterRange("dRoverRIons>0. && dRoverRIons<=1.");
  StepFuncCmd3->SetParameter(dRoverRPrm3);
 
  auto finalRangePrm3 = new G4UIparameter("finalRangeIons",'d',false);
  finalRangePrm3->SetParameterRange("finalRangeIons>0.");
  StepFuncCmd3->SetParameter(finalRangePrm3);
 
  auto unitPrm3 = new G4UIparameter("unit",'s',true);
  unitPrm3->SetDefaultValue("mm");
  StepFuncCmd3->SetParameter(unitPrm3);
 
  bfCmd = new G4UIcommand("/process/em/setBiasingFactor",this);
  bfCmd->SetGuidance("Set factor for the process cross section.");
  bfCmd->SetGuidance("  procName   : process name");
  bfCmd->SetGuidance("  procFact   : factor");
  bfCmd->SetGuidance("  flagFact   : flag to change weight");
  bfCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  bfCmd->SetToBeBroadcasted(false);
 
  auto procName = new G4UIparameter("procName",'s',false);
  bfCmd->SetParameter(procName);
 
  auto procFact = new G4UIparameter("procFact",'d',false);
  bfCmd->SetParameter(procFact);
 
  auto flagFact = new G4UIparameter("flagFact",'s',false);
  bfCmd->SetParameter(flagFact);
 
  fiCmd = new G4UIcommand("/process/em/setForcedInteraction",this);
  fiCmd->SetGuidance("Set factor for the process cross section.");
  fiCmd->SetGuidance("  procNam    : process name");
  fiCmd->SetGuidance("  regNam     : region name");
  fiCmd->SetGuidance("  tlength    : fixed target length");
  fiCmd->SetGuidance("  unitT      : length unit");
  fiCmd->SetGuidance("  tflag      : flag to change weight");
  fiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  fiCmd->SetToBeBroadcasted(false);
 
  auto procNam = new G4UIparameter("procNam",'s',false);
  fiCmd->SetParameter(procNam);
 
  auto  regNam = new G4UIparameter("regNam",'s',false);
  fiCmd->SetParameter(regNam);
 
  auto tlength = new G4UIparameter("tlength",'d',false);
  tlength->SetParameterRange("tlength>0");
  fiCmd->SetParameter(tlength);
 
  auto unitT = new G4UIparameter("unitT",'s',true);
  unitT->SetDefaultUnit("mm");
  fiCmd->SetParameter(unitT);
 
  auto flagT = new G4UIparameter("tflag",'b',true);
  flagT->SetDefaultValue(true);
  fiCmd->SetParameter(flagT);
 
  bsCmd = new G4UIcommand("/process/em/setSecBiasing",this);
  bsCmd->SetGuidance("Set bremsstrahlung or delta-e- splitting/Russian roulette per region.");
  bsCmd->SetGuidance("  bProcNam : process name");
  bsCmd->SetGuidance("  bRegNam  : region name");
  bsCmd->SetGuidance("  bFactor  : number of split gamma or probability of Russian roulette");
  bsCmd->SetGuidance("  bEnergy  : max energy of a secondary for this biasing method");
  bsCmd->SetGuidance("  bUnit    : energy unit");
  bsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  bsCmd->SetToBeBroadcasted(false);
 
  auto bProcNam = new G4UIparameter("bProcNam",'s',false);
  bsCmd->SetParameter(bProcNam);
 
  auto bRegNam = new G4UIparameter("bRegNam",'s',false);
  bsCmd->SetParameter(bRegNam);
 
  auto bFactor = new G4UIparameter("bFactor",'d',false);
  bsCmd->SetParameter(bFactor);
 
  auto bEnergy = new G4UIparameter("bEnergy",'d',false);
  bsCmd->SetParameter(bEnergy);
 
  auto bUnit = new G4UIparameter("bUnit",'s',true);
  bUnit->SetDefaultUnit("MeV");
  bsCmd->SetParameter(bUnit);
 
  dirSplitCmd = new G4UIcmdWithABool("/process/em/setDirectionalSplitting",this);
  dirSplitCmd->SetGuidance("Enable directional brem splitting");
  dirSplitCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  dirSplitCmd->SetToBeBroadcasted(false);
 
  qeCmd = new G4UIcmdWithABool("/process/em/QuantumEntanglement",this);
  qeCmd->SetGuidance("Enable quantum entanglement");
  qeCmd->AvailableForStates(G4State_PreInit);
  qeCmd->SetToBeBroadcasted(false);
 
  dirSplitTargetCmd = new G4UIcmdWith3VectorAndUnit("/process/em/setDirectionalSplittingTarget",this);
  dirSplitTargetCmd->SetGuidance("Position of arget for directional splitting");
  dirSplitTargetCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
  dirSplitRadiusCmd = new G4UIcmdWithADoubleAndUnit("/process/em/setDirectionalSplittingRadius",this);
  dirSplitRadiusCmd->SetGuidance("Radius of target for directional splitting");
  dirSplitRadiusCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  dirSplitRadiusCmd->SetToBeBroadcasted(false);
}

~G4EmExtraParametersMessenger()

G4EmExtraParametersMessenger::~G4EmExtraParametersMessenger ( )

override

Definition at line 268 of file G4EmExtraParametersMessenger.cc.

{
  delete paiCmd;
  delete mscoCmd;
  delete SubSecCmd;
  delete bfCmd;
  delete fiCmd;
  delete bsCmd;
  delete qeCmd;
  delete StepFuncCmd;
  delete StepFuncCmd1;
  delete StepFuncCmd2;
  delete StepFuncCmd3;
  delete dirSplitCmd;
  delete dirSplitTargetCmd;
  delete dirSplitRadiusCmd;
}

G4EmExtraParametersMessenger() [2/2]

G4EmExtraParametersMessenger::G4EmExtraParametersMessenger ( const G4EmExtraParametersMessenger &  )

delete

Member Function Documentation

operator=()

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

delete

SetNewValue()

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

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 288 of file G4EmExtraParametersMessenger.cc.

{
  G4bool physicsModified = false;
 
  if (command == paiCmd) {
    G4String s1(""),s2(""),s3("");
    std::istringstream is(newValue);
    is >> s1 >> s2 >> s3;
    theParameters->AddPAIModel(s1, s2, s3);
  } else if (command == mscoCmd) {
    G4String s1(""),s2("");
    std::istringstream is(newValue);
    is >> s1 >> s2;
    theParameters->AddPhysics(s1, s2);
  } else if (command == StepFuncCmd || command == StepFuncCmd1 || command == StepFuncCmd2 || command == StepFuncCmd3) {
    G4double v1,v2;
    G4String unt;
    std::istringstream is(newValue);
    is >> v1 >> v2 >> unt;
    v2 *= G4UIcommand::ValueOf(unt);
    if(command == StepFuncCmd) {
      theParameters->SetStepFunction(v1,v2);
    } else if(command == StepFuncCmd1) {
      theParameters->SetStepFunctionMuHad(v1,v2);
    } else if(command == StepFuncCmd2) {
      theParameters->SetStepFunctionLightIons(v1,v2);
    } else {
      theParameters->SetStepFunctionIons(v1,v2);
    }
    physicsModified = true;
  } else if (command == SubSecCmd) {
    theParameters->SetSubCutRegion(newValue);
  } else if (command == bfCmd) {
    G4double v1(1.0);
    G4String s0(""),s1("");
    std::istringstream is(newValue);
    is >> s0 >> v1 >> s1;
    G4bool yes = false;
    if(s1 == "true") { yes = true; }
    theParameters->SetProcessBiasingFactor(s0,v1,yes);
    physicsModified = true;
  } else if (command == fiCmd) {
    G4double v1(0.0);
    G4String s1(""),s2(""),s3(""),unt("mm");
    std::istringstream is(newValue);
    is >> s1 >> s2 >> v1 >> unt >> s3;
    G4bool yes = false;
    if(s3 == "true") { yes = true; }
    v1 *= G4UIcommand::ValueOf(unt);
    theParameters->ActivateForcedInteraction(s1,s2,v1,yes);
    physicsModified = true;
  } else if (command == bsCmd) {
    G4double fb(1.0),en(1.e+30);
    G4String s1(""),s2(""),unt("MeV");
    std::istringstream is(newValue);
    is >> s1 >> s2 >> fb >> en >> unt;
    en *= G4UIcommand::ValueOf(unt);    
    theParameters->ActivateSecondaryBiasing(s1,s2,fb,en);
    physicsModified = true;
  } else if (command == qeCmd) {
    theParameters->SetQuantumEntanglement(qeCmd->GetNewBoolValue(newValue));
  } else if (command == dirSplitCmd) {
    theParameters->SetDirectionalSplitting(
      dirSplitCmd->GetNewBoolValue(newValue));
    physicsModified = true;
  } else if (command == dirSplitTargetCmd) {
    G4ThreeVector t = dirSplitTargetCmd->GetNew3VectorValue(newValue);
    theParameters->SetDirectionalSplittingTarget(t);
    physicsModified = true;
  } else if (command == dirSplitRadiusCmd) {
    G4double r = dirSplitRadiusCmd->GetNewDoubleValue(newValue);
    theParameters->SetDirectionalSplittingRadius(r);
    physicsModified = true;
  }
  
  if(physicsModified) {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }
}

---

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

• G4EmExtraParametersMessenger.hh
• G4EmExtraParametersMessenger.cc