Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions
G4EmManagerMessenger Class Reference

#include <G4EmManagerMessenger.hh>

Inheritance diagram for G4EmManagerMessenger:
G4UImessenger

Public Member Functions

 G4EmManagerMessenger (G4EmManager *)
 
virtual ~G4EmManagerMessenger ()
 
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
 

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
 

Detailed Description

Definition at line 68 of file G4EmManagerMessenger.hh.

Constructor & Destructor Documentation

G4EmManagerMessenger::G4EmManagerMessenger ( G4EmManager *  p)

Definition at line 64 of file G4EmManagerMessenger.cc.

References G4UIcommand::AvailableForStates(), G4UIcommand::CategoryOf(), G4State_Idle, G4State_PreInit, G4UIcmdWithAnInteger::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIparameter::SetDefaultValue(), G4UIparameter::SetGuidance(), G4UIcommand::SetGuidance(), G4UIcommand::SetParameter(), G4UIparameter::SetParameterCandidates(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIparameter::SetParameterRange(), G4UIcmdWithADoubleAndUnit::SetUnitCategory(), and G4UIcommand::UnitsList().

64  : theManager(p)
65 {
66  eLossDirectory = new G4UIdirectory("/process/eLoss/");
67  eLossDirectory->SetGuidance("Commands for EM processes.");
68  mscDirectory = new G4UIdirectory("/process/msc/");
69  mscDirectory->SetGuidance("Commands for EM scattering processes.");
70  emDirectory = new G4UIdirectory("/process/em/");
71  emDirectory->SetGuidance("General commands for EM processes.");
72 
73  EnlossFlucCmd = new G4UIcmdWithABool("/process/eLoss/fluct",this);
74  EnlossFlucCmd->SetGuidance("Enable/disable energy loss fluctuations.");
75  EnlossFlucCmd->SetParameterName("choice",true);
76  EnlossFlucCmd->SetDefaultValue(true);
77  EnlossFlucCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
78 
79  RndmStepCmd = new G4UIcmdWithABool("/process/eLoss/useCutAsFinalRange",this);
80  RndmStepCmd->SetGuidance("Use cut in range as a final range");
81  RndmStepCmd->SetParameterName("choice",true);
82  RndmStepCmd->SetDefaultValue(false);
83  RndmStepCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
84 
85  SubSecCmd = new G4UIcmdWithABool("/process/eLoss/subsec",this);
86  SubSecCmd->SetGuidance("Switch true/false the subcutoff generation.");
87  SubSecCmd->SetParameterName("choice",true);
88  SubSecCmd->SetDefaultValue(true);
89  SubSecCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
90 
91  MinSubSecCmd = new G4UIcmdWithADouble("/process/eLoss/minsubsec",this);
92  MinSubSecCmd->SetGuidance("Set the ratio subcut/cut ");
93  MinSubSecCmd->SetParameterName("rcmin",true);
94  MinSubSecCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
95 
96  StepFuncCmd = new G4UIcommand("/process/eLoss/StepFunction",this);
97  StepFuncCmd->SetGuidance("Set the energy loss step limitation parameters.");
98  StepFuncCmd->SetGuidance(" dRoverR : max Range variation per step");
99  StepFuncCmd->SetGuidance(" finalRange: range for final step");
100 
101  G4UIparameter* dRoverRPrm = new G4UIparameter("dRoverR",'d',false);
102  dRoverRPrm->SetGuidance("max Range variation per step (fractional number)");
103  dRoverRPrm->SetParameterRange("dRoverR>0. && dRoverR<=1.");
104  StepFuncCmd->SetParameter(dRoverRPrm);
105 
106  G4UIparameter* finalRangePrm = new G4UIparameter("finalRange",'d',false);
107  finalRangePrm->SetGuidance("range for final step");
108  finalRangePrm->SetParameterRange("finalRange>0.");
109  StepFuncCmd->SetParameter(finalRangePrm);
110 
111  G4UIparameter* unitPrm = new G4UIparameter("unit",'s',true);
112  unitPrm->SetGuidance("unit of finalRange");
113  unitPrm->SetDefaultValue("mm");
114  G4String unitCandidates =
115  G4UIcommand::UnitsList(G4UIcommand::CategoryOf("mm"));
116  unitPrm->SetParameterCandidates(unitCandidates);
117 
118  StepFuncCmd->SetParameter(unitPrm);
119  StepFuncCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
120 
121  MinEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/minKinEnergy",this);
122  MinEnCmd->SetGuidance("Set the min kinetic energy");
123  MinEnCmd->SetParameterName("emin",true);
124  MinEnCmd->SetUnitCategory("Energy");
125  MinEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
126 
127  MaxEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergy",this);
128  MaxEnCmd->SetGuidance("Set the max kinetic energy");
129  MaxEnCmd->SetParameterName("emax",true);
130  MaxEnCmd->SetUnitCategory("Energy");
131  MaxEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
132 
133  IntegCmd = new G4UIcmdWithABool("/process/eLoss/integral",this);
134  IntegCmd->SetGuidance("Switch true/false the integral option");
135  IntegCmd->SetParameterName("integ",true);
136  IntegCmd->SetDefaultValue(true);
137  IntegCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
138 
139  rangeCmd = new G4UIcmdWithABool("/process/eLoss/CSDARange",this);
140  rangeCmd->SetGuidance("Switch true/false the CSDA range calculation");
141  rangeCmd->SetParameterName("range",true);
142  rangeCmd->SetDefaultValue(true);
143  rangeCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
144 
145  lpmCmd = new G4UIcmdWithABool("/process/eLoss/LPM",this);
146  lpmCmd->SetGuidance("The flag of the LPM effect calculation");
147  lpmCmd->SetParameterName("lpm",true);
148  lpmCmd->SetDefaultValue(true);
149  lpmCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
150 
151  splCmd = new G4UIcmdWithABool("/process/em/spline",this);
152  splCmd->SetGuidance("The flag of usage spline for Physics Vectors");
153  splCmd->SetParameterName("spl",true);
154  splCmd->SetDefaultValue(false);
155  splCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
156  /*
157  aplCmd = new G4UIcmdWithABool("/process/em/applyCuts",this);
158  aplCmd->SetGuidance("The flag to Apply Cuts for gamma processes");
159  aplCmd->SetParameterName("apl",true);
160  aplCmd->SetDefaultValue(false);
161  aplCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
162 
163  deCmd = new G4UIcmdWithABool("/process/em/fluo",this);
164  deCmd->SetGuidance("The flag to enable/disable deexcitation");
165  deCmd->SetParameterName("fluoFlag",true);
166  deCmd->SetDefaultValue(false);
167  deCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
168 
169  auCmd = new G4UIcmdWithABool("/process/em/auger",this);
170  auCmd->SetGuidance("The flag to enable/disable Auger electrons");
171  auCmd->SetParameterName("augerFlag",true);
172  auCmd->SetDefaultValue(false);
173  auCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
174 
175  pixeCmd = new G4UIcmdWithABool("/process/em/pixe",this);
176  pixeCmd->SetGuidance("The flag to enable/disable PIXE");
177  pixeCmd->SetParameterName("pixeFlag",true);
178  pixeCmd->SetDefaultValue(false);
179  pixeCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
180 
181  pixeXsCmd = new G4UIcmdWithAString("/process/em/pixeXSmodel",this);
182  pixeXsCmd->SetGuidance("The name of PIXE cross section");
183  pixeXsCmd->SetParameterName("pixeXS",true);
184  pixeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
185 
186  pixeeXsCmd = new G4UIcmdWithAString("/process/em/pixeElecXSmodel",this);
187  pixeeXsCmd->SetGuidance("The name of PIXE cross section for electron");
188  pixeeXsCmd->SetParameterName("pixeEXS",true);
189  pixeeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
190 
191  deexCmd = new G4UIcommand("/process/em/deexcitation",this);
192  deexCmd->SetGuidance("Set deexcitation flags per G4Region.");
193  deexCmd->SetGuidance(" regName : G4Region name");
194  deexCmd->SetGuidance(" flagFluo : Fluorescence");
195  deexCmd->SetGuidance(" flagAuger : Auger");
196  deexCmd->SetGuidance(" flagPIXE : PIXE");
197 
198  G4UIparameter* regName = new G4UIparameter("regName",'s',false);
199  deexCmd->SetParameter(regName);
200 
201  G4UIparameter* flagFluo = new G4UIparameter("flagFluo",'s',false);
202  deexCmd->SetParameter(flagFluo);
203 
204  G4UIparameter* flagAuger = new G4UIparameter("flagAuger",'s',false);
205  deexCmd->SetParameter(flagAuger);
206 
207  G4UIparameter* flagPIXE = new G4UIparameter("flagPIXE",'s',false);
208  deexCmd->SetParameter(flagPIXE);
209  */
210  dedxCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsDEDX",this);
211  dedxCmd->SetGuidance("Set number of bins for DEDX tables");
212  dedxCmd->SetParameterName("binsDEDX",true);
213  dedxCmd->SetDefaultValue(77);
214  dedxCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
215 
216  lamCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsLambda",this);
217  lamCmd->SetGuidance("Set number of bins for Lambda tables");
218  lamCmd->SetParameterName("binsL",true);
219  lamCmd->SetDefaultValue(77);
220  lamCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
221  /*
222  verCmd = new G4UIcmdWithAnInteger("/process/eLoss/verbose",this);
223  verCmd->SetGuidance("Set verbose level for EM physics");
224  verCmd->SetParameterName("verb",true);
225  verCmd->SetDefaultValue(1);
226  verCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
227 
228  ver1Cmd = new G4UIcmdWithAnInteger("/process/em/verbose",this);
229  ver1Cmd->SetGuidance("Set verbose level for EM physics");
230  ver1Cmd->SetParameterName("verb1",true);
231  ver1Cmd->SetDefaultValue(1);
232  ver1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
233  */
234  lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this);
235  lllCmd->SetGuidance("Set linearLossLimit parameter");
236  lllCmd->SetParameterName("linlim",true);
237  lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
238  /*
239  labCmd = new G4UIcmdWithADouble("/process/eLoss/LambdaFactor",this);
240  labCmd->SetGuidance("Set lambdaFactor parameter for integral option");
241  labCmd->SetParameterName("Fl",true);
242  labCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
243 
244  mscCmd = new G4UIcmdWithAString("/process/msc/StepLimit",this);
245  mscCmd->SetGuidance("Set msc step limitation type");
246  mscCmd->SetParameterName("StepLim",true);
247  mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
248 
249  latCmd = new G4UIcmdWithABool("/process/msc/LateralDisplacement",this);
250  latCmd->SetGuidance("Set flag of sampling of lateral displacement");
251  latCmd->SetParameterName("lat",true);
252  latCmd->SetDefaultValue(true);
253  latCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
254 
255  frCmd = new G4UIcmdWithADouble("/process/msc/RangeFactor",this);
256  frCmd->SetGuidance("Set RangeFactor parameter for msc processes");
257  frCmd->SetParameterName("Fr",true);
258  frCmd->SetRange("Fr>0");
259  frCmd->SetDefaultValue(0.04);
260  frCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
261 
262  fgCmd = new G4UIcmdWithADouble("/process/msc/GeomFactor",this);
263  fgCmd->SetGuidance("Set GeomFactor parameter for msc processes");
264  fgCmd->SetParameterName("Fg",true);
265  fgCmd->SetRange("Fg>0");
266  fgCmd->SetDefaultValue(3.5);
267  fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
268 
269  mscfCmd = new G4UIcmdWithADouble("/process/msc/FactorForAngleLimit",this);
270  mscfCmd->SetGuidance("Set factor for computation of a limit for -t (invariant trasfer)");
271  mscfCmd->SetParameterName("Fact",true);
272  mscfCmd->SetRange("Fact>0");
273  mscfCmd->SetDefaultValue(1.);
274  mscfCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
275 
276  skinCmd = new G4UIcmdWithADouble("/process/msc/Skin",this);
277  skinCmd->SetGuidance("Set skin parameter for msc processes");
278  skinCmd->SetParameterName("skin",true);
279  skinCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
280 
281  angCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/ThetaLimit",this);
282  angCmd->SetGuidance("Set the limit on the polar angle for msc and single scattering");
283  angCmd->SetParameterName("theta",true);
284  angCmd->SetUnitCategory("Angle");
285  angCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
286 
287  bfCmd = new G4UIcommand("/process/em/setBiasingFactor",this);
288  bfCmd->SetGuidance("Set factor for the process cross section.");
289  bfCmd->SetGuidance(" procName : process name");
290  bfCmd->SetGuidance(" procFact : factor");
291  bfCmd->SetGuidance(" flagFact : flag to change weight");
292 
293  G4UIparameter* procName = new G4UIparameter("procName",'s',false);
294  bfCmd->SetParameter(procName);
295 
296  G4UIparameter* procFact = new G4UIparameter("procFact",'d',false);
297  bfCmd->SetParameter(procFact);
298 
299  G4UIparameter* flagFact = new G4UIparameter("flagFact",'s',false);
300  bfCmd->SetParameter(flagFact);
301  bfCmd->AvailableForStates(G4State_Idle);
302 
303  fiCmd = new G4UIcommand("/process/em/setForcedInteraction",this);
304  fiCmd->SetGuidance("Set factor for the process cross section.");
305  fiCmd->SetGuidance(" procNam : process name");
306  fiCmd->SetGuidance(" regNam : region name");
307  fiCmd->SetGuidance(" tlength : fixed target length");
308  fiCmd->SetGuidance(" tflag : flag to change weight");
309 
310  G4UIparameter* procNam = new G4UIparameter("procNam",'s',false);
311  fiCmd->SetParameter(procNam);
312 
313  G4UIparameter* regNam = new G4UIparameter("regNam",'s',false);
314  fiCmd->SetParameter(regNam);
315 
316  G4UIparameter* tlength = new G4UIparameter("tlength",'d',false);
317  fiCmd->SetParameter(tlength);
318 
319  G4UIparameter* unitT = new G4UIparameter("unitT",'s',true);
320  fiCmd->SetParameter(unitT);
321  unitT->SetGuidance("unit of tlength");
322 
323  G4UIparameter* flagT = new G4UIparameter("tflag",'s',true);
324  fiCmd->SetParameter(flagT);
325  fiCmd->AvailableForStates(G4State_Idle);
326 
327  brCmd = new G4UIcommand("/process/em/setSecBiasing",this);
328  brCmd->SetGuidance("Set bremsstrahlung or delta-electron splitting/Russian roullette per region.");
329  brCmd->SetGuidance(" bProcNam : process name");
330  brCmd->SetGuidance(" bRegNam : region name");
331  brCmd->SetGuidance(" bFactor : number of splitted gamma or probability of Russian roulette");
332  brCmd->SetGuidance(" bEnergy : max energy of a secondary for this biasing method");
333 
334  G4UIparameter* bProcNam = new G4UIparameter("bProcNam",'s',false);
335  brCmd->SetParameter(bProcNam);
336 
337  G4UIparameter* bRegNam = new G4UIparameter("bRegNam",'s',false);
338  brCmd->SetParameter(bRegNam);
339 
340  G4UIparameter* bFactor = new G4UIparameter("bFactor",'d',false);
341  brCmd->SetParameter(bFactor);
342 
343  G4UIparameter* bEnergy = new G4UIparameter("bEnergy",'d',false);
344  brCmd->SetParameter(bEnergy);
345 
346  G4UIparameter* bUnit = new G4UIparameter("bUnit",'s',true);
347  brCmd->SetParameter(bUnit);
348  brCmd->SetGuidance("unit of energy");
349 
350  brCmd->AvailableForStates(G4State_Idle);
351  */
352 }
G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:152
G4UIcmdWithAnInteger::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAnInteger.cc:47
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:95
G4UIparameter::SetParameterCandidates
void SetParameterCandidates(const char *theString)
Definition: G4UIparameter.hh:113
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:83
G4UIcmdWithADoubleAndUnit::SetUnitCategory
void SetUnitCategory(const char *unitCategory)
Definition: G4UIcmdWithADoubleAndUnit.cc:150
G4UIcmdWithABool::SetDefaultValue
void SetDefaultValue(G4bool defVal)
Definition: G4UIcmdWithABool.cc:55
G4UIcmdWithABool::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithABool.cc:47
G4UIcommand::UnitsList
static G4String UnitsList(const char *unitCategory)
Definition: G4UIcommand.cc:306
G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:161
G4UIcommand::AvailableForStates
void AvailableForStates(G4ApplicationState s1)
Definition: G4UIcommand.cc:225
G4UIcmdWithADouble::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithADouble.cc:47
G4State_Idle
Definition: G4ApplicationState.hh:85
G4UIcmdWithAnInteger::SetDefaultValue
void SetDefaultValue(G4int defVal)
Definition: G4UIcmdWithAnInteger.cc:55
G4UIparameter::SetGuidance
void SetGuidance(const char *theGuidance)
Definition: G4UIparameter.hh:138
G4State_PreInit
Definition: G4ApplicationState.hh:85
G4UIcommand::CategoryOf
static G4String CategoryOf(const char *unitName)
Definition: G4UIcommand.cc:301
G4UIcmdWithADoubleAndUnit::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithADoubleAndUnit.cc:136
G4EmManagerMessenger::~G4EmManagerMessenger ( )
virtual

