Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4OpticalParametersMessenger Class Reference

#include <G4OpticalParametersMessenger.hh>

Inheritance diagram for G4OpticalParametersMessenger:

Public Member Functions

 G4OpticalParametersMessenger (G4OpticalParameters *)
virtual ~G4OpticalParametersMessenger ()
virtual void SetNewValue (G4UIcommand *, G4String)
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 61 of file G4OpticalParametersMessenger.hh.

Constructor & Destructor Documentation

◆ G4OpticalParametersMessenger()

G4OpticalParametersMessenger::G4OpticalParametersMessenger ( G4OpticalParameters * opticalParameters)

Definition at line 54 of file G4OpticalParametersMessenger.cc.

56 : params(opticalParameters)
57
58{
59 G4bool toBeBroadcasted = false;
60 fDir = new G4UIdirectory("/process/optical/", toBeBroadcasted);
61 fDir->SetGuidance(
62 "Commands related to the optical physics simulation engine.");
63
64 fCerenkovDir =
65 new G4UIdirectory("/process/optical/cerenkov/", toBeBroadcasted);
66 fCerenkovDir->SetGuidance("Cerenkov process commands");
67 fScintDir =
68 new G4UIdirectory("/process/optical/scintillation/", toBeBroadcasted);
69 fScintDir->SetGuidance("Scintillation process commands");
70 fWlsDir = new G4UIdirectory("/process/optical/wls/", toBeBroadcasted);
71 fWlsDir->SetGuidance("Wave length shifting process commands");
72 fWls2Dir = new G4UIdirectory("/process/optical/wls2/", toBeBroadcasted);
73 fWls2Dir->SetGuidance("Second Wave length shifting process commands");
74 fBoundaryDir =
75 new G4UIdirectory("/process/optical/boundary/", toBeBroadcasted);
76 fBoundaryDir->SetGuidance("Boundary scattering commands");
77 fMieDir = new G4UIdirectory("/process/optical/mie/", toBeBroadcasted);
78 fMieDir->SetGuidance("Mie scattering process commands");
79 fAbsDir = new G4UIdirectory("/process/optical/absorption/", toBeBroadcasted);
80 fAbsDir->SetGuidance("absorption process commands");
81 fRaylDir = new G4UIdirectory("/process/optical/rayleigh/", toBeBroadcasted);
82 fRaylDir->SetGuidance("Rayleigh scattering commands");
83
84 // general commands
85 fActivateProcessCmd =
86 new G4UIcommand("/process/optical/processActivation", this);
87 fActivateProcessCmd->SetGuidance(
88 "Activate/deactivate the specified optical process");
89 auto par = new G4UIparameter("proc_name", 's', false);
90 G4String candidates;
91 for(G4int i = 0; i < kNoProcess; ++i)
92 {
93 candidates += G4OpticalProcessName(i);
94 candidates += G4String(" ");
95 }
96 par->SetParameterCandidates(candidates);
97 par->SetGuidance("the process name");
98 fActivateProcessCmd->SetParameter(par);
99 par = new G4UIparameter("flag", 'b', true);
100 par->SetDefaultValue(true);
101 par->SetGuidance("activation flag");
102 fActivateProcessCmd->SetParameter(par);
103 fActivateProcessCmd->AvailableForStates(G4State_PreInit);
104
105 fVerboseCmd = new G4UIcmdWithAnInteger("/process/optical/verbose", this);
106 fVerboseCmd->SetGuidance("Set default verbose level for optical processes");
107 fVerboseCmd->SetParameterName("ver", true);
108 fVerboseCmd->SetDefaultValue(1);
109 fVerboseCmd->SetRange("ver>=0");
110 fVerboseCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
111
112 fDumpCmd = new G4UIcommand("/process/optical/printParameters", this);
113 fDumpCmd->SetGuidance("Print all optical parameters.");
114 fDumpCmd->SetToBeBroadcasted(false);
115
116 fXRayCmd = new G4UIcommand("/process/optical/XRayModel", this);
117 fXRayCmd->SetGuidance("Add XRay model per G4LogicalVolume.");
118 fXRayCmd->SetGuidance(" lvName : G4LogicalVolume name");
119 fXRayCmd->SetGuidance(" xrayType : X-Ray model type");
120 fXRayCmd->AvailableForStates(G4State_PreInit);
121 fXRayCmd->SetToBeBroadcasted(false);
122 auto lvName = new G4UIparameter("lvName",'s',false);
123 fXRayCmd->SetParameter(lvName);
124 auto xrayT = new G4UIparameter("xrayT",'s',false);
125 fXRayCmd->SetParameter(xrayT);
126
127 // Cerenkov ////////////////////
128 fCerenkovMaxPhotonsCmd =
129 new G4UIcmdWithAnInteger("/process/optical/cerenkov/setMaxPhotons", this);
130 fCerenkovMaxPhotonsCmd->SetGuidance("Set maximum number of photons per step");
131 fCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
132 fCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
133 fCerenkovMaxPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
134
135 fCerenkovMaxBetaChangeCmd =
136 new G4UIcmdWithADouble("/process/optical/cerenkov/setMaxBetaChange", this);
137 fCerenkovMaxBetaChangeCmd->SetGuidance(
138 "Set maximum change of beta of parent particle per step (in percent)");
139 fCerenkovMaxBetaChangeCmd->SetParameterName("CerenkovMaxBetaChange", false);
140 fCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
141 fCerenkovMaxBetaChangeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
142
143 fCerenkovStackPhotonsCmd =
144 new G4UIcmdWithABool("/process/optical/cerenkov/setStackPhotons", this);
145 fCerenkovStackPhotonsCmd->SetGuidance(
146 "Set whether or not to stack secondary Cerenkov photons");
147 fCerenkovStackPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
148
149 fCerenkovOffloadPhotonsCmd =
150 new G4UIcmdWithABool("/process/optical/cerenkov/setOffloadPhotons", this);
151 fCerenkovOffloadPhotonsCmd->SetGuidance(
152 "Set whether or not to offload secondary Cerenkov photons");
153 fCerenkovOffloadPhotonsCmd->SetParameterName("CerenkovOffloadPhotons", false);
154 fCerenkovOffloadPhotonsCmd->SetDefaultValue(false);
155 fCerenkovOffloadPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
156
157 fCerenkovTrackSecondariesFirstCmd = new G4UIcmdWithABool(
158 "/process/optical/cerenkov/setTrackSecondariesFirst", this);
159 fCerenkovTrackSecondariesFirstCmd->SetGuidance(
160 "Whether to track secondary Cerenkov photons before the primary.");
161 fCerenkovTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit,
162 G4State_Idle);
163
164 fCerenkovVerboseLevelCmd =
165 new G4UIcmdWithAnInteger("/process/optical/cerenkov/verbose", this);
166 fCerenkovVerboseLevelCmd->SetGuidance("Verbose level for Cerenkov process.");
167 fCerenkovVerboseLevelCmd->SetParameterName("verbose", true);
168 fCerenkovVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
169 fCerenkovVerboseLevelCmd->SetDefaultValue(2);
170 fCerenkovVerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
171
172 // Scintillation //////////////////////////
173 fScintByParticleTypeCmd = new G4UIcmdWithABool(
174 "/process/optical/scintillation/setByParticleType", this);
175 fScintByParticleTypeCmd->SetGuidance(
176 "Activate/Inactivate scintillation process by particle type");
177 fScintByParticleTypeCmd->SetParameterName(
178 "ScintillationByParticleTypeActivation", false);
179 fScintByParticleTypeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
180
181 fScintTrackInfoCmd =
182 new G4UIcmdWithABool("/process/optical/scintillation/setTrackInfo", this);
183 fScintTrackInfoCmd->SetGuidance(
184 "Activate/Inactivate scintillation TrackInformation");
185 fScintTrackInfoCmd->SetParameterName("ScintillationTrackInfo", false);
186 fScintTrackInfoCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
187
188 fScintFiniteRiseTimeCmd = new G4UIcmdWithABool(
189 "/process/optical/scintillation/setFiniteRiseTime", this);
190 fScintFiniteRiseTimeCmd->SetGuidance(
191 "Set option of a finite rise-time for G4Scintillation");
192 fScintFiniteRiseTimeCmd->SetGuidance(
193 "If set, the G4Scintillation process expects the user to have set the");
194 fScintFiniteRiseTimeCmd->SetGuidance(
195 "constant material property SCINTILLATIONRISETIME{1,2,3}");
196 fScintFiniteRiseTimeCmd->SetParameterName("FiniteRiseTime", false);
197 fScintFiniteRiseTimeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
198
199 fScintStackPhotonsCmd = new G4UIcmdWithABool(
200 "/process/optical/scintillation/setStackPhotons", this);
201 fScintStackPhotonsCmd->SetGuidance(
202 "Set whether or not to stack secondary Scintillation photons");
203 fScintStackPhotonsCmd->SetParameterName("ScintillationStackPhotons", true);
204 fScintStackPhotonsCmd->SetDefaultValue(true);
205 fScintStackPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
206
207 fScintOffloadPhotonsCmd = new G4UIcmdWithABool(
208 "/process/optical/scintillation/setOffloadPhotons", this);
209 fScintOffloadPhotonsCmd->SetGuidance(
210 "Set whether or not to offload secondary scintillation photons");
211 fScintOffloadPhotonsCmd->SetParameterName("ScintillationOffloadPhotons", false);
212 fScintOffloadPhotonsCmd->SetDefaultValue(false);
213 fScintOffloadPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
214
215 fScintTrackSecondariesFirstCmd = new G4UIcmdWithABool(
216 "/process/optical/scintillation/setTrackSecondariesFirst", this);
217 fScintTrackSecondariesFirstCmd->SetGuidance(
218 "Whether to track scintillation secondaries before primary.");
219 fScintTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit,
220 G4State_Idle);
221
222 fScintVerboseLevelCmd =
223 new G4UIcmdWithAnInteger("/process/optical/scintillation/verbose", this);
224 fScintVerboseLevelCmd->SetGuidance(
225 "Verbose level for scintillation process.");
226 fScintVerboseLevelCmd->SetParameterName("verbose", true);
227 fScintVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
228 fScintVerboseLevelCmd->AvailableForStates(G4State_Idle, G4State_PreInit);
229
230 // WLS //////////////////////////////////
231 fWLSTimeProfileCmd =
232 new G4UIcmdWithAString("/process/optical/wls/setTimeProfile", this);
233 fWLSTimeProfileCmd->SetGuidance(
234 "Set the WLS time profile (delta or exponential)");
235 fWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
236 fWLSTimeProfileCmd->SetCandidates("delta exponential");
237 fWLSTimeProfileCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
238
239 fWLSVerboseLevelCmd =
240 new G4UIcmdWithAnInteger("/process/optical/wls/verbose", this);
241 fWLSVerboseLevelCmd->SetGuidance("Verbose level for WLS process.");
242 fWLSVerboseLevelCmd->SetParameterName("verbose", true);
243 fWLSVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
244 fWLSVerboseLevelCmd->SetDefaultValue(1);
245 fWLSVerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
246
247 // WLS2 //////////////////////////////////
248 fWLS2TimeProfileCmd =
249 new G4UIcmdWithAString("/process/optical/wls2/setTimeProfile", this);
250 fWLS2TimeProfileCmd->SetGuidance(
251 "Set the WLS2 time profile (delta or exponential)");
252 fWLS2TimeProfileCmd->SetParameterName("WLS2TimeProfile", false);
253 fWLS2TimeProfileCmd->SetCandidates("delta exponential");
254 fWLS2TimeProfileCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
255
256 fWLS2VerboseLevelCmd =
257 new G4UIcmdWithAnInteger("/process/optical/wls2/verbose", this);
258 fWLS2VerboseLevelCmd->SetGuidance("Verbose level for WLS2 process.");
259 fWLS2VerboseLevelCmd->SetParameterName("verbose", true);
260 fWLS2VerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
261 fWLS2VerboseLevelCmd->SetDefaultValue(1);
262 fWLS2VerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
263
264 // boundary //////////////////////////////////////
265 fBoundaryInvokeSDCmd =
266 new G4UIcmdWithABool("/process/optical/boundary/setInvokeSD", this);
267 fBoundaryInvokeSDCmd->SetGuidance(
268 "Set option for calling InvokeSD in G4OpBoundaryProcess");
269 fBoundaryInvokeSDCmd->SetParameterName("InvokeSD", false);
270 fBoundaryInvokeSDCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
271
272 fBoundaryVerboseLevelCmd =
273 new G4UIcmdWithAnInteger("/process/optical/boundary/verbose", this);
274 fBoundaryVerboseLevelCmd->SetGuidance("Verbose level for boundary process.");
275 fBoundaryVerboseLevelCmd->SetParameterName("verbose", true);
276 fBoundaryVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
277 fBoundaryVerboseLevelCmd->SetDefaultValue(1);
278 fBoundaryVerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
279
280 // absorption //////////////////////////////////////
281 fAbsorptionVerboseLevelCmd =
282 new G4UIcmdWithAnInteger("/process/optical/absorption/verbose", this);
283 fAbsorptionVerboseLevelCmd->SetGuidance(
284 "Verbose level for absorption process.");
285 fAbsorptionVerboseLevelCmd->SetParameterName("verbose", true);
286 fAbsorptionVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
287 fAbsorptionVerboseLevelCmd->SetDefaultValue(1);
288 fAbsorptionVerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
289
290 // rayleigh //////////////////////////////////////
291 fRayleighVerboseLevelCmd =
292 new G4UIcmdWithAnInteger("/process/optical/rayleigh/verbose", this);
293 fRayleighVerboseLevelCmd->SetGuidance("Verbose level for Rayleigh process.");
294 fRayleighVerboseLevelCmd->SetParameterName("verbose", true);
295 fRayleighVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
296 fRayleighVerboseLevelCmd->SetDefaultValue(1);
297 fRayleighVerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
298
299 // mie //////////////////////////////////////
300 fMieVerboseLevelCmd =
301 new G4UIcmdWithAnInteger("/process/optical/mie/verbose", this);
302 fMieVerboseLevelCmd->SetGuidance("Verbose level for Mie process.");
303 fMieVerboseLevelCmd->SetParameterName("verbose", true);
304 fMieVerboseLevelCmd->SetRange("verbose >= 0 && verbose <= 2");
305 fMieVerboseLevelCmd->SetDefaultValue(1);
306 fMieVerboseLevelCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
307}
G4State_Idle
@ G4State_Idle
Definition G4ApplicationState.hh:86
G4State_PreInit
@ G4State_PreInit
Definition G4ApplicationState.hh:84
kNoProcess
@ kNoProcess
Number of processes, no selected process.
Definition G4OpticalParameters.hh:74
G4OpticalProcessName
G4String G4OpticalProcessName(G4int)
Return the name for a given optical process index.
Definition G4OpticalParameters.hh:86
G4bool
bool G4bool
Definition G4Types.hh:86
G4int
int G4int
Definition G4Types.hh:85

