| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // ------------------------------------------- 26 // -------------------------------------------------------------------
27 // 27 //
28 // GEANT4 Class file 28 // GEANT4 Class file
29 // 29 //
30 // File name: G4EmParametersMessenger 30 // File name: G4EmParametersMessenger
31 // 31 //
32 // Author: Vladimir Ivanchenko created 32 // Author: Vladimir Ivanchenko created from G4EnergyLossMessenger
33 // 33 //
34 // Creation date: 22-05-2013 34 // Creation date: 22-05-2013
35 // 35 //
36 // ------------------------------------------- 36 // -------------------------------------------------------------------
37 // 37 //
38 38
39 //....oooOO0OOooo........oooOO0OOooo........oo 39 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
40 //....oooOO0OOooo........oooOO0OOooo........oo 40 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
41 41
42 #include "G4EmParametersMessenger.hh" 42 #include "G4EmParametersMessenger.hh"
43 #include "G4UIdirectory.hh" 43 #include "G4UIdirectory.hh"
44 #include "G4UIcommand.hh" 44 #include "G4UIcommand.hh"
45 #include "G4UIparameter.hh" 45 #include "G4UIparameter.hh"
46 #include "G4UIcmdWithABool.hh" 46 #include "G4UIcmdWithABool.hh"
47 #include "G4UIcmdWithAnInteger.hh" 47 #include "G4UIcmdWithAnInteger.hh"
48 #include "G4UIcmdWithADouble.hh" 48 #include "G4UIcmdWithADouble.hh"
49 #include "G4UIcmdWithADoubleAndUnit.hh" 49 #include "G4UIcmdWithADoubleAndUnit.hh"
50 #include "G4UIcmdWithAString.hh" 50 #include "G4UIcmdWithAString.hh"
51 #include "G4UIcmdWith3VectorAndUnit.hh" 51 #include "G4UIcmdWith3VectorAndUnit.hh"
52 #include "G4UImanager.hh" 52 #include "G4UImanager.hh"
53 #include "G4MscStepLimitType.hh" 53 #include "G4MscStepLimitType.hh"
54 #include "G4NuclearFormfactorType.hh" 54 #include "G4NuclearFormfactorType.hh"
55 #include "G4EmParameters.hh" 55 #include "G4EmParameters.hh"
56 56
57 #include <sstream> 57 #include <sstream>
58 58
59 //....oooOO0OOooo........oooOO0OOooo........oo 59 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
60 60
61 G4EmParametersMessenger::G4EmParametersMesseng 61 G4EmParametersMessenger::G4EmParametersMessenger(G4EmParameters* ptr)
62 : theParameters(ptr) 62 : theParameters(ptr)
63 { 63 {
64 emDirectory = new G4UIdirectory("/process/em 64 emDirectory = new G4UIdirectory("/process/em/", false);
65 emDirectory->SetGuidance("General commands f 65 emDirectory->SetGuidance("General commands for EM processes.");
66 eLossDirectory = new G4UIdirectory("/process 66 eLossDirectory = new G4UIdirectory("/process/eLoss/", false);
67 eLossDirectory->SetGuidance("Commands for en 67 eLossDirectory->SetGuidance("Commands for energy loss processes.");
68 mscDirectory = new G4UIdirectory("/process/m 68 mscDirectory = new G4UIdirectory("/process/msc/", false);
69 mscDirectory->SetGuidance("Commands for EM s 69 mscDirectory->SetGuidance("Commands for EM scattering processes.");
70 gconvDirectory = new G4UIdirectory("/process 70 gconvDirectory = new G4UIdirectory("/process/gconv/", false);
71 gconvDirectory->SetGuidance("Commands for EM 71 gconvDirectory->SetGuidance("Commands for EM gamma conversion BH5D model.");
72 dnaDirectory = new G4UIdirectory("/process/d 72 dnaDirectory = new G4UIdirectory("/process/dna/", false);
73 dnaDirectory->SetGuidance("Commands for DNA 73 dnaDirectory->SetGuidance("Commands for DNA processes.");
74 74
75 flucCmd = new G4UIcmdWithABool("/process/eLo 75 flucCmd = new G4UIcmdWithABool("/process/eLoss/fluct",this);
76 flucCmd->SetGuidance("Enable/disable energy 76 flucCmd->SetGuidance("Enable/disable energy loss fluctuations.");
77 flucCmd->SetParameterName("choice",true); 77 flucCmd->SetParameterName("choice",true);
78 flucCmd->SetDefaultValue(true); 78 flucCmd->SetDefaultValue(true);
79 flucCmd->AvailableForStates(G4State_PreInit, 79 flucCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
80 flucCmd->SetToBeBroadcasted(false); 80 flucCmd->SetToBeBroadcasted(false);
81 81
82 rangeCmd = new G4UIcmdWithABool("/process/eL 82 rangeCmd = new G4UIcmdWithABool("/process/eLoss/CSDARange",this);
83 rangeCmd->SetGuidance("Enable/disable CSDA r 83 rangeCmd->SetGuidance("Enable/disable CSDA range calculation");
84 rangeCmd->SetParameterName("range",true); 84 rangeCmd->SetParameterName("range",true);
85 rangeCmd->SetDefaultValue(false); 85 rangeCmd->SetDefaultValue(false);
86 rangeCmd->AvailableForStates(G4State_PreInit 86 rangeCmd->AvailableForStates(G4State_PreInit);
87 rangeCmd->SetToBeBroadcasted(false); 87 rangeCmd->SetToBeBroadcasted(false);
88 88
89 lpmCmd = new G4UIcmdWithABool("/process/eLos 89 lpmCmd = new G4UIcmdWithABool("/process/eLoss/LPM",this);
90 lpmCmd->SetGuidance("Enable/disable LPM effe 90 lpmCmd->SetGuidance("Enable/disable LPM effect calculation");
91 lpmCmd->SetParameterName("lpm",true); 91 lpmCmd->SetParameterName("lpm",true);
92 lpmCmd->SetDefaultValue(true); 92 lpmCmd->SetDefaultValue(true);
93 lpmCmd->AvailableForStates(G4State_PreInit,G 93 lpmCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
94 lpmCmd->SetToBeBroadcasted(false); 94 lpmCmd->SetToBeBroadcasted(false);
95 95
96 rsCmd = new G4UIcmdWithABool("/process/eLoss 96 rsCmd = new G4UIcmdWithABool("/process/eLoss/useCutAsFinalRange",this);
97 rsCmd->SetGuidance("Enable/disable use of cu 97 rsCmd->SetGuidance("Enable/disable use of cut in range as a final range");
98 rsCmd->SetParameterName("choice",true); 98 rsCmd->SetParameterName("choice",true);
99 rsCmd->SetDefaultValue(false); 99 rsCmd->SetDefaultValue(false);
100 rsCmd->AvailableForStates(G4State_PreInit,G4 100 rsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
101 rsCmd->SetToBeBroadcasted(false); 101 rsCmd->SetToBeBroadcasted(false);
102 102
103 aplCmd = new G4UIcmdWithABool("/process/em/a 103 aplCmd = new G4UIcmdWithABool("/process/em/applyCuts",this);
104 aplCmd->SetGuidance("Enable/disable applying 104 aplCmd->SetGuidance("Enable/disable applying cuts for gamma processes");
105 aplCmd->SetParameterName("apl",true); 105 aplCmd->SetParameterName("apl",true);
106 aplCmd->SetDefaultValue(false); 106 aplCmd->SetDefaultValue(false);
107 aplCmd->AvailableForStates(G4State_PreInit,G 107 aplCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
108 aplCmd->SetToBeBroadcasted(false); 108 aplCmd->SetToBeBroadcasted(false);
109 109
110 intCmd = new G4UIcmdWithABool("/process/em/i 110 intCmd = new G4UIcmdWithABool("/process/em/integral",this);
111 intCmd->SetGuidance("Enable/disable integral 111 intCmd->SetGuidance("Enable/disable integral method.");
112 intCmd->SetParameterName("choice",true); 112 intCmd->SetParameterName("choice",true);
113 intCmd->SetDefaultValue(true); 113 intCmd->SetDefaultValue(true);
114 intCmd->AvailableForStates(G4State_PreInit); 114 intCmd->AvailableForStates(G4State_PreInit);
115 intCmd->SetToBeBroadcasted(false); 115 intCmd->SetToBeBroadcasted(false);
116 116
117 latCmd = new G4UIcmdWithABool("/process/msc/ 117 latCmd = new G4UIcmdWithABool("/process/msc/LateralDisplacement",this);
118 latCmd->SetGuidance("Enable/disable sampling 118 latCmd->SetGuidance("Enable/disable sampling of lateral displacement");
119 latCmd->SetParameterName("lat",true); 119 latCmd->SetParameterName("lat",true);
120 latCmd->SetDefaultValue(true); 120 latCmd->SetDefaultValue(true);
121 latCmd->AvailableForStates(G4State_PreInit,G 121 latCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
122 latCmd->SetToBeBroadcasted(false); 122 latCmd->SetToBeBroadcasted(false);
123 123
124 lat96Cmd = new G4UIcmdWithABool("/process/ms 124 lat96Cmd = new G4UIcmdWithABool("/process/msc/LateralDisplacementAlg96",this);
125 lat96Cmd->SetGuidance("Enable/disable sampli 125 lat96Cmd->SetGuidance("Enable/disable sampling of lateral displacement");
126 lat96Cmd->SetParameterName("lat96",true); 126 lat96Cmd->SetParameterName("lat96",true);
127 lat96Cmd->SetDefaultValue(false); 127 lat96Cmd->SetDefaultValue(false);
128 lat96Cmd->AvailableForStates(G4State_PreInit 128 lat96Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
129 lat96Cmd->SetToBeBroadcasted(false); 129 lat96Cmd->SetToBeBroadcasted(false);
130 130
131 mulatCmd = new G4UIcmdWithABool("/process/ms 131 mulatCmd = new G4UIcmdWithABool("/process/msc/MuHadLateralDisplacement",this);
132 mulatCmd->SetGuidance("Enable/disable sampli 132 mulatCmd->SetGuidance("Enable/disable sampling of lateral displacement for muons and hadrons");
133 mulatCmd->SetParameterName("mulat",true); 133 mulatCmd->SetParameterName("mulat",true);
134 mulatCmd->SetDefaultValue(true); 134 mulatCmd->SetDefaultValue(true);
135 mulatCmd->AvailableForStates(G4State_PreInit 135 mulatCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
136 mulatCmd->SetToBeBroadcasted(false); 136 mulatCmd->SetToBeBroadcasted(false);
137 137
138 delCmd = new G4UIcmdWithABool("/process/eLos 138 delCmd = new G4UIcmdWithABool("/process/eLoss/UseAngularGenerator",this);
139 delCmd->SetGuidance("Enable usage of angular 139 delCmd->SetGuidance("Enable usage of angular generator for ionisation");
140 delCmd->SetParameterName("del",true); 140 delCmd->SetParameterName("del",true);
141 delCmd->SetDefaultValue(false); 141 delCmd->SetDefaultValue(false);
142 delCmd->AvailableForStates(G4State_PreInit); 142 delCmd->AvailableForStates(G4State_PreInit);
143 delCmd->SetToBeBroadcasted(false); 143 delCmd->SetToBeBroadcasted(false);
144 144
145 mottCmd = new G4UIcmdWithABool("/process/msc 145 mottCmd = new G4UIcmdWithABool("/process/msc/UseMottCorrection",this);
146 mottCmd->SetGuidance("Enable usage of Mott c 146 mottCmd->SetGuidance("Enable usage of Mott corrections for e- elastic scattering");
147 mottCmd->SetParameterName("mott",true); 147 mottCmd->SetParameterName("mott",true);
148 mottCmd->SetDefaultValue(false); 148 mottCmd->SetDefaultValue(false);
149 mottCmd->AvailableForStates(G4State_PreInit) 149 mottCmd->AvailableForStates(G4State_PreInit);
150 mottCmd->SetToBeBroadcasted(false); 150 mottCmd->SetToBeBroadcasted(false);
151 151
152 birksCmd = new G4UIcmdWithABool("/process/em 152 birksCmd = new G4UIcmdWithABool("/process/em/UseG4EmSaturation",this);
153 birksCmd->SetGuidance("Enable usage of built 153 birksCmd->SetGuidance("Enable usage of built-in Birks saturation");
154 birksCmd->SetParameterName("birks",true); 154 birksCmd->SetParameterName("birks",true);
155 birksCmd->SetDefaultValue(false); 155 birksCmd->SetDefaultValue(false);
156 birksCmd->AvailableForStates(G4State_PreInit 156 birksCmd->AvailableForStates(G4State_PreInit,G4State_Init);
157 birksCmd->SetToBeBroadcasted(false); 157 birksCmd->SetToBeBroadcasted(false);
158 158
159 sharkCmd = new G4UIcmdWithABool("/process/em 159 sharkCmd = new G4UIcmdWithABool("/process/em/UseGeneralProcess",this);
160 sharkCmd->SetGuidance("Enable gamma, e+- gen 160 sharkCmd->SetGuidance("Enable gamma, e+- general process");
161 sharkCmd->SetParameterName("gen",true); 161 sharkCmd->SetParameterName("gen",true);
162 sharkCmd->SetDefaultValue(false); 162 sharkCmd->SetDefaultValue(false);
163 sharkCmd->AvailableForStates(G4State_PreInit 163 sharkCmd->AvailableForStates(G4State_PreInit);
164 sharkCmd->SetToBeBroadcasted(false); 164 sharkCmd->SetToBeBroadcasted(false);
165 165
166 poCmd = new G4UIcmdWithABool("/process/em/Po 166 poCmd = new G4UIcmdWithABool("/process/em/Polarisation",this);
167 poCmd->SetGuidance("Enable polarisation"); 167 poCmd->SetGuidance("Enable polarisation");
168 poCmd->AvailableForStates(G4State_PreInit); 168 poCmd->AvailableForStates(G4State_PreInit);
169 poCmd->SetToBeBroadcasted(false); 169 poCmd->SetToBeBroadcasted(false);
170 170
171 sampleTCmd = new G4UIcmdWithABool("/process/ 171 sampleTCmd = new G4UIcmdWithABool("/process/em/enableSamplingTable",this);
172 sampleTCmd->SetGuidance("Enable usage of sam 172 sampleTCmd->SetGuidance("Enable usage of sampling table for secondary generation");
173 sampleTCmd->SetParameterName("sampleT",true) 173 sampleTCmd->SetParameterName("sampleT",true);
174 sampleTCmd->SetDefaultValue(false); 174 sampleTCmd->SetDefaultValue(false);
175 sampleTCmd->AvailableForStates(G4State_PreIn 175 sampleTCmd->AvailableForStates(G4State_PreInit);
176 sampleTCmd->SetToBeBroadcasted(false); 176 sampleTCmd->SetToBeBroadcasted(false);
177 177
178 icru90Cmd = new G4UIcmdWithABool("/process/e 178 icru90Cmd = new G4UIcmdWithABool("/process/eLoss/UseICRU90",this);
179 icru90Cmd->SetGuidance("Enable usage of ICRU 179 icru90Cmd->SetGuidance("Enable usage of ICRU90 stopping powers");
180 icru90Cmd->SetParameterName("icru90",true); 180 icru90Cmd->SetParameterName("icru90",true);
181 icru90Cmd->SetDefaultValue(false); 181 icru90Cmd->SetDefaultValue(false);
182 icru90Cmd->AvailableForStates(G4State_PreIni 182 icru90Cmd->AvailableForStates(G4State_PreInit);
183 icru90Cmd->SetToBeBroadcasted(false); 183 icru90Cmd->SetToBeBroadcasted(false);
184 184
185 mudatCmd = new G4UIcmdWithABool("/process/em 185 mudatCmd = new G4UIcmdWithABool("/process/em/MuDataFromFile",this);
186 mudatCmd->SetGuidance("Enable usage of muon 186 mudatCmd->SetGuidance("Enable usage of muon data from file");
187 mudatCmd->SetParameterName("mudat",true); 187 mudatCmd->SetParameterName("mudat",true);
188 mudatCmd->SetDefaultValue(false); 188 mudatCmd->SetDefaultValue(false);
189 mudatCmd->AvailableForStates(G4State_PreInit 189 mudatCmd->AvailableForStates(G4State_PreInit);
190 mudatCmd->SetToBeBroadcasted(false); 190 mudatCmd->SetToBeBroadcasted(false);
191 191
192 peKCmd = new G4UIcmdWithABool("/process/em/P 192 peKCmd = new G4UIcmdWithABool("/process/em/PhotoeffectBelowKShell",this);
193 peKCmd->SetGuidance("Enable sampling of phot 193 peKCmd->SetGuidance("Enable sampling of photoeffect below K-shell");
194 peKCmd->SetParameterName("peK",true); 194 peKCmd->SetParameterName("peK",true);
195 peKCmd->SetDefaultValue(true); 195 peKCmd->SetDefaultValue(true);
196 peKCmd->AvailableForStates(G4State_PreInit); 196 peKCmd->AvailableForStates(G4State_PreInit);
197 peKCmd->SetToBeBroadcasted(false); 197 peKCmd->SetToBeBroadcasted(false);
198 198
199 mscPCmd = new G4UIcmdWithABool("/process/msc 199 mscPCmd = new G4UIcmdWithABool("/process/msc/PositronCorrection",this);
200 mscPCmd->SetGuidance("Enable msc positron co 200 mscPCmd->SetGuidance("Enable msc positron correction");
201 mscPCmd->SetParameterName("mscPC",true); 201 mscPCmd->SetParameterName("mscPC",true);
202 mscPCmd->SetDefaultValue(true); 202 mscPCmd->SetDefaultValue(true);
203 mscPCmd->AvailableForStates(G4State_PreInit, 203 mscPCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
204 mscPCmd->SetToBeBroadcasted(false); 204 mscPCmd->SetToBeBroadcasted(false);
205 205
206 pepicsCmd = new G4UIcmdWithABool("/process/e <<
207 pepicsCmd->SetGuidance("Use EPICS2017 data f <<
208 pepicsCmd->SetParameterName("pepics",true); <<
209 pepicsCmd->SetDefaultValue(false); <<
210 pepicsCmd->AvailableForStates(G4State_PreIni <<
211 pepicsCmd->SetToBeBroadcasted(false); <<
212 <<
213 f3gCmd = new G4UIcmdWithABool("/process/em/3 <<
214 f3gCmd->SetGuidance("Enable/disable 3 gamma <<
215 f3gCmd->SetParameterName("f3gamma",true); <<
216 f3gCmd->SetDefaultValue(false); <<
217 f3gCmd->AvailableForStates(G4State_PreInit); <<
218 f3gCmd->SetToBeBroadcasted(false); <<
219 <<
220 minEnCmd = new G4UIcmdWithADoubleAndUnit("/p 206 minEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/minKinEnergy",this);
221 minEnCmd->SetGuidance("Set the min kinetic e 207 minEnCmd->SetGuidance("Set the min kinetic energy for EM tables");
222 minEnCmd->SetParameterName("emin",true); 208 minEnCmd->SetParameterName("emin",true);
223 minEnCmd->SetUnitCategory("Energy"); 209 minEnCmd->SetUnitCategory("Energy");
224 minEnCmd->AvailableForStates(G4State_PreInit 210 minEnCmd->AvailableForStates(G4State_PreInit);
225 minEnCmd->SetToBeBroadcasted(false); 211 minEnCmd->SetToBeBroadcasted(false);
226 212
227 maxEnCmd = new G4UIcmdWithADoubleAndUnit("/p 213 maxEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergy",this);
228 maxEnCmd->SetGuidance("Set the max kinetic e 214 maxEnCmd->SetGuidance("Set the max kinetic energy for EM tables");
229 maxEnCmd->SetParameterName("emax",true); 215 maxEnCmd->SetParameterName("emax",true);
230 maxEnCmd->SetUnitCategory("Energy"); 216 maxEnCmd->SetUnitCategory("Energy");
231 maxEnCmd->AvailableForStates(G4State_PreInit 217 maxEnCmd->AvailableForStates(G4State_PreInit);
232 maxEnCmd->SetToBeBroadcasted(false); 218 maxEnCmd->SetToBeBroadcasted(false);
233 219
234 cenCmd = new G4UIcmdWithADoubleAndUnit("/pro 220 cenCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergyCSDA",this);
235 cenCmd->SetGuidance("Set the max kinetic ene 221 cenCmd->SetGuidance("Set the max kinetic energy for CSDA table");
236 cenCmd->SetParameterName("emaxCSDA",true); 222 cenCmd->SetParameterName("emaxCSDA",true);
237 cenCmd->SetUnitCategory("Energy"); 223 cenCmd->SetUnitCategory("Energy");
238 cenCmd->AvailableForStates(G4State_PreInit); 224 cenCmd->AvailableForStates(G4State_PreInit);
239 cenCmd->SetToBeBroadcasted(false); 225 cenCmd->SetToBeBroadcasted(false);
240 226
241 max5DCmd = new G4UIcmdWithADoubleAndUnit("/p 227 max5DCmd = new G4UIcmdWithADoubleAndUnit("/process/em/max5DMuPairEnergy",this);
242 max5DCmd->SetGuidance("Set the max kinetic e 228 max5DCmd->SetGuidance("Set the max kinetic energy for 5D muon pair production");
243 max5DCmd->SetParameterName("emax5D",true); 229 max5DCmd->SetParameterName("emax5D",true);
244 max5DCmd->SetUnitCategory("Energy"); 230 max5DCmd->SetUnitCategory("Energy");
245 max5DCmd->AvailableForStates(G4State_PreInit 231 max5DCmd->AvailableForStates(G4State_PreInit);
246 max5DCmd->SetToBeBroadcasted(false); 232 max5DCmd->SetToBeBroadcasted(false);
247 233
248 lowEnCmd = new G4UIcmdWithADoubleAndUnit("/p 234 lowEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestElectronEnergy",this);
249 lowEnCmd->SetGuidance("Set the lowest kineti 235 lowEnCmd->SetGuidance("Set the lowest kinetic energy for e+-");
250 lowEnCmd->SetParameterName("elow",true); 236 lowEnCmd->SetParameterName("elow",true);
251 lowEnCmd->SetUnitCategory("Energy"); 237 lowEnCmd->SetUnitCategory("Energy");
252 lowEnCmd->AvailableForStates(G4State_PreInit 238 lowEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
253 lowEnCmd->SetToBeBroadcasted(false); 239 lowEnCmd->SetToBeBroadcasted(false);
254 240
255 lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/ 241 lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestMuHadEnergy",this);
256 lowhEnCmd->SetGuidance("Set the lowest kinet 242 lowhEnCmd->SetGuidance("Set the lowest kinetic energy for muons and hadrons");
257 lowhEnCmd->SetParameterName("elowh",true); 243 lowhEnCmd->SetParameterName("elowh",true);
258 lowhEnCmd->SetUnitCategory("Energy"); 244 lowhEnCmd->SetUnitCategory("Energy");
259 lowhEnCmd->AvailableForStates(G4State_PreIni 245 lowhEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
260 lowhEnCmd->SetToBeBroadcasted(false); 246 lowhEnCmd->SetToBeBroadcasted(false);
261 247
262 lowEn3Cmd = new G4UIcmdWithADoubleAndUnit("/ 248 lowEn3Cmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestTripletEnergy",this);
263 lowEn3Cmd->SetGuidance("Set the lowest kinet 249 lowEn3Cmd->SetGuidance("Set the lowest kinetic energy for triplet production");
264 lowEn3Cmd->SetParameterName("elow3",true); 250 lowEn3Cmd->SetParameterName("elow3",true);
265 lowEn3Cmd->SetUnitCategory("Energy"); 251 lowEn3Cmd->SetUnitCategory("Energy");
266 lowEn3Cmd->AvailableForStates(G4State_PreIni 252 lowEn3Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
267 lowEn3Cmd->SetToBeBroadcasted(false); 253 lowEn3Cmd->SetToBeBroadcasted(false);
268 254
269 lllCmd = new G4UIcmdWithADouble("/process/eL 255 lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this);
270 lllCmd->SetGuidance("Set linearLossLimit par 256 lllCmd->SetGuidance("Set linearLossLimit parameter");
271 lllCmd->SetParameterName("linlim",true); 257 lllCmd->SetParameterName("linlim",true);
272 lllCmd->AvailableForStates(G4State_PreInit,G 258 lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
273 lllCmd->SetToBeBroadcasted(false); 259 lllCmd->SetToBeBroadcasted(false);
274 260
275 brCmd = new G4UIcmdWithADoubleAndUnit("/proc 261 brCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremThreshold",this);
276 brCmd->SetGuidance("Set e+- bremsstrahlung e 262 brCmd->SetGuidance("Set e+- bremsstrahlung energy threshold");
277 brCmd->SetParameterName("emaxBrem",true); 263 brCmd->SetParameterName("emaxBrem",true);
278 brCmd->SetUnitCategory("Energy"); 264 brCmd->SetUnitCategory("Energy");
279 brCmd->AvailableForStates(G4State_PreInit); 265 brCmd->AvailableForStates(G4State_PreInit);
280 brCmd->SetToBeBroadcasted(false); 266 brCmd->SetToBeBroadcasted(false);
281 267
282 br1Cmd = new G4UIcmdWithADoubleAndUnit("/pro 268 br1Cmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremMuHadThreshold",this);
283 br1Cmd->SetGuidance("Set muon/hadron bremsst 269 br1Cmd->SetGuidance("Set muon/hadron bremsstrahlung energy threshold");
284 br1Cmd->SetParameterName("emaxMuHadBrem",tru 270 br1Cmd->SetParameterName("emaxMuHadBrem",true);
285 br1Cmd->SetUnitCategory("Energy"); 271 br1Cmd->SetUnitCategory("Energy");
286 br1Cmd->AvailableForStates(G4State_PreInit); 272 br1Cmd->AvailableForStates(G4State_PreInit);
287 br1Cmd->SetToBeBroadcasted(false); 273 br1Cmd->SetToBeBroadcasted(false);
288 274
289 labCmd = new G4UIcmdWithADouble("/process/eL 275 labCmd = new G4UIcmdWithADouble("/process/eLoss/LambdaFactor",this);
290 labCmd->SetGuidance("Set lambdaFactor parame 276 labCmd->SetGuidance("Set lambdaFactor parameter for integral option");
291 labCmd->SetParameterName("Fl",true); 277 labCmd->SetParameterName("Fl",true);
292 labCmd->AvailableForStates(G4State_PreInit,G 278 labCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
293 labCmd->SetToBeBroadcasted(false); 279 labCmd->SetToBeBroadcasted(false);
294 280
295 mscfCmd = new G4UIcmdWithADouble("/process/m 281 mscfCmd = new G4UIcmdWithADouble("/process/msc/FactorForAngleLimit",this);
296 mscfCmd->SetGuidance("Set factor for computa 282 mscfCmd->SetGuidance("Set factor for computation of a limit for -t (invariant transfer)");
297 mscfCmd->SetParameterName("Fact",true); 283 mscfCmd->SetParameterName("Fact",true);
298 mscfCmd->SetRange("Fact>0"); 284 mscfCmd->SetRange("Fact>0");
299 mscfCmd->SetDefaultValue(1.); 285 mscfCmd->SetDefaultValue(1.);
300 mscfCmd->AvailableForStates(G4State_PreInit) 286 mscfCmd->AvailableForStates(G4State_PreInit);
301 mscfCmd->SetToBeBroadcasted(false); 287 mscfCmd->SetToBeBroadcasted(false);
302 288
303 angCmd = new G4UIcmdWithADoubleAndUnit("/pro 289 angCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/ThetaLimit",this);
304 angCmd->SetGuidance("Set the limit on the po 290 angCmd->SetGuidance("Set the limit on the polar angle for msc and single scattering");
305 angCmd->SetParameterName("theta",true); 291 angCmd->SetParameterName("theta",true);
306 angCmd->SetUnitCategory("Angle"); 292 angCmd->SetUnitCategory("Angle");
307 angCmd->AvailableForStates(G4State_PreInit); 293 angCmd->AvailableForStates(G4State_PreInit);
308 angCmd->SetToBeBroadcasted(false); 294 angCmd->SetToBeBroadcasted(false);
309 295
310 msceCmd = new G4UIcmdWithADoubleAndUnit("/pr 296 msceCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/EnergyLimit",this);
311 msceCmd->SetGuidance("Set the upper energy l 297 msceCmd->SetGuidance("Set the upper energy limit for msc");
312 msceCmd->SetParameterName("mscE",true); 298 msceCmd->SetParameterName("mscE",true);
313 msceCmd->SetUnitCategory("Energy"); 299 msceCmd->SetUnitCategory("Energy");
314 msceCmd->AvailableForStates(G4State_PreInit) 300 msceCmd->AvailableForStates(G4State_PreInit);
315 msceCmd->SetToBeBroadcasted(false); 301 msceCmd->SetToBeBroadcasted(false);
316 302
317 nielCmd = new G4UIcmdWithADoubleAndUnit("/pr 303 nielCmd = new G4UIcmdWithADoubleAndUnit("/process/em/MaxEnergyNIEL",this);
318 nielCmd->SetGuidance("Set the upper energy l 304 nielCmd->SetGuidance("Set the upper energy limit for NIEL");
319 nielCmd->SetParameterName("niel",true); 305 nielCmd->SetParameterName("niel",true);
320 nielCmd->SetUnitCategory("Energy"); 306 nielCmd->SetUnitCategory("Energy");
321 nielCmd->AvailableForStates(G4State_PreInit) 307 nielCmd->AvailableForStates(G4State_PreInit);
322 nielCmd->SetToBeBroadcasted(false); 308 nielCmd->SetToBeBroadcasted(false);
323 309
324 frCmd = new G4UIcmdWithADouble("/process/msc 310 frCmd = new G4UIcmdWithADouble("/process/msc/RangeFactor",this);
325 frCmd->SetGuidance("Set RangeFactor for msc 311 frCmd->SetGuidance("Set RangeFactor for msc processes of e+-");
326 frCmd->SetParameterName("Fr",true); 312 frCmd->SetParameterName("Fr",true);
327 frCmd->SetRange("Fr>0"); 313 frCmd->SetRange("Fr>0");
328 frCmd->SetDefaultValue(0.04); 314 frCmd->SetDefaultValue(0.04);
329 frCmd->AvailableForStates(G4State_PreInit,G4 315 frCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
330 frCmd->SetToBeBroadcasted(false); 316 frCmd->SetToBeBroadcasted(false);
331 317
332 fr1Cmd = new G4UIcmdWithADouble("/process/ms 318 fr1Cmd = new G4UIcmdWithADouble("/process/msc/RangeFactorMuHad",this);
333 fr1Cmd->SetGuidance("Set RangeFactor for msc 319 fr1Cmd->SetGuidance("Set RangeFactor for msc processes of muons/hadrons");
334 fr1Cmd->SetParameterName("Fr1",true); 320 fr1Cmd->SetParameterName("Fr1",true);
335 fr1Cmd->SetRange("Fr1>0"); 321 fr1Cmd->SetRange("Fr1>0");
336 fr1Cmd->SetDefaultValue(0.2); 322 fr1Cmd->SetDefaultValue(0.2);
337 fr1Cmd->AvailableForStates(G4State_PreInit,G 323 fr1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
338 fr1Cmd->SetToBeBroadcasted(false); 324 fr1Cmd->SetToBeBroadcasted(false);
339 325
340 fgCmd = new G4UIcmdWithADouble("/process/msc 326 fgCmd = new G4UIcmdWithADouble("/process/msc/GeomFactor",this);
341 fgCmd->SetGuidance("Set GeomFactor parameter 327 fgCmd->SetGuidance("Set GeomFactor parameter for msc processes");
342 fgCmd->SetParameterName("Fg",true); 328 fgCmd->SetParameterName("Fg",true);
343 fgCmd->SetRange("Fg>0"); 329 fgCmd->SetRange("Fg>0");
344 fgCmd->SetDefaultValue(2.5); 330 fgCmd->SetDefaultValue(2.5);
345 fgCmd->AvailableForStates(G4State_PreInit,G4 331 fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
346 fgCmd->SetToBeBroadcasted(false); 332 fgCmd->SetToBeBroadcasted(false);
347 333
348 skinCmd = new G4UIcmdWithADouble("/process/m 334 skinCmd = new G4UIcmdWithADouble("/process/msc/Skin",this);
349 skinCmd->SetGuidance("Set skin parameter for 335 skinCmd->SetGuidance("Set skin parameter for msc processes");
350 skinCmd->SetParameterName("skin",true); 336 skinCmd->SetParameterName("skin",true);
351 skinCmd->AvailableForStates(G4State_PreInit, 337 skinCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
352 skinCmd->SetToBeBroadcasted(false); 338 skinCmd->SetToBeBroadcasted(false);
353 339
354 screCmd = new G4UIcmdWithADouble("/process/m 340 screCmd = new G4UIcmdWithADouble("/process/msc/ScreeningFactor",this);
355 screCmd->SetGuidance("Set screening factor") 341 screCmd->SetGuidance("Set screening factor");
356 screCmd->SetParameterName("screen",true); 342 screCmd->SetParameterName("screen",true);
357 screCmd->AvailableForStates(G4State_PreInit) 343 screCmd->AvailableForStates(G4State_PreInit);
358 screCmd->SetToBeBroadcasted(false); 344 screCmd->SetToBeBroadcasted(false);
359 345
360 safCmd = new G4UIcmdWithADouble("/process/ms 346 safCmd = new G4UIcmdWithADouble("/process/msc/SafetyFactor",this);
361 safCmd->SetGuidance("Set safety factor"); 347 safCmd->SetGuidance("Set safety factor");
362 safCmd->SetParameterName("fsafe",true); 348 safCmd->SetParameterName("fsafe",true);
363 safCmd->AvailableForStates(G4State_PreInit); 349 safCmd->AvailableForStates(G4State_PreInit);
364 safCmd->SetToBeBroadcasted(false); 350 safCmd->SetToBeBroadcasted(false);
365 351
366 llimCmd = new G4UIcmdWithADoubleAndUnit("/pr 352 llimCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/LambdaLimit",this);
367 llimCmd->SetGuidance("Set the upper energy l 353 llimCmd->SetGuidance("Set the upper energy limit for NIEL");
368 llimCmd->SetParameterName("ll",true); 354 llimCmd->SetParameterName("ll",true);
369 llimCmd->SetUnitCategory("Length"); 355 llimCmd->SetUnitCategory("Length");
370 llimCmd->AvailableForStates(G4State_PreInit) 356 llimCmd->AvailableForStates(G4State_PreInit);
371 llimCmd->SetToBeBroadcasted(false); 357 llimCmd->SetToBeBroadcasted(false);
372 358
373 amCmd = new G4UIcmdWithAnInteger("/process/e 359 amCmd = new G4UIcmdWithAnInteger("/process/em/binsPerDecade",this);
374 amCmd->SetGuidance("Set number of bins per d 360 amCmd->SetGuidance("Set number of bins per decade for EM tables");
375 amCmd->SetParameterName("bins",true); 361 amCmd->SetParameterName("bins",true);
376 amCmd->SetDefaultValue(7); 362 amCmd->SetDefaultValue(7);
377 amCmd->AvailableForStates(G4State_PreInit); 363 amCmd->AvailableForStates(G4State_PreInit);
378 amCmd->SetToBeBroadcasted(false); 364 amCmd->SetToBeBroadcasted(false);
379 365
380 verCmd = new G4UIcmdWithAnInteger("/process/ 366 verCmd = new G4UIcmdWithAnInteger("/process/eLoss/verbose",this);
381 verCmd->SetGuidance("Set verbose level for E 367 verCmd->SetGuidance("Set verbose level for EM physics");
382 verCmd->SetParameterName("verb",true); 368 verCmd->SetParameterName("verb",true);
383 verCmd->SetDefaultValue(1); 369 verCmd->SetDefaultValue(1);
384 verCmd->AvailableForStates(G4State_PreInit,G 370 verCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
385 verCmd->SetToBeBroadcasted(false); 371 verCmd->SetToBeBroadcasted(false);
386 372
387 ver1Cmd = new G4UIcmdWithAnInteger("/process 373 ver1Cmd = new G4UIcmdWithAnInteger("/process/em/verbose",this);
388 ver1Cmd->SetGuidance("Set verbose level for 374 ver1Cmd->SetGuidance("Set verbose level for EM physics");
389 ver1Cmd->SetParameterName("verb1",true); 375 ver1Cmd->SetParameterName("verb1",true);
390 ver1Cmd->SetDefaultValue(1); 376 ver1Cmd->SetDefaultValue(1);
391 ver1Cmd->AvailableForStates(G4State_PreInit, 377 ver1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
392 ver1Cmd->SetToBeBroadcasted(false); 378 ver1Cmd->SetToBeBroadcasted(false);
393 379
394 ver2Cmd = new G4UIcmdWithAnInteger("/process 380 ver2Cmd = new G4UIcmdWithAnInteger("/process/em/workerVerbose",this);
395 ver2Cmd->SetGuidance("Set worker verbose lev 381 ver2Cmd->SetGuidance("Set worker verbose level for EM physics");
396 ver2Cmd->SetParameterName("verb2",true); 382 ver2Cmd->SetParameterName("verb2",true);
397 ver2Cmd->SetDefaultValue(0); 383 ver2Cmd->SetDefaultValue(0);
398 ver2Cmd->AvailableForStates(G4State_PreInit, 384 ver2Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
399 ver2Cmd->SetToBeBroadcasted(false); 385 ver2Cmd->SetToBeBroadcasted(false);
400 386
401 nFreeCmd = new G4UIcmdWithAnInteger("/proces <<
402 nFreeCmd->SetGuidance("Set number for logari <<
403 nFreeCmd->SetParameterName("nFree",true); <<
404 nFreeCmd->SetDefaultValue(2); <<
405 nFreeCmd->AvailableForStates(G4State_PreInit <<
406 nFreeCmd->SetToBeBroadcasted(false); <<
407 <<
408 transWithMscCmd = new G4UIcmdWithAString("/p 387 transWithMscCmd = new G4UIcmdWithAString("/process/em/transportationWithMsc",this);
409 transWithMscCmd->SetGuidance("Enable/disable 388 transWithMscCmd->SetGuidance("Enable/disable the G4TransportationWithMsc process");
410 transWithMscCmd->SetParameterName("trans",tr 389 transWithMscCmd->SetParameterName("trans",true);
411 transWithMscCmd->SetCandidates("Disabled Ena 390 transWithMscCmd->SetCandidates("Disabled Enabled MultipleSteps");
412 transWithMscCmd->AvailableForStates(G4State_ 391 transWithMscCmd->AvailableForStates(G4State_PreInit);
413 transWithMscCmd->SetToBeBroadcasted(false); 392 transWithMscCmd->SetToBeBroadcasted(false);
414 393
415 mscCmd = new G4UIcmdWithAString("/process/ms 394 mscCmd = new G4UIcmdWithAString("/process/msc/StepLimit",this);
416 mscCmd->SetGuidance("Set msc step limitation 395 mscCmd->SetGuidance("Set msc step limitation type");
417 mscCmd->SetParameterName("StepLim",true); 396 mscCmd->SetParameterName("StepLim",true);
418 mscCmd->SetCandidates("Minimal UseSafety Use 397 mscCmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary");
419 mscCmd->AvailableForStates(G4State_PreInit,G 398 mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
420 mscCmd->SetToBeBroadcasted(false); 399 mscCmd->SetToBeBroadcasted(false);
421 400
422 msc1Cmd = new G4UIcmdWithAString("/process/m 401 msc1Cmd = new G4UIcmdWithAString("/process/msc/StepLimitMuHad",this);
423 msc1Cmd->SetGuidance("Set msc step limitatio 402 msc1Cmd->SetGuidance("Set msc step limitation type for muons/hadrons");
424 msc1Cmd->SetParameterName("StepLim1",true); 403 msc1Cmd->SetParameterName("StepLim1",true);
425 msc1Cmd->SetCandidates("Minimal UseSafety Us 404 msc1Cmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary");
426 msc1Cmd->AvailableForStates(G4State_PreInit, 405 msc1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
427 msc1Cmd->SetToBeBroadcasted(false); 406 msc1Cmd->SetToBeBroadcasted(false);
428 407
429 dumpCmd = new G4UIcommand("/process/em/print 408 dumpCmd = new G4UIcommand("/process/em/printParameters",this);
430 dumpCmd->SetGuidance("Print all EM parameter 409 dumpCmd->SetGuidance("Print all EM parameters.");
431 dumpCmd->AvailableForStates(G4State_PreInit, 410 dumpCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
432 dumpCmd->SetToBeBroadcasted(false); 411 dumpCmd->SetToBeBroadcasted(false);
433 412
434 nffCmd = new G4UIcmdWithAString("/process/em 413 nffCmd = new G4UIcmdWithAString("/process/em/setNuclearFormFactor",this);
435 nffCmd->SetGuidance("Define type of nuclear 414 nffCmd->SetGuidance("Define type of nuclear form-factor");
436 nffCmd->SetParameterName("NucFF",true); 415 nffCmd->SetParameterName("NucFF",true);
437 nffCmd->SetCandidates("None Exponential Gaus 416 nffCmd->SetCandidates("None Exponential Gaussian Flat");
438 nffCmd->AvailableForStates(G4State_PreInit); 417 nffCmd->AvailableForStates(G4State_PreInit);
439 nffCmd->SetToBeBroadcasted(false); 418 nffCmd->SetToBeBroadcasted(false);
440 419
441 ssCmd = new G4UIcmdWithAString("/process/em/ 420 ssCmd = new G4UIcmdWithAString("/process/em/setSingleScattering",this);
442 ssCmd->SetGuidance("Define type of e+- singl 421 ssCmd->SetGuidance("Define type of e+- single scattering model");
443 ssCmd->SetParameterName("SS",true); 422 ssCmd->SetParameterName("SS",true);
444 ssCmd->SetCandidates("WVI Mott DPWA"); 423 ssCmd->SetCandidates("WVI Mott DPWA");
445 ssCmd->AvailableForStates(G4State_PreInit); 424 ssCmd->AvailableForStates(G4State_PreInit);
446 ssCmd->SetToBeBroadcasted(false); 425 ssCmd->SetToBeBroadcasted(false);
447 426
448 fluc1Cmd = new G4UIcmdWithAString("/process/ << 427 fluc1Cmd = new G4UIcmdWithAString("/process/eloss/setFluctModel",this);
449 fluc1Cmd->SetGuidance("Define type of energy 428 fluc1Cmd->SetGuidance("Define type of energy loss fluctuation model");
450 fluc1Cmd->SetParameterName("Fluc1",true); 429 fluc1Cmd->SetParameterName("Fluc1",true);
451 fluc1Cmd->SetCandidates("Dummy Universal Urb 430 fluc1Cmd->SetCandidates("Dummy Universal Urban");
452 fluc1Cmd->AvailableForStates(G4State_PreInit 431 fluc1Cmd->AvailableForStates(G4State_PreInit);
453 fluc1Cmd->SetToBeBroadcasted(false); 432 fluc1Cmd->SetToBeBroadcasted(false);
454 433
455 posiCmd = new G4UIcmdWithAString("/process/e <<
456 posiCmd->SetGuidance("Define model of positr <<
457 posiCmd->SetParameterName("Posi",true); <<
458 posiCmd->SetCandidates("Simple Allison OrePa <<
459 posiCmd->AvailableForStates(G4State_PreInit) <<
460 posiCmd->SetToBeBroadcasted(false); <<
461 <<
462 tripletCmd = new G4UIcmdWithAnInteger("/proc 434 tripletCmd = new G4UIcmdWithAnInteger("/process/gconv/conversionType",this);
463 tripletCmd->SetGuidance("gamma conversion tr 435 tripletCmd->SetGuidance("gamma conversion triplet/nuclear generation type:");
464 tripletCmd->SetGuidance("0 - (default) both 436 tripletCmd->SetGuidance("0 - (default) both triplet and nuclear");
465 tripletCmd->SetGuidance("1 - force nuclear") 437 tripletCmd->SetGuidance("1 - force nuclear");
466 tripletCmd->SetGuidance("2 - force triplet") 438 tripletCmd->SetGuidance("2 - force triplet");
467 tripletCmd->SetParameterName("type",false); 439 tripletCmd->SetParameterName("type",false);
468 tripletCmd->SetRange("type >= 0 && type <= 2 440 tripletCmd->SetRange("type >= 0 && type <= 2");
469 tripletCmd->SetDefaultValue(0); 441 tripletCmd->SetDefaultValue(0);
470 tripletCmd->AvailableForStates(G4State_PreIn 442 tripletCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
471 tripletCmd->SetToBeBroadcasted(false); 443 tripletCmd->SetToBeBroadcasted(false);
472 444
473 onIsolatedCmd = new G4UIcmdWithABool("/proce 445 onIsolatedCmd = new G4UIcmdWithABool("/process/gconv/onIsolated",this);
474 onIsolatedCmd->SetGuidance("Conversion on is 446 onIsolatedCmd->SetGuidance("Conversion on isolated charged particles");
475 onIsolatedCmd->SetGuidance("false (default) 447 onIsolatedCmd->SetGuidance("false (default) : atomic electron screening");
476 onIsolatedCmd->SetGuidance("true : conversio 448 onIsolatedCmd->SetGuidance("true : conversion on isolated particles.");
477 onIsolatedCmd->SetParameterName("flag",false 449 onIsolatedCmd->SetParameterName("flag",false);
478 onIsolatedCmd->SetDefaultValue(false); 450 onIsolatedCmd->SetDefaultValue(false);
479 onIsolatedCmd->AvailableForStates(G4State_Pr 451 onIsolatedCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
480 onIsolatedCmd->SetToBeBroadcasted(false); 452 onIsolatedCmd->SetToBeBroadcasted(false);
481 } 453 }
482 454
483 //....oooOO0OOooo........oooOO0OOooo........oo 455 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
484 456
485 G4EmParametersMessenger::~G4EmParametersMessen 457 G4EmParametersMessenger::~G4EmParametersMessenger()
486 { 458 {
487 delete gconvDirectory; 459 delete gconvDirectory;
488 delete eLossDirectory; 460 delete eLossDirectory;
489 delete mscDirectory; 461 delete mscDirectory;
490 delete emDirectory; 462 delete emDirectory;
491 delete dnaDirectory; 463 delete dnaDirectory;
492 464
493 delete flucCmd; 465 delete flucCmd;
494 delete rangeCmd; 466 delete rangeCmd;
495 delete lpmCmd; 467 delete lpmCmd;
496 delete rsCmd; 468 delete rsCmd;
497 delete aplCmd; 469 delete aplCmd;
498 delete intCmd; 470 delete intCmd;
499 delete latCmd; 471 delete latCmd;
500 delete lat96Cmd; 472 delete lat96Cmd;
501 delete mulatCmd; 473 delete mulatCmd;
502 delete delCmd; 474 delete delCmd;
503 delete mottCmd; 475 delete mottCmd;
504 delete birksCmd; 476 delete birksCmd;
505 delete sharkCmd; 477 delete sharkCmd;
506 delete onIsolatedCmd; 478 delete onIsolatedCmd;
507 delete sampleTCmd; 479 delete sampleTCmd;
508 delete poCmd; 480 delete poCmd;
509 delete icru90Cmd; 481 delete icru90Cmd;
510 delete mudatCmd; 482 delete mudatCmd;
511 delete peKCmd; 483 delete peKCmd;
512 delete f3gCmd; <<
513 delete mscPCmd; 484 delete mscPCmd;
514 delete pepicsCmd; <<
515 485
516 delete minEnCmd; 486 delete minEnCmd;
517 delete maxEnCmd; 487 delete maxEnCmd;
518 delete max5DCmd; 488 delete max5DCmd;
519 delete cenCmd; 489 delete cenCmd;
520 delete lowEnCmd; 490 delete lowEnCmd;
521 delete lowhEnCmd; 491 delete lowhEnCmd;
522 delete lowEn3Cmd; 492 delete lowEn3Cmd;
523 delete lllCmd; 493 delete lllCmd;
524 delete brCmd; 494 delete brCmd;
525 delete br1Cmd; 495 delete br1Cmd;
526 delete labCmd; 496 delete labCmd;
527 delete mscfCmd; 497 delete mscfCmd;
528 delete angCmd; 498 delete angCmd;
529 delete msceCmd; 499 delete msceCmd;
530 delete nielCmd; 500 delete nielCmd;
531 delete frCmd; 501 delete frCmd;
532 delete fr1Cmd; 502 delete fr1Cmd;
533 delete fgCmd; 503 delete fgCmd;
534 delete skinCmd; 504 delete skinCmd;
535 delete safCmd; 505 delete safCmd;
536 delete llimCmd; 506 delete llimCmd;
537 delete screCmd; 507 delete screCmd;
538 508
539 delete amCmd; 509 delete amCmd;
540 delete verCmd; 510 delete verCmd;
541 delete ver1Cmd; 511 delete ver1Cmd;
542 delete ver2Cmd; 512 delete ver2Cmd;
543 delete transWithMscCmd; 513 delete transWithMscCmd;
544 delete nFreeCmd; <<
545 delete tripletCmd; 514 delete tripletCmd;
546 515
547 delete mscCmd; 516 delete mscCmd;
548 delete msc1Cmd; 517 delete msc1Cmd;
549 delete nffCmd; 518 delete nffCmd;
550 delete ssCmd; 519 delete ssCmd;
551 delete fluc1Cmd; 520 delete fluc1Cmd;
552 delete posiCmd; <<
553 521
554 delete dumpCmd; 522 delete dumpCmd;
555 } 523 }
556 524
557 //....oooOO0OOooo........oooOO0OOooo........oo 525 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
558 526
559 void G4EmParametersMessenger::SetNewValue(G4UI 527 void G4EmParametersMessenger::SetNewValue(G4UIcommand* command,
560 G4St 528 G4String newValue)
561 { 529 {
562 G4bool physicsModified = false; 530 G4bool physicsModified = false;
563 if (command == flucCmd) { 531 if (command == flucCmd) {
564 theParameters->SetLossFluctuations(flucCmd 532 theParameters->SetLossFluctuations(flucCmd->GetNewBoolValue(newValue));
565 physicsModified = true; 533 physicsModified = true;
566 } else if (command == rangeCmd) { 534 } else if (command == rangeCmd) {
567 theParameters->SetBuildCSDARange(rangeCmd- 535 theParameters->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue));
568 } else if (command == lpmCmd) { 536 } else if (command == lpmCmd) {
569 theParameters->SetLPM(lpmCmd->GetNewBoolVa 537 theParameters->SetLPM(lpmCmd->GetNewBoolValue(newValue));
570 physicsModified = true; 538 physicsModified = true;
571 } else if (command == rsCmd) { 539 } else if (command == rsCmd) {
572 theParameters->SetUseCutAsFinalRange(rsCmd 540 theParameters->SetUseCutAsFinalRange(rsCmd->GetNewBoolValue(newValue));
573 physicsModified = true; 541 physicsModified = true;
574 } else if (command == aplCmd) { 542 } else if (command == aplCmd) {
575 theParameters->SetApplyCuts(aplCmd->GetNew 543 theParameters->SetApplyCuts(aplCmd->GetNewBoolValue(newValue));
576 physicsModified = true; 544 physicsModified = true;
577 } else if (command == intCmd) { 545 } else if (command == intCmd) {
578 theParameters->SetIntegral(intCmd->GetNewB 546 theParameters->SetIntegral(intCmd->GetNewBoolValue(newValue));
579 } else if (command == latCmd) { 547 } else if (command == latCmd) {
580 theParameters->SetLateralDisplacement(latC 548 theParameters->SetLateralDisplacement(latCmd->GetNewBoolValue(newValue));
581 physicsModified = true; 549 physicsModified = true;
582 } else if (command == lat96Cmd) { 550 } else if (command == lat96Cmd) {
583 theParameters->SetLateralDisplacementAlg96 551 theParameters->SetLateralDisplacementAlg96(lat96Cmd->GetNewBoolValue(newValue));
584 physicsModified = true; 552 physicsModified = true;
585 } else if (command == mulatCmd) { 553 } else if (command == mulatCmd) {
586 theParameters->SetMuHadLateralDisplacement 554 theParameters->SetMuHadLateralDisplacement(mulatCmd->GetNewBoolValue(newValue));
587 physicsModified = true; 555 physicsModified = true;
588 } else if (command == delCmd) { 556 } else if (command == delCmd) {
589 theParameters->ActivateAngularGeneratorFor 557 theParameters->ActivateAngularGeneratorForIonisation(delCmd->GetNewBoolValue(newValue));
590 } else if (command == mottCmd) { 558 } else if (command == mottCmd) {
591 theParameters->SetUseMottCorrection(mottCm 559 theParameters->SetUseMottCorrection(mottCmd->GetNewBoolValue(newValue));
592 } else if (command == birksCmd) { 560 } else if (command == birksCmd) {
593 theParameters->SetBirksActive(birksCmd->Ge 561 theParameters->SetBirksActive(birksCmd->GetNewBoolValue(newValue));
594 } else if (command == icru90Cmd) { 562 } else if (command == icru90Cmd) {
595 theParameters->SetUseICRU90Data(icru90Cmd- 563 theParameters->SetUseICRU90Data(icru90Cmd->GetNewBoolValue(newValue));
596 } else if (command == sharkCmd) { 564 } else if (command == sharkCmd) {
597 theParameters->SetGeneralProcessActive(sha 565 theParameters->SetGeneralProcessActive(sharkCmd->GetNewBoolValue(newValue));
598 } else if (command == poCmd) { 566 } else if (command == poCmd) {
599 theParameters->SetEnablePolarisation(poCmd 567 theParameters->SetEnablePolarisation(poCmd->GetNewBoolValue(newValue));
600 } else if (command == sampleTCmd) { 568 } else if (command == sampleTCmd) {
601 theParameters->SetEnableSamplingTable(samp 569 theParameters->SetEnableSamplingTable(sampleTCmd->GetNewBoolValue(newValue));
602 } else if (command == mudatCmd) { 570 } else if (command == mudatCmd) {
603 theParameters->SetRetrieveMuDataFromFile(m 571 theParameters->SetRetrieveMuDataFromFile(mudatCmd->GetNewBoolValue(newValue));
604 } else if (command == peKCmd) { 572 } else if (command == peKCmd) {
605 theParameters->SetPhotoeffectBelowKShell(p 573 theParameters->SetPhotoeffectBelowKShell(peKCmd->GetNewBoolValue(newValue));
606 } else if (command == f3gCmd) { <<
607 theParameters->Set3GammaAnnihilationOnFly( <<
608 } else if (command == mscPCmd) { 574 } else if (command == mscPCmd) {
609 theParameters->SetMscPositronCorrection(ms 575 theParameters->SetMscPositronCorrection(mscPCmd->GetNewBoolValue(newValue));
610 } else if (command == pepicsCmd) { <<
611 theParameters->SetUseEPICS2017XS(pepicsCmd <<
612 576
613 } else if (command == minEnCmd) { 577 } else if (command == minEnCmd) {
614 theParameters->SetMinEnergy(minEnCmd->GetN 578 theParameters->SetMinEnergy(minEnCmd->GetNewDoubleValue(newValue));
615 } else if (command == maxEnCmd) { 579 } else if (command == maxEnCmd) {
616 theParameters->SetMaxEnergy(maxEnCmd->GetN 580 theParameters->SetMaxEnergy(maxEnCmd->GetNewDoubleValue(newValue));
617 } else if (command == max5DCmd) { 581 } else if (command == max5DCmd) {
618 theParameters->SetMaxEnergyFor5DMuPair(max 582 theParameters->SetMaxEnergyFor5DMuPair(max5DCmd->GetNewDoubleValue(newValue));
619 } else if (command == cenCmd) { 583 } else if (command == cenCmd) {
620 theParameters->SetMaxEnergyForCSDARange(ce 584 theParameters->SetMaxEnergyForCSDARange(cenCmd->GetNewDoubleValue(newValue));
621 physicsModified = true; 585 physicsModified = true;
622 } else if (command == lowEnCmd) { 586 } else if (command == lowEnCmd) {
623 theParameters->SetLowestElectronEnergy(low 587 theParameters->SetLowestElectronEnergy(lowEnCmd->GetNewDoubleValue(newValue));
624 physicsModified = true; 588 physicsModified = true;
625 } else if (command == lowEn3Cmd) { 589 } else if (command == lowEn3Cmd) {
626 theParameters->SetLowestTripletEnergy(lowE 590 theParameters->SetLowestTripletEnergy(lowEn3Cmd->GetNewDoubleValue(newValue));
627 physicsModified = true; 591 physicsModified = true;
628 } else if (command == lowhEnCmd) { 592 } else if (command == lowhEnCmd) {
629 theParameters->SetLowestMuHadEnergy(lowhEn 593 theParameters->SetLowestMuHadEnergy(lowhEnCmd->GetNewDoubleValue(newValue));
630 physicsModified = true; 594 physicsModified = true;
631 } else if (command == lllCmd) { 595 } else if (command == lllCmd) {
632 theParameters->SetLinearLossLimit(lllCmd-> 596 theParameters->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue));
633 physicsModified = true; 597 physicsModified = true;
634 } else if (command == brCmd) { 598 } else if (command == brCmd) {
635 theParameters->SetBremsstrahlungTh(brCmd-> 599 theParameters->SetBremsstrahlungTh(brCmd->GetNewDoubleValue(newValue));
636 physicsModified = true; 600 physicsModified = true;
637 } else if (command == br1Cmd) { 601 } else if (command == br1Cmd) {
638 theParameters->SetMuHadBremsstrahlungTh(br 602 theParameters->SetMuHadBremsstrahlungTh(br1Cmd->GetNewDoubleValue(newValue));
639 physicsModified = true; 603 physicsModified = true;
640 } else if (command == labCmd) { 604 } else if (command == labCmd) {
641 theParameters->SetLambdaFactor(labCmd->Get 605 theParameters->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue));
642 physicsModified = true; 606 physicsModified = true;
643 } else if (command == mscfCmd) { 607 } else if (command == mscfCmd) {
644 theParameters->SetFactorForAngleLimit(mscf 608 theParameters->SetFactorForAngleLimit(mscfCmd->GetNewDoubleValue(newValue));
645 } else if (command == angCmd) { 609 } else if (command == angCmd) {
646 theParameters->SetMscThetaLimit(angCmd->Ge 610 theParameters->SetMscThetaLimit(angCmd->GetNewDoubleValue(newValue));
647 } else if (command == msceCmd) { 611 } else if (command == msceCmd) {
648 theParameters->SetMscEnergyLimit(msceCmd-> 612 theParameters->SetMscEnergyLimit(msceCmd->GetNewDoubleValue(newValue));
649 } else if (command == nielCmd) { 613 } else if (command == nielCmd) {
650 theParameters->SetMaxNIELEnergy(nielCmd->G 614 theParameters->SetMaxNIELEnergy(nielCmd->GetNewDoubleValue(newValue));
651 } else if (command == frCmd) { 615 } else if (command == frCmd) {
652 theParameters->SetMscRangeFactor(frCmd->Ge 616 theParameters->SetMscRangeFactor(frCmd->GetNewDoubleValue(newValue));
653 physicsModified = true; 617 physicsModified = true;
654 } else if (command == fr1Cmd) { 618 } else if (command == fr1Cmd) {
655 theParameters->SetMscMuHadRangeFactor(fr1C 619 theParameters->SetMscMuHadRangeFactor(fr1Cmd->GetNewDoubleValue(newValue));
656 physicsModified = true; 620 physicsModified = true;
657 } else if (command == fgCmd) { 621 } else if (command == fgCmd) {
658 theParameters->SetMscGeomFactor(fgCmd->Get 622 theParameters->SetMscGeomFactor(fgCmd->GetNewDoubleValue(newValue));
659 physicsModified = true; 623 physicsModified = true;
660 } else if (command == skinCmd) { 624 } else if (command == skinCmd) {
661 theParameters->SetMscSkin(skinCmd->GetNewD 625 theParameters->SetMscSkin(skinCmd->GetNewDoubleValue(newValue));
662 physicsModified = true; 626 physicsModified = true;
663 } else if (command == safCmd) { 627 } else if (command == safCmd) {
664 theParameters->SetMscSafetyFactor(safCmd-> 628 theParameters->SetMscSafetyFactor(safCmd->GetNewDoubleValue(newValue));
665 } else if (command == llimCmd) { 629 } else if (command == llimCmd) {
666 theParameters->SetMscLambdaLimit(llimCmd-> 630 theParameters->SetMscLambdaLimit(llimCmd->GetNewDoubleValue(newValue));
667 } else if (command == screCmd) { 631 } else if (command == screCmd) {
668 theParameters->SetScreeningFactor(screCmd- 632 theParameters->SetScreeningFactor(screCmd->GetNewDoubleValue(newValue));
669 } else if (command == amCmd) { 633 } else if (command == amCmd) {
670 theParameters->SetNumberOfBinsPerDecade(am 634 theParameters->SetNumberOfBinsPerDecade(amCmd->GetNewIntValue(newValue));
671 } else if (command == verCmd) { 635 } else if (command == verCmd) {
672 theParameters->SetVerbose(verCmd->GetNewIn 636 theParameters->SetVerbose(verCmd->GetNewIntValue(newValue));
673 } else if (command == ver1Cmd) { 637 } else if (command == ver1Cmd) {
674 theParameters->SetVerbose(ver1Cmd->GetNewI 638 theParameters->SetVerbose(ver1Cmd->GetNewIntValue(newValue));
675 } else if (command == ver2Cmd) { 639 } else if (command == ver2Cmd) {
676 theParameters->SetWorkerVerbose(ver2Cmd->G 640 theParameters->SetWorkerVerbose(ver2Cmd->GetNewIntValue(newValue));
677 } else if (command == nFreeCmd) { <<
678 theParameters->SetNumberForFreeVector(nFre <<
679 } else if (command == dumpCmd) { 641 } else if (command == dumpCmd) {
680 theParameters->SetIsPrintedFlag(false); 642 theParameters->SetIsPrintedFlag(false);
681 theParameters->Dump(); 643 theParameters->Dump();
682 } else if (command == transWithMscCmd) { 644 } else if (command == transWithMscCmd) {
683 G4TransportationWithMscType type = G4Trans 645 G4TransportationWithMscType type = G4TransportationWithMscType::fDisabled;
684 if(newValue == "Disabled") { 646 if(newValue == "Disabled") {
685 type = G4TransportationWithMscType::fDis 647 type = G4TransportationWithMscType::fDisabled;
686 } else if(newValue == "Enabled") { 648 } else if(newValue == "Enabled") {
687 type = G4TransportationWithMscType::fEna 649 type = G4TransportationWithMscType::fEnabled;
688 } else if(newValue == "MultipleSteps") { 650 } else if(newValue == "MultipleSteps") {
689 type = G4TransportationWithMscType::fMul 651 type = G4TransportationWithMscType::fMultipleSteps;
690 } else { 652 } else {
691 G4ExceptionDescription ed; 653 G4ExceptionDescription ed;
692 ed << " TransportationWithMsc type <" << 654 ed << " TransportationWithMsc type <" << newValue << "> unknown!";
693 G4Exception("G4EmParametersMessenger", " 655 G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
694 } 656 }
695 theParameters->SetTransportationWithMsc(ty 657 theParameters->SetTransportationWithMsc(type);
696 } else if (command == mscCmd || command == m 658 } else if (command == mscCmd || command == msc1Cmd) {
697 G4MscStepLimitType msctype = fUseSafety; 659 G4MscStepLimitType msctype = fUseSafety;
698 if(newValue == "Minimal") { 660 if(newValue == "Minimal") {
699 msctype = fMinimal; 661 msctype = fMinimal;
700 } else if(newValue == "UseDistanceToBounda 662 } else if(newValue == "UseDistanceToBoundary") {
701 msctype = fUseDistanceToBoundary; 663 msctype = fUseDistanceToBoundary;
702 } else if(newValue == "UseSafety") { 664 } else if(newValue == "UseSafety") {
703 msctype = fUseSafety; 665 msctype = fUseSafety;
704 } else if(newValue == "UseSafetyPlus") { 666 } else if(newValue == "UseSafetyPlus") {
705 msctype = fUseSafetyPlus; 667 msctype = fUseSafetyPlus;
706 } else { 668 } else {
707 G4ExceptionDescription ed; 669 G4ExceptionDescription ed;
708 ed << " StepLimit type <" << newValue << 670 ed << " StepLimit type <" << newValue << "> unknown!";
709 G4Exception("G4EmParametersMessenger", " 671 G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
710 return; 672 return;
711 } 673 }
712 if (command == mscCmd) { 674 if (command == mscCmd) {
713 theParameters->SetMscStepLimitType(mscty 675 theParameters->SetMscStepLimitType(msctype);
714 } else { 676 } else {
715 theParameters->SetMscMuHadStepLimitType( 677 theParameters->SetMscMuHadStepLimitType(msctype);
716 } 678 }
717 physicsModified = true; 679 physicsModified = true;
718 } else if (command == nffCmd) { 680 } else if (command == nffCmd) {
719 G4NuclearFormfactorType x = fNoneNF; 681 G4NuclearFormfactorType x = fNoneNF;
720 if(newValue == "Exponential") { x = fExpon 682 if(newValue == "Exponential") { x = fExponentialNF; }
721 else if(newValue == "Gaussian") { x = fGau 683 else if(newValue == "Gaussian") { x = fGaussianNF; }
722 else if(newValue == "Flat") { x = fFlatNF; 684 else if(newValue == "Flat") { x = fFlatNF; }
723 else if(newValue != "None") { 685 else if(newValue != "None") {
724 G4ExceptionDescription ed; 686 G4ExceptionDescription ed;
725 ed << " NuclearFormFactor type <" << new 687 ed << " NuclearFormFactor type <" << newValue << "> unknown!";
726 G4Exception("G4EmParametersMessenger", " 688 G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
727 return; 689 return;
728 } 690 }
729 theParameters->SetNuclearFormfactorType(x) 691 theParameters->SetNuclearFormfactorType(x);
730 } else if (command == ssCmd) { 692 } else if (command == ssCmd) {
731 G4eSingleScatteringType x = fWVI; 693 G4eSingleScatteringType x = fWVI;
732 if(newValue == "DPWA") { x = fDPWA; } 694 if(newValue == "DPWA") { x = fDPWA; }
733 else if(newValue == "Mott") { x = fMott; } 695 else if(newValue == "Mott") { x = fMott; }
734 else if(newValue != "WVI") { 696 else if(newValue != "WVI") {
735 G4ExceptionDescription ed; 697 G4ExceptionDescription ed;
736 ed << " G4eSingleScatteringType type <" 698 ed << " G4eSingleScatteringType type <" << newValue << "> unknown!";
737 G4Exception("G4EmParametersMessenger", " 699 G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
738 return; 700 return;
739 } 701 }
740 theParameters->SetSingleScatteringType(x); 702 theParameters->SetSingleScatteringType(x);
741 } else if (command == fluc1Cmd) { 703 } else if (command == fluc1Cmd) {
742 G4EmFluctuationType x = fUniversalFluctuat 704 G4EmFluctuationType x = fUniversalFluctuation;
743 if(newValue == "Dummy") { x = fDummyFluctu 705 if(newValue == "Dummy") { x = fDummyFluctuation; }
744 else if(newValue == "Urban") { x = fUrbanF 706 else if(newValue == "Urban") { x = fUrbanFluctuation; }
745 theParameters->SetFluctuationType(x); 707 theParameters->SetFluctuationType(x);
746 } else if (command == posiCmd) { <<
747 G4PositronAtRestModelType x = fSimplePosit <<
748 if (newValue == "Allison") { x = fAllisonP <<
749 else if (newValue == "OrePowell") { x = fO <<
750 else if (newValue == "OrePowellPolar") { x <<
751 theParameters->SetPositronAtRestModelType( <<
752 } else if ( command==tripletCmd ) { 708 } else if ( command==tripletCmd ) {
753 theParameters->SetConversionType(tripletCm 709 theParameters->SetConversionType(tripletCmd->GetNewIntValue(newValue));
754 } else if ( command==onIsolatedCmd ) { 710 } else if ( command==onIsolatedCmd ) {
755 theParameters->SetOnIsolated(onIsolatedCmd 711 theParameters->SetOnIsolated(onIsolatedCmd->GetNewBoolValue(newValue));
756 physicsModified = true; 712 physicsModified = true;
757 } 713 }
758 714
759 if(physicsModified) { 715 if(physicsModified) {
760 G4UImanager::GetUIpointer()->ApplyCommand( 716 G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
761 } 717 }
762 } 718 }
763 719
764 //....oooOO0OOooo........oooOO0OOooo........oo 720 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
765 721