Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/src/G4EmParametersMessenger.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/utils/src/G4EmParametersMessenger.cc (Version 11.3.0) and /processes/electromagnetic/utils/src/G4EmParametersMessenger.cc (Version 10.5)


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