◆ ~G4OpticalParametersMessenger()

G4OpticalParametersMessenger::~G4OpticalParametersMessenger ( )
virtual

Definition at line 309 of file G4OpticalParametersMessenger.cc.

310{
311 delete fDir;
312 delete fCerenkovDir;
313 delete fScintDir;
314 delete fWlsDir;
315 delete fBoundaryDir;
316 delete fMieDir;
317 delete fAbsDir;
318 delete fRaylDir;
319 delete fActivateProcessCmd;
320 delete fVerboseCmd;
321 delete fDumpCmd;
322 delete fXRayCmd;
323 delete fCerenkovMaxPhotonsCmd;
324 delete fCerenkovMaxBetaChangeCmd;
325 delete fCerenkovStackPhotonsCmd;
326 delete fCerenkovTrackSecondariesFirstCmd;
327 delete fCerenkovVerboseLevelCmd;
328 delete fScintByParticleTypeCmd;
329 delete fScintTrackInfoCmd;
330 delete fScintStackPhotonsCmd;
331 delete fScintVerboseLevelCmd;
332 delete fScintFiniteRiseTimeCmd;
333 delete fScintTrackSecondariesFirstCmd;
334 delete fWLSTimeProfileCmd;
335 delete fWLSVerboseLevelCmd;
336 delete fWLS2TimeProfileCmd;
337 delete fWLS2VerboseLevelCmd;
338 delete fAbsorptionVerboseLevelCmd;
339 delete fRayleighVerboseLevelCmd;
340 delete fMieVerboseLevelCmd;
341 delete fBoundaryVerboseLevelCmd;
342 delete fBoundaryInvokeSDCmd;
343}

