Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // >> 26 // $Id: G4EmParametersMessenger.cc 66241 2012-12-13 18:34:42Z gunter $ >> 27 // 26 // ------------------------------------------- 28 // ------------------------------------------------------------------- 27 // 29 // 28 // GEANT4 Class file 30 // GEANT4 Class file 29 // 31 // 30 // File name: G4EmParametersMessenger 32 // File name: G4EmParametersMessenger 31 // 33 // 32 // Author: Vladimir Ivanchenko created 34 // Author: Vladimir Ivanchenko created from G4EnergyLossMessenger 33 // 35 // 34 // Creation date: 22-05-2013 36 // Creation date: 22-05-2013 35 // 37 // >> 38 // Modifications: >> 39 // 36 // ------------------------------------------- 40 // ------------------------------------------------------------------- 37 // 41 // 38 42 39 //....oooOO0OOooo........oooOO0OOooo........oo 43 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 40 //....oooOO0OOooo........oooOO0OOooo........oo 44 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 41 45 42 #include "G4EmParametersMessenger.hh" 46 #include "G4EmParametersMessenger.hh" 43 #include "G4UIdirectory.hh" 47 #include "G4UIdirectory.hh" 44 #include "G4UIcommand.hh" 48 #include "G4UIcommand.hh" 45 #include "G4UIparameter.hh" 49 #include "G4UIparameter.hh" 46 #include "G4UIcmdWithABool.hh" 50 #include "G4UIcmdWithABool.hh" 47 #include "G4UIcmdWithAnInteger.hh" 51 #include "G4UIcmdWithAnInteger.hh" 48 #include "G4UIcmdWithADouble.hh" 52 #include "G4UIcmdWithADouble.hh" 49 #include "G4UIcmdWithADoubleAndUnit.hh" 53 #include "G4UIcmdWithADoubleAndUnit.hh" 50 #include "G4UIcmdWithAString.hh" 54 #include "G4UIcmdWithAString.hh" 51 #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 eLossDirectory = new G4UIdirectory("/process/eLoss/"); 65 emDirectory->SetGuidance("General commands f << 68 eLossDirectory->SetGuidance("Commands for EM processes."); 66 eLossDirectory = new G4UIdirectory("/process << 69 mscDirectory = new G4UIdirectory("/process/msc/"); 67 eLossDirectory->SetGuidance("Commands for en << 68 mscDirectory = new G4UIdirectory("/process/m << 69 mscDirectory->SetGuidance("Commands for EM s 70 mscDirectory->SetGuidance("Commands for EM scattering processes."); 70 gconvDirectory = new G4UIdirectory("/process << 71 emDirectory = new G4UIdirectory("/process/em/"); 71 gconvDirectory->SetGuidance("Commands for EM << 72 emDirectory->SetGuidance("General commands for EM processes."); 72 dnaDirectory = new G4UIdirectory("/process/d << 73 dnaDirectory->SetGuidance("Commands for DNA << 74 73 75 flucCmd = new G4UIcmdWithABool("/process/eLo 74 flucCmd = new G4UIcmdWithABool("/process/eLoss/fluct",this); 76 flucCmd->SetGuidance("Enable/disable energy 75 flucCmd->SetGuidance("Enable/disable energy loss fluctuations."); 77 flucCmd->SetParameterName("choice",true); 76 flucCmd->SetParameterName("choice",true); 78 flucCmd->SetDefaultValue(true); 77 flucCmd->SetDefaultValue(true); 79 flucCmd->AvailableForStates(G4State_PreInit, 78 flucCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 80 flucCmd->SetToBeBroadcasted(false); << 81 79 82 rangeCmd = new G4UIcmdWithABool("/process/eL 80 rangeCmd = new G4UIcmdWithABool("/process/eLoss/CSDARange",this); 83 rangeCmd->SetGuidance("Enable/disable CSDA r 81 rangeCmd->SetGuidance("Enable/disable CSDA range calculation"); 84 rangeCmd->SetParameterName("range",true); 82 rangeCmd->SetParameterName("range",true); 85 rangeCmd->SetDefaultValue(false); 83 rangeCmd->SetDefaultValue(false); 86 rangeCmd->AvailableForStates(G4State_PreInit 84 rangeCmd->AvailableForStates(G4State_PreInit); 87 rangeCmd->SetToBeBroadcasted(false); << 88 85 89 lpmCmd = new G4UIcmdWithABool("/process/eLos 86 lpmCmd = new G4UIcmdWithABool("/process/eLoss/LPM",this); 90 lpmCmd->SetGuidance("Enable/disable LPM effe 87 lpmCmd->SetGuidance("Enable/disable LPM effect calculation"); 91 lpmCmd->SetParameterName("lpm",true); 88 lpmCmd->SetParameterName("lpm",true); 92 lpmCmd->SetDefaultValue(true); 89 lpmCmd->SetDefaultValue(true); 93 lpmCmd->AvailableForStates(G4State_PreInit,G 90 lpmCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 94 lpmCmd->SetToBeBroadcasted(false); << 91 >> 92 splCmd = new G4UIcmdWithABool("/process/em/spline",this); >> 93 splCmd->SetGuidance("Enable/disable usage spline for Physics Vectors"); >> 94 splCmd->SetParameterName("spl",true); >> 95 splCmd->SetDefaultValue(false); >> 96 splCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 95 97 96 rsCmd = new G4UIcmdWithABool("/process/eLoss 98 rsCmd = new G4UIcmdWithABool("/process/eLoss/useCutAsFinalRange",this); 97 rsCmd->SetGuidance("Enable/disable use of cu 99 rsCmd->SetGuidance("Enable/disable use of cut in range as a final range"); 98 rsCmd->SetParameterName("choice",true); 100 rsCmd->SetParameterName("choice",true); 99 rsCmd->SetDefaultValue(false); 101 rsCmd->SetDefaultValue(false); 100 rsCmd->AvailableForStates(G4State_PreInit,G4 102 rsCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 101 rsCmd->SetToBeBroadcasted(false); << 102 103 103 aplCmd = new G4UIcmdWithABool("/process/em/a 104 aplCmd = new G4UIcmdWithABool("/process/em/applyCuts",this); 104 aplCmd->SetGuidance("Enable/disable applying 105 aplCmd->SetGuidance("Enable/disable applying cuts for gamma processes"); 105 aplCmd->SetParameterName("apl",true); 106 aplCmd->SetParameterName("apl",true); 106 aplCmd->SetDefaultValue(false); 107 aplCmd->SetDefaultValue(false); 107 aplCmd->AvailableForStates(G4State_PreInit,G 108 aplCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 108 aplCmd->SetToBeBroadcasted(false); << 109 109 110 intCmd = new G4UIcmdWithABool("/process/em/i << 110 deCmd = new G4UIcmdWithABool("/process/em/fluo",this); 111 intCmd->SetGuidance("Enable/disable integral << 111 deCmd->SetGuidance("Enable/disable atomic deexcitation"); 112 intCmd->SetParameterName("choice",true); << 112 deCmd->SetParameterName("fluoFlag",true); 113 intCmd->SetDefaultValue(true); << 113 deCmd->SetDefaultValue(false); 114 intCmd->AvailableForStates(G4State_PreInit); << 114 deCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 115 intCmd->SetToBeBroadcasted(false); << 115 >> 116 dirFluoCmd = new G4UIcmdWithABool("/process/em/fluoBearden",this); >> 117 dirFluoCmd->SetGuidance("Enable/disable usage of Bearden fluorescence files"); >> 118 dirFluoCmd->SetParameterName("fluoBeardenFlag",true); >> 119 dirFluoCmd->SetDefaultValue(false); >> 120 dirFluoCmd->AvailableForStates(G4State_PreInit); >> 121 >> 122 auCmd = new G4UIcmdWithABool("/process/em/auger",this); >> 123 auCmd->SetGuidance("Enable/disable Auger electrons production"); >> 124 auCmd->SetParameterName("augerFlag",true); >> 125 auCmd->SetDefaultValue(false); >> 126 auCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 127 >> 128 auCascadeCmd = new G4UIcmdWithABool("/process/em/augerCascade",this); >> 129 auCascadeCmd->SetGuidance("Enable/disable simulation of cascade of Auger electrons"); >> 130 auCascadeCmd->SetParameterName("augerCascadeFlag",true); >> 131 auCascadeCmd->SetDefaultValue(false); >> 132 auCascadeCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 133 >> 134 pixeCmd = new G4UIcmdWithABool("/process/em/pixe",this); >> 135 pixeCmd->SetGuidance("Enable/disable PIXE simulation"); >> 136 pixeCmd->SetParameterName("pixeFlag",true); >> 137 pixeCmd->SetDefaultValue(false); >> 138 pixeCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 139 >> 140 dcutCmd = new G4UIcmdWithABool("/process/em/deexcitationIgnoreCut",this); >> 141 dcutCmd->SetGuidance("Enable/Disable usage of cuts in de-excitation module"); >> 142 dcutCmd->SetParameterName("deexcut",true); >> 143 dcutCmd->SetDefaultValue(false); >> 144 dcutCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 116 145 117 latCmd = new G4UIcmdWithABool("/process/msc/ 146 latCmd = new G4UIcmdWithABool("/process/msc/LateralDisplacement",this); 118 latCmd->SetGuidance("Enable/disable sampling 147 latCmd->SetGuidance("Enable/disable sampling of lateral displacement"); 119 latCmd->SetParameterName("lat",true); 148 latCmd->SetParameterName("lat",true); 120 latCmd->SetDefaultValue(true); 149 latCmd->SetDefaultValue(true); 121 latCmd->AvailableForStates(G4State_PreInit,G 150 latCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 122 latCmd->SetToBeBroadcasted(false); << 123 << 124 lat96Cmd = new G4UIcmdWithABool("/process/ms << 125 lat96Cmd->SetGuidance("Enable/disable sampli << 126 lat96Cmd->SetParameterName("lat96",true); << 127 lat96Cmd->SetDefaultValue(false); << 128 lat96Cmd->AvailableForStates(G4State_PreInit << 129 lat96Cmd->SetToBeBroadcasted(false); << 130 151 131 mulatCmd = new G4UIcmdWithABool("/process/ms 152 mulatCmd = new G4UIcmdWithABool("/process/msc/MuHadLateralDisplacement",this); 132 mulatCmd->SetGuidance("Enable/disable sampli 153 mulatCmd->SetGuidance("Enable/disable sampling of lateral displacement for muons and hadrons"); 133 mulatCmd->SetParameterName("mulat",true); 154 mulatCmd->SetParameterName("mulat",true); 134 mulatCmd->SetDefaultValue(true); 155 mulatCmd->SetDefaultValue(true); 135 mulatCmd->AvailableForStates(G4State_PreInit 156 mulatCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 136 mulatCmd->SetToBeBroadcasted(false); << 157 >> 158 catCmd = new G4UIcmdWithABool("/process/msc/DisplacementBeyondSafety",this); >> 159 catCmd->SetGuidance("Enable/disable displacement at geometry boundary"); >> 160 catCmd->SetParameterName("cat",true); >> 161 catCmd->SetDefaultValue(false); >> 162 catCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 137 163 138 delCmd = new G4UIcmdWithABool("/process/eLos 164 delCmd = new G4UIcmdWithABool("/process/eLoss/UseAngularGenerator",this); 139 delCmd->SetGuidance("Enable usage of angular << 165 delCmd->SetGuidance("Enable usage of angular generator"); 140 delCmd->SetParameterName("del",true); 166 delCmd->SetParameterName("del",true); 141 delCmd->SetDefaultValue(false); 167 delCmd->SetDefaultValue(false); 142 delCmd->AvailableForStates(G4State_PreInit); 168 delCmd->AvailableForStates(G4State_PreInit); 143 delCmd->SetToBeBroadcasted(false); << 169 >> 170 IntegCmd = new G4UIcmdWithABool("/process/eLoss/integral",this); >> 171 IntegCmd->SetGuidance("Switch true/false the integral option"); >> 172 IntegCmd->SetParameterName("integ",true); >> 173 IntegCmd->SetDefaultValue(true); >> 174 IntegCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 144 175 145 mottCmd = new G4UIcmdWithABool("/process/msc 176 mottCmd = new G4UIcmdWithABool("/process/msc/UseMottCorrection",this); 146 mottCmd->SetGuidance("Enable usage of Mott c 177 mottCmd->SetGuidance("Enable usage of Mott corrections for e- elastic scattering"); 147 mottCmd->SetParameterName("mott",true); 178 mottCmd->SetParameterName("mott",true); 148 mottCmd->SetDefaultValue(false); 179 mottCmd->SetDefaultValue(false); 149 mottCmd->AvailableForStates(G4State_PreInit) 180 mottCmd->AvailableForStates(G4State_PreInit); 150 mottCmd->SetToBeBroadcasted(false); << 151 181 152 birksCmd = new G4UIcmdWithABool("/process/em << 182 birksCmd = new G4UIcmdWithABool("/process/msc/UseG4EmSaturation",this); 153 birksCmd->SetGuidance("Enable usage of built 183 birksCmd->SetGuidance("Enable usage of built-in Birks saturation"); 154 birksCmd->SetParameterName("birks",true); 184 birksCmd->SetParameterName("birks",true); 155 birksCmd->SetDefaultValue(false); 185 birksCmd->SetDefaultValue(false); 156 birksCmd->AvailableForStates(G4State_PreInit << 186 birksCmd->AvailableForStates(G4State_PreInit); 157 birksCmd->SetToBeBroadcasted(false); << 158 187 159 sharkCmd = new G4UIcmdWithABool("/process/em << 188 minSubSecCmd = new G4UIcmdWithADouble("/process/eLoss/minsubsec",this); 160 sharkCmd->SetGuidance("Enable gamma, e+- gen << 189 minSubSecCmd->SetGuidance("Set the ratio subcut/cut "); 161 sharkCmd->SetParameterName("gen",true); << 190 minSubSecCmd->SetParameterName("rcmin",true); 162 sharkCmd->SetDefaultValue(false); << 191 minSubSecCmd->AvailableForStates(G4State_PreInit); 163 sharkCmd->AvailableForStates(G4State_PreInit << 164 sharkCmd->SetToBeBroadcasted(false); << 165 << 166 poCmd = new G4UIcmdWithABool("/process/em/Po << 167 poCmd->SetGuidance("Enable polarisation"); << 168 poCmd->AvailableForStates(G4State_PreInit); << 169 poCmd->SetToBeBroadcasted(false); << 170 << 171 sampleTCmd = new G4UIcmdWithABool("/process/ << 172 sampleTCmd->SetGuidance("Enable usage of sam << 173 sampleTCmd->SetParameterName("sampleT",true) << 174 sampleTCmd->SetDefaultValue(false); << 175 sampleTCmd->AvailableForStates(G4State_PreIn << 176 sampleTCmd->SetToBeBroadcasted(false); << 177 << 178 icru90Cmd = new G4UIcmdWithABool("/process/e << 179 icru90Cmd->SetGuidance("Enable usage of ICRU << 180 icru90Cmd->SetParameterName("icru90",true); << 181 icru90Cmd->SetDefaultValue(false); << 182 icru90Cmd->AvailableForStates(G4State_PreIni << 183 icru90Cmd->SetToBeBroadcasted(false); << 184 << 185 mudatCmd = new G4UIcmdWithABool("/process/em << 186 mudatCmd->SetGuidance("Enable usage of muon << 187 mudatCmd->SetParameterName("mudat",true); << 188 mudatCmd->SetDefaultValue(false); << 189 mudatCmd->AvailableForStates(G4State_PreInit << 190 mudatCmd->SetToBeBroadcasted(false); << 191 << 192 peKCmd = new G4UIcmdWithABool("/process/em/P << 193 peKCmd->SetGuidance("Enable sampling of phot << 194 peKCmd->SetParameterName("peK",true); << 195 peKCmd->SetDefaultValue(true); << 196 peKCmd->AvailableForStates(G4State_PreInit); << 197 peKCmd->SetToBeBroadcasted(false); << 198 << 199 mscPCmd = new G4UIcmdWithABool("/process/msc << 200 mscPCmd->SetGuidance("Enable msc positron co << 201 mscPCmd->SetParameterName("mscPC",true); << 202 mscPCmd->SetDefaultValue(true); << 203 mscPCmd->AvailableForStates(G4State_PreInit, << 204 mscPCmd->SetToBeBroadcasted(false); << 205 << 206 pepicsCmd = new G4UIcmdWithABool("/process/e << 207 pepicsCmd->SetGuidance("Use EPICS2017 data f << 208 pepicsCmd->SetParameterName("pepics",true); << 209 pepicsCmd->SetDefaultValue(false); << 210 pepicsCmd->AvailableForStates(G4State_PreIni << 211 pepicsCmd->SetToBeBroadcasted(false); << 212 << 213 f3gCmd = new G4UIcmdWithABool("/process/em/3 << 214 f3gCmd->SetGuidance("Enable/disable 3 gamma << 215 f3gCmd->SetParameterName("f3gamma",true); << 216 f3gCmd->SetDefaultValue(false); << 217 f3gCmd->AvailableForStates(G4State_PreInit); << 218 f3gCmd->SetToBeBroadcasted(false); << 219 192 220 minEnCmd = new G4UIcmdWithADoubleAndUnit("/p 193 minEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/minKinEnergy",this); 221 minEnCmd->SetGuidance("Set the min kinetic e 194 minEnCmd->SetGuidance("Set the min kinetic energy for EM tables"); 222 minEnCmd->SetParameterName("emin",true); 195 minEnCmd->SetParameterName("emin",true); 223 minEnCmd->SetUnitCategory("Energy"); 196 minEnCmd->SetUnitCategory("Energy"); 224 minEnCmd->AvailableForStates(G4State_PreInit << 197 minEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 225 minEnCmd->SetToBeBroadcasted(false); << 226 198 227 maxEnCmd = new G4UIcmdWithADoubleAndUnit("/p 199 maxEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergy",this); 228 maxEnCmd->SetGuidance("Set the max kinetic e 200 maxEnCmd->SetGuidance("Set the max kinetic energy for EM tables"); 229 maxEnCmd->SetParameterName("emax",true); 201 maxEnCmd->SetParameterName("emax",true); 230 maxEnCmd->SetUnitCategory("Energy"); 202 maxEnCmd->SetUnitCategory("Energy"); 231 maxEnCmd->AvailableForStates(G4State_PreInit << 203 maxEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 232 maxEnCmd->SetToBeBroadcasted(false); << 233 204 234 cenCmd = new G4UIcmdWithADoubleAndUnit("/pro 205 cenCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/maxKinEnergyCSDA",this); 235 cenCmd->SetGuidance("Set the max kinetic ene 206 cenCmd->SetGuidance("Set the max kinetic energy for CSDA table"); 236 cenCmd->SetParameterName("emaxCSDA",true); 207 cenCmd->SetParameterName("emaxCSDA",true); 237 cenCmd->SetUnitCategory("Energy"); 208 cenCmd->SetUnitCategory("Energy"); 238 cenCmd->AvailableForStates(G4State_PreInit); << 209 cenCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 239 cenCmd->SetToBeBroadcasted(false); << 240 << 241 max5DCmd = new G4UIcmdWithADoubleAndUnit("/p << 242 max5DCmd->SetGuidance("Set the max kinetic e << 243 max5DCmd->SetParameterName("emax5D",true); << 244 max5DCmd->SetUnitCategory("Energy"); << 245 max5DCmd->AvailableForStates(G4State_PreInit << 246 max5DCmd->SetToBeBroadcasted(false); << 247 210 248 lowEnCmd = new G4UIcmdWithADoubleAndUnit("/p 211 lowEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestElectronEnergy",this); 249 lowEnCmd->SetGuidance("Set the lowest kineti 212 lowEnCmd->SetGuidance("Set the lowest kinetic energy for e+-"); 250 lowEnCmd->SetParameterName("elow",true); 213 lowEnCmd->SetParameterName("elow",true); 251 lowEnCmd->SetUnitCategory("Energy"); 214 lowEnCmd->SetUnitCategory("Energy"); 252 lowEnCmd->AvailableForStates(G4State_PreInit 215 lowEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 253 lowEnCmd->SetToBeBroadcasted(false); << 254 216 255 lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/ 217 lowhEnCmd = new G4UIcmdWithADoubleAndUnit("/process/em/lowestMuHadEnergy",this); 256 lowhEnCmd->SetGuidance("Set the lowest kinet 218 lowhEnCmd->SetGuidance("Set the lowest kinetic energy for muons and hadrons"); 257 lowhEnCmd->SetParameterName("elowh",true); 219 lowhEnCmd->SetParameterName("elowh",true); 258 lowhEnCmd->SetUnitCategory("Energy"); 220 lowhEnCmd->SetUnitCategory("Energy"); 259 lowhEnCmd->AvailableForStates(G4State_PreIni 221 lowhEnCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 260 lowhEnCmd->SetToBeBroadcasted(false); << 261 << 262 lowEn3Cmd = new G4UIcmdWithADoubleAndUnit("/ << 263 lowEn3Cmd->SetGuidance("Set the lowest kinet << 264 lowEn3Cmd->SetParameterName("elow3",true); << 265 lowEn3Cmd->SetUnitCategory("Energy"); << 266 lowEn3Cmd->AvailableForStates(G4State_PreIni << 267 lowEn3Cmd->SetToBeBroadcasted(false); << 268 222 269 lllCmd = new G4UIcmdWithADouble("/process/eL 223 lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this); 270 lllCmd->SetGuidance("Set linearLossLimit par 224 lllCmd->SetGuidance("Set linearLossLimit parameter"); 271 lllCmd->SetParameterName("linlim",true); 225 lllCmd->SetParameterName("linlim",true); 272 lllCmd->AvailableForStates(G4State_PreInit,G 226 lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 273 lllCmd->SetToBeBroadcasted(false); << 274 227 275 brCmd = new G4UIcmdWithADoubleAndUnit("/proc 228 brCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/bremThreshold",this); 276 brCmd->SetGuidance("Set e+- bremsstrahlung e << 229 brCmd->SetGuidance("Set bremsstrahlung energy threshold"); 277 brCmd->SetParameterName("emaxBrem",true); 230 brCmd->SetParameterName("emaxBrem",true); 278 brCmd->SetUnitCategory("Energy"); 231 brCmd->SetUnitCategory("Energy"); 279 brCmd->AvailableForStates(G4State_PreInit); << 232 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 233 289 labCmd = new G4UIcmdWithADouble("/process/eL 234 labCmd = new G4UIcmdWithADouble("/process/eLoss/LambdaFactor",this); 290 labCmd->SetGuidance("Set lambdaFactor parame 235 labCmd->SetGuidance("Set lambdaFactor parameter for integral option"); 291 labCmd->SetParameterName("Fl",true); 236 labCmd->SetParameterName("Fl",true); 292 labCmd->AvailableForStates(G4State_PreInit,G 237 labCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 293 labCmd->SetToBeBroadcasted(false); << 294 238 295 mscfCmd = new G4UIcmdWithADouble("/process/m 239 mscfCmd = new G4UIcmdWithADouble("/process/msc/FactorForAngleLimit",this); 296 mscfCmd->SetGuidance("Set factor for computa << 240 mscfCmd->SetGuidance("Set factor for computation of a limit for -t (invariant trasfer)"); 297 mscfCmd->SetParameterName("Fact",true); 241 mscfCmd->SetParameterName("Fact",true); 298 mscfCmd->SetRange("Fact>0"); 242 mscfCmd->SetRange("Fact>0"); 299 mscfCmd->SetDefaultValue(1.); 243 mscfCmd->SetDefaultValue(1.); 300 mscfCmd->AvailableForStates(G4State_PreInit) << 244 mscfCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 301 mscfCmd->SetToBeBroadcasted(false); << 302 245 303 angCmd = new G4UIcmdWithADoubleAndUnit("/pro 246 angCmd = new G4UIcmdWithADoubleAndUnit("/process/msc/ThetaLimit",this); 304 angCmd->SetGuidance("Set the limit on the po 247 angCmd->SetGuidance("Set the limit on the polar angle for msc and single scattering"); 305 angCmd->SetParameterName("theta",true); 248 angCmd->SetParameterName("theta",true); 306 angCmd->SetUnitCategory("Angle"); 249 angCmd->SetUnitCategory("Angle"); 307 angCmd->AvailableForStates(G4State_PreInit); << 250 angCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 308 angCmd->SetToBeBroadcasted(false); << 309 << 310 msceCmd = new G4UIcmdWithADoubleAndUnit("/pr << 311 msceCmd->SetGuidance("Set the upper energy l << 312 msceCmd->SetParameterName("mscE",true); << 313 msceCmd->SetUnitCategory("Energy"); << 314 msceCmd->AvailableForStates(G4State_PreInit) << 315 msceCmd->SetToBeBroadcasted(false); << 316 << 317 nielCmd = new G4UIcmdWithADoubleAndUnit("/pr << 318 nielCmd->SetGuidance("Set the upper energy l << 319 nielCmd->SetParameterName("niel",true); << 320 nielCmd->SetUnitCategory("Energy"); << 321 nielCmd->AvailableForStates(G4State_PreInit) << 322 nielCmd->SetToBeBroadcasted(false); << 323 251 324 frCmd = new G4UIcmdWithADouble("/process/msc 252 frCmd = new G4UIcmdWithADouble("/process/msc/RangeFactor",this); 325 frCmd->SetGuidance("Set RangeFactor for msc 253 frCmd->SetGuidance("Set RangeFactor for msc processes of e+-"); 326 frCmd->SetParameterName("Fr",true); 254 frCmd->SetParameterName("Fr",true); 327 frCmd->SetRange("Fr>0"); 255 frCmd->SetRange("Fr>0"); 328 frCmd->SetDefaultValue(0.04); 256 frCmd->SetDefaultValue(0.04); 329 frCmd->AvailableForStates(G4State_PreInit,G4 257 frCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 330 frCmd->SetToBeBroadcasted(false); << 331 258 332 fr1Cmd = new G4UIcmdWithADouble("/process/ms 259 fr1Cmd = new G4UIcmdWithADouble("/process/msc/RangeFactorMuHad",this); 333 fr1Cmd->SetGuidance("Set RangeFactor for msc 260 fr1Cmd->SetGuidance("Set RangeFactor for msc processes of muons/hadrons"); 334 fr1Cmd->SetParameterName("Fr1",true); 261 fr1Cmd->SetParameterName("Fr1",true); 335 fr1Cmd->SetRange("Fr1>0"); 262 fr1Cmd->SetRange("Fr1>0"); 336 fr1Cmd->SetDefaultValue(0.2); 263 fr1Cmd->SetDefaultValue(0.2); 337 fr1Cmd->AvailableForStates(G4State_PreInit,G 264 fr1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle); 338 fr1Cmd->SetToBeBroadcasted(false); << 339 265 340 fgCmd = new G4UIcmdWithADouble("/process/msc 266 fgCmd = new G4UIcmdWithADouble("/process/msc/GeomFactor",this); 341 fgCmd->SetGuidance("Set GeomFactor parameter 267 fgCmd->SetGuidance("Set GeomFactor parameter for msc processes"); 342 fgCmd->SetParameterName("Fg",true); 268 fgCmd->SetParameterName("Fg",true); 343 fgCmd->SetRange("Fg>0"); 269 fgCmd->SetRange("Fg>0"); 344 fgCmd->SetDefaultValue(2.5); << 270 fgCmd->SetDefaultValue(3.5); 345 fgCmd->AvailableForStates(G4State_PreInit,G4 271 fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 346 fgCmd->SetToBeBroadcasted(false); << 347 272 348 skinCmd = new G4UIcmdWithADouble("/process/m 273 skinCmd = new G4UIcmdWithADouble("/process/msc/Skin",this); 349 skinCmd->SetGuidance("Set skin parameter for 274 skinCmd->SetGuidance("Set skin parameter for msc processes"); 350 skinCmd->SetParameterName("skin",true); 275 skinCmd->SetParameterName("skin",true); 351 skinCmd->AvailableForStates(G4State_PreInit, 276 skinCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 352 skinCmd->SetToBeBroadcasted(false); << 353 277 354 screCmd = new G4UIcmdWithADouble("/process/m << 278 dedxCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsDEDX",this); 355 screCmd->SetGuidance("Set screening factor") << 279 dedxCmd->SetGuidance("Set number of bins for EM tables"); 356 screCmd->SetParameterName("screen",true); << 280 dedxCmd->SetParameterName("binsDEDX",true); 357 screCmd->AvailableForStates(G4State_PreInit) << 281 dedxCmd->SetDefaultValue(77); 358 screCmd->SetToBeBroadcasted(false); << 282 dedxCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 359 << 283 360 safCmd = new G4UIcmdWithADouble("/process/ms << 284 lamCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsLambda",this); 361 safCmd->SetGuidance("Set safety factor"); << 285 lamCmd->SetGuidance("Set number of bins for EM tables"); 362 safCmd->SetParameterName("fsafe",true); << 286 lamCmd->SetParameterName("binsL",true); 363 safCmd->AvailableForStates(G4State_PreInit); << 287 lamCmd->SetDefaultValue(77); 364 safCmd->SetToBeBroadcasted(false); << 288 lamCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 365 << 366 llimCmd = new G4UIcmdWithADoubleAndUnit("/pr << 367 llimCmd->SetGuidance("Set the upper energy l << 368 llimCmd->SetParameterName("ll",true); << 369 llimCmd->SetUnitCategory("Length"); << 370 llimCmd->AvailableForStates(G4State_PreInit) << 371 llimCmd->SetToBeBroadcasted(false); << 372 289 373 amCmd = new G4UIcmdWithAnInteger("/process/e << 290 amCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsPerDecade",this); 374 amCmd->SetGuidance("Set number of bins per d 291 amCmd->SetGuidance("Set number of bins per decade for EM tables"); 375 amCmd->SetParameterName("bins",true); 292 amCmd->SetParameterName("bins",true); 376 amCmd->SetDefaultValue(7); 293 amCmd->SetDefaultValue(7); 377 amCmd->AvailableForStates(G4State_PreInit); << 294 amCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 378 amCmd->SetToBeBroadcasted(false); << 379 295 380 verCmd = new G4UIcmdWithAnInteger("/process/ 296 verCmd = new G4UIcmdWithAnInteger("/process/eLoss/verbose",this); 381 verCmd->SetGuidance("Set verbose level for E 297 verCmd->SetGuidance("Set verbose level for EM physics"); 382 verCmd->SetParameterName("verb",true); 298 verCmd->SetParameterName("verb",true); 383 verCmd->SetDefaultValue(1); 299 verCmd->SetDefaultValue(1); 384 verCmd->AvailableForStates(G4State_PreInit,G 300 verCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 385 verCmd->SetToBeBroadcasted(false); << 386 301 387 ver1Cmd = new G4UIcmdWithAnInteger("/process 302 ver1Cmd = new G4UIcmdWithAnInteger("/process/em/verbose",this); 388 ver1Cmd->SetGuidance("Set verbose level for 303 ver1Cmd->SetGuidance("Set verbose level for EM physics"); 389 ver1Cmd->SetParameterName("verb1",true); 304 ver1Cmd->SetParameterName("verb1",true); 390 ver1Cmd->SetDefaultValue(1); 305 ver1Cmd->SetDefaultValue(1); 391 ver1Cmd->AvailableForStates(G4State_PreInit, 306 ver1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle); 392 ver1Cmd->SetToBeBroadcasted(false); << 393 307 394 ver2Cmd = new G4UIcmdWithAnInteger("/process 308 ver2Cmd = new G4UIcmdWithAnInteger("/process/em/workerVerbose",this); 395 ver2Cmd->SetGuidance("Set worker verbose lev 309 ver2Cmd->SetGuidance("Set worker verbose level for EM physics"); 396 ver2Cmd->SetParameterName("verb2",true); 310 ver2Cmd->SetParameterName("verb2",true); 397 ver2Cmd->SetDefaultValue(0); << 311 ver2Cmd->SetDefaultValue(1); 398 ver2Cmd->AvailableForStates(G4State_PreInit, 312 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 313 415 mscCmd = new G4UIcmdWithAString("/process/ms 314 mscCmd = new G4UIcmdWithAString("/process/msc/StepLimit",this); 416 mscCmd->SetGuidance("Set msc step limitation 315 mscCmd->SetGuidance("Set msc step limitation type"); 417 mscCmd->SetParameterName("StepLim",true); 316 mscCmd->SetParameterName("StepLim",true); 418 mscCmd->SetCandidates("Minimal UseSafety Use 317 mscCmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary"); 419 mscCmd->AvailableForStates(G4State_PreInit,G 318 mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 420 mscCmd->SetToBeBroadcasted(false); << 421 319 422 msc1Cmd = new G4UIcmdWithAString("/process/m 320 msc1Cmd = new G4UIcmdWithAString("/process/msc/StepLimitMuHad",this); 423 msc1Cmd->SetGuidance("Set msc step limitatio 321 msc1Cmd->SetGuidance("Set msc step limitation type for muons/hadrons"); 424 msc1Cmd->SetParameterName("StepLim1",true); 322 msc1Cmd->SetParameterName("StepLim1",true); 425 msc1Cmd->SetCandidates("Minimal UseSafety Us 323 msc1Cmd->SetCandidates("Minimal UseSafety UseSafetyPlus UseDistanceToBoundary"); 426 msc1Cmd->AvailableForStates(G4State_PreInit, 324 msc1Cmd->AvailableForStates(G4State_PreInit,G4State_Idle); 427 msc1Cmd->SetToBeBroadcasted(false); << 325 >> 326 pixeXsCmd = new G4UIcmdWithAString("/process/em/pixeXSmodel",this); >> 327 pixeXsCmd->SetGuidance("The name of PIXE cross section"); >> 328 pixeXsCmd->SetParameterName("pixeXS",true); >> 329 pixeXsCmd->SetCandidates("ECPSSR_Analytical Empirical ECPSSR_FormFactor"); >> 330 pixeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 331 >> 332 pixeeXsCmd = new G4UIcmdWithAString("/process/em/pixeElecXSmodel",this); >> 333 pixeeXsCmd->SetGuidance("The name of PIXE cross section for electron"); >> 334 pixeeXsCmd->SetParameterName("pixeEXS",true); >> 335 pixeeXsCmd->SetCandidates("ECPSSR_Analytical Empirical Livermore Penelope"); >> 336 pixeeXsCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 337 >> 338 paiCmd = new G4UIcommand("/process/em/AddPAIRegion",this); >> 339 paiCmd->SetGuidance("Activate PAI in the G4Region."); >> 340 paiCmd->SetGuidance(" partName : particle name (default - all)"); >> 341 paiCmd->SetGuidance(" regName : G4Region name"); >> 342 paiCmd->SetGuidance(" paiType : PAI, PAIphoton"); >> 343 paiCmd->AvailableForStates(G4State_PreInit); >> 344 >> 345 G4UIparameter* part = new G4UIparameter("partName",'s',false); >> 346 paiCmd->SetParameter(part); >> 347 >> 348 G4UIparameter* pregName = new G4UIparameter("regName",'s',false); >> 349 paiCmd->SetParameter(pregName); >> 350 >> 351 G4UIparameter* ptype = new G4UIparameter("type",'s',false); >> 352 paiCmd->SetParameter(ptype); >> 353 >> 354 meCmd = new G4UIcmdWithAString("/process/em/AddMicroElecRegion",this); >> 355 meCmd->SetGuidance("Activate MicroElec model in the G4Region"); >> 356 meCmd->SetParameterName("MicroElec",true); >> 357 meCmd->AvailableForStates(G4State_PreInit); >> 358 >> 359 dnaCmd = new G4UIcommand("/process/em/AddDNARegion",this); >> 360 dnaCmd->SetGuidance("Activate DNA in a G4Region."); >> 361 dnaCmd->SetGuidance(" regName : G4Region name"); >> 362 dnaCmd->SetGuidance(" dnaType : DNA_opt0, DNA_opt1, DNA_opt2"); >> 363 dnaCmd->AvailableForStates(G4State_PreInit); >> 364 >> 365 G4UIparameter* regName = new G4UIparameter("regName",'s',false); >> 366 dnaCmd->SetParameter(regName); >> 367 >> 368 G4UIparameter* type = new G4UIparameter("dnaType",'s',false); >> 369 dnaCmd->SetParameter(type); >> 370 >> 371 mscoCmd = new G4UIcommand("/process/em/AddEmRegion",this); >> 372 mscoCmd->SetGuidance("Add optional EM configuration for a G4Region."); >> 373 mscoCmd->SetGuidance(" regName : G4Region name"); >> 374 mscoCmd->SetGuidance(" mscType : G4EmStandard, G4EmStandard_opt1, ..."); >> 375 mscoCmd->AvailableForStates(G4State_PreInit); >> 376 >> 377 G4UIparameter* mregName = new G4UIparameter("regName",'s',false); >> 378 mscoCmd->SetParameter(mregName); >> 379 >> 380 G4UIparameter* mtype = new G4UIparameter("mscType",'s',false); >> 381 mscoCmd->SetParameter(mtype); 428 382 429 dumpCmd = new G4UIcommand("/process/em/print 383 dumpCmd = new G4UIcommand("/process/em/printParameters",this); 430 dumpCmd->SetGuidance("Print all EM parameter 384 dumpCmd->SetGuidance("Print all EM parameters."); 431 dumpCmd->AvailableForStates(G4State_PreInit, << 385 432 dumpCmd->SetToBeBroadcasted(false); << 386 SubSecCmd = new G4UIcommand("/process/eLoss/subsec",this); >> 387 SubSecCmd->SetGuidance("Switch true/false the subcutoff generation per region."); >> 388 SubSecCmd->SetGuidance(" subSec : true/false"); >> 389 SubSecCmd->SetGuidance(" Region : region name"); >> 390 SubSecCmd->AvailableForStates(G4State_PreInit); >> 391 >> 392 G4UIparameter* subSec = new G4UIparameter("subSec",'s',false); >> 393 SubSecCmd->SetParameter(subSec); >> 394 >> 395 G4UIparameter* subSecReg = new G4UIparameter("Region",'s',false); >> 396 SubSecCmd->SetParameter(subSecReg); >> 397 >> 398 StepFuncCmd = new G4UIcommand("/process/eLoss/StepFunction",this); >> 399 StepFuncCmd->SetGuidance("Set the energy loss step limitation parameters for e+-."); >> 400 StepFuncCmd->SetGuidance(" dRoverR : max Range variation per step"); >> 401 StepFuncCmd->SetGuidance(" finalRange: range for final step"); >> 402 StepFuncCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 403 >> 404 G4UIparameter* dRoverRPrm = new G4UIparameter("dRoverR",'d',false); >> 405 dRoverRPrm->SetParameterRange("dRoverR>0. && dRoverR<=1."); >> 406 StepFuncCmd->SetParameter(dRoverRPrm); >> 407 >> 408 G4UIparameter* finalRangePrm = new G4UIparameter("finalRange",'d',false); >> 409 finalRangePrm->SetParameterRange("finalRange>0."); >> 410 StepFuncCmd->SetParameter(finalRangePrm); >> 411 >> 412 G4UIparameter* unitPrm = new G4UIparameter("unit",'s',true); >> 413 unitPrm->SetDefaultValue("mm"); >> 414 StepFuncCmd->SetParameter(unitPrm); >> 415 >> 416 StepFuncCmd1 = new G4UIcommand("/process/eLoss/StepFunctionMuHad",this); >> 417 StepFuncCmd1->SetGuidance("Set the energy loss step limitation parameters for muon/hadron."); >> 418 StepFuncCmd1->SetGuidance(" dRoverR : max Range variation per step"); >> 419 StepFuncCmd1->SetGuidance(" finalRange: range for final step"); >> 420 StepFuncCmd1->AvailableForStates(G4State_PreInit,G4State_Idle); >> 421 >> 422 G4UIparameter* dRoverRPrm1 = new G4UIparameter("dRoverRMuHad",'d',false); >> 423 dRoverRPrm1->SetParameterRange("dRoverRMuHad>0. && dRoverRMuHad<=1."); >> 424 StepFuncCmd1->SetParameter(dRoverRPrm1); >> 425 >> 426 G4UIparameter* finalRangePrm1 = new G4UIparameter("finalRangeMuHad",'d',false); >> 427 finalRangePrm1->SetParameterRange("finalRangeMuHad>0."); >> 428 StepFuncCmd1->SetParameter(finalRangePrm1); >> 429 >> 430 G4UIparameter* unitPrm1 = new G4UIparameter("unit",'s',true); >> 431 unitPrm1->SetDefaultValue("mm"); >> 432 StepFuncCmd1->SetParameter(unitPrm1); >> 433 >> 434 deexCmd = new G4UIcommand("/process/em/deexcitation",this); >> 435 deexCmd->SetGuidance("Set deexcitation flags per G4Region."); >> 436 deexCmd->SetGuidance(" regName : G4Region name"); >> 437 deexCmd->SetGuidance(" flagFluo : Fluorescence"); >> 438 deexCmd->SetGuidance(" flagAuger : Auger"); >> 439 deexCmd->SetGuidance(" flagPIXE : PIXE"); >> 440 deexCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 441 >> 442 G4UIparameter* regNameD = new G4UIparameter("regName",'s',false); >> 443 deexCmd->SetParameter(regNameD); >> 444 >> 445 G4UIparameter* flagFluo = new G4UIparameter("flagFluo",'s',false); >> 446 deexCmd->SetParameter(flagFluo); >> 447 >> 448 G4UIparameter* flagAuger = new G4UIparameter("flagAuger",'s',false); >> 449 deexCmd->SetParameter(flagAuger); >> 450 >> 451 G4UIparameter* flagPIXE = new G4UIparameter("flagPIXE",'s',false); >> 452 deexCmd->SetParameter(flagPIXE); >> 453 >> 454 bfCmd = new G4UIcommand("/process/em/setBiasingFactor",this); >> 455 bfCmd->SetGuidance("Set factor for the process cross section."); >> 456 bfCmd->SetGuidance(" procName : process name"); >> 457 bfCmd->SetGuidance(" procFact : factor"); >> 458 bfCmd->SetGuidance(" flagFact : flag to change weight"); >> 459 bfCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 460 >> 461 G4UIparameter* procName = new G4UIparameter("procName",'s',false); >> 462 bfCmd->SetParameter(procName); >> 463 >> 464 G4UIparameter* procFact = new G4UIparameter("procFact",'d',false); >> 465 bfCmd->SetParameter(procFact); >> 466 >> 467 G4UIparameter* flagFact = new G4UIparameter("flagFact",'s',false); >> 468 bfCmd->SetParameter(flagFact); >> 469 >> 470 fiCmd = new G4UIcommand("/process/em/setForcedInteraction",this); >> 471 fiCmd->SetGuidance("Set factor for the process cross section."); >> 472 fiCmd->SetGuidance(" procNam : process name"); >> 473 fiCmd->SetGuidance(" regNam : region name"); >> 474 fiCmd->SetGuidance(" tlength : fixed target length"); >> 475 fiCmd->SetGuidance(" unitT : length unit"); >> 476 fiCmd->SetGuidance(" tflag : flag to change weight"); >> 477 fiCmd->AvailableForStates(G4State_PreInit,G4State_Idle); >> 478 >> 479 G4UIparameter* procNam = new G4UIparameter("procNam",'s',false); >> 480 fiCmd->SetParameter(procNam); >> 481 >> 482 G4UIparameter* regNam = new G4UIparameter("regNam",'s',false); >> 483 fiCmd->SetParameter(regNam); >> 484 >> 485 G4UIparameter* tlength = new G4UIparameter("tlength",'d',false); >> 486 fiCmd->SetParameter(tlength); >> 487 >> 488 G4UIparameter* unitT = new G4UIparameter("unitT",'s',true); >> 489 fiCmd->SetParameter(unitT); >> 490 >> 491 G4UIparameter* flagT = new G4UIparameter("tflag",'s',true); >> 492 fiCmd->SetParameter(flagT); >> 493 >> 494 bsCmd = new G4UIcommand("/process/em/setSecBiasing",this); >> 495 bsCmd->SetGuidance("Set bremsstrahlung or delta-e- splitting/Russian roullette per region."); >> 496 bsCmd->SetGuidance(" bProcNam : process name"); >> 497 bsCmd->SetGuidance(" bRegNam : region name"); >> 498 bsCmd->SetGuidance(" bFactor : number of splitted gamma or probability of Russian roulette"); >> 499 bsCmd->SetGuidance(" bEnergy : max energy of a secondary for this biasing method"); >> 500 bsCmd->SetGuidance(" bUnit : energy unit"); >> 501 bsCmd->AvailableForStates(G4State_Idle,G4State_Idle); >> 502 >> 503 G4UIparameter* bProcNam = new G4UIparameter("bProcNam",'s',false); >> 504 bsCmd->SetParameter(bProcNam); >> 505 >> 506 G4UIparameter* bRegNam = new G4UIparameter("bRegNam",'s',false); >> 507 bsCmd->SetParameter(bRegNam); >> 508 >> 509 G4UIparameter* bFactor = new G4UIparameter("bFactor",'d',false); >> 510 bsCmd->SetParameter(bFactor); >> 511 >> 512 G4UIparameter* bEnergy = new G4UIparameter("bEnergy",'d',false); >> 513 bsCmd->SetParameter(bEnergy); >> 514 >> 515 G4UIparameter* bUnit = new G4UIparameter("bUnit",'s',true); >> 516 bsCmd->SetParameter(bUnit); 433 517 434 nffCmd = new G4UIcmdWithAString("/process/em 518 nffCmd = new G4UIcmdWithAString("/process/em/setNuclearFormFactor",this); 435 nffCmd->SetGuidance("Define type of nuclear << 519 nffCmd->SetGuidance("Define typy of nuclear form-factor"); 436 nffCmd->SetParameterName("NucFF",true); 520 nffCmd->SetParameterName("NucFF",true); 437 nffCmd->SetCandidates("None Exponential Gaus 521 nffCmd->SetCandidates("None Exponential Gaussian Flat"); 438 nffCmd->AvailableForStates(G4State_PreInit); << 522 nffCmd->AvailableForStates(G4State_PreInit,G4State_Idle); 439 nffCmd->SetToBeBroadcasted(false); << 440 << 441 ssCmd = new G4UIcmdWithAString("/process/em/ << 442 ssCmd->SetGuidance("Define type of e+- singl << 443 ssCmd->SetParameterName("SS",true); << 444 ssCmd->SetCandidates("WVI Mott DPWA"); << 445 ssCmd->AvailableForStates(G4State_PreInit); << 446 ssCmd->SetToBeBroadcasted(false); << 447 << 448 fluc1Cmd = new G4UIcmdWithAString("/process/ << 449 fluc1Cmd->SetGuidance("Define type of energy << 450 fluc1Cmd->SetParameterName("Fluc1",true); << 451 fluc1Cmd->SetCandidates("Dummy Universal Urb << 452 fluc1Cmd->AvailableForStates(G4State_PreInit << 453 fluc1Cmd->SetToBeBroadcasted(false); << 454 << 455 posiCmd = new G4UIcmdWithAString("/process/e << 456 posiCmd->SetGuidance("Define model of positr << 457 posiCmd->SetParameterName("Posi",true); << 458 posiCmd->SetCandidates("Simple Allison OrePa << 459 posiCmd->AvailableForStates(G4State_PreInit) << 460 posiCmd->SetToBeBroadcasted(false); << 461 << 462 tripletCmd = new G4UIcmdWithAnInteger("/proc << 463 tripletCmd->SetGuidance("gamma conversion tr << 464 tripletCmd->SetGuidance("0 - (default) both << 465 tripletCmd->SetGuidance("1 - force nuclear") << 466 tripletCmd->SetGuidance("2 - force triplet") << 467 tripletCmd->SetParameterName("type",false); << 468 tripletCmd->SetRange("type >= 0 && type <= 2 << 469 tripletCmd->SetDefaultValue(0); << 470 tripletCmd->AvailableForStates(G4State_PreIn << 471 tripletCmd->SetToBeBroadcasted(false); << 472 << 473 onIsolatedCmd = new G4UIcmdWithABool("/proce << 474 onIsolatedCmd->SetGuidance("Conversion on is << 475 onIsolatedCmd->SetGuidance("false (default) << 476 onIsolatedCmd->SetGuidance("true : conversio << 477 onIsolatedCmd->SetParameterName("flag",false << 478 onIsolatedCmd->SetDefaultValue(false); << 479 onIsolatedCmd->AvailableForStates(G4State_Pr << 480 onIsolatedCmd->SetToBeBroadcasted(false); << 481 } 523 } 482 524 483 //....oooOO0OOooo........oooOO0OOooo........oo 525 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 484 526 485 G4EmParametersMessenger::~G4EmParametersMessen 527 G4EmParametersMessenger::~G4EmParametersMessenger() 486 { 528 { 487 delete gconvDirectory; << 488 delete eLossDirectory; 529 delete eLossDirectory; 489 delete mscDirectory; 530 delete mscDirectory; 490 delete emDirectory; 531 delete emDirectory; 491 delete dnaDirectory; << 492 532 493 delete flucCmd; 533 delete flucCmd; 494 delete rangeCmd; 534 delete rangeCmd; 495 delete lpmCmd; 535 delete lpmCmd; >> 536 delete splCmd; 496 delete rsCmd; 537 delete rsCmd; 497 delete aplCmd; 538 delete aplCmd; 498 delete intCmd; << 539 delete deCmd; >> 540 delete dirFluoCmd; >> 541 delete auCmd; >> 542 delete auCascadeCmd; >> 543 delete pixeCmd; >> 544 delete dcutCmd; 499 delete latCmd; 545 delete latCmd; 500 delete lat96Cmd; << 501 delete mulatCmd; 546 delete mulatCmd; >> 547 delete catCmd; 502 delete delCmd; 548 delete delCmd; >> 549 delete IntegCmd; 503 delete mottCmd; 550 delete mottCmd; 504 delete birksCmd; 551 delete birksCmd; 505 delete sharkCmd; << 506 delete onIsolatedCmd; << 507 delete sampleTCmd; << 508 delete poCmd; << 509 delete icru90Cmd; << 510 delete mudatCmd; << 511 delete peKCmd; << 512 delete f3gCmd; << 513 delete mscPCmd; << 514 delete pepicsCmd; << 515 552 >> 553 delete minSubSecCmd; 516 delete minEnCmd; 554 delete minEnCmd; 517 delete maxEnCmd; 555 delete maxEnCmd; 518 delete max5DCmd; << 519 delete cenCmd; 556 delete cenCmd; 520 delete lowEnCmd; 557 delete lowEnCmd; 521 delete lowhEnCmd; 558 delete lowhEnCmd; 522 delete lowEn3Cmd; << 523 delete lllCmd; 559 delete lllCmd; 524 delete brCmd; 560 delete brCmd; 525 delete br1Cmd; << 526 delete labCmd; 561 delete labCmd; 527 delete mscfCmd; 562 delete mscfCmd; 528 delete angCmd; 563 delete angCmd; 529 delete msceCmd; << 530 delete nielCmd; << 531 delete frCmd; 564 delete frCmd; 532 delete fr1Cmd; 565 delete fr1Cmd; 533 delete fgCmd; 566 delete fgCmd; 534 delete skinCmd; 567 delete skinCmd; 535 delete safCmd; << 536 delete llimCmd; << 537 delete screCmd; << 538 568 >> 569 delete dedxCmd; >> 570 delete lamCmd; 539 delete amCmd; 571 delete amCmd; 540 delete verCmd; 572 delete verCmd; 541 delete ver1Cmd; 573 delete ver1Cmd; 542 delete ver2Cmd; 574 delete ver2Cmd; 543 delete transWithMscCmd; << 544 delete nFreeCmd; << 545 delete tripletCmd; << 546 575 547 delete mscCmd; 576 delete mscCmd; 548 delete msc1Cmd; 577 delete msc1Cmd; 549 delete nffCmd; << 550 delete ssCmd; << 551 delete fluc1Cmd; << 552 delete posiCmd; << 553 578 >> 579 delete pixeXsCmd; >> 580 delete pixeeXsCmd; >> 581 >> 582 delete paiCmd; >> 583 delete meCmd; >> 584 delete dnaCmd; >> 585 delete mscoCmd; 554 delete dumpCmd; 586 delete dumpCmd; >> 587 >> 588 delete SubSecCmd; >> 589 delete StepFuncCmd; >> 590 delete StepFuncCmd1; >> 591 delete deexCmd; >> 592 delete bfCmd; >> 593 delete fiCmd; >> 594 delete bsCmd; >> 595 delete nffCmd; 555 } 596 } 556 597 557 //....oooOO0OOooo........oooOO0OOooo........oo 598 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 558 599 559 void G4EmParametersMessenger::SetNewValue(G4UI 600 void G4EmParametersMessenger::SetNewValue(G4UIcommand* command, 560 G4St 601 G4String newValue) 561 { 602 { 562 G4bool physicsModified = false; 603 G4bool physicsModified = false; 563 if (command == flucCmd) { 604 if (command == flucCmd) { 564 theParameters->SetLossFluctuations(flucCmd 605 theParameters->SetLossFluctuations(flucCmd->GetNewBoolValue(newValue)); 565 physicsModified = true; 606 physicsModified = true; 566 } else if (command == rangeCmd) { 607 } else if (command == rangeCmd) { 567 theParameters->SetBuildCSDARange(rangeCmd- 608 theParameters->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue)); 568 } else if (command == lpmCmd) { 609 } else if (command == lpmCmd) { 569 theParameters->SetLPM(lpmCmd->GetNewBoolVa 610 theParameters->SetLPM(lpmCmd->GetNewBoolValue(newValue)); 570 physicsModified = true; 611 physicsModified = true; >> 612 } else if (command == splCmd) { >> 613 theParameters->SetSpline(splCmd->GetNewBoolValue(newValue)); >> 614 physicsModified = true; 571 } else if (command == rsCmd) { 615 } else if (command == rsCmd) { 572 theParameters->SetUseCutAsFinalRange(rsCmd 616 theParameters->SetUseCutAsFinalRange(rsCmd->GetNewBoolValue(newValue)); 573 physicsModified = true; 617 physicsModified = true; 574 } else if (command == aplCmd) { 618 } else if (command == aplCmd) { 575 theParameters->SetApplyCuts(aplCmd->GetNew 619 theParameters->SetApplyCuts(aplCmd->GetNewBoolValue(newValue)); 576 physicsModified = true; 620 physicsModified = true; 577 } else if (command == intCmd) { << 621 } else if (command == deCmd) { 578 theParameters->SetIntegral(intCmd->GetNewB << 622 theParameters->SetFluo(deCmd->GetNewBoolValue(newValue)); >> 623 physicsModified = true; >> 624 } else if (command == dirFluoCmd) { >> 625 theParameters->SetBeardenFluoDir(dirFluoCmd->GetNewBoolValue(newValue)); >> 626 } else if (command == auCmd) { >> 627 theParameters->SetAuger(auCmd->GetNewBoolValue(newValue)); >> 628 physicsModified = true; >> 629 } else if (command == auCascadeCmd) { >> 630 theParameters->SetAugerCascade(auCascadeCmd->GetNewBoolValue(newValue)); >> 631 physicsModified = true; >> 632 } else if (command == pixeCmd) { >> 633 theParameters->SetPixe(pixeCmd->GetNewBoolValue(newValue)); >> 634 physicsModified = true; >> 635 } else if (command == dcutCmd) { >> 636 theParameters->SetDeexcitationIgnoreCut(dcutCmd->GetNewBoolValue(newValue)); >> 637 physicsModified = true; 579 } else if (command == latCmd) { 638 } else if (command == latCmd) { 580 theParameters->SetLateralDisplacement(latC 639 theParameters->SetLateralDisplacement(latCmd->GetNewBoolValue(newValue)); 581 physicsModified = true; 640 physicsModified = true; 582 } else if (command == lat96Cmd) { << 583 theParameters->SetLateralDisplacementAlg96 << 584 physicsModified = true; << 585 } else if (command == mulatCmd) { 641 } else if (command == mulatCmd) { 586 theParameters->SetMuHadLateralDisplacement 642 theParameters->SetMuHadLateralDisplacement(mulatCmd->GetNewBoolValue(newValue)); 587 physicsModified = true; 643 physicsModified = true; >> 644 } else if (command == catCmd) { >> 645 theParameters->SetLatDisplacementBeyondSafety(catCmd->GetNewBoolValue(newValue)); >> 646 physicsModified = true; 588 } else if (command == delCmd) { 647 } else if (command == delCmd) { 589 theParameters->ActivateAngularGeneratorFor 648 theParameters->ActivateAngularGeneratorForIonisation(delCmd->GetNewBoolValue(newValue)); >> 649 } else if (command == IntegCmd) { >> 650 theParameters->SetIntegral(IntegCmd->GetNewBoolValue(newValue)); >> 651 physicsModified = true; 590 } else if (command == mottCmd) { 652 } else if (command == mottCmd) { 591 theParameters->SetUseMottCorrection(mottCm 653 theParameters->SetUseMottCorrection(mottCmd->GetNewBoolValue(newValue)); 592 } else if (command == birksCmd) { 654 } else if (command == birksCmd) { 593 theParameters->SetBirksActive(birksCmd->Ge 655 theParameters->SetBirksActive(birksCmd->GetNewBoolValue(newValue)); 594 } else if (command == icru90Cmd) { << 595 theParameters->SetUseICRU90Data(icru90Cmd- << 596 } else if (command == sharkCmd) { << 597 theParameters->SetGeneralProcessActive(sha << 598 } else if (command == poCmd) { << 599 theParameters->SetEnablePolarisation(poCmd << 600 } else if (command == sampleTCmd) { << 601 theParameters->SetEnableSamplingTable(samp << 602 } else if (command == mudatCmd) { << 603 theParameters->SetRetrieveMuDataFromFile(m << 604 } else if (command == peKCmd) { << 605 theParameters->SetPhotoeffectBelowKShell(p << 606 } else if (command == f3gCmd) { << 607 theParameters->Set3GammaAnnihilationOnFly( << 608 } else if (command == mscPCmd) { << 609 theParameters->SetMscPositronCorrection(ms << 610 } else if (command == pepicsCmd) { << 611 theParameters->SetUseEPICS2017XS(pepicsCmd << 612 656 >> 657 } else if (command == minSubSecCmd) { >> 658 theParameters->SetMinSubRange(minSubSecCmd->GetNewDoubleValue(newValue)); 613 } else if (command == minEnCmd) { 659 } else if (command == minEnCmd) { 614 theParameters->SetMinEnergy(minEnCmd->GetN 660 theParameters->SetMinEnergy(minEnCmd->GetNewDoubleValue(newValue)); >> 661 physicsModified = true; 615 } else if (command == maxEnCmd) { 662 } else if (command == maxEnCmd) { 616 theParameters->SetMaxEnergy(maxEnCmd->GetN 663 theParameters->SetMaxEnergy(maxEnCmd->GetNewDoubleValue(newValue)); 617 } else if (command == max5DCmd) { << 664 physicsModified = true; 618 theParameters->SetMaxEnergyFor5DMuPair(max << 619 } else if (command == cenCmd) { 665 } else if (command == cenCmd) { 620 theParameters->SetMaxEnergyForCSDARange(ce 666 theParameters->SetMaxEnergyForCSDARange(cenCmd->GetNewDoubleValue(newValue)); 621 physicsModified = true; 667 physicsModified = true; 622 } else if (command == lowEnCmd) { 668 } else if (command == lowEnCmd) { 623 theParameters->SetLowestElectronEnergy(low 669 theParameters->SetLowestElectronEnergy(lowEnCmd->GetNewDoubleValue(newValue)); 624 physicsModified = true; 670 physicsModified = true; 625 } else if (command == lowEn3Cmd) { << 626 theParameters->SetLowestTripletEnergy(lowE << 627 physicsModified = true; << 628 } else if (command == lowhEnCmd) { 671 } else if (command == lowhEnCmd) { 629 theParameters->SetLowestMuHadEnergy(lowhEn 672 theParameters->SetLowestMuHadEnergy(lowhEnCmd->GetNewDoubleValue(newValue)); 630 physicsModified = true; 673 physicsModified = true; 631 } else if (command == lllCmd) { 674 } else if (command == lllCmd) { 632 theParameters->SetLinearLossLimit(lllCmd-> 675 theParameters->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue)); 633 physicsModified = true; 676 physicsModified = true; 634 } else if (command == brCmd) { 677 } else if (command == brCmd) { 635 theParameters->SetBremsstrahlungTh(brCmd-> 678 theParameters->SetBremsstrahlungTh(brCmd->GetNewDoubleValue(newValue)); 636 physicsModified = true; 679 physicsModified = true; 637 } else if (command == br1Cmd) { << 638 theParameters->SetMuHadBremsstrahlungTh(br << 639 physicsModified = true; << 640 } else if (command == labCmd) { 680 } else if (command == labCmd) { 641 theParameters->SetLambdaFactor(labCmd->Get 681 theParameters->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue)); 642 physicsModified = true; 682 physicsModified = true; 643 } else if (command == mscfCmd) { 683 } else if (command == mscfCmd) { 644 theParameters->SetFactorForAngleLimit(mscf 684 theParameters->SetFactorForAngleLimit(mscfCmd->GetNewDoubleValue(newValue)); >> 685 physicsModified = true; 645 } else if (command == angCmd) { 686 } else if (command == angCmd) { 646 theParameters->SetMscThetaLimit(angCmd->Ge 687 theParameters->SetMscThetaLimit(angCmd->GetNewDoubleValue(newValue)); 647 } else if (command == msceCmd) { << 688 physicsModified = true; 648 theParameters->SetMscEnergyLimit(msceCmd-> << 649 } else if (command == nielCmd) { << 650 theParameters->SetMaxNIELEnergy(nielCmd->G << 651 } else if (command == frCmd) { 689 } else if (command == frCmd) { 652 theParameters->SetMscRangeFactor(frCmd->Ge 690 theParameters->SetMscRangeFactor(frCmd->GetNewDoubleValue(newValue)); 653 physicsModified = true; 691 physicsModified = true; 654 } else if (command == fr1Cmd) { 692 } else if (command == fr1Cmd) { 655 theParameters->SetMscMuHadRangeFactor(fr1C 693 theParameters->SetMscMuHadRangeFactor(fr1Cmd->GetNewDoubleValue(newValue)); 656 physicsModified = true; 694 physicsModified = true; 657 } else if (command == fgCmd) { 695 } else if (command == fgCmd) { 658 theParameters->SetMscGeomFactor(fgCmd->Get 696 theParameters->SetMscGeomFactor(fgCmd->GetNewDoubleValue(newValue)); 659 physicsModified = true; 697 physicsModified = true; 660 } else if (command == skinCmd) { 698 } else if (command == skinCmd) { 661 theParameters->SetMscSkin(skinCmd->GetNewD 699 theParameters->SetMscSkin(skinCmd->GetNewDoubleValue(newValue)); 662 physicsModified = true; 700 physicsModified = true; 663 } else if (command == safCmd) { << 701 664 theParameters->SetMscSafetyFactor(safCmd-> << 702 } else if (command == dedxCmd) { 665 } else if (command == llimCmd) { << 703 theParameters->SetNumberOfBins(dedxCmd->GetNewIntValue(newValue)); 666 theParameters->SetMscLambdaLimit(llimCmd-> << 704 physicsModified = true; 667 } else if (command == screCmd) { << 705 } else if (command == lamCmd) { 668 theParameters->SetScreeningFactor(screCmd- << 706 theParameters->SetNumberOfBins(lamCmd->GetNewIntValue(newValue)); 669 } else if (command == amCmd) { << 707 physicsModified = true; >> 708 } else if (command == amCmd) { 670 theParameters->SetNumberOfBinsPerDecade(am 709 theParameters->SetNumberOfBinsPerDecade(amCmd->GetNewIntValue(newValue)); >> 710 physicsModified = true; 671 } else if (command == verCmd) { 711 } else if (command == verCmd) { 672 theParameters->SetVerbose(verCmd->GetNewIn 712 theParameters->SetVerbose(verCmd->GetNewIntValue(newValue)); 673 } else if (command == ver1Cmd) { 713 } else if (command == ver1Cmd) { 674 theParameters->SetVerbose(ver1Cmd->GetNewI 714 theParameters->SetVerbose(ver1Cmd->GetNewIntValue(newValue)); 675 } else if (command == ver2Cmd) { 715 } else if (command == ver2Cmd) { 676 theParameters->SetWorkerVerbose(ver2Cmd->G 716 theParameters->SetWorkerVerbose(ver2Cmd->GetNewIntValue(newValue)); 677 } else if (command == nFreeCmd) { << 717 678 theParameters->SetNumberForFreeVector(nFre << 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 718 } else if (command == mscCmd || command == msc1Cmd) { 697 G4MscStepLimitType msctype = fUseSafety; 719 G4MscStepLimitType msctype = fUseSafety; 698 if(newValue == "Minimal") { 720 if(newValue == "Minimal") { 699 msctype = fMinimal; 721 msctype = fMinimal; 700 } else if(newValue == "UseDistanceToBounda 722 } else if(newValue == "UseDistanceToBoundary") { 701 msctype = fUseDistanceToBoundary; 723 msctype = fUseDistanceToBoundary; 702 } else if(newValue == "UseSafety") { 724 } else if(newValue == "UseSafety") { 703 msctype = fUseSafety; 725 msctype = fUseSafety; 704 } else if(newValue == "UseSafetyPlus") { 726 } else if(newValue == "UseSafetyPlus") { 705 msctype = fUseSafetyPlus; 727 msctype = fUseSafetyPlus; 706 } else { 728 } else { 707 G4ExceptionDescription ed; << 729 G4cout << "### G4EmParametersMessenger WARNING: StepLimit type <" 708 ed << " StepLimit type <" << newValue << << 730 << newValue << "> unknown!" << G4endl; 709 G4Exception("G4EmParametersMessenger", " << 710 return; 731 return; 711 } 732 } 712 if (command == mscCmd) { 733 if (command == mscCmd) { 713 theParameters->SetMscStepLimitType(mscty 734 theParameters->SetMscStepLimitType(msctype); 714 } else { 735 } else { 715 theParameters->SetMscMuHadStepLimitType( 736 theParameters->SetMscMuHadStepLimitType(msctype); 716 } 737 } 717 physicsModified = true; 738 physicsModified = true; >> 739 } else if (command == pixeXsCmd) { >> 740 theParameters->SetPIXECrossSectionModel(newValue); >> 741 physicsModified = true; >> 742 } else if (command == pixeeXsCmd) { >> 743 theParameters->SetPIXEElectronCrossSectionModel(newValue); >> 744 physicsModified = true; >> 745 } else if (command == paiCmd) { >> 746 G4String s1(""),s2(""),s3(""); >> 747 std::istringstream is(newValue); >> 748 is >> s1 >> s2 >> s3; >> 749 theParameters->AddPAIModel(s1, s2, s3); >> 750 } else if (command == meCmd) { >> 751 theParameters->AddMicroElec(newValue); >> 752 } else if (command == dnaCmd) { >> 753 G4String s1(""),s2(""); >> 754 std::istringstream is(newValue); >> 755 is >> s1 >> s2; >> 756 theParameters->AddDNA(s1, s2); >> 757 } else if (command == mscoCmd) { >> 758 G4String s1(""),s2(""); >> 759 std::istringstream is(newValue); >> 760 is >> s1 >> s2; >> 761 theParameters->AddMsc(s1, s2); >> 762 } else if (command == dumpCmd) { >> 763 theParameters->Dump(); >> 764 } else if (command == SubSecCmd) { >> 765 G4String s1, s2; >> 766 std::istringstream is(newValue); >> 767 is >> s1 >> s2; >> 768 G4bool yes = false; >> 769 if(s1 == "true") { yes = true; } >> 770 theParameters->SetSubCutoff(yes,s2); >> 771 } else if (command == StepFuncCmd || command == StepFuncCmd1) { >> 772 G4double v1,v2; >> 773 G4String unt; >> 774 std::istringstream is(newValue); >> 775 is >> v1 >> v2 >> unt; >> 776 v2 *= G4UIcommand::ValueOf(unt); >> 777 if(command == StepFuncCmd) { >> 778 theParameters->SetStepFunction(v1,v2); >> 779 } else { >> 780 theParameters->SetStepFunctionMuHad(v1,v2); >> 781 } >> 782 physicsModified = true; >> 783 } else if (command == deexCmd) { >> 784 G4String s1 (""), s2(""), s3(""), s4(""); >> 785 G4bool b2(false), b3(false), b4(false); >> 786 std::istringstream is(newValue); >> 787 is >> s1 >> s2 >> s3 >> s4; >> 788 if(s2 == "true") { b2 = true; } >> 789 if(s3 == "true") { b3 = true; } >> 790 if(s4 == "true") { b4 = true; } >> 791 theParameters->SetDeexActiveRegion(s1,b2,b3,b4); >> 792 physicsModified = true; >> 793 } else if (command == bfCmd) { >> 794 G4double v1(1.0); >> 795 G4String s0(""),s1(""); >> 796 std::istringstream is(newValue); >> 797 is >> s0 >> v1 >> s1; >> 798 G4bool yes = false; >> 799 if(s1 == "true") { yes = true; } >> 800 theParameters->SetProcessBiasingFactor(s0,v1,yes); >> 801 physicsModified = true; >> 802 } else if (command == fiCmd) { >> 803 G4double v1(0.0); >> 804 G4String s1(""),s2(""),s3(""),unt("mm"); >> 805 std::istringstream is(newValue); >> 806 is >> s1 >> s2 >> v1 >> unt >> s3; >> 807 G4bool yes = false; >> 808 if(s3 == "true") { yes = true; } >> 809 v1 *= G4UIcommand::ValueOf(unt); >> 810 theParameters->ActivateForcedInteraction(s1,s2,v1,yes); >> 811 physicsModified = true; >> 812 } else if (command == bsCmd) { >> 813 G4double fb(1.0),en(1.e+30); >> 814 G4String s1(""),s2(""),unt("MeV"); >> 815 std::istringstream is(newValue); >> 816 is >> s1 >> s2 >> fb >> en >> unt; >> 817 en *= G4UIcommand::ValueOf(unt); >> 818 theParameters->ActivateSecondaryBiasing(s1,s2,fb,en); >> 819 physicsModified = true; 718 } else if (command == nffCmd) { 820 } else if (command == nffCmd) { 719 G4NuclearFormfactorType x = fNoneNF; 821 G4NuclearFormfactorType x = fNoneNF; 720 if(newValue == "Exponential") { x = fExpon 822 if(newValue == "Exponential") { x = fExponentialNF; } 721 else if(newValue == "Gaussian") { x = fGau 823 else if(newValue == "Gaussian") { x = fGaussianNF; } 722 else if(newValue == "Flat") { x = fFlatNF; 824 else if(newValue == "Flat") { x = fFlatNF; } 723 else if(newValue != "None") { << 724 G4ExceptionDescription ed; << 725 ed << " NuclearFormFactor type <" << new << 726 G4Exception("G4EmParametersMessenger", " << 727 return; << 728 } << 729 theParameters->SetNuclearFormfactorType(x) 825 theParameters->SetNuclearFormfactorType(x); 730 } else if (command == ssCmd) { << 731 G4eSingleScatteringType x = fWVI; << 732 if(newValue == "DPWA") { x = fDPWA; } << 733 else if(newValue == "Mott") { x = fMott; } << 734 else if(newValue != "WVI") { << 735 G4ExceptionDescription ed; << 736 ed << " G4eSingleScatteringType type <" << 737 G4Exception("G4EmParametersMessenger", " << 738 return; << 739 } << 740 theParameters->SetSingleScatteringType(x); << 741 } else if (command == fluc1Cmd) { << 742 G4EmFluctuationType x = fUniversalFluctuat << 743 if(newValue == "Dummy") { x = fDummyFluctu << 744 else if(newValue == "Urban") { x = fUrbanF << 745 theParameters->SetFluctuationType(x); << 746 } else if (command == posiCmd) { << 747 G4PositronAtRestModelType x = fSimplePosit << 748 if (newValue == "Allison") { x = fAllisonP << 749 else if (newValue == "OrePowell") { x = fO << 750 else if (newValue == "OrePowellPolar") { x << 751 theParameters->SetPositronAtRestModelType( << 752 } else if ( command==tripletCmd ) { << 753 theParameters->SetConversionType(tripletCm << 754 } else if ( command==onIsolatedCmd ) { << 755 theParameters->SetOnIsolated(onIsolatedCmd << 756 physicsModified = true; 826 physicsModified = true; 757 } 827 } 758 << 759 if(physicsModified) { 828 if(physicsModified) { 760 G4UImanager::GetUIpointer()->ApplyCommand( 829 G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified"); 761 } 830 } 762 } 831 } 763 832 764 //....oooOO0OOooo........oooOO0OOooo........oo 833 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 765 834