G4EnergyLossMessenger Class Reference

#include <G4EnergyLossMessenger.hh>

Inheritance diagram for G4EnergyLossMessenger:

Collaboration diagram for G4EnergyLossMessenger:

Public Member Functions
	G4EnergyLossMessenger ()
virtual	~G4EnergyLossMessenger ()
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
G4EmProcessOptions *	opt
G4UIcmdWithABool *	SubSecCmd
G4UIcommand *	StepFuncCmd
G4UIcommand *	deexCmd
G4UIcmdWithABool *	IntegCmd
G4UIcommand *	bfCmd
G4UIcommand *	fiCmd
G4UIcommand *	brCmd

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 74 of file G4EnergyLossMessenger.hh.

Constructor & Destructor Documentation

G4EnergyLossMessenger()

G4EnergyLossMessenger::G4EnergyLossMessenger

(

)

Definition at line 76 of file G4EnergyLossMessenger.cc.

{
  
  opt = 0;
  SubSecCmd = new G4UIcmdWithABool("/process/eLoss/subsec",this);
  SubSecCmd->SetGuidance("Switch true/false the subcutoff generation.");
  SubSecCmd->SetParameterName("choice",true);
  SubSecCmd->SetDefaultValue(true);
  SubSecCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  StepFuncCmd = new G4UIcommand("/process/eLoss/StepFunction",this);
  StepFuncCmd->SetGuidance("Set the energy loss step limitation parameters.");
  StepFuncCmd->SetGuidance("  dRoverR   : max Range variation per step");
  StepFuncCmd->SetGuidance("  finalRange: range for final step");

  G4UIparameter* dRoverRPrm = new G4UIparameter("dRoverR",'d',false);
  dRoverRPrm->SetGuidance("max Range variation per step (fractional number)");
  dRoverRPrm->SetParameterRange("dRoverR>0. && dRoverR<=1.");
  StepFuncCmd->SetParameter(dRoverRPrm);

  G4UIparameter* finalRangePrm = new G4UIparameter("finalRange",'d',false);
  finalRangePrm->SetGuidance("range for final step");
  finalRangePrm->SetParameterRange("finalRange>0.");
  StepFuncCmd->SetParameter(finalRangePrm);

  G4UIparameter* unitPrm = new G4UIparameter("unit",'s',true);
  unitPrm->SetGuidance("unit of finalRange");
  unitPrm->SetDefaultValue("mm");
  G4String unitCandidates = 
    G4UIcommand::UnitsList(G4UIcommand::CategoryOf("mm"));
  unitPrm->SetParameterCandidates(unitCandidates);

  StepFuncCmd->SetParameter(unitPrm);
  StepFuncCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  IntegCmd = new G4UIcmdWithABool("/process/eLoss/integral",this);
  IntegCmd->SetGuidance("Switch true/false the integral option");
  IntegCmd->SetParameterName("integ",true);
  IntegCmd->SetDefaultValue(true);
  IntegCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

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

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

  G4UIparameter* flagFluo = new G4UIparameter("flagFluo",'s',false);
  deexCmd->SetParameter(flagFluo);

  G4UIparameter* flagAuger = new G4UIparameter("flagAuger",'s',false);
  deexCmd->SetParameter(flagAuger);

  G4UIparameter* flagPIXE = new G4UIparameter("flagPIXE",'s',false);
  deexCmd->SetParameter(flagPIXE);

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

  G4UIparameter* procName = new G4UIparameter("procName",'s',false);
  bfCmd->SetParameter(procName);

  G4UIparameter* procFact = new G4UIparameter("procFact",'d',false);
  bfCmd->SetParameter(procFact);

  G4UIparameter* flagFact = new G4UIparameter("flagFact",'s',false);
  bfCmd->SetParameter(flagFact);
  bfCmd->AvailableForStates(G4State_Idle);

  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("  tflag      : flag to change weight");

  G4UIparameter* procNam = new G4UIparameter("procNam",'s',false);
  fiCmd->SetParameter(procNam);

  G4UIparameter* regNam = new G4UIparameter("regNam",'s',false);
  fiCmd->SetParameter(regNam);

  G4UIparameter* tlength = new G4UIparameter("tlength",'d',false);
  fiCmd->SetParameter(tlength);

  G4UIparameter* unitT = new G4UIparameter("unitT",'s',true);
  fiCmd->SetParameter(unitT);
  unitT->SetGuidance("unit of tlength");

  G4UIparameter* flagT = new G4UIparameter("tflag",'s',true);
  fiCmd->SetParameter(flagT);
  fiCmd->AvailableForStates(G4State_Idle);

  brCmd = new G4UIcommand("/process/em/setSecBiasing",this);
  brCmd->SetGuidance("Set bremsstrahlung or delta-e- splitting/Russian roullette per region.");
  brCmd->SetGuidance("  bProcNam : process name");
  brCmd->SetGuidance("  bRegNam  : region name");
  brCmd->SetGuidance("  bFactor  : number of splitted gamma or probability of Russian roulette");
  brCmd->SetGuidance("  bEnergy  : max energy of a secondary for this biasing method");

  G4UIparameter* bProcNam = new G4UIparameter("bProcNam",'s',false);
  brCmd->SetParameter(bProcNam);

  G4UIparameter* bRegNam = new G4UIparameter("bRegNam",'s',false);
  brCmd->SetParameter(bRegNam);

  G4UIparameter* bFactor = new G4UIparameter("bFactor",'d',false);
  brCmd->SetParameter(bFactor);

  G4UIparameter* bEnergy = new G4UIparameter("bEnergy",'d',false);
  brCmd->SetParameter(bEnergy);

  G4UIparameter* bUnit = new G4UIparameter("bUnit",'s',true);
  brCmd->SetParameter(bUnit);
  brCmd->SetGuidance("unit of energy");

  brCmd->AvailableForStates(G4State_Idle);
}

