| 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 //
28 // GEANT4 Class file 29 // GEANT4 Class file
29 // 30 //
30 // File name: G4EmParametersMessenger 31 // File name: G4EmParametersMessenger
31 // 32 //
32 // Author: Vladimir Ivanchenko created 33 // Author: Vladimir Ivanchenko created from G4EnergyLossMessenger
33 // 34 //
34 // Creation date: 22-05-2013 35 // Creation date: 22-05-2013
35 // 36 //
>> 37 // Modifications:
>> 38 //
36 // ------------------------------------------- 39 // -------------------------------------------------------------------
37 // 40 //
38 41
39 //....oooOO0OOooo........oooOO0OOooo........oo 42 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
40 //....oooOO0OOooo........oooOO0OOooo........oo 43 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
41 44
42 #include "G4EmParametersMessenger.hh" 45 #include "G4EmParametersMessenger.hh"
43 #include "G4UIdirectory.hh" 46 #include "G4UIdirectory.hh"
44 #include "G4UIcommand.hh" 47 #include "G4UIcommand.hh"
45 #include "G4UIparameter.hh" 48 #include "G4UIparameter.hh"
46 #include "G4UIcmdWithABool.hh" 49 #include "G4UIcmdWithABool.hh"
47 #include "G4UIcmdWithAnInteger.hh" 50 #include "G4UIcmdWithAnInteger.hh"
48 #include "G4UIcmdWithADouble.hh" 51 #include "G4UIcmdWithADouble.hh"
49 #include "G4UIcmdWithADoubleAndUnit.hh" 52 #include "G4UIcmdWithADoubleAndUnit.hh"
50 #include "G4UIcmdWithAString.hh" 53 #include "G4UIcmdWithAString.hh"
51 #include "G4UIcmdWith3VectorAndUnit.hh" 54 #include "G4UIcmdWith3VectorAndUnit.hh"
52 #include "G4UImanager.hh" 55 #include "G4UImanager.hh"
53 #include "G4MscStepLimitType.hh" 56 #include "G4MscStepLimitType.hh"
54 #include "G4NuclearFormfactorType.hh" 57 #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 gconvDirectory = new G4UIdirectory("/process/gconv/");
65 emDirectory->SetGuidance("General commands f <<
66 eLossDirectory = new G4UIdirectory("/process <<
67 eLossDirectory->SetGuidance("Commands for en <<
68 mscDirectory = new G4UIdirectory("/process/m <<
69 mscDirectory->SetGuidance("Commands for EM s <<
70 gconvDirectory = new G4UIdirectory("/process <<
71 gconvDirectory->SetGuidance("Commands for EM 68 gconvDirectory->SetGuidance("Commands for EM gamma conversion BH5D model.");
72 dnaDirectory = new G4UIdirectory("/process/d << 69 eLossDirectory = new G4UIdirectory("/process/eLoss/");
>> 70 eLossDirectory->SetGuidance("Commands for EM processes.");
>> 71 mscDirectory = new G4UIdirectory("/process/msc/");
>> 72 mscDirectory->SetGuidance("Commands for EM scattering processes.");
>> 73 emDirectory = new G4UIdirectory("/process/em/");
>> 74 emDirectory->SetGuidance("General commands for EM processes.");
>> 75 dnaDirectory = new G4UIdirectory("/process/dna/");
73 dnaDirectory->SetGuidance("Commands for DNA 76 dnaDirectory->SetGuidance("Commands for DNA processes.");
74 77
75 flucCmd = new G4UIcmdWithABool("/process/eLo 78 flucCmd = new G4UIcmdWithABool("/process/eLoss/fluct",this);
76 flucCmd->SetGuidance("Enable/disable energy 79 flucCmd->SetGuidance("Enable/disable energy loss fluctuations.");
77 flucCmd->SetParameterName("choice",true); 80 flucCmd->SetParameterName("choice",true);
78 flucCmd->SetDefaultValue(true); 81 flucCmd->SetDefaultValue(true);
79 flucCmd->AvailableForStates(G4State_PreInit, 82 flucCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
80 flucCmd->SetToBeBroadcasted(false); <<
81 83
82 rangeCmd = new G4UIcmdWithABool("/process/eL 84 rangeCmd = new G4UIcmdWithABool("/process/eLoss/CSDARange",this);
83 rangeCmd->SetGuidance("Enable/disable CSDA r 85 rangeCmd->SetGuidance("Enable/disable CSDA range calculation");
84 rangeCmd->SetParameterName("range",true); 86 rangeCmd->SetParameterName("range",true);
85 rangeCmd->SetDefaultValue(false); 87 rangeCmd->SetDefaultValue(false);
86 rangeCmd->AvailableForStates(G4State_PreInit 88 rangeCmd->AvailableForStates(G4State_PreInit);
87 rangeCmd->SetToBeBroadcasted(false); <<
88 89
89 lpmCmd = new G4UIcmdWithABool("/process/eLos 90 lpmCmd = new G4UIcmdWithABool("/process/eLoss/LPM",this);
90 lpmCmd->SetGuidance("Enable/disable LPM effe 91 lpmCmd->SetGuidance("Enable/disable LPM effect calculation");
91 lpmCmd->SetParameterName("lpm",true); 92 lpmCmd->SetParameterName("lpm",true);
92 lpmCmd->SetDefaultValue(true); 93 lpmCmd->SetDefaultValue(true);
93 lpmCmd->AvailableForStates(G4State_PreInit,G 94 lpmCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
94 lpmCmd->SetToBeBroadcasted(false); << 95
>> 96 splCmd = new G4UIcmdWithABool("/process/em/spline",this);
>> 97 splCmd->SetGuidance("Enable/disable usage spline for Physics Vectors");
>> 98 splCmd->SetParameterName("spl",true);
>> 99 splCmd->SetDefaultValue(false);
>> 100 splCmd->AvailableForStates(G4State_PreInit);
95 101
96 rsCmd = new G4UIcmdWithABool("/process/eLoss 102 rsCmd = new G4UIcmdWithABool("/process/eLoss/useCutAsFinalRange",this);
97 rsCmd->SetGuidance("Enable/disable use of cu 103 rsCmd->SetGuidance("Enable/disable use of cut in range as a final range");
98 rsCmd->SetParameterName("choice",true); 104 rsCmd->SetParameterName("choice",true);
99 rsCmd->SetDefaultValue(false); 105 rsCmd->SetDefaultValue(false);
100 rsCmd->AvailableForStates(G4State_PreInit,G4 106 rsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
101 rsCmd->SetToBeBroadcasted(false); <<
102 107
103 aplCmd = new G4UIcmdWithABool("/process/em/a 108 aplCmd = new G4UIcmdWithABool("/process/em/applyCuts",this);
104 aplCmd->SetGuidance("Enable/disable applying 109 aplCmd->SetGuidance("Enable/disable applying cuts for gamma processes");
105 aplCmd->SetParameterName("apl",true); 110 aplCmd->SetParameterName("apl",true);
106 aplCmd->SetDefaultValue(false); 111 aplCmd->SetDefaultValue(false);
107 aplCmd->AvailableForStates(G4State_PreInit,G 112 aplCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
108 aplCmd->SetToBeBroadcasted(false); <<
109 113
110 intCmd = new G4UIcmdWithABool("/process/em/i << 114 deCmd = new G4UIcmdWithABool("/process/em/fluo",this);
111 intCmd->SetGuidance("Enable/disable integral << 115 deCmd->SetGuidance("Enable/disable atomic deexcitation");
112 intCmd->SetParameterName("choice",true); << 116 deCmd->SetParameterName("fluoFlag",true);
113 intCmd->SetDefaultValue(true); << 117 deCmd->SetDefaultValue(false);
114 intCmd->AvailableForStates(G4State_PreInit); << 118 deCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
115 intCmd->SetToBeBroadcasted(false); << 119
>> 120 dirFluoCmd = new G4UIcmdWithABool("/process/em/fluoBearden",this);
>> 121 dirFluoCmd->SetGuidance("Enable/disable usage of Bearden fluorescence files");
>> 122 dirFluoCmd->SetParameterName("fluoBeardenFlag",true);
>> 123 dirFluoCmd->SetDefaultValue(false);
>> 124 dirFluoCmd->AvailableForStates(G4State_PreInit,G4State_Init);
>> 125
>> 126 auCmd = new G4UIcmdWithABool("/process/em/auger",this);
>> 127 auCmd->SetGuidance("Enable/disable Auger electrons production");
>> 128 auCmd->SetParameterName("augerFlag",true);
>> 129 auCmd->SetDefaultValue(false);
>> 130 auCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
>> 131
>> 132 auCascadeCmd = new G4UIcmdWithABool("/process/em/augerCascade",this);
>> 133 auCascadeCmd->SetGuidance("Enable/disable simulation of cascade of Auger electrons");
>> 134 auCascadeCmd->SetParameterName("augerCascadeFlag",true);
>> 135 auCascadeCmd->SetDefaultValue(false);
>> 136 auCascadeCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
>> 137
>> 138 pixeCmd = new G4UIcmdWithABool("/process/em/pixe",this);
>> 139 pixeCmd->SetGuidance("Enable/disable PIXE simulation");
>> 140 pixeCmd->SetParameterName("pixeFlag",true);
>> 141 pixeCmd->SetDefaultValue(false);
>> 142 pixeCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
>> 143
>> 144 dcutCmd = new G4UIcmdWithABool("/process/em/deexcitationIgnoreCut",this);
>> 145 dcutCmd->SetGuidance("Enable/Disable usage of cuts in de-excitation module");
>> 146 dcutCmd->SetParameterName("deexcut",true);
>> 147 dcutCmd->SetDefaultValue(false);
>> 148 dcutCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
116 149
117 latCmd = new G4UIcmdWithABool("/process/msc/ 150 latCmd = new G4UIcmdWithABool("/process/msc/LateralDisplacement",this);
118 latCmd->SetGuidance("Enable/disable sampling 151 latCmd->SetGuidance("Enable/disable sampling of lateral displacement");
119 latCmd->SetParameterName("lat",true); 152 latCmd->SetParameterName("lat",true);
120 latCmd->SetDefaultValue(true); 153 latCmd->SetDefaultValue(true);
121 latCmd->AvailableForStates(G4State_PreInit,G 154 latCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
122 latCmd->SetToBeBroadcasted(false); <<
123 155
124 lat96Cmd = new G4UIcmdWithABool("/process/ms 156 lat96Cmd = new G4UIcmdWithABool("/process/msc/LateralDisplacementAlg96",this);
125 lat96Cmd->SetGuidance("Enable/disable sampli 157 lat96Cmd->SetGuidance("Enable/disable sampling of lateral displacement");
126 lat96Cmd->SetParameterName("lat96",true); 158 lat96Cmd->SetParameterName("lat96",true);
127 lat96Cmd->SetDefaultValue(false); 159 lat96Cmd->SetDefaultValue(false);
128 lat96Cmd->AvailableForStates(G4State_PreInit 160 lat96Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
129 lat96Cmd->SetToBeBroadcasted(false); <<
130 161
131 mulatCmd = new G4UIcmdWithABool("/process/ms 162 mulatCmd = new G4UIcmdWithABool("/process/msc/MuHadLateralDisplacement",this);
132 mulatCmd->SetGuidance("Enable/disable sampli 163 mulatCmd->SetGuidance("Enable/disable sampling of lateral displacement for muons and hadrons");
133 mulatCmd->SetParameterName("mulat",true); 164 mulatCmd->SetParameterName("mulat",true);
134 mulatCmd->SetDefaultValue(true); 165 mulatCmd->SetDefaultValue(true);
135 mulatCmd->AvailableForStates(G4State_PreInit 166 mulatCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
136 mulatCmd->SetToBeBroadcasted(false); << 167
>> 168 catCmd = new G4UIcmdWithABool("/process/msc/DisplacementBeyondSafety",this);
>> 169 catCmd->SetGuidance("Enable/disable displacement at geometry boundary");
>> 170 catCmd->SetParameterName("cat",true);
>> 171 catCmd->SetDefaultValue(false);
>> 172 catCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
137 173
138 delCmd = new G4UIcmdWithABool("/process/eLos 174 delCmd = new G4UIcmdWithABool("/process/eLoss/UseAngularGenerator",this);
139 delCmd->SetGuidance("Enable usage of angular 175 delCmd->SetGuidance("Enable usage of angular generator for ionisation");
140 delCmd->SetParameterName("del",true); 176 delCmd->SetParameterName("del",true);
141 delCmd->SetDefaultValue(false); 177 delCmd->SetDefaultValue(false);
142 delCmd->AvailableForStates(G4State_PreInit); 178 delCmd->AvailableForStates(G4State_PreInit);
143 delCmd->SetToBeBroadcasted(false); << 179
>> 180 IntegCmd = new G4UIcmdWithABool("/process/eLoss/integral",this);
>> 181 IntegCmd->SetGuidance("Switch true/false the integral option");
>> 182 IntegCmd->SetParameterName("integ",true);
>> 183 IntegCmd->SetDefaultValue(true);
>> 184 IntegCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
144 185
145 mottCmd = new G4UIcmdWithABool("/process/msc 186 mottCmd = new G4UIcmdWithABool("/process/msc/UseMottCorrection",this);
146 mottCmd->SetGuidance("Enable usage of Mott c 187 mottCmd->SetGuidance("Enable usage of Mott corrections for e- elastic scattering");
147 mottCmd->SetParameterName("mott",true); 188 mottCmd->SetParameterName("mott",true);
148 mottCmd->SetDefaultValue(false); 189 mottCmd->SetDefaultValue(false);
149 mottCmd->AvailableForStates(G4State_PreInit) 190 mottCmd->AvailableForStates(G4State_PreInit);
150 mottCmd->SetToBeBroadcasted(false); <<
151 191
152 birksCmd = new G4UIcmdWithABool("/process/em << 192 birksCmd = new G4UIcmdWithABool("/process/msc/UseG4EmSaturation",this);
153 birksCmd->SetGuidance("Enable usage of built 193 birksCmd->SetGuidance("Enable usage of built-in Birks saturation");
154 birksCmd->SetParameterName("birks",true); 194 birksCmd->SetParameterName("birks",true);
155 birksCmd->SetDefaultValue(false); 195 birksCmd->SetDefaultValue(false);
156 birksCmd->AvailableForStates(G4State_PreInit 196 birksCmd->AvailableForStates(G4State_PreInit,G4State_Init);
157 birksCmd->SetToBeBroadcasted(false); << 197
>> 198 dnafCmd = new G4UIcmdWithABool("/process/dna/UseDNAFast",this);
>> 199 dnafCmd->SetGuidance("Enable usage of fast sampling for DNA models");
>> 200 dnafCmd->SetParameterName("dnaf",true);
>> 201 dnafCmd->SetDefaultValue(false);
>> 202 dnafCmd->AvailableForStates(G4State_PreInit);
>> 203
>> 204 dnasCmd = new G4UIcmdWithABool("/process/dna/UseDNAStationary",this);
>> 205 dnasCmd->SetGuidance("Enable usage of Stationary option for DNA models");
>> 206 dnasCmd->SetParameterName("dnas",true);
>> 207 dnasCmd->SetDefaultValue(false);
>> 208 dnasCmd->AvailableForStates(G4State_PreInit);
>> 209
>> 210 dnamscCmd = new G4UIcmdWithABool("/process/dna/UseDNAElectronMsc",this);
>> 211 dnamscCmd->SetGuidance("Enable usage of e- msc for DNA");
>> 212 dnamscCmd->SetParameterName("dnamsc",true);
>> 213 dnamscCmd->SetDefaultValue(false);
>> 214 dnamscCmd->AvailableForStates(G4State_PreInit);
158 215
159 sharkCmd = new G4UIcmdWithABool("/process/em 216 sharkCmd = new G4UIcmdWithABool("/process/em/UseGeneralProcess",this);
160 sharkCmd->SetGuidance("Enable gamma, e+- gen 217 sharkCmd->SetGuidance("Enable gamma, e+- general process");
161 sharkCmd->SetParameterName("gen",true); 218 sharkCmd->SetParameterName("gen",true);
162 sharkCmd->SetDefaultValue(false); 219 sharkCmd->SetDefaultValue(false);
163 sharkCmd->AvailableForStates(G4State_PreInit 220 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 221
171 sampleTCmd = new G4UIcmdWithABool("/process/ 222 sampleTCmd = new G4UIcmdWithABool("/process/em/enableSamplingTable",this);
172 sampleTCmd->SetGuidance("Enable usage of sam 223 sampleTCmd->SetGuidance("Enable usage of sampling table for secondary generation");
173 sampleTCmd->SetParameterName("sampleT",true) 224 sampleTCmd->SetParameterName("sampleT",true);
174 sampleTCmd->SetDefaultValue(false); 225 sampleTCmd->SetDefaultValue(false);
175 sampleTCmd->AvailableForStates(G4State_PreIn 226 sampleTCmd->AvailableForStates(G4State_PreInit);
176 sampleTCmd->SetToBeBroadcasted(false); <<
177 227
178 icru90Cmd = new G4UIcmdWithABool("/process/e 228 icru90Cmd = new G4UIcmdWithABool("/process/eLoss/UseICRU90",this);
179 icru90Cmd->SetGuidance("Enable usage of ICRU 229 icru90Cmd->SetGuidance("Enable usage of ICRU90 stopping powers");
180 icru90Cmd->SetParameterName("icru90",true); 230 icru90Cmd->SetParameterName("icru90",true);
181 icru90Cmd->SetDefaultValue(false); 231 icru90Cmd->SetDefaultValue(false);
182 icru90Cmd->AvailableForStates(G4State_PreIni 232 icru90Cmd->AvailableForStates(G4State_PreInit);
183 icru90Cmd->SetToBeBroadcasted(false); <<
184 233
185 mudatCmd = new G4UIcmdWithABool("/process/em << 234 minSubSecCmd = new G4UIcmdWithADouble("/process/eLoss/minsubsec",this);
186 mudatCmd->SetGuidance("Enable usage of muon << 235 minSubSecCmd->SetGuidance("Set the ratio subcut/cut ");
187 mudatCmd->SetParameterName("mudat",true); << 236 minSubSecCmd->SetParameterName("rcmin",true);
188 mudatCmd->SetDefaultValue(false); << 237 minSubSecCmd->AvailableForStates(G4State_PreInit);
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 238
220 minEnCmd = new G4UIcmdWithADoubleAndUnit("/p 239 minEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/minKinEnergy",this);
221 minEnCmd->SetGuidance("Set the min kinetic e 240 minEnCmd->SetGuidance("Set the min kinetic energy for EM tables");
222 minEnCmd->SetParameterName("emin",true); 241 minEnCmd->SetParameterName("emin",true);
223 minEnCmd->SetUnitCategory("Energy"); 242 minEnCmd->SetUnitCategory("Energy");
224 minEnCmd->AvailableForStates(G4State_PreInit 243 minEnCmd->AvailableForStates(G4State_PreInit);
225 minEnCmd->SetToBeBroadcasted(false); <<
226 244
227 maxEnCmd = new G4UIcmdWithADoubleAndUnit("/p 245 maxEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergy",this);
228 maxEnCmd->SetGuidance("Set the max kinetic e 246 maxEnCmd->SetGuidance("Set the max kinetic energy for EM tables");
229 maxEnCmd->SetParameterName("emax",true); 247 maxEnCmd->SetParameterName("emax",true);
230 maxEnCmd->SetUnitCategory("Energy"); 248 maxEnCmd->SetUnitCategory("Energy");
231 maxEnCmd->AvailableForStates(G4State_PreInit 249 maxEnCmd->AvailableForStates(G4State_PreInit);
232 maxEnCmd->SetToBeBroadcasted(false); <<
233 250
234 cenCmd = new G4UIcmdWithADoubleAndUnit("/pro 251 cenCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergyCSDA",this);
235 cenCmd->SetGuidance("Set the max kinetic ene 252 cenCmd->SetGuidance("Set the max kinetic energy for CSDA table");
236 cenCmd->SetParameterName("emaxCSDA",true); 253 cenCmd->SetParameterName("emaxCSDA",true);
237 cenCmd->SetUnitCategory("Energy"); 254 cenCmd->SetUnitCategory("Energy");
238 cenCmd->AvailableForStates(G4State_PreInit); 255 cenCmd->AvailableForStates(G4State_PreInit);
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 256
248 lowEnCmd = new G4UIcmdWithADoubleAndUnit("/p 257 lowEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestElectronEnergy",this);
249 lowEnCmd->SetGuidance("Set the lowest kineti 258 lowEnCmd->SetGuidance("Set the lowest kinetic energy for e+-");
250 lowEnCmd->SetParameterName("elow",true); 259 lowEnCmd->SetParameterName("elow",true);
251 lowEnCmd->SetUnitCategory("Energy"); 260 lowEnCmd->SetUnitCategory("Energy");
252 lowEnCmd->AvailableForStates(G4State_PreInit 261 lowEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
253 lowEnCmd->SetToBeBroadcasted(false); <<
254 262
255 lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/ 263 lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestMuHadEnergy",this);
256 lowhEnCmd->SetGuidance("Set the lowest kinet 264 lowhEnCmd->SetGuidance("Set the lowest kinetic energy for muons and hadrons");
257 lowhEnCmd->SetParameterName("elowh",true); 265 lowhEnCmd->SetParameterName("elowh",true);
258 lowhEnCmd->SetUnitCategory("Energy"); 266 lowhEnCmd->SetUnitCategory("Energy");
259 lowhEnCmd->AvailableForStates(G4State_PreIni 267 lowhEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
260 lowhEnCmd->SetToBeBroadcasted(false); <<
261 268
262 lowEn3Cmd = new G4UIcmdWithADoubleAndUnit("/ 269 lowEn3Cmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestTripletEnergy",this);
263 lowEn3Cmd->SetGuidance("Set the lowest kinet 270 lowEn3Cmd->SetGuidance("Set the lowest kinetic energy for triplet production");
264 lowEn3Cmd->SetParameterName("elow3",true); 271 lowEn3Cmd->SetParameterName("elow3",true);
265 lowEn3Cmd->SetUnitCategory("Energy"); 272 lowEn3Cmd->SetUnitCategory("Energy");
266 lowEn3Cmd->AvailableForStates(G4State_PreIni 273 lowEn3Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
267 lowEn3Cmd->SetToBeBroadcasted(false); <<
268 274
269 lllCmd = new G4UIcmdWithADouble("/process/eL 275 lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this);
270 lllCmd->SetGuidance("Set linearLossLimit par 276 lllCmd->SetGuidance("Set linearLossLimit parameter");
271 lllCmd->SetParameterName("linlim",true); 277 lllCmd->SetParameterName("linlim",true);
272 lllCmd->AvailableForStates(G4State_PreInit,G 278 lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
273 lllCmd->SetToBeBroadcasted(false); <<
274 279
275 brCmd = new G4UIcmdWithADoubleAndUnit("/proc 280 brCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremThreshold",this);
276 brCmd->SetGuidance("Set e+- bremsstrahlung e << 281 brCmd->SetGuidance("Set bremsstrahlung energy threshold");
277 brCmd->SetParameterName("emaxBrem",true); 282 brCmd->SetParameterName("emaxBrem",true);
278 brCmd->SetUnitCategory("Energy"); 283 brCmd->SetUnitCategory("Energy");
279 brCmd->AvailableForStates(G4State_PreInit); << 284 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 285
289 labCmd = new G4UIcmdWithADouble("/process/eL 286 labCmd = new G4UIcmdWithADouble("/process/eLoss/LambdaFactor",this);
290 labCmd->SetGuidance("Set lambdaFactor parame 287 labCmd->SetGuidance("Set lambdaFactor parameter for integral option");
291 labCmd->SetParameterName("Fl",true); 288 labCmd->SetParameterName("Fl",true);
292 labCmd->AvailableForStates(G4State_PreInit,G 289 labCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
293 labCmd->SetToBeBroadcasted(false); <<
294 290
295 mscfCmd = new G4UIcmdWithADouble("/process/m 291 mscfCmd = new G4UIcmdWithADouble("/process/msc/FactorForAngleLimit",this);
296 mscfCmd->SetGuidance("Set factor for computa 292 mscfCmd->SetGuidance("Set factor for computation of a limit for -t (invariant transfer)");
297 mscfCmd->SetParameterName("Fact",true); 293 mscfCmd->SetParameterName("Fact",true);
298 mscfCmd->SetRange("Fact>0"); 294 mscfCmd->SetRange("Fact>0");
299 mscfCmd->SetDefaultValue(1.); 295 mscfCmd->SetDefaultValue(1.);
300 mscfCmd->AvailableForStates(G4State_PreInit) 296 mscfCmd->AvailableForStates(G4State_PreInit);
301 mscfCmd->SetToBeBroadcasted(false); <<
302 297
303 angCmd = new G4UIcmdWithADoubleAndUnit("/pro 298 angCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/ThetaLimit",this);
304 angCmd->SetGuidance("Set the limit on the po 299 angCmd->SetGuidance("Set the limit on the polar angle for msc and single scattering");
305 angCmd->SetParameterName("theta",true); 300 angCmd->SetParameterName("theta",true);
306 angCmd->SetUnitCategory("Angle"); 301 angCmd->SetUnitCategory("Angle");
307 angCmd->AvailableForStates(G4State_PreInit); << 302 angCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
308 angCmd->SetToBeBroadcasted(false); <<
309 303
310 msceCmd = new G4UIcmdWithADoubleAndUnit("/pr 304 msceCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/EnergyLimit",this);
311 msceCmd->SetGuidance("Set the upper energy l 305 msceCmd->SetGuidance("Set the upper energy limit for msc");
312 msceCmd->SetParameterName("mscE",true); 306 msceCmd->SetParameterName("mscE",true);
313 msceCmd->SetUnitCategory("Energy"); 307 msceCmd->SetUnitCategory("Energy");
314 msceCmd->AvailableForStates(G4State_PreInit) 308 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 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); <<
331 316
332 fr1Cmd = new G4UIcmdWithADouble("/process/ms 317 fr1Cmd = new G4UIcmdWithADouble("/process/msc/RangeFactorMuHad",this);
333 fr1Cmd->SetGuidance("Set RangeFactor for msc 318 fr1Cmd->SetGuidance("Set RangeFactor for msc processes of muons/hadrons");
334 fr1Cmd->SetParameterName("Fr1",true); 319 fr1Cmd->SetParameterName("Fr1",true);
335 fr1Cmd->SetRange("Fr1>0"); 320 fr1Cmd->SetRange("Fr1>0");
336 fr1Cmd->SetDefaultValue(0.2); 321 fr1Cmd->SetDefaultValue(0.2);
337 fr1Cmd->AvailableForStates(G4State_PreInit,G 322 fr1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
338 fr1Cmd->SetToBeBroadcasted(false); <<
339 323
340 fgCmd = new G4UIcmdWithADouble("/process/msc 324 fgCmd = new G4UIcmdWithADouble("/process/msc/GeomFactor",this);
341 fgCmd->SetGuidance("Set GeomFactor parameter 325 fgCmd->SetGuidance("Set GeomFactor parameter for msc processes");
342 fgCmd->SetParameterName("Fg",true); 326 fgCmd->SetParameterName("Fg",true);
343 fgCmd->SetRange("Fg>0"); 327 fgCmd->SetRange("Fg>0");
344 fgCmd->SetDefaultValue(2.5); << 328 fgCmd->SetDefaultValue(3.5);
345 fgCmd->AvailableForStates(G4State_PreInit,G4 329 fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
346 fgCmd->SetToBeBroadcasted(false); <<
347 330
348 skinCmd = new G4UIcmdWithADouble("/process/m 331 skinCmd = new G4UIcmdWithADouble("/process/msc/Skin",this);
349 skinCmd->SetGuidance("Set skin parameter for 332 skinCmd->SetGuidance("Set skin parameter for msc processes");
350 skinCmd->SetParameterName("skin",true); 333 skinCmd->SetParameterName("skin",true);
351 skinCmd->AvailableForStates(G4State_PreInit, 334 skinCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
352 skinCmd->SetToBeBroadcasted(false); <<
353 335
354 screCmd = new G4UIcmdWithADouble("/process/m 336 screCmd = new G4UIcmdWithADouble("/process/msc/ScreeningFactor",this);
355 screCmd->SetGuidance("Set screening factor") 337 screCmd->SetGuidance("Set screening factor");
356 screCmd->SetParameterName("screen",true); 338 screCmd->SetParameterName("screen",true);
357 screCmd->AvailableForStates(G4State_PreInit) << 339 screCmd->AvailableForStates(G4State_Idle);
358 screCmd->SetToBeBroadcasted(false); <<
359 340
360 safCmd = new G4UIcmdWithADouble("/process/ms << 341 dedxCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsDEDX",this);
361 safCmd->SetGuidance("Set safety factor"); << 342 dedxCmd->SetGuidance("Set number of bins for EM tables");
362 safCmd->SetParameterName("fsafe",true); << 343 dedxCmd->SetParameterName("binsDEDX",true);
363 safCmd->AvailableForStates(G4State_PreInit); << 344 dedxCmd->SetDefaultValue(84);
364 safCmd->SetToBeBroadcasted(false); << 345 dedxCmd->AvailableForStates(G4State_PreInit);
365 << 346
366 llimCmd = new G4UIcmdWithADoubleAndUnit("/pr << 347 lamCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsLambda",this);
367 llimCmd->SetGuidance("Set the upper energy l << 348 lamCmd->SetGuidance("Set number of bins for EM tables");
368 llimCmd->SetParameterName("ll",true); << 349 lamCmd->SetParameterName("binsL",true);
369 llimCmd->SetUnitCategory("Length"); << 350 lamCmd->SetDefaultValue(84);
370 llimCmd->AvailableForStates(G4State_PreInit) << 351 lamCmd->AvailableForStates(G4State_PreInit);
371 llimCmd->SetToBeBroadcasted(false); <<
372 352
373 amCmd = new G4UIcmdWithAnInteger("/process/e << 353 amCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsPerDecade",this);
374 amCmd->SetGuidance("Set number of bins per d 354 amCmd->SetGuidance("Set number of bins per decade for EM tables");
375 amCmd->SetParameterName("bins",true); 355 amCmd->SetParameterName("bins",true);
376 amCmd->SetDefaultValue(7); 356 amCmd->SetDefaultValue(7);
377 amCmd->AvailableForStates(G4State_PreInit); 357 amCmd->AvailableForStates(G4State_PreInit);
378 amCmd->SetToBeBroadcasted(false); <<
379 358
380 verCmd = new G4UIcmdWithAnInteger("/process/ 359 verCmd = new G4UIcmdWithAnInteger("/process/eLoss/verbose",this);
381 verCmd->SetGuidance("Set verbose level for E 360 verCmd->SetGuidance("Set verbose level for EM physics");
382 verCmd->SetParameterName("verb",true); 361 verCmd->SetParameterName("verb",true);
383 verCmd->SetDefaultValue(1); 362 verCmd->SetDefaultValue(1);
384 verCmd->AvailableForStates(G4State_PreInit,G 363 verCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
385 verCmd->SetToBeBroadcasted(false); <<
386 364
387 ver1Cmd = new G4UIcmdWithAnInteger("/process 365 ver1Cmd = new G4UIcmdWithAnInteger("/process/em/verbose",this);
388 ver1Cmd->SetGuidance("Set verbose level for 366 ver1Cmd->SetGuidance("Set verbose level for EM physics");
389 ver1Cmd->SetParameterName("verb1",true); 367 ver1Cmd->SetParameterName("verb1",true);
390 ver1Cmd->SetDefaultValue(1); 368 ver1Cmd->SetDefaultValue(1);
391 ver1Cmd->AvailableForStates(G4State_PreInit, 369 ver1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
392 ver1Cmd->SetToBeBroadcasted(false); <<
393 370
394 ver2Cmd = new G4UIcmdWithAnInteger("/process 371 ver2Cmd = new G4UIcmdWithAnInteger("/process/em/workerVerbose",this);
395 ver2Cmd->SetGuidance("Set worker verbose lev 372 ver2Cmd->SetGuidance("Set worker verbose level for EM physics");
396 ver2Cmd->SetParameterName("verb2",true); 373 ver2Cmd->SetParameterName("verb2",true);
397 ver2Cmd->SetDefaultValue(0); << 374 ver2Cmd->SetDefaultValue(1);
398 ver2Cmd->AvailableForStates(G4State_PreInit, 375 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 376
415 mscCmd = new G4UIcmdWithAString("/process/ms 377 mscCmd = new G4UIcmdWithAString("/process/msc/StepLimit",this);
416 mscCmd->SetGuidance("Set msc step limitation 378 mscCmd->SetGuidance("Set msc step limitation type");
417 mscCmd->SetParameterName("StepLim",true); 379 mscCmd->SetParameterName("StepLim",true);
418 mscCmd->SetCandidates("Minimal UseSafety Use 380 mscCmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary");
419 mscCmd->AvailableForStates(G4State_PreInit,G 381 mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
420 mscCmd->SetToBeBroadcasted(false); <<
421 382
422 msc1Cmd = new G4UIcmdWithAString("/process/m 383 msc1Cmd = new G4UIcmdWithAString("/process/msc/StepLimitMuHad",this);
423 msc1Cmd->SetGuidance("Set msc step limitatio 384 msc1Cmd->SetGuidance("Set msc step limitation type for muons/hadrons");
424 msc1Cmd->SetParameterName("StepLim1",true); 385 msc1Cmd->SetParameterName("StepLim1",true);
425 msc1Cmd->SetCandidates("Minimal UseSafety Us 386 msc1Cmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary");
426 msc1Cmd->AvailableForStates(G4State_PreInit, 387 msc1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle);
427 msc1Cmd->SetToBeBroadcasted(false); << 388
>> 389 pixeXsCmd = new G4UIcmdWithAString("/process/em/pixeXSmodel",this);
>> 390 pixeXsCmd->SetGuidance("The name of PIXE cross section");
>> 391 pixeXsCmd->SetParameterName("pixeXS",true);
>> 392 pixeXsCmd->SetCandidates("ECPSSR_Analytical Empirical ECPSSR_FormFactor");
>> 393 pixeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
>> 394
>> 395 pixeeXsCmd = new G4UIcmdWithAString("/process/em/pixeElecXSmodel",this);
>> 396 pixeeXsCmd->SetGuidance("The name of PIXE cross section for electron");
>> 397 pixeeXsCmd->SetParameterName("pixeEXS",true);
>> 398 pixeeXsCmd->SetCandidates("ECPSSR_Analytical Empirical Livermore Penelope");
>> 399 pixeeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
>> 400
>> 401 dnaSolCmd = new G4UIcmdWithAString("/process/dna/e-SolvationSubType",this);
>> 402 dnaSolCmd->SetGuidance("The name of e- solvation DNA model");
>> 403 dnaSolCmd->SetParameterName("dnaSol",true);
>> 404 dnaSolCmd->SetCandidates("Ritchie1994 Terrisol1990 Meesungnoen2002");
>> 405 dnaSolCmd->AvailableForStates(G4State_PreInit);
>> 406
>> 407 paiCmd = new G4UIcommand("/process/em/AddPAIRegion",this);
>> 408 paiCmd->SetGuidance("Activate PAI in the G4Region.");
>> 409 paiCmd->SetGuidance(" partName : particle name (default - all)");
>> 410 paiCmd->SetGuidance(" regName : G4Region name");
>> 411 paiCmd->SetGuidance(" paiType : PAI, PAIphoton");
>> 412 paiCmd->AvailableForStates(G4State_PreInit);
>> 413
>> 414 G4UIparameter* part = new G4UIparameter("partName",'s',false);
>> 415 paiCmd->SetParameter(part);
>> 416
>> 417 G4UIparameter* pregName = new G4UIparameter("regName",'s',false);
>> 418 paiCmd->SetParameter(pregName);
>> 419
>> 420 G4UIparameter* ptype = new G4UIparameter("type",'s',false);
>> 421 paiCmd->SetParameter(ptype);
>> 422 ptype->SetParameterCandidates("pai PAI PAIphoton");
>> 423
>> 424 meCmd = new G4UIcmdWithAString("/process/em/AddMicroElecRegion",this);
>> 425 meCmd->SetGuidance("Activate MicroElec model in the G4Region");
>> 426 meCmd->SetParameterName("MicroElec",true);
>> 427 meCmd->AvailableForStates(G4State_PreInit);
>> 428
>> 429 dnaCmd = new G4UIcommand("/process/em/AddDNARegion",this);
>> 430 dnaCmd->SetGuidance("Activate DNA in a G4Region.");
>> 431 dnaCmd->SetGuidance(" regName : G4Region name");
>> 432 dnaCmd->SetGuidance(" dnaType : DNA_opt0, DNA_opt1, DNA_opt2");
>> 433 dnaCmd->AvailableForStates(G4State_PreInit);
>> 434
>> 435 G4UIparameter* regName = new G4UIparameter("regName",'s',false);
>> 436 dnaCmd->SetParameter(regName);
>> 437
>> 438 G4UIparameter* type = new G4UIparameter("dnaType",'s',false);
>> 439 dnaCmd->SetParameter(type);
>> 440 type->SetParameterCandidates("DNA_Opt0");
>> 441
>> 442 mscoCmd = new G4UIcommand("/process/em/AddEmRegion",this);
>> 443 mscoCmd->SetGuidance("Add optional EM configuration for a G4Region.");
>> 444 mscoCmd->SetGuidance(" regName : G4Region name");
>> 445 mscoCmd->SetGuidance(" emType : G4EmStandard, G4EmStandard_opt1, ...");
>> 446 mscoCmd->AvailableForStates(G4State_PreInit);
>> 447
>> 448 G4UIparameter* mregName = new G4UIparameter("regName",'s',false);
>> 449 mscoCmd->SetParameter(mregName);
>> 450
>> 451 G4UIparameter* mtype = new G4UIparameter("mscType",'s',false);
>> 452 mscoCmd->SetParameter(mtype);
>> 453 mtype->SetParameterCandidates("G4EmStandard G4EmStandard_opt1 G4EmStandard_opt2 G4EmStandard_opt3 G4EmStandard_opt4 G4EmStandardGS G4EmStandardSS G4EmLivermore G4EmPenelope G4RadioactiveDecay");
428 454
429 dumpCmd = new G4UIcommand("/process/em/print 455 dumpCmd = new G4UIcommand("/process/em/printParameters",this);
430 dumpCmd->SetGuidance("Print all EM parameter 456 dumpCmd->SetGuidance("Print all EM parameters.");
431 dumpCmd->AvailableForStates(G4State_PreInit, << 457
432 dumpCmd->SetToBeBroadcasted(false); << 458 SubSecCmd = new G4UIcommand("/process/eLoss/subsec",this);
>> 459 SubSecCmd->SetGuidance("Switch true/false the subcutoff generation per region.");
>> 460 SubSecCmd->SetGuidance(" subSec : true/false");
>> 461 SubSecCmd->SetGuidance(" Region : region name");
>> 462 SubSecCmd->AvailableForStates(G4State_PreInit);
>> 463
>> 464 G4UIparameter* subSec = new G4UIparameter("subSec",'s',false);
>> 465 SubSecCmd->SetParameter(subSec);
>> 466
>> 467 G4UIparameter* subSecReg = new G4UIparameter("Region",'s',false);
>> 468 SubSecCmd->SetParameter(subSecReg);
>> 469
>> 470 StepFuncCmd = new G4UIcommand("/process/eLoss/StepFunction",this);
>> 471 StepFuncCmd->SetGuidance("Set the energy loss step limitation parameters for e+-.");
>> 472 StepFuncCmd->SetGuidance(" dRoverR : max Range variation per step");
>> 473 StepFuncCmd->SetGuidance(" finalRange: range for final step");
>> 474 StepFuncCmd->SetGuidance(" unit : unit of finalRange");
>> 475 StepFuncCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
>> 476
>> 477 G4UIparameter* dRoverRPrm = new G4UIparameter("dRoverR",'d',false);
>> 478 dRoverRPrm->SetParameterRange("dRoverR>0. && dRoverR<=1.");
>> 479 StepFuncCmd->SetParameter(dRoverRPrm);
>> 480
>> 481 G4UIparameter* finalRangePrm = new G4UIparameter("finalRange",'d',false);
>> 482 finalRangePrm->SetParameterRange("finalRange>0.");
>> 483 StepFuncCmd->SetParameter(finalRangePrm);
>> 484
>> 485 G4UIparameter* unitPrm = new G4UIparameter("unit",'s',true);
>> 486 unitPrm->SetDefaultUnit("mm");
>> 487 StepFuncCmd->SetParameter(unitPrm);
>> 488
>> 489 StepFuncCmd1 = new G4UIcommand("/process/eLoss/StepFunctionMuHad",this);
>> 490 StepFuncCmd1->SetGuidance("Set the energy loss step limitation parameters for muon/hadron.");
>> 491 StepFuncCmd1->SetGuidance(" dRoverR : max Range variation per step");
>> 492 StepFuncCmd1->SetGuidance(" finalRange: range for final step");
>> 493 StepFuncCmd1->AvailableForStates(G4State_PreInit,G4State_Idle);
>> 494
>> 495 G4UIparameter* dRoverRPrm1 = new G4UIparameter("dRoverRMuHad",'d',false);
>> 496 dRoverRPrm1->SetParameterRange("dRoverRMuHad>0. && dRoverRMuHad<=1.");
>> 497 StepFuncCmd1->SetParameter(dRoverRPrm1);
>> 498
>> 499 G4UIparameter* finalRangePrm1 = new G4UIparameter("finalRangeMuHad",'d',false);
>> 500 finalRangePrm1->SetParameterRange("finalRangeMuHad>0.");
>> 501 StepFuncCmd1->SetParameter(finalRangePrm1);
>> 502
>> 503 G4UIparameter* unitPrm1 = new G4UIparameter("unit",'s',true);
>> 504 unitPrm1->SetDefaultValue("mm");
>> 505 StepFuncCmd1->SetParameter(unitPrm1);
>> 506
>> 507 deexCmd = new G4UIcommand("/process/em/deexcitation",this);
>> 508 deexCmd->SetGuidance("Set deexcitation flags per G4Region.");
>> 509 deexCmd->SetGuidance(" regName : G4Region name");
>> 510 deexCmd->SetGuidance(" flagFluo : Fluorescence");
>> 511 deexCmd->SetGuidance(" flagAuger : Auger");
>> 512 deexCmd->SetGuidance(" flagPIXE : PIXE");
>> 513 deexCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
>> 514
>> 515 G4UIparameter* regNameD = new G4UIparameter("regName",'s',false);
>> 516 deexCmd->SetParameter(regNameD);
>> 517
>> 518 G4UIparameter* flagFluo = new G4UIparameter("flagFluo",'s',false);
>> 519 deexCmd->SetParameter(flagFluo);
>> 520
>> 521 G4UIparameter* flagAuger = new G4UIparameter("flagAuger",'s',false);
>> 522 deexCmd->SetParameter(flagAuger);
>> 523
>> 524 G4UIparameter* flagPIXE = new G4UIparameter("flagPIXE",'s',false);
>> 525 deexCmd->SetParameter(flagPIXE);
>> 526
>> 527 bfCmd = new G4UIcommand("/process/em/setBiasingFactor",this);
>> 528 bfCmd->SetGuidance("Set factor for the process cross section.");
>> 529 bfCmd->SetGuidance(" procName : process name");
>> 530 bfCmd->SetGuidance(" procFact : factor");
>> 531 bfCmd->SetGuidance(" flagFact : flag to change weight");
>> 532 bfCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
>> 533
>> 534 G4UIparameter* procName = new G4UIparameter("procName",'s',false);
>> 535 bfCmd->SetParameter(procName);
>> 536
>> 537 G4UIparameter* procFact = new G4UIparameter("procFact",'d',false);
>> 538 bfCmd->SetParameter(procFact);
>> 539
>> 540 G4UIparameter* flagFact = new G4UIparameter("flagFact",'s',false);
>> 541 bfCmd->SetParameter(flagFact);
>> 542
>> 543 fiCmd = new G4UIcommand("/process/em/setForcedInteraction",this);
>> 544 fiCmd->SetGuidance("Set factor for the process cross section.");
>> 545 fiCmd->SetGuidance(" procNam : process name");
>> 546 fiCmd->SetGuidance(" regNam : region name");
>> 547 fiCmd->SetGuidance(" tlength : fixed target length");
>> 548 fiCmd->SetGuidance(" unitT : length unit");
>> 549 fiCmd->SetGuidance(" tflag : flag to change weight");
>> 550 fiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
>> 551
>> 552 G4UIparameter* procNam = new G4UIparameter("procNam",'s',false);
>> 553 fiCmd->SetParameter(procNam);
>> 554
>> 555 G4UIparameter* regNam = new G4UIparameter("regNam",'s',false);
>> 556 fiCmd->SetParameter(regNam);
>> 557
>> 558 G4UIparameter* tlength = new G4UIparameter("tlength",'d',false);
>> 559 tlength->SetParameterRange("tlength>0");
>> 560 fiCmd->SetParameter(tlength);
>> 561
>> 562 G4UIparameter* unitT = new G4UIparameter("unitT",'s',true);
>> 563 unitT->SetDefaultUnit("mm");
>> 564 fiCmd->SetParameter(unitT);
>> 565
>> 566 G4UIparameter* flagT = new G4UIparameter("tflag",'b',true);
>> 567 flagT->SetDefaultValue(true);
>> 568 fiCmd->SetParameter(flagT);
>> 569
>> 570 bsCmd = new G4UIcommand("/process/em/setSecBiasing",this);
>> 571 bsCmd->SetGuidance("Set bremsstrahlung or delta-e- splitting/Russian roulette per region.");
>> 572 bsCmd->SetGuidance(" bProcNam : process name");
>> 573 bsCmd->SetGuidance(" bRegNam : region name");
>> 574 bsCmd->SetGuidance(" bFactor : number of split gamma or probability of Russian roulette");
>> 575 bsCmd->SetGuidance(" bEnergy : max energy of a secondary for this biasing method");
>> 576 bsCmd->SetGuidance(" bUnit : energy unit");
>> 577 bsCmd->AvailableForStates(G4State_Idle,G4State_Idle);
>> 578
>> 579 G4UIparameter* bProcNam = new G4UIparameter("bProcNam",'s',false);
>> 580 bsCmd->SetParameter(bProcNam);
>> 581
>> 582 G4UIparameter* bRegNam = new G4UIparameter("bRegNam",'s',false);
>> 583 bsCmd->SetParameter(bRegNam);
>> 584
>> 585 G4UIparameter* bFactor = new G4UIparameter("bFactor",'d',false);
>> 586 bsCmd->SetParameter(bFactor);
>> 587
>> 588 G4UIparameter* bEnergy = new G4UIparameter("bEnergy",'d',false);
>> 589 bsCmd->SetParameter(bEnergy);
>> 590
>> 591 G4UIparameter* bUnit = new G4UIparameter("bUnit",'s',true);
>> 592 bUnit->SetDefaultUnit("MeV");
>> 593 bsCmd->SetParameter(bUnit);
>> 594
>> 595 dirSplitCmd = new G4UIcmdWithABool("/process/em/setDirectionalSplitting",this);
>> 596 dirSplitCmd->SetGuidance("Enable directional brem splitting");
>> 597 dirSplitCmd->AvailableForStates(G4State_Idle,G4State_Idle);
>> 598
>> 599 dirSplitTargetCmd = new G4UIcmdWith3VectorAndUnit("/process/em/setDirectionalSplittingTarget",this);
>> 600 dirSplitTargetCmd->SetGuidance("Position of arget for directional splitting");
>> 601 dirSplitTargetCmd->AvailableForStates(G4State_Idle,G4State_Idle);
>> 602
>> 603 dirSplitRadiusCmd = new G4UIcmdWithADoubleAndUnit("/process/em/setDirectionalSplittingRadius",this);
>> 604 dirSplitRadiusCmd->SetGuidance("Radius of target for directional splitting");
>> 605 dirSplitRadiusCmd->AvailableForStates(G4State_Idle,G4State_Idle);
433 606
434 nffCmd = new G4UIcmdWithAString("/process/em 607 nffCmd = new G4UIcmdWithAString("/process/em/setNuclearFormFactor",this);
435 nffCmd->SetGuidance("Define type of nuclear << 608 nffCmd->SetGuidance("Define typy of nuclear form-factor");
436 nffCmd->SetParameterName("NucFF",true); 609 nffCmd->SetParameterName("NucFF",true);
437 nffCmd->SetCandidates("None Exponential Gaus 610 nffCmd->SetCandidates("None Exponential Gaussian Flat");
438 nffCmd->AvailableForStates(G4State_PreInit); 611 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 612
462 tripletCmd = new G4UIcmdWithAnInteger("/proc 613 tripletCmd = new G4UIcmdWithAnInteger("/process/gconv/conversionType",this);
463 tripletCmd->SetGuidance("gamma conversion tr 614 tripletCmd->SetGuidance("gamma conversion triplet/nuclear generation type:");
464 tripletCmd->SetGuidance("0 - (default) both 615 tripletCmd->SetGuidance("0 - (default) both triplet and nuclear");
465 tripletCmd->SetGuidance("1 - force nuclear") 616 tripletCmd->SetGuidance("1 - force nuclear");
466 tripletCmd->SetGuidance("2 - force triplet") 617 tripletCmd->SetGuidance("2 - force triplet");
467 tripletCmd->SetParameterName("type",false); 618 tripletCmd->SetParameterName("type",false);
468 tripletCmd->SetRange("type >= 0 && type <= 2 619 tripletCmd->SetRange("type >= 0 && type <= 2");
469 tripletCmd->SetDefaultValue(0); 620 tripletCmd->SetDefaultValue(0);
470 tripletCmd->AvailableForStates(G4State_PreIn 621 tripletCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
471 tripletCmd->SetToBeBroadcasted(false); <<
472 622
473 onIsolatedCmd = new G4UIcmdWithABool("/proce 623 onIsolatedCmd = new G4UIcmdWithABool("/process/gconv/onIsolated",this);
474 onIsolatedCmd->SetGuidance("Conversion on is 624 onIsolatedCmd->SetGuidance("Conversion on isolated charged particles");
475 onIsolatedCmd->SetGuidance("false (default) 625 onIsolatedCmd->SetGuidance("false (default) : atomic electron screening");
476 onIsolatedCmd->SetGuidance("true : conversio 626 onIsolatedCmd->SetGuidance("true : conversion on isolated particles.");
477 onIsolatedCmd->SetParameterName("flag",false 627 onIsolatedCmd->SetParameterName("flag",false);
478 onIsolatedCmd->SetDefaultValue(false); 628 onIsolatedCmd->SetDefaultValue(false);
479 onIsolatedCmd->AvailableForStates(G4State_Pr 629 onIsolatedCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
480 onIsolatedCmd->SetToBeBroadcasted(false); <<
481 } 630 }
482 631
483 //....oooOO0OOooo........oooOO0OOooo........oo 632 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
484 633
485 G4EmParametersMessenger::~G4EmParametersMessen 634 G4EmParametersMessenger::~G4EmParametersMessenger()
486 { 635 {
487 delete gconvDirectory; 636 delete gconvDirectory;
488 delete eLossDirectory; 637 delete eLossDirectory;
489 delete mscDirectory; 638 delete mscDirectory;
490 delete emDirectory; 639 delete emDirectory;
491 delete dnaDirectory; 640 delete dnaDirectory;
492 641
493 delete flucCmd; 642 delete flucCmd;
494 delete rangeCmd; 643 delete rangeCmd;
495 delete lpmCmd; 644 delete lpmCmd;
>> 645 delete splCmd;
496 delete rsCmd; 646 delete rsCmd;
497 delete aplCmd; 647 delete aplCmd;
498 delete intCmd; << 648 delete deCmd;
>> 649 delete dirFluoCmd;
>> 650 delete auCmd;
>> 651 delete auCascadeCmd;
>> 652 delete pixeCmd;
>> 653 delete dcutCmd;
499 delete latCmd; 654 delete latCmd;
500 delete lat96Cmd; 655 delete lat96Cmd;
501 delete mulatCmd; 656 delete mulatCmd;
>> 657 delete catCmd;
502 delete delCmd; 658 delete delCmd;
>> 659 delete IntegCmd;
503 delete mottCmd; 660 delete mottCmd;
504 delete birksCmd; 661 delete birksCmd;
>> 662 delete dnafCmd;
>> 663 delete dnasCmd;
>> 664 delete dnamscCmd;
505 delete sharkCmd; 665 delete sharkCmd;
506 delete onIsolatedCmd; <<
507 delete sampleTCmd; 666 delete sampleTCmd;
508 delete poCmd; <<
509 delete icru90Cmd; 667 delete icru90Cmd;
510 delete mudatCmd; <<
511 delete peKCmd; <<
512 delete f3gCmd; <<
513 delete mscPCmd; <<
514 delete pepicsCmd; <<
515 668
>> 669 delete minSubSecCmd;
516 delete minEnCmd; 670 delete minEnCmd;
517 delete maxEnCmd; 671 delete maxEnCmd;
518 delete max5DCmd; <<
519 delete cenCmd; 672 delete cenCmd;
520 delete lowEnCmd; 673 delete lowEnCmd;
521 delete lowhEnCmd; 674 delete lowhEnCmd;
522 delete lowEn3Cmd; 675 delete lowEn3Cmd;
523 delete lllCmd; 676 delete lllCmd;
524 delete brCmd; 677 delete brCmd;
525 delete br1Cmd; <<
526 delete labCmd; 678 delete labCmd;
527 delete mscfCmd; 679 delete mscfCmd;
528 delete angCmd; 680 delete angCmd;
529 delete msceCmd; 681 delete msceCmd;
530 delete nielCmd; <<
531 delete frCmd; 682 delete frCmd;
532 delete fr1Cmd; 683 delete fr1Cmd;
533 delete fgCmd; 684 delete fgCmd;
534 delete skinCmd; 685 delete skinCmd;
535 delete safCmd; <<
536 delete llimCmd; <<
537 delete screCmd; 686 delete screCmd;
538 687
>> 688 delete dedxCmd;
>> 689 delete lamCmd;
539 delete amCmd; 690 delete amCmd;
540 delete verCmd; 691 delete verCmd;
541 delete ver1Cmd; 692 delete ver1Cmd;
542 delete ver2Cmd; 693 delete ver2Cmd;
543 delete transWithMscCmd; <<
544 delete nFreeCmd; <<
545 delete tripletCmd; <<
546 694
547 delete mscCmd; 695 delete mscCmd;
548 delete msc1Cmd; 696 delete msc1Cmd;
549 delete nffCmd; <<
550 delete ssCmd; <<
551 delete fluc1Cmd; <<
552 delete posiCmd; <<
553 697
>> 698 delete pixeXsCmd;
>> 699 delete pixeeXsCmd;
>> 700 delete dnaSolCmd;
>> 701
>> 702 delete paiCmd;
>> 703 delete meCmd;
>> 704 delete dnaCmd;
>> 705 delete mscoCmd;
554 delete dumpCmd; 706 delete dumpCmd;
>> 707
>> 708 delete SubSecCmd;
>> 709 delete StepFuncCmd;
>> 710 delete StepFuncCmd1;
>> 711 delete deexCmd;
>> 712 delete bfCmd;
>> 713 delete fiCmd;
>> 714 delete bsCmd;
>> 715 delete dirSplitCmd;
>> 716 delete dirSplitTargetCmd;
>> 717 delete dirSplitRadiusCmd;
>> 718 delete nffCmd;
>> 719
>> 720 delete onIsolatedCmd;
>> 721 delete tripletCmd;
555 } 722 }
556 723
557 //....oooOO0OOooo........oooOO0OOooo........oo 724 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
558 725
559 void G4EmParametersMessenger::SetNewValue(G4UI 726 void G4EmParametersMessenger::SetNewValue(G4UIcommand* command,
560 G4St 727 G4String newValue)
561 { 728 {
562 G4bool physicsModified = false; 729 G4bool physicsModified = false;
563 if (command == flucCmd) { 730 if (command == flucCmd) {
564 theParameters->SetLossFluctuations(flucCmd 731 theParameters->SetLossFluctuations(flucCmd->GetNewBoolValue(newValue));
565 physicsModified = true; 732 physicsModified = true;
566 } else if (command == rangeCmd) { 733 } else if (command == rangeCmd) {
567 theParameters->SetBuildCSDARange(rangeCmd- 734 theParameters->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue));
568 } else if (command == lpmCmd) { 735 } else if (command == lpmCmd) {
569 theParameters->SetLPM(lpmCmd->GetNewBoolVa 736 theParameters->SetLPM(lpmCmd->GetNewBoolValue(newValue));
570 physicsModified = true; 737 physicsModified = true;
>> 738 } else if (command == splCmd) {
>> 739 theParameters->SetSpline(splCmd->GetNewBoolValue(newValue));
571 } else if (command == rsCmd) { 740 } else if (command == rsCmd) {
572 theParameters->SetUseCutAsFinalRange(rsCmd 741 theParameters->SetUseCutAsFinalRange(rsCmd->GetNewBoolValue(newValue));
573 physicsModified = true; 742 physicsModified = true;
574 } else if (command == aplCmd) { 743 } else if (command == aplCmd) {
575 theParameters->SetApplyCuts(aplCmd->GetNew 744 theParameters->SetApplyCuts(aplCmd->GetNewBoolValue(newValue));
576 physicsModified = true; 745 physicsModified = true;
577 } else if (command == intCmd) { << 746 } else if (command == deCmd) {
578 theParameters->SetIntegral(intCmd->GetNewB << 747 theParameters->SetFluo(deCmd->GetNewBoolValue(newValue));
>> 748 physicsModified = true;
>> 749 } else if (command == dirFluoCmd) {
>> 750 theParameters->SetBeardenFluoDir(dirFluoCmd->GetNewBoolValue(newValue));
>> 751 } else if (command == auCmd) {
>> 752 theParameters->SetAuger(auCmd->GetNewBoolValue(newValue));
>> 753 physicsModified = true;
>> 754 } else if (command == auCascadeCmd) {
>> 755 theParameters->SetAugerCascade(auCascadeCmd->GetNewBoolValue(newValue));
>> 756 physicsModified = true;
>> 757 } else if (command == pixeCmd) {
>> 758 theParameters->SetPixe(pixeCmd->GetNewBoolValue(newValue));
>> 759 physicsModified = true;
>> 760 } else if (command == dcutCmd) {
>> 761 theParameters->SetDeexcitationIgnoreCut(dcutCmd->GetNewBoolValue(newValue));
>> 762 physicsModified = true;
579 } else if (command == latCmd) { 763 } else if (command == latCmd) {
580 theParameters->SetLateralDisplacement(latC 764 theParameters->SetLateralDisplacement(latCmd->GetNewBoolValue(newValue));
581 physicsModified = true; 765 physicsModified = true;
582 } else if (command == lat96Cmd) { 766 } else if (command == lat96Cmd) {
583 theParameters->SetLateralDisplacementAlg96 767 theParameters->SetLateralDisplacementAlg96(lat96Cmd->GetNewBoolValue(newValue));
584 physicsModified = true; 768 physicsModified = true;
585 } else if (command == mulatCmd) { 769 } else if (command == mulatCmd) {
586 theParameters->SetMuHadLateralDisplacement 770 theParameters->SetMuHadLateralDisplacement(mulatCmd->GetNewBoolValue(newValue));
587 physicsModified = true; 771 physicsModified = true;
>> 772 } else if (command == catCmd) {
>> 773 theParameters->SetLatDisplacementBeyondSafety(catCmd->GetNewBoolValue(newValue));
>> 774 physicsModified = true;
588 } else if (command == delCmd) { 775 } else if (command == delCmd) {
589 theParameters->ActivateAngularGeneratorFor 776 theParameters->ActivateAngularGeneratorForIonisation(delCmd->GetNewBoolValue(newValue));
>> 777 } else if (command == IntegCmd) {
>> 778 theParameters->SetIntegral(IntegCmd->GetNewBoolValue(newValue));
>> 779 physicsModified = true;
590 } else if (command == mottCmd) { 780 } else if (command == mottCmd) {
591 theParameters->SetUseMottCorrection(mottCm 781 theParameters->SetUseMottCorrection(mottCmd->GetNewBoolValue(newValue));
592 } else if (command == birksCmd) { 782 } else if (command == birksCmd) {
593 theParameters->SetBirksActive(birksCmd->Ge 783 theParameters->SetBirksActive(birksCmd->GetNewBoolValue(newValue));
594 } else if (command == icru90Cmd) { 784 } else if (command == icru90Cmd) {
595 theParameters->SetUseICRU90Data(icru90Cmd- 785 theParameters->SetUseICRU90Data(icru90Cmd->GetNewBoolValue(newValue));
>> 786 } else if (command == dnafCmd) {
>> 787 theParameters->SetDNAFast(dnafCmd->GetNewBoolValue(newValue));
>> 788 } else if (command == dnasCmd) {
>> 789 theParameters->SetDNAStationary(dnasCmd->GetNewBoolValue(newValue));
>> 790 } else if (command == dnamscCmd) {
>> 791 theParameters->SetDNAElectronMsc(dnamscCmd->GetNewBoolValue(newValue));
>> 792 } else if (command == dnaSolCmd) {
>> 793 G4DNAModelSubType ttt = fDNAUnknownModel;
>> 794 if(newValue == "Ritchie1994") {
>> 795 ttt = fRitchie1994eSolvation;
>> 796 } else if(newValue == "Terrisol1990") {
>> 797 ttt = fTerrisol1990eSolvation;
>> 798 } else if (newValue == "Meesungnoen2002") {
>> 799 ttt = fMeesungnoen2002eSolvation;
>> 800 }
>> 801 theParameters->SetDNAeSolvationSubType(ttt);
596 } else if (command == sharkCmd) { 802 } else if (command == sharkCmd) {
597 theParameters->SetGeneralProcessActive(sha 803 theParameters->SetGeneralProcessActive(sharkCmd->GetNewBoolValue(newValue));
598 } else if (command == poCmd) { <<
599 theParameters->SetEnablePolarisation(poCmd <<
600 } else if (command == sampleTCmd) { 804 } else if (command == sampleTCmd) {
601 theParameters->SetEnableSamplingTable(samp 805 theParameters->SetEnableSamplingTable(sampleTCmd->GetNewBoolValue(newValue));
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 806
>> 807 } else if (command == minSubSecCmd) {
>> 808 theParameters->SetMinSubRange(minSubSecCmd->GetNewDoubleValue(newValue));
613 } else if (command == minEnCmd) { 809 } else if (command == minEnCmd) {
614 theParameters->SetMinEnergy(minEnCmd->GetN 810 theParameters->SetMinEnergy(minEnCmd->GetNewDoubleValue(newValue));
615 } else if (command == maxEnCmd) { 811 } else if (command == maxEnCmd) {
616 theParameters->SetMaxEnergy(maxEnCmd->GetN 812 theParameters->SetMaxEnergy(maxEnCmd->GetNewDoubleValue(newValue));
617 } else if (command == max5DCmd) { <<
618 theParameters->SetMaxEnergyFor5DMuPair(max <<
619 } else if (command == cenCmd) { 813 } else if (command == cenCmd) {
620 theParameters->SetMaxEnergyForCSDARange(ce 814 theParameters->SetMaxEnergyForCSDARange(cenCmd->GetNewDoubleValue(newValue));
621 physicsModified = true; 815 physicsModified = true;
622 } else if (command == lowEnCmd) { 816 } else if (command == lowEnCmd) {
623 theParameters->SetLowestElectronEnergy(low 817 theParameters->SetLowestElectronEnergy(lowEnCmd->GetNewDoubleValue(newValue));
624 physicsModified = true; 818 physicsModified = true;
625 } else if (command == lowEn3Cmd) { 819 } else if (command == lowEn3Cmd) {
626 theParameters->SetLowestTripletEnergy(lowE 820 theParameters->SetLowestTripletEnergy(lowEn3Cmd->GetNewDoubleValue(newValue));
627 physicsModified = true; 821 physicsModified = true;
628 } else if (command == lowhEnCmd) { 822 } else if (command == lowhEnCmd) {
629 theParameters->SetLowestMuHadEnergy(lowhEn 823 theParameters->SetLowestMuHadEnergy(lowhEnCmd->GetNewDoubleValue(newValue));
630 physicsModified = true; 824 physicsModified = true;
631 } else if (command == lllCmd) { 825 } else if (command == lllCmd) {
632 theParameters->SetLinearLossLimit(lllCmd-> 826 theParameters->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue));
633 physicsModified = true; 827 physicsModified = true;
634 } else if (command == brCmd) { 828 } else if (command == brCmd) {
635 theParameters->SetBremsstrahlungTh(brCmd-> 829 theParameters->SetBremsstrahlungTh(brCmd->GetNewDoubleValue(newValue));
636 physicsModified = true; 830 physicsModified = true;
637 } else if (command == br1Cmd) { <<
638 theParameters->SetMuHadBremsstrahlungTh(br <<
639 physicsModified = true; <<
640 } else if (command == labCmd) { 831 } else if (command == labCmd) {
641 theParameters->SetLambdaFactor(labCmd->Get 832 theParameters->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue));
642 physicsModified = true; 833 physicsModified = true;
643 } else if (command == mscfCmd) { 834 } else if (command == mscfCmd) {
644 theParameters->SetFactorForAngleLimit(mscf 835 theParameters->SetFactorForAngleLimit(mscfCmd->GetNewDoubleValue(newValue));
645 } else if (command == angCmd) { 836 } else if (command == angCmd) {
646 theParameters->SetMscThetaLimit(angCmd->Ge 837 theParameters->SetMscThetaLimit(angCmd->GetNewDoubleValue(newValue));
>> 838 physicsModified = true;
647 } else if (command == msceCmd) { 839 } else if (command == msceCmd) {
648 theParameters->SetMscEnergyLimit(msceCmd-> 840 theParameters->SetMscEnergyLimit(msceCmd->GetNewDoubleValue(newValue));
649 } else if (command == nielCmd) { <<
650 theParameters->SetMaxNIELEnergy(nielCmd->G <<
651 } else if (command == frCmd) { 841 } else if (command == frCmd) {
652 theParameters->SetMscRangeFactor(frCmd->Ge 842 theParameters->SetMscRangeFactor(frCmd->GetNewDoubleValue(newValue));
653 physicsModified = true; 843 physicsModified = true;
654 } else if (command == fr1Cmd) { 844 } else if (command == fr1Cmd) {
655 theParameters->SetMscMuHadRangeFactor(fr1C 845 theParameters->SetMscMuHadRangeFactor(fr1Cmd->GetNewDoubleValue(newValue));
656 physicsModified = true; 846 physicsModified = true;
657 } else if (command == fgCmd) { 847 } else if (command == fgCmd) {
658 theParameters->SetMscGeomFactor(fgCmd->Get 848 theParameters->SetMscGeomFactor(fgCmd->GetNewDoubleValue(newValue));
659 physicsModified = true; 849 physicsModified = true;
660 } else if (command == skinCmd) { 850 } else if (command == skinCmd) {
661 theParameters->SetMscSkin(skinCmd->GetNewD 851 theParameters->SetMscSkin(skinCmd->GetNewDoubleValue(newValue));
662 physicsModified = true; 852 physicsModified = true;
663 } else if (command == safCmd) { <<
664 theParameters->SetMscSafetyFactor(safCmd-> <<
665 } else if (command == llimCmd) { <<
666 theParameters->SetMscLambdaLimit(llimCmd-> <<
667 } else if (command == screCmd) { 853 } else if (command == screCmd) {
668 theParameters->SetScreeningFactor(screCmd- 854 theParameters->SetScreeningFactor(screCmd->GetNewDoubleValue(newValue));
669 } else if (command == amCmd) { << 855
>> 856 } else if (command == dedxCmd) {
>> 857 theParameters->SetNumberOfBins(dedxCmd->GetNewIntValue(newValue));
>> 858 } else if (command == lamCmd) {
>> 859 theParameters->SetNumberOfBins(lamCmd->GetNewIntValue(newValue));
>> 860 } else if (command == amCmd) {
670 theParameters->SetNumberOfBinsPerDecade(am 861 theParameters->SetNumberOfBinsPerDecade(amCmd->GetNewIntValue(newValue));
671 } else if (command == verCmd) { 862 } else if (command == verCmd) {
672 theParameters->SetVerbose(verCmd->GetNewIn 863 theParameters->SetVerbose(verCmd->GetNewIntValue(newValue));
673 } else if (command == ver1Cmd) { 864 } else if (command == ver1Cmd) {
674 theParameters->SetVerbose(ver1Cmd->GetNewI 865 theParameters->SetVerbose(ver1Cmd->GetNewIntValue(newValue));
>> 866 physicsModified = true;
675 } else if (command == ver2Cmd) { 867 } else if (command == ver2Cmd) {
676 theParameters->SetWorkerVerbose(ver2Cmd->G 868 theParameters->SetWorkerVerbose(ver2Cmd->GetNewIntValue(newValue));
677 } else if (command == nFreeCmd) { << 869 physicsModified = true;
678 theParameters->SetNumberForFreeVector(nFre << 870
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 871 } else if (command == mscCmd || command == msc1Cmd) {
697 G4MscStepLimitType msctype = fUseSafety; 872 G4MscStepLimitType msctype = fUseSafety;
698 if(newValue == "Minimal") { 873 if(newValue == "Minimal") {
699 msctype = fMinimal; 874 msctype = fMinimal;
700 } else if(newValue == "UseDistanceToBounda 875 } else if(newValue == "UseDistanceToBoundary") {
701 msctype = fUseDistanceToBoundary; 876 msctype = fUseDistanceToBoundary;
702 } else if(newValue == "UseSafety") { 877 } else if(newValue == "UseSafety") {
703 msctype = fUseSafety; 878 msctype = fUseSafety;
704 } else if(newValue == "UseSafetyPlus") { 879 } else if(newValue == "UseSafetyPlus") {
705 msctype = fUseSafetyPlus; 880 msctype = fUseSafetyPlus;
706 } else { 881 } else {
707 G4ExceptionDescription ed; 882 G4ExceptionDescription ed;
708 ed << " StepLimit type <" << newValue << 883 ed << " StepLimit type <" << newValue << "> unknown!";
709 G4Exception("G4EmParametersMessenger", " 884 G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
710 return; 885 return;
711 } 886 }
712 if (command == mscCmd) { 887 if (command == mscCmd) {
713 theParameters->SetMscStepLimitType(mscty 888 theParameters->SetMscStepLimitType(msctype);
714 } else { 889 } else {
715 theParameters->SetMscMuHadStepLimitType( 890 theParameters->SetMscMuHadStepLimitType(msctype);
716 } 891 }
717 physicsModified = true; 892 physicsModified = true;
>> 893 } else if (command == pixeXsCmd) {
>> 894 theParameters->SetPIXECrossSectionModel(newValue);
>> 895 physicsModified = true;
>> 896 } else if (command == pixeeXsCmd) {
>> 897 theParameters->SetPIXEElectronCrossSectionModel(newValue);
>> 898 physicsModified = true;
>> 899 } else if (command == paiCmd) {
>> 900 G4String s1(""),s2(""),s3("");
>> 901 std::istringstream is(newValue);
>> 902 is >> s1 >> s2 >> s3;
>> 903 theParameters->AddPAIModel(s1, s2, s3);
>> 904 } else if (command == meCmd) {
>> 905 theParameters->AddMicroElec(newValue);
>> 906 } else if (command == dnaCmd) {
>> 907 G4String s1(""),s2("");
>> 908 std::istringstream is(newValue);
>> 909 is >> s1 >> s2;
>> 910 theParameters->AddDNA(s1, s2);
>> 911 } else if (command == mscoCmd) {
>> 912 G4String s1(""),s2("");
>> 913 std::istringstream is(newValue);
>> 914 is >> s1 >> s2;
>> 915 theParameters->AddPhysics(s1, s2);
>> 916 } else if (command == dumpCmd) {
>> 917 theParameters->Dump();
>> 918 } else if (command == SubSecCmd) {
>> 919 G4String s1, s2;
>> 920 std::istringstream is(newValue);
>> 921 is >> s1 >> s2;
>> 922 G4bool yes = false;
>> 923 if(s1 == "true") { yes = true; }
>> 924 theParameters->SetSubCutoff(yes,s2);
>> 925 } else if (command == StepFuncCmd || command == StepFuncCmd1) {
>> 926 G4double v1,v2;
>> 927 G4String unt;
>> 928 std::istringstream is(newValue);
>> 929 is >> v1 >> v2 >> unt;
>> 930 v2 *= G4UIcommand::ValueOf(unt);
>> 931 if(command == StepFuncCmd) {
>> 932 theParameters->SetStepFunction(v1,v2);
>> 933 } else {
>> 934 theParameters->SetStepFunctionMuHad(v1,v2);
>> 935 }
>> 936 physicsModified = true;
>> 937 } else if (command == deexCmd) {
>> 938 G4String s1 (""), s2(""), s3(""), s4("");
>> 939 G4bool b2(false), b3(false), b4(false);
>> 940 std::istringstream is(newValue);
>> 941 is >> s1 >> s2 >> s3 >> s4;
>> 942 if(s2 == "true") { b2 = true; }
>> 943 if(s3 == "true") { b3 = true; }
>> 944 if(s4 == "true") { b4 = true; }
>> 945 theParameters->SetDeexActiveRegion(s1,b2,b3,b4);
>> 946 physicsModified = true;
>> 947 } else if (command == bfCmd) {
>> 948 G4double v1(1.0);
>> 949 G4String s0(""),s1("");
>> 950 std::istringstream is(newValue);
>> 951 is >> s0 >> v1 >> s1;
>> 952 G4bool yes = false;
>> 953 if(s1 == "true") { yes = true; }
>> 954 theParameters->SetProcessBiasingFactor(s0,v1,yes);
>> 955 physicsModified = true;
>> 956 } else if (command == fiCmd) {
>> 957 G4double v1(0.0);
>> 958 G4String s1(""),s2(""),s3(""),unt("mm");
>> 959 std::istringstream is(newValue);
>> 960 is >> s1 >> s2 >> v1 >> unt >> s3;
>> 961 G4bool yes = false;
>> 962 if(s3 == "true") { yes = true; }
>> 963 v1 *= G4UIcommand::ValueOf(unt);
>> 964 theParameters->ActivateForcedInteraction(s1,s2,v1,yes);
>> 965 physicsModified = true;
>> 966 } else if (command == bsCmd) {
>> 967 G4double fb(1.0),en(1.e+30);
>> 968 G4String s1(""),s2(""),unt("MeV");
>> 969 std::istringstream is(newValue);
>> 970 is >> s1 >> s2 >> fb >> en >> unt;
>> 971 en *= G4UIcommand::ValueOf(unt);
>> 972 theParameters->ActivateSecondaryBiasing(s1,s2,fb,en);
>> 973 physicsModified = true;
>> 974 } else if (command == dirSplitCmd) {
>> 975 theParameters->SetDirectionalSplitting(
>> 976 dirSplitCmd->GetNewBoolValue(newValue));
>> 977 physicsModified = true;
>> 978 } else if (command == dirSplitTargetCmd) {
>> 979 G4ThreeVector t = dirSplitTargetCmd->GetNew3VectorValue(newValue);
>> 980 theParameters->SetDirectionalSplittingTarget(t);
>> 981 physicsModified = true;
>> 982 } else if (command == dirSplitRadiusCmd) {
>> 983 G4double r = dirSplitRadiusCmd->GetNewDoubleValue(newValue);
>> 984 theParameters->SetDirectionalSplittingRadius(r);
>> 985 physicsModified = true;
718 } else if (command == nffCmd) { 986 } else if (command == nffCmd) {
719 G4NuclearFormfactorType x = fNoneNF; 987 G4NuclearFormfactorType x = fNoneNF;
720 if(newValue == "Exponential") { x = fExpon 988 if(newValue == "Exponential") { x = fExponentialNF; }
721 else if(newValue == "Gaussian") { x = fGau 989 else if(newValue == "Gaussian") { x = fGaussianNF; }
722 else if(newValue == "Flat") { x = fFlatNF; 990 else if(newValue == "Flat") { x = fFlatNF; }
723 else if(newValue != "None") { 991 else if(newValue != "None") {
724 G4ExceptionDescription ed; 992 G4ExceptionDescription ed;
725 ed << " NuclearFormFactor type <" << new 993 ed << " NuclearFormFactor type <" << newValue << "> unknown!";
726 G4Exception("G4EmParametersMessenger", " 994 G4Exception("G4EmParametersMessenger", "em0044", JustWarning, ed);
727 return; 995 return;
728 } 996 }
729 theParameters->SetNuclearFormfactorType(x) 997 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 ) { 998 } else if ( command==tripletCmd ) {
753 theParameters->SetConversionType(tripletCm 999 theParameters->SetConversionType(tripletCmd->GetNewIntValue(newValue));
>> 1000 physicsModified = true;
754 } else if ( command==onIsolatedCmd ) { 1001 } else if ( command==onIsolatedCmd ) {
755 theParameters->SetOnIsolated(onIsolatedCmd 1002 theParameters->SetOnIsolated(onIsolatedCmd->GetNewBoolValue(newValue));
756 physicsModified = true; 1003 physicsModified = true;
757 } 1004 }
758 1005
759 if(physicsModified) { 1006 if(physicsModified) {
760 G4UImanager::GetUIpointer()->ApplyCommand( 1007 G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
761 } 1008 }
762 } 1009 }
763 1010
764 //....oooOO0OOooo........oooOO0OOooo........oo 1011 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
765 1012