Member Function Documentation

◆ SetNewValue()

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

Apply command to the associated object.

Reimplemented from G4UImessenger.

Definition at line 345 of file G4OpticalParametersMessenger.cc.

347{
348 // physics needs to be rebuilt for all commands
349 G4bool physicsModified = true;
350
351 /// Apply command to the associated object.
352 if(command == fActivateProcessCmd)
353 {
354 std::istringstream is(newValue.data());
355 G4String pn;
356 G4String flag;
357 is >> pn >> flag;
358 G4bool value = G4UIcommand::ConvertToBool(flag);
359 params->SetProcessActivation(pn, value);
360 }
361 else if(command == fXRayCmd)
362 {
363 std::istringstream is(newValue.data());
364 G4String lv;
365 G4String sss;
366 is >> lv >> sss;
367 G4XRayModelType type;
368 if (sss == "CerenkovDefault")
369 {
370 type = kCerenkovDefault;
371 }
372 else if (sss == "ScintillationDefault")
373 {
374 type = kScintillationDefault;
375 }
376 else
377 {
378 G4cout << "G4OpticalParametersMessenger::SetNewValue: "
379 << " fail for /process/optical/XRayModel \n"
380 << " type " << sss << " is unknown, no model assigned."
381 << G4endl;
382 return;
383 }
384 params->SetActiveVolume(lv, type);
385 }
386 else if(command == fVerboseCmd)
387 {
388 params->SetVerboseLevel(fVerboseCmd->GetNewIntValue(newValue));
389 }
390 else if(command == fDumpCmd)
391 {
392 params->Dump();
393 }
394 else if(command == fCerenkovMaxPhotonsCmd)
395 {
396 params->SetCerenkovMaxPhotonsPerStep(
397 fCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
398 G4cout << "Cerenkov max photons: " << params->GetCerenkovMaxPhotonsPerStep()
399 << G4endl;
400 }
401 else if(command == fCerenkovMaxBetaChangeCmd)
402 {
403 params->SetCerenkovMaxBetaChange(
404 fCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
405 }
406 else if(command == fCerenkovStackPhotonsCmd)
407 {
408 params->SetCerenkovStackPhotons(
409 fCerenkovStackPhotonsCmd->GetNewBoolValue(newValue));
410 }
411 else if(command == fCerenkovOffloadPhotonsCmd)
412 {
413 params->SetCerenkovOffloadPhotons(
414 fCerenkovOffloadPhotonsCmd->GetNewBoolValue(newValue));
415 }
416 else if(command == fCerenkovTrackSecondariesFirstCmd)
417 {
418 params->SetCerenkovTrackSecondariesFirst(
419 fCerenkovTrackSecondariesFirstCmd->GetNewBoolValue(newValue));
420 }
421 else if(command == fCerenkovVerboseLevelCmd)
422 {
423 params->SetCerenkovVerboseLevel(
424 fCerenkovVerboseLevelCmd->GetNewIntValue(newValue));
425 }
426 else if(command == fScintByParticleTypeCmd)
427 {
428 params->SetScintByParticleType(
429 fScintByParticleTypeCmd->GetNewBoolValue(newValue));
430 }
431 else if(command == fScintTrackInfoCmd)
432 {
433 params->SetScintTrackInfo(fScintTrackInfoCmd->GetNewBoolValue(newValue));
434 }
435 else if(command == fScintFiniteRiseTimeCmd)
436 {
437 params->SetScintFiniteRiseTime(
438 fScintFiniteRiseTimeCmd->GetNewBoolValue(newValue));
439 }
440 else if(command == fScintStackPhotonsCmd)
441 {
442 params->SetScintStackPhotons(
443 fScintStackPhotonsCmd->GetNewBoolValue(newValue));
444 }
445 else if(command == fScintOffloadPhotonsCmd)
446 {
447 params->SetScintOffloadPhotons(
448 fScintOffloadPhotonsCmd->GetNewBoolValue(newValue));
449 }
450 else if(command == fScintTrackSecondariesFirstCmd)
451 {
452 params->SetScintTrackSecondariesFirst(
453 fScintTrackSecondariesFirstCmd->GetNewBoolValue(newValue));
454 }
455 else if(command == fScintVerboseLevelCmd)
456 {
457 params->SetScintVerboseLevel(
458 fScintVerboseLevelCmd->GetNewIntValue(newValue));
459 }
460 else if(command == fWLSTimeProfileCmd)
461 {
462 params->SetWLSTimeProfile(newValue);
463 }
464 else if(command == fWLSVerboseLevelCmd)
465 {
466 params->SetWLSVerboseLevel(fWLSVerboseLevelCmd->GetNewIntValue(newValue));
467 }
468 else if(command == fWLS2TimeProfileCmd)
469 {
470 params->SetWLS2TimeProfile(newValue);
471 }
472 else if(command == fWLS2VerboseLevelCmd)
473 {
474 params->SetWLS2VerboseLevel(fWLS2VerboseLevelCmd->GetNewIntValue(newValue));
475 }
476 else if(command == fAbsorptionVerboseLevelCmd)
477 {
478 params->SetAbsorptionVerboseLevel(
479 fAbsorptionVerboseLevelCmd->GetNewIntValue(newValue));
480 }
481 else if(command == fRayleighVerboseLevelCmd)
482 {
483 params->SetRayleighVerboseLevel(
484 fRayleighVerboseLevelCmd->GetNewIntValue(newValue));
485 }
486 else if(command == fMieVerboseLevelCmd)
487 {
488 params->SetMieVerboseLevel(fMieVerboseLevelCmd->GetNewIntValue(newValue));
489 }
490 else if(command == fBoundaryVerboseLevelCmd)
491 {
492 params->SetBoundaryVerboseLevel(
493 fBoundaryVerboseLevelCmd->GetNewIntValue(newValue));
494 }
495 else if(command == fBoundaryInvokeSDCmd)
496 {
497 params->SetBoundaryInvokeSD(
498 fBoundaryInvokeSDCmd->GetNewBoolValue(newValue));
499 }
500 if(physicsModified)
501 {
502 G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
503 }
504}
kScintillationDefault
@ kScintillationDefault
Definition G4OpticalParameters.hh:80
kCerenkovDefault
@ kCerenkovDefault
Definition G4OpticalParameters.hh:79
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4UIcommand::ConvertToBool
static G4bool ConvertToBool(const char *st)
Definition G4UIcommand.cc:414
G4UImanager::ApplyCommand
G4int ApplyCommand(const char *aCommand)
Definition G4UImanager.cc:448
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition G4UImanager.cc:78
The documentation for this class was generated from the following files: