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