Definition at line 356 of file G4EmManagerMessenger.cc.

357 {
358  delete RndmStepCmd;
359  delete EnlossFlucCmd;
360  delete SubSecCmd;
361  delete MinSubSecCmd;
362  delete StepFuncCmd;
363  delete deexCmd;
364  delete eLossDirectory;
365  delete mscDirectory;
366  delete emDirectory;
367  delete MinEnCmd;
368  delete MaxEnCmd;
369  delete IntegCmd;
370  delete rangeCmd;
371  delete lpmCmd;
372  delete splCmd;
373  delete lllCmd;
374  delete lamCmd;
375  delete dedxCmd;
376  /*
377  delete aplCmd;
378  delete latCmd;
379  delete verCmd;
380  delete ver1Cmd;
381  delete mscCmd;
382  delete deCmd;
383  delete auCmd;
384  delete pixeCmd;
385  delete pixeXsCmd;
386  delete pixeeXsCmd;
387  delete frCmd;
388  delete fgCmd;
389  delete labCmd;
390  delete skinCmd;
391  delete angCmd;
392  delete mscfCmd;
393  delete bfCmd;
394  delete fiCmd;
395  delete brCmd;
396  */
397 }

Member Function Documentation

void G4EmManagerMessenger::SetNewValue ( G4UIcommand *  command,
G4String  newValue 
)
virtual