Here is the call graph for this function:

~G4EnergyLossMessenger()

G4EnergyLossMessenger::~G4EnergyLossMessenger ( )

virtual

Definition at line 204 of file G4EnergyLossMessenger.cc.

{
  delete opt;
  delete SubSecCmd;
  delete StepFuncCmd;
  delete IntegCmd;
  delete bfCmd;
  delete fiCmd;
  delete brCmd;
}

Member Function Documentation

SetNewValue()

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

virtual

Reimplemented from G4UImessenger.

Definition at line 217 of file G4EnergyLossMessenger.cc.

{
  if(!opt) { opt = new G4EmProcessOptions(); }

  if(command == SubSecCmd) {
    opt->SetSubCutoff(SubSecCmd->GetNewBoolValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  } else if (command == StepFuncCmd) {
    G4double v1,v2;
    G4String unt;
    std::istringstream is(newValue);
    is >> v1 >> v2 >> unt;
    v2 *= G4UIcommand::ValueOf(unt);
    opt->SetStepFunction(v1,v2);
  } 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; }
    opt->SetDeexcitationActiveRegion(s1,b2,b3,b4);
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  } else if (command == IntegCmd) {
    opt->SetIntegral(IntegCmd->GetNewBoolValue(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; }
    opt->SetProcessBiasingFactor(s0,v1,yes);
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  } 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);
    opt->ActivateForcedInteraction(s1,v1,s2,yes);
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  } else if (command == brCmd) {
    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);    
    if (s1=="phot"||s1=="compt"||s1=="conv") 
                opt->ActivateSecondaryBiasingForGamma(s1,s2,fb,en);
    else opt->ActivateSecondaryBiasing(s1,s2,fb,en);
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }  
}

Here is the call graph for this function:

Member Data Documentation

bfCmd

G4UIcommand* G4EnergyLossMessenger::bfCmd

private

Definition at line 90 of file G4EnergyLossMessenger.hh.

brCmd

G4UIcommand* G4EnergyLossMessenger::brCmd

private

Definition at line 92 of file G4EnergyLossMessenger.hh.

deexCmd

G4UIcommand* G4EnergyLossMessenger::deexCmd

private

Definition at line 88 of file G4EnergyLossMessenger.hh.

fiCmd

G4UIcommand* G4EnergyLossMessenger::fiCmd

private

Definition at line 91 of file G4EnergyLossMessenger.hh.

IntegCmd

G4UIcmdWithABool* G4EnergyLossMessenger::IntegCmd

private

Definition at line 89 of file G4EnergyLossMessenger.hh.

opt

G4EmProcessOptions* G4EnergyLossMessenger::opt

private

Definition at line 85 of file G4EnergyLossMessenger.hh.

StepFuncCmd

G4UIcommand* G4EnergyLossMessenger::StepFuncCmd

private

Definition at line 87 of file G4EnergyLossMessenger.hh.

SubSecCmd

G4UIcmdWithABool* G4EnergyLossMessenger::SubSecCmd

private

Definition at line 86 of file G4EnergyLossMessenger.hh.

---

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

• G4EnergyLossMessenger.hh
• G4EnergyLossMessenger.cc