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