Reimplemented from G4UImessenger.

Definition at line 401 of file G4EmManagerMessenger.cc.

References G4UImanager::ApplyCommand(), G4UIcmdWithABool::GetNewBoolValue(), G4UIcmdWithADouble::GetNewDoubleValue(), G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(), G4UIcmdWithAnInteger::GetNewIntValue(), G4UImanager::GetUIpointer(), G4EmManager::SetBuildCSDARange(), G4EmManager::SetDEDXBinning(), G4EmManager::SetIntegral(), G4EmManager::SetLambdaBinning(), G4EmManager::SetLinearLossLimit(), G4EmManager::SetLossFluctuations(), G4EmManager::SetLPMFlag(), G4EmManager::SetMaxEnergy(), G4EmManager::SetMinEnergy(), G4EmManager::SetMinSubRange(), G4EmManager::SetRandomStep(), G4EmManager::SetSplineFlag(), G4EmManager::SetStepFunction(), G4EmManager::SetSubCutoff(), and G4UIcommand::ValueOf().

402 {
403  if (command == RndmStepCmd) {
404  theManager->SetRandomStep(RndmStepCmd->GetNewBoolValue(newValue));
405  } else if (command == EnlossFlucCmd) {
406  theManager->SetLossFluctuations(EnlossFlucCmd->GetNewBoolValue(newValue));
407  } else if(command == SubSecCmd) {
408  theManager->SetSubCutoff(SubSecCmd->GetNewBoolValue(newValue));
409  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
410  } else if (command == MinSubSecCmd) {
411  theManager->SetMinSubRange(MinSubSecCmd->GetNewDoubleValue(newValue));
412  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
413  } else if (command == StepFuncCmd) {
414  G4double v1,v2;
415  G4String unt;
416  std::istringstream is(newValue);
417  is >> v1 >> v2 >> unt;
418  v2 *= G4UIcommand::ValueOf(unt);
419  theManager->SetStepFunction(v1,v2);
420  /*
421  } else if (command == deexCmd) {
422  G4String s1 (""), s2(""), s3(""), s4("");
423  G4bool b2(false), b3(false), b4(false);
424  std::istringstream is(newValue);
425  is >> s1 >> s2 >> s3 >> s4;
426  if(s2 == "true") { b2 = true; }
427  if(s3 == "true") { b3 = true; }
428  if(s4 == "true") { b4 = true; }
429  theManager->SetDeexcitationActiveRegion(s1,b2,b3,b4);
430  } else if (command == deCmd) {
431  theManager->SetFluo(deCmd->GetNewBoolValue(newValue));
432  } else if (command == auCmd) {
433  theManager->SetAuger(auCmd->GetNewBoolValue(newValue));
434  } else if (command == pixeCmd) {
435  theManager->SetPIXE(pixeCmd->GetNewBoolValue(newValue));
436  } else if (command == pixeXsCmd) {
437  G4String name;
438  if (newValue == "ecpssr_analytical")
439  {name = "ECPSSR_Analytical";}
440  else if (newValue == "ecpssr_interpolated")
441  {name = "ECPSSR_FormFactor";}
442  else
443  {name = newValue;}
444  theManager->SetPIXECrossSectionModel(name);
445  } else if (command == pixeeXsCmd) {
446  theManager->SetPIXEElectronCrossSectionModel(newValue);
447  } else if (command == mscCmd) {
448  if(newValue == "Minimal")
449  theManager->SetMscStepLimitation(fMinimal);
450 
451  else if(newValue == "UseDistanceToBoundary")
452  theManager->SetMscStepLimitation(fUseDistanceToBoundary);
453 
454  else if(newValue == "UseSafety")
455  theManager->SetMscStepLimitation(fUseSafety);
456 
457  else {
458  G4cout << "### G4EmManagerMessenger WARNING: StepLimit type <"
459  << newValue << "> unknown!" << G4endl;
460  return;
461  }
462  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
463 */
464  } else if (command == MinEnCmd) {
465  theManager->SetMinEnergy(MinEnCmd->GetNewDoubleValue(newValue));
466  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
467  } else if (command == MaxEnCmd) {
468  theManager->SetMaxEnergy(MaxEnCmd->GetNewDoubleValue(newValue));
469  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
470  } else if (command == IntegCmd) {
471  theManager->SetIntegral(IntegCmd->GetNewBoolValue(newValue));
472  } else if (command == rangeCmd) {
473  theManager->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue));
474  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
475  } else if (command == lpmCmd) {
476  theManager->SetLPMFlag(lpmCmd->GetNewBoolValue(newValue));
477  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
478  } else if (command == splCmd) {
479  theManager->SetSplineFlag(splCmd->GetNewBoolValue(newValue));
480  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
481  /*
482  } else if (command == aplCmd) {
483  theManager->SetApplyCuts(aplCmd->GetNewBoolValue(newValue));
484  } else if (command == latCmd) {
485  theManager->SetMscLateralDisplacement(latCmd->GetNewBoolValue(newValue));
486  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
487  } else if (command == verCmd) {
488  theManager->SetVerbose(verCmd->GetNewIntValue(newValue));
489  } else if (command == ver1Cmd) {
490  theManager->SetVerbose(ver1Cmd->GetNewIntValue(newValue));
491 */
492  } else if (command == lllCmd) {
493  theManager->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue));
494  /*
495  } else if (command == labCmd) {
496  theManager->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue));
497  } else if (command == skinCmd) {
498  theManager->SetSkin(skinCmd->GetNewDoubleValue(newValue));
499  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
500 */
501  } else if (command == dedxCmd) {
502  theManager->SetDEDXBinning(dedxCmd->GetNewIntValue(newValue));
503  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
504  } else if (command == lamCmd) {
505  theManager->SetLambdaBinning(lamCmd->GetNewIntValue(newValue));
506  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
507  /*
508  } else if (command == frCmd) {
509  theManager->SetMscRangeFactor(frCmd->GetNewDoubleValue(newValue));
510  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
511  } else if (command == fgCmd) {
512  theManager->SetMscGeomFactor(fgCmd->GetNewDoubleValue(newValue));
513  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
514  } else if (command == mscfCmd) {
515  theManager->SetFactorForAngleLimit(mscfCmd->GetNewDoubleValue(newValue));
516  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
517  } else if (command == angCmd) {
518  theManager->SetPolarAngleLimit(angCmd->GetNewDoubleValue(newValue));
519  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
520  } else if (command == bfCmd) {
521  G4double v1(1.0);
522  G4String s0(""),s1("");
523  std::istringstream is(newValue);
524  is >> s0 >> v1 >> s1;
525  G4bool yes = false;
526  if(s1 == "true") { yes = true; }
527  theManager->SetProcessBiasingFactor(s0,v1,yes);
528  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
529  } else if (command == fiCmd) {
530  G4double v1(0.0);
531  G4String s1(""),s2(""),s3(""),unt("mm");
532  std::istringstream is(newValue);
533  is >> s1 >> s2 >> v1 >> unt >> s3;
534  G4bool yes = false;
535  if(s3 == "true") { yes = true; }
536  v1 *= G4UIcommand::ValueOf(unt);
537  theManager->ActivateForcedInteraction(s1,v1,s2,yes);
538  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
539  } else if (command == brCmd) {
540  G4double fb(1.0),en(1.e+30);
541  G4String s1(""),s2(""),unt("MeV");
542  std::istringstream is(newValue);
543  is >> s1 >> s2 >> fb >> en >> unt;
544  en *= G4UIcommand::ValueOf(unt);
545  if (s1=="phot"||s1=="compt"||s1=="conv")
546  theManager->ActivateSecondaryBiasingForGamma(s1,s2,fb,en);
547  else theManager->ActivateSecondaryBiasing(s1,s2,fb,en);
548  G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
549 */
550  }
551 }
G4UIcmdWithAnInteger::GetNewIntValue
static G4int GetNewIntValue(const char *paramString)
Definition: G4UIcmdWithAnInteger.cc:41
G4EmManager::SetMaxEnergy
void SetMaxEnergy(G4double val)
Definition: G4EmManager.cc:690
G4EmManager::SetSplineFlag
void SetSplineFlag(G4bool val)
Definition: G4EmManager.cc:875
G4EmManager::SetRandomStep
void SetRandomStep(G4bool val)
Definition: G4EmManager.cc:665
G4EmManager::SetLossFluctuations
void SetLossFluctuations(G4bool val)
Definition: G4EmManager.cc:620
G4UIcmdWithADoubleAndUnit::GetNewDoubleValue
static G4double GetNewDoubleValue(const char *paramString)
Definition: G4UIcmdWithADoubleAndUnit.cc:83
G4EmManager::SetSubCutoff
void SetSubCutoff(G4bool val, const G4Region *r=0)
Definition: G4EmManager.cc:630
G4UIcmdWithABool::GetNewBoolValue
static G4bool GetNewBoolValue(const char *paramString)
Definition: G4UIcmdWithABool.cc:41
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58
G4EmManager::SetIntegral
void SetIntegral(G4bool val)
Definition: G4EmManager.cc:640
G4EmManager::SetBuildCSDARange
void SetBuildCSDARange(G4bool val)
Definition: G4EmManager.cc:815
G4UIcmdWithADouble::GetNewDoubleValue
static G4double GetNewDoubleValue(const char *paramString)
Definition: G4UIcmdWithADouble.cc:41
G4EmManager::SetDEDXBinning
void SetDEDXBinning(G4int val)
Definition: G4EmManager.cc:722
G4EmManager::SetLinearLossLimit
void SetLinearLossLimit(G4double val)
Definition: G4EmManager.cc:806
G4EmManager::SetLambdaBinning
void SetLambdaBinning(G4int val)
Definition: G4EmManager.cc:740
G4EmManager::SetLPMFlag
void SetLPMFlag(G4bool val)
Definition: G4EmManager.cc:861
G4UIcommand::ValueOf
static G4double ValueOf(const char *unitName)
Definition: G4UIcommand.cc:294
G4EmManager::SetStepFunction
void SetStepFunction(G4double v1, G4double v2)
Definition: G4EmManager.cc:794
G4double
double G4double
Definition: G4Types.hh:76
G4EmManager::SetMinSubRange
void SetMinSubRange(G4double val)
Definition: G4EmManager.cc:655
G4EmManager::SetMinEnergy
void SetMinEnergy(G4double val)
Definition: G4EmManager.cc:675
G4UImanager::ApplyCommand
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:419
The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:56:22 for Geant4.10 by   doxygen 1.8.7