Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/event/src/G4GeneralParticleSourceMessenger.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 /event/src/G4GeneralParticleSourceMessenger.cc (Version 11.3.0) and /event/src/G4GeneralParticleSourceMessenger.cc (Version 10.0.p4)


  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 // G4GeneralParticleSourceMessenger class impl <<  26 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  27 //
                                                   >>  28 // MODULE:       G4GeneralParticleSourceMessenger.cc
                                                   >>  29 //
                                                   >>  30 // Version:      2.0
                                                   >>  31 // Date:         5/02/04
                                                   >>  32 // Author:       Fan Lei 
                                                   >>  33 // Organisation: QinetiQ ltd.
                                                   >>  34 // Customer:     ESA/ESTEC
                                                   >>  35 //
                                                   >>  36 ///////////////////////////////////////////////////////////////////////////////
                                                   >>  37 //
                                                   >>  38 // CHANGE HISTORY
                                                   >>  39 // --------------
                                                   >>  40 //
                                                   >>  41 // Version 2.0, 05/02/2004, Fan Lei, Created.
                                                   >>  42 //    After changes to version 1.1 as in Geant4 v6.0
                                                   >>  43 //     - Mutilple particle source definition
                                                   >>  44 //     - Re-structured commands
                                                   >>  45 //     - old commands have been retained for backward compatibility, will be
                                                   >>  46 //       removed in the future. 
                                                   >>  47 //
                                                   >>  48 ///////////////////////////////////////////////////////////////////////////////
 27 //                                                 49 //
 28 // Author: Fan Lei, QinetiQ ltd.               << 
 29 // Customer: ESA/ESTEC                         << 
 30 // Revisions: Andrew Green, Andrea Dotti       << 
 31 // ------------------------------------------- << 
 32                                                    50 
 33 #include "G4GeneralParticleSourceMessenger.hh"     51 #include "G4GeneralParticleSourceMessenger.hh"
 34                                                    52 
 35 #include "G4PhysicalConstants.hh"                  53 #include "G4PhysicalConstants.hh"
 36 #include "G4SystemOfUnits.hh"                      54 #include "G4SystemOfUnits.hh"
 37 #include "G4Geantino.hh"                           55 #include "G4Geantino.hh"
 38 #include "G4ThreeVector.hh"                        56 #include "G4ThreeVector.hh"
 39 #include "G4ParticleTable.hh"                      57 #include "G4ParticleTable.hh"
 40 #include "G4IonTable.hh"                       << 
 41 #include "G4UIdirectory.hh"                        58 #include "G4UIdirectory.hh"
 42 #include "G4UIcmdWithoutParameter.hh"              59 #include "G4UIcmdWithoutParameter.hh"
 43 #include "G4UIcmdWithAString.hh"                   60 #include "G4UIcmdWithAString.hh"
 44 #include "G4UIcmdWithADoubleAndUnit.hh"            61 #include "G4UIcmdWithADoubleAndUnit.hh"
 45 #include "G4UIcmdWith3Vector.hh"                   62 #include "G4UIcmdWith3Vector.hh"
 46 #include "G4UIcmdWith3VectorAndUnit.hh"            63 #include "G4UIcmdWith3VectorAndUnit.hh"
 47 #include "G4UIcmdWithAnInteger.hh"                 64 #include "G4UIcmdWithAnInteger.hh"
 48 #include "G4UIcmdWithADouble.hh"                   65 #include "G4UIcmdWithADouble.hh"
 49 #include "G4UIcmdWithABool.hh"                     66 #include "G4UIcmdWithABool.hh"
 50 #include "G4ios.hh"                                67 #include "G4ios.hh"
 51                                                    68 
 52 #include "G4Tokenizer.hh"                          69 #include "G4Tokenizer.hh"
 53 #include "G4SingleParticleSource.hh"               70 #include "G4SingleParticleSource.hh"
 54 #include "G4GeneralParticleSource.hh"              71 #include "G4GeneralParticleSource.hh"
 55                                                    72 
 56 #include "G4AutoLock.hh"                       <<  73 ///////////////////////////////////////////////////////////////////////////////
 57                                                << 
 58 namespace                                      << 
 59 {                                              << 
 60   G4Mutex creationM = G4MUTEX_INITIALIZER;     << 
 61   G4GeneralParticleSourceMessenger* theInstanc << 
 62 }                                              << 
 63                                                << 
 64 G4GeneralParticleSourceMessenger*              << 
 65 G4GeneralParticleSourceMessenger::GetInstance( << 
 66 {                                              << 
 67   G4AutoLock l(&creationM);                    << 
 68   if ( theInstance == nullptr )                << 
 69     theInstance = new G4GeneralParticleSourceM << 
 70   return theInstance;                          << 
 71 }                                              << 
 72                                                << 
 73 void G4GeneralParticleSourceMessenger::Destroy << 
 74 {                                              << 
 75   G4AutoLock l(&creationM);                    << 
 76   if ( theInstance != nullptr )                << 
 77   {                                            << 
 78     delete theInstance;                        << 
 79     theInstance = nullptr;                     << 
 80   }                                            << 
 81 }                                              << 
 82                                                << 
 83 // ------------------------------------------- << 
 84 //                                                 74 //
 85 G4GeneralParticleSourceMessenger::             <<  75 G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger
 86 G4GeneralParticleSourceMessenger(G4GeneralPart <<  76   (G4GeneralParticleSource *fPtclGun) 
 87   : fGPS(fPtclGun)                             <<  77     : fGPS(fPtclGun),fShootIon(false)
 88 {                                                  78 {
 89   // A.Dotti - 10th October 2014               << 
 90   // This messenger is special: it is instanti << 
 91   // in a thread).                             << 
 92   // The UI commands it defines should be exec << 
 93   // because they operate on shared resources  << 
 94   // take effect BEFORE the threads do some wo << 
 95   // initialized).                             << 
 96   // To achieve this behavior we set to true a << 
 97   // data member. Since it makes no sense to h << 
 98   // of the messenger, we check that we actual << 
 99   // Note that the logic of implementing, in a << 
100   // messenger is deleted/fated to the creator << 
101                                                << 
102   commandsShouldBeInMaster = true;             << 
103                                                << 
104   particleTable = G4ParticleTable::GetParticle     79   particleTable = G4ParticleTable::GetParticleTable();
105   histtype = "biasx";                              80   histtype = "biasx";
106                                                    81 
107   // UI Commands only for master               <<  82   gpsDirectory = new G4UIdirectory("/gps/");
108   //                                           <<  83   gpsDirectory->SetGuidance("General Paricle Source control commands.");
109   G4bool broadcast = false;                    <<  84   //  gpsDirectory->SetGuidance(" The first 9 commands are the same as in G4ParticleGun ");
110   gpsDirectory = new G4UIdirectory("/gps/",bro << 
111                                                << 
112   gpsDirectory->SetGuidance("General Particle  << 
113                                                    85 
114   // Now the commands for multiple sources     <<  86   // now the commands for mutiple sources
115   //                                           << 
116   sourceDirectory = new G4UIdirectory("/gps/so     87   sourceDirectory = new G4UIdirectory("/gps/source/");
117   sourceDirectory->SetGuidance("Multiple sourc     88   sourceDirectory->SetGuidance("Multiple source control sub-directory");
118                                                    89 
119   addsourceCmd = new G4UIcmdWithADouble("/gps/     90   addsourceCmd = new G4UIcmdWithADouble("/gps/source/add",this);
120   addsourceCmd->SetGuidance("Add a new source  <<  91   addsourceCmd->SetGuidance("add a new source defintion to the particle gun with the specified intensity");
121   addsourceCmd->SetGuidance(" with the specifi << 
122   addsourceCmd->SetParameterName("addsource",f     92   addsourceCmd->SetParameterName("addsource",false,false);
123   addsourceCmd->SetRange("addsource > 0.");        93   addsourceCmd->SetRange("addsource > 0.");
124                                                    94 
125   listsourceCmd = new G4UIcmdWithoutParameter(     95   listsourceCmd = new G4UIcmdWithoutParameter("/gps/source/list",this);
126   listsourceCmd->SetGuidance("List the defined     96   listsourceCmd->SetGuidance("List the defined particle sources");
127                                                    97 
128   clearsourceCmd = new G4UIcmdWithoutParameter     98   clearsourceCmd = new G4UIcmdWithoutParameter("/gps/source/clear",this);
129   clearsourceCmd->SetGuidance("Remove all the      99   clearsourceCmd->SetGuidance("Remove all the defined particle sources");
130                                                   100 
131   getsourceCmd = new G4UIcmdWithoutParameter("    101   getsourceCmd = new G4UIcmdWithoutParameter("/gps/source/show",this);
132   getsourceCmd->SetGuidance("Show the current     102   getsourceCmd->SetGuidance("Show the current source index and intensity");
133                                                   103 
134   setsourceCmd = new G4UIcmdWithAnInteger("/gp    104   setsourceCmd = new G4UIcmdWithAnInteger("/gps/source/set",this);
135   setsourceCmd->SetGuidance("Set the indexed s << 105   setsourceCmd->SetGuidance("set the indexed source as the current one");
136   setsourceCmd->SetGuidance(" so one can chang << 106   setsourceCmd->SetGuidance("  so one can change its source definition");
137   setsourceCmd->SetParameterName("setsource",f    107   setsourceCmd->SetParameterName("setsource",false,false);
138   setsourceCmd->SetRange("setsource >= 0");       108   setsourceCmd->SetRange("setsource >= 0");
139                                                   109 
140   deletesourceCmd = new G4UIcmdWithAnInteger("    110   deletesourceCmd = new G4UIcmdWithAnInteger("/gps/source/delete",this);
141   deletesourceCmd->SetGuidance("Delete the ind << 111   deletesourceCmd->SetGuidance("delete the indexed source from the list");
142   deletesourceCmd->SetParameterName("deletesou    112   deletesourceCmd->SetParameterName("deletesource",false,false);
143   deletesourceCmd->SetRange("deletesource > 0"    113   deletesourceCmd->SetRange("deletesource > 0");
144                                                   114 
145   setintensityCmd = new G4UIcmdWithADouble("/g    115   setintensityCmd = new G4UIcmdWithADouble("/gps/source/intensity",this);
146   setintensityCmd->SetGuidance("Reset the curr << 116   setintensityCmd->SetGuidance("reset the current source to the specified intensity");
147   setintensityCmd->SetParameterName("setintens    117   setintensityCmd->SetParameterName("setintensity",false,false);
148   setintensityCmd->SetRange("setintensity > 0.    118   setintensityCmd->SetRange("setintensity > 0."); 
149                                                   119 
150   multiplevertexCmd = new G4UIcmdWithABool("/g    120   multiplevertexCmd = new G4UIcmdWithABool("/gps/source/multiplevertex",this);
151   multiplevertexCmd->SetGuidance("True for sim << 121   multiplevertexCmd->SetGuidance("true for simulaneous generation mutiple vertex");
152   multiplevertexCmd->SetGuidance(" Default is  << 122   multiplevertexCmd->SetGuidance("Default is false");
153   multiplevertexCmd->SetParameterName("multipl    123   multiplevertexCmd->SetParameterName("multiplevertex",true);
154   multiplevertexCmd->SetDefaultValue(false);      124   multiplevertexCmd->SetDefaultValue(false);
155                                                   125 
156   flatsamplingCmd = new G4UIcmdWithABool("/gps    126   flatsamplingCmd = new G4UIcmdWithABool("/gps/source/flatsampling",this);
157   flatsamplingCmd->SetGuidance("True for apply << 127   flatsamplingCmd->SetGuidance("true for appling flat (biased) sampling among the sources");
158   flatsamplingCmd->SetGuidance("Default is fal    128   flatsamplingCmd->SetGuidance("Default is false");
159   flatsamplingCmd->SetParameterName("flatsampl    129   flatsamplingCmd->SetParameterName("flatsampling",true);
160   flatsamplingCmd->SetDefaultValue(false);        130   flatsamplingCmd->SetDefaultValue(false);
161                                                   131 
162   // Below we reproduce commands awailable in  << 132   // below we reproduce commands awailable in G4Particle Gun
163   //                                           << 133 
164   listCmd = new G4UIcmdWithoutParameter("/gps/    134   listCmd = new G4UIcmdWithoutParameter("/gps/List",this);
165   listCmd->SetGuidance("List available particl    135   listCmd->SetGuidance("List available particles.");
166   listCmd->SetGuidance(" Invoke G4ParticleTabl    136   listCmd->SetGuidance(" Invoke G4ParticleTable.");
167                                                   137 
168   particleCmd = new G4UIcmdWithAString("/gps/p    138   particleCmd = new G4UIcmdWithAString("/gps/particle",this);
169   particleCmd->SetGuidance("Set particle to be    139   particleCmd->SetGuidance("Set particle to be generated.");
170   particleCmd->SetGuidance(" (geantino is defa    140   particleCmd->SetGuidance(" (geantino is default)");
171   particleCmd->SetGuidance(" (ion can be speci    141   particleCmd->SetGuidance(" (ion can be specified for shooting ions)");
172   particleCmd->SetParameterName("particleName"    142   particleCmd->SetParameterName("particleName",true);
173   particleCmd->SetDefaultValue("geantino");       143   particleCmd->SetDefaultValue("geantino");
174   G4String candidateList;                         144   G4String candidateList; 
175   G4int nPtcl = particleTable->entries();         145   G4int nPtcl = particleTable->entries();
176   for(G4int i=0; i<nPtcl; ++i)                 << 146   for(G4int i=0;i<nPtcl;i++)
177   {                                               147   {
178     candidateList += particleTable->GetParticl    148     candidateList += particleTable->GetParticleName(i);
179     candidateList += " ";                         149     candidateList += " ";
180   }                                               150   }
181   candidateList += "ion ";                        151   candidateList += "ion ";
182   particleCmd->SetCandidates(candidateList);      152   particleCmd->SetCandidates(candidateList);
183                                                   153 
184   directionCmd = new G4UIcmdWith3Vector("/gps/    154   directionCmd = new G4UIcmdWith3Vector("/gps/direction",this);
185   directionCmd->SetGuidance("Set momentum dire    155   directionCmd->SetGuidance("Set momentum direction.");
186   directionCmd->SetGuidance(" Direction needs  << 156   directionCmd->SetGuidance("Direction needs not to be a unit vector.");
187   directionCmd->SetGuidance(" Angular distribu << 
188   directionCmd->SetParameterName("Px","Py","Pz    157   directionCmd->SetParameterName("Px","Py","Pz",false,false); 
189   directionCmd->SetRange("Px != 0 || Py != 0 |    158   directionCmd->SetRange("Px != 0 || Py != 0 || Pz != 0");
190                                                   159   
191   energyCmd = new G4UIcmdWithADoubleAndUnit("/    160   energyCmd = new G4UIcmdWithADoubleAndUnit("/gps/energy",this);
192   energyCmd->SetGuidance("Set kinetic energy."    161   energyCmd->SetGuidance("Set kinetic energy.");
193   energyCmd->SetParameterName("Energy",false,f    162   energyCmd->SetParameterName("Energy",false,false);
194   energyCmd->SetDefaultUnit("GeV");               163   energyCmd->SetDefaultUnit("GeV");
195   //energyCmd->SetUnitCategory("Energy");         164   //energyCmd->SetUnitCategory("Energy");
196   //energyCmd->SetUnitCandidates("eV keV MeV G    165   //energyCmd->SetUnitCandidates("eV keV MeV GeV TeV");
197                                                   166 
198   positionCmd = new G4UIcmdWith3VectorAndUnit(    167   positionCmd = new G4UIcmdWith3VectorAndUnit("/gps/position",this);
199   positionCmd->SetGuidance("Set starting posit << 168   positionCmd->SetGuidance("Set starting position of the particle.");
200   positionCmd->SetGuidance(" Same effect as th << 
201   positionCmd->SetParameterName("X","Y","Z",fa    169   positionCmd->SetParameterName("X","Y","Z",false,false);
202   positionCmd->SetDefaultUnit("cm");              170   positionCmd->SetDefaultUnit("cm");
203   //positionCmd->SetUnitCategory("Length");       171   //positionCmd->SetUnitCategory("Length");
204   //positionCmd->SetUnitCandidates("microm mm     172   //positionCmd->SetUnitCandidates("microm mm cm m km");
205                                                   173 
206   ionCmd = new G4UIcommand("/gps/ion",this);      174   ionCmd = new G4UIcommand("/gps/ion",this);
207   ionCmd->SetGuidance("Set properties of ion t    175   ionCmd->SetGuidance("Set properties of ion to be generated.");
208   ionCmd->SetGuidance("[usage] /gps/ion Z A Q     176   ionCmd->SetGuidance("[usage] /gps/ion Z A Q E");
209   ionCmd->SetGuidance("        Z:(int) AtomicN    177   ionCmd->SetGuidance("        Z:(int) AtomicNumber");
210   ionCmd->SetGuidance("        A:(int) AtomicM    178   ionCmd->SetGuidance("        A:(int) AtomicMass");
211   ionCmd->SetGuidance("        Q:(int) Charge     179   ionCmd->SetGuidance("        Q:(int) Charge of Ion (in unit of e)");
212   ionCmd->SetGuidance("        E:(double) Exci    180   ionCmd->SetGuidance("        E:(double) Excitation energy (in keV)");
213                                                   181 
214   G4UIparameter* param;                           182   G4UIparameter* param;
215   param = new G4UIparameter("Z",'i',false);       183   param = new G4UIparameter("Z",'i',false);
216   param->SetDefaultValue("1");                    184   param->SetDefaultValue("1");
217   ionCmd->SetParameter(param);                    185   ionCmd->SetParameter(param);
218   param = new G4UIparameter("A",'i',false);       186   param = new G4UIparameter("A",'i',false);
219   param->SetDefaultValue("1");                    187   param->SetDefaultValue("1");
220   ionCmd->SetParameter(param);                    188   ionCmd->SetParameter(param);
221   param = new G4UIparameter("Q",'i',true);        189   param = new G4UIparameter("Q",'i',true);
222   param->SetDefaultValue("0");                    190   param->SetDefaultValue("0");
223   ionCmd->SetParameter(param);                    191   ionCmd->SetParameter(param);
224   param = new G4UIparameter("E",'d',true);        192   param = new G4UIparameter("E",'d',true);
225   param->SetDefaultValue("0.0");                  193   param->SetDefaultValue("0.0");
226   ionCmd->SetParameter(param);                    194   ionCmd->SetParameter(param);
227                                                   195 
228   ionLvlCmd = new G4UIcommand("/gps/ionLvl",th    196   ionLvlCmd = new G4UIcommand("/gps/ionLvl",this);
229   ionLvlCmd->SetGuidance("Set properties of io    197   ionLvlCmd->SetGuidance("Set properties of ion to be generated.");
230   ionLvlCmd->SetGuidance("[usage] /gps/ion Z A    198   ionLvlCmd->SetGuidance("[usage] /gps/ion Z A Q Lvl");
231   ionLvlCmd->SetGuidance("        Z:(int) Atom    199   ionLvlCmd->SetGuidance("        Z:(int) AtomicNumber");
232   ionLvlCmd->SetGuidance("        A:(int) Atom    200   ionLvlCmd->SetGuidance("        A:(int) AtomicMass");
233   ionLvlCmd->SetGuidance("        Q:(int) Char    201   ionLvlCmd->SetGuidance("        Q:(int) Charge of Ion (in unit of e)");
234   ionLvlCmd->SetGuidance("        Lvl:(int) Nu    202   ionLvlCmd->SetGuidance("        Lvl:(int) Number of metastable state excitation level (0-9)");
235                                                   203 
236   G4UIparameter* paramL;                          204   G4UIparameter* paramL;
237   paramL = new G4UIparameter("Z",'i',false);      205   paramL = new G4UIparameter("Z",'i',false);
238   paramL->SetDefaultValue("1");                   206   paramL->SetDefaultValue("1");
239   ionLvlCmd->SetParameter(paramL);                207   ionLvlCmd->SetParameter(paramL);
240   paramL = new G4UIparameter("A",'i',false);      208   paramL = new G4UIparameter("A",'i',false);
241   paramL->SetDefaultValue("1");                   209   paramL->SetDefaultValue("1");
242   ionLvlCmd->SetParameter(paramL);                210   ionLvlCmd->SetParameter(paramL);
243   paramL = new G4UIparameter("Q",'i',true);       211   paramL = new G4UIparameter("Q",'i',true);
244   paramL->SetDefaultValue("0");                   212   paramL->SetDefaultValue("0");
245   ionLvlCmd->SetParameter(paramL);                213   ionLvlCmd->SetParameter(paramL);
246   paramL = new G4UIparameter("Lvl",'i',true);     214   paramL = new G4UIparameter("Lvl",'i',true);
247   paramL->SetDefaultValue("0.0");                 215   paramL->SetDefaultValue("0.0");
248   ionLvlCmd->SetParameter(paramL);                216   ionLvlCmd->SetParameter(paramL);
249                                                   217 
250   timeCmd = new G4UIcmdWithADoubleAndUnit("/gp    218   timeCmd = new G4UIcmdWithADoubleAndUnit("/gps/time",this);
251   timeCmd->SetGuidance("Set initial time of th    219   timeCmd->SetGuidance("Set initial time of the particle.");
252   timeCmd->SetParameterName("t0",false,false);    220   timeCmd->SetParameterName("t0",false,false);
253   timeCmd->SetDefaultUnit("ns");                  221   timeCmd->SetDefaultUnit("ns");
254   //timeCmd->SetUnitCategory("Time");             222   //timeCmd->SetUnitCategory("Time");
255   //timeCmd->SetUnitCandidates("ns ms s");        223   //timeCmd->SetUnitCandidates("ns ms s");
256                                                   224   
257   polCmd = new G4UIcmdWith3Vector("/gps/polari    225   polCmd = new G4UIcmdWith3Vector("/gps/polarization",this);
258   polCmd->SetGuidance("Set polarization.");       226   polCmd->SetGuidance("Set polarization.");
259   polCmd->SetParameterName("Px","Py","Pz",fals    227   polCmd->SetParameterName("Px","Py","Pz",false,false); 
260   polCmd->SetRange("Px>=-1.&&Px<=1.&&Py>=-1.&&    228   polCmd->SetRange("Px>=-1.&&Px<=1.&&Py>=-1.&&Py<=1.&&Pz>=-1.&&Pz<=1.");
261                                                   229 
262   numberCmd = new G4UIcmdWithAnInteger("/gps/n    230   numberCmd = new G4UIcmdWithAnInteger("/gps/number",this);
263   numberCmd->SetGuidance("Set number of partic    231   numberCmd->SetGuidance("Set number of particles to be generated per vertex.");
264   numberCmd->SetParameterName("N",false,false)    232   numberCmd->SetParameterName("N",false,false);
265   numberCmd->SetRange("N>0");                     233   numberCmd->SetRange("N>0");
266                                                   234 
267   // Verbosity                                 << 235   // verbosity
268   //                                           << 
269   verbosityCmd = new G4UIcmdWithAnInteger("/gp    236   verbosityCmd = new G4UIcmdWithAnInteger("/gps/verbose",this);
270   verbosityCmd->SetGuidance("Set Verbose level    237   verbosityCmd->SetGuidance("Set Verbose level for GPS");
271   verbosityCmd->SetGuidance(" 0 : Silent");       238   verbosityCmd->SetGuidance(" 0 : Silent");
272   verbosityCmd->SetGuidance(" 1 : Limited info    239   verbosityCmd->SetGuidance(" 1 : Limited information");
273   verbosityCmd->SetGuidance(" 2 : Detailed inf    240   verbosityCmd->SetGuidance(" 2 : Detailed information");
274   verbosityCmd->SetParameterName("level",false    241   verbosityCmd->SetParameterName("level",false);
275   verbosityCmd->SetRange("level>=0 && level <=    242   verbosityCmd->SetRange("level>=0 && level <=2");
276                                                   243 
277   volChkCmd = new G4UIcmdWithABool("/gps/check << 244   // now extended commands
278   volChkCmd->SetGuidance("Switch on/off the ch << 
279   volChkCmd->SetGuidance("By default the check << 
280   volChkCmd->SetGuidance("but the user has to  << 
281   volChkCmd->SetParameterName("switch",true,tr << 
282                                                << 
283   // Now extended commands                     << 
284   // Positional ones:                             245   // Positional ones:
285   //                                           << 
286   positionDirectory = new G4UIdirectory("/gps/    246   positionDirectory = new G4UIdirectory("/gps/pos/");
287   positionDirectory->SetGuidance("Positional c    247   positionDirectory->SetGuidance("Positional commands sub-directory");
288                                                   248 
289   typeCmd1 = new G4UIcmdWithAString("/gps/pos/    249   typeCmd1 = new G4UIcmdWithAString("/gps/pos/type",this);
290   typeCmd1->SetGuidance("Sets source distribut    250   typeCmd1->SetGuidance("Sets source distribution type.");
291   typeCmd1->SetGuidance("Either Point, Beam, P    251   typeCmd1->SetGuidance("Either Point, Beam, Plane, Surface or Volume");
292   typeCmd1->SetParameterName("DisType",false,f    252   typeCmd1->SetParameterName("DisType",false,false);
293   typeCmd1->SetDefaultValue("Point");             253   typeCmd1->SetDefaultValue("Point");
294   typeCmd1->SetCandidates("Point Beam Plane Su    254   typeCmd1->SetCandidates("Point Beam Plane Surface Volume");
295                                                   255 
296   shapeCmd1 = new G4UIcmdWithAString("/gps/pos    256   shapeCmd1 = new G4UIcmdWithAString("/gps/pos/shape",this);
297   shapeCmd1->SetGuidance("Sets source shape fo    257   shapeCmd1->SetGuidance("Sets source shape for Plan, Surface or Volume type source.");
298   shapeCmd1->SetParameterName("Shape",false,fa    258   shapeCmd1->SetParameterName("Shape",false,false);
299   shapeCmd1->SetDefaultValue("NULL");             259   shapeCmd1->SetDefaultValue("NULL");
300   shapeCmd1->SetCandidates("Circle Annulus Ell << 260   shapeCmd1->SetCandidates("Circle Annulus Ellipse Square Rectangle Sphere Ellipsoid Cylinder Para");
301                                                   261 
302   centreCmd1 = new G4UIcmdWith3VectorAndUnit("    262   centreCmd1 = new G4UIcmdWith3VectorAndUnit("/gps/pos/centre",this);
303   centreCmd1->SetGuidance("Set centre coordina    263   centreCmd1->SetGuidance("Set centre coordinates of source.");
                                                   >> 264   centreCmd1->SetGuidance("   same effect as the /gps/position command");
304   centreCmd1->SetParameterName("X","Y","Z",fal    265   centreCmd1->SetParameterName("X","Y","Z",false,false);
305   centreCmd1->SetDefaultUnit("cm");               266   centreCmd1->SetDefaultUnit("cm");
306   // centreCmd1->SetUnitCandidates("micron mm  << 267   //  centreCmd1->SetUnitCandidates("micron mm cm m km");
307                                                   268 
308   posrot1Cmd1 = new G4UIcmdWith3Vector("/gps/p    269   posrot1Cmd1 = new G4UIcmdWith3Vector("/gps/pos/rot1",this);
309   posrot1Cmd1->SetGuidance("Set the 1st vector    270   posrot1Cmd1->SetGuidance("Set the 1st vector defining the rotation matrix'.");
310   posrot1Cmd1->SetGuidance("It does not need t    271   posrot1Cmd1->SetGuidance("It does not need to be a unit vector.");
311   posrot1Cmd1->SetParameterName("R1x","R1y","R    272   posrot1Cmd1->SetParameterName("R1x","R1y","R1z",false,false); 
312   posrot1Cmd1->SetRange("R1x != 0 || R1y != 0     273   posrot1Cmd1->SetRange("R1x != 0 || R1y != 0 || R1z != 0");
313                                                   274 
314   posrot2Cmd1 = new G4UIcmdWith3Vector("/gps/p    275   posrot2Cmd1 = new G4UIcmdWith3Vector("/gps/pos/rot2",this);
315   posrot2Cmd1->SetGuidance("Set the 2nd vector    276   posrot2Cmd1->SetGuidance("Set the 2nd vector defining the rotation matrix'.");
316   posrot2Cmd1->SetGuidance("It does not need t    277   posrot2Cmd1->SetGuidance("It does not need to be a unit vector.");
317   posrot2Cmd1->SetParameterName("R2x","R2y","R    278   posrot2Cmd1->SetParameterName("R2x","R2y","R2z",false,false); 
318   posrot2Cmd1->SetRange("R2x != 0 || R2y != 0     279   posrot2Cmd1->SetRange("R2x != 0 || R2y != 0 || R2z != 0");
319                                                   280 
320   halfxCmd1 = new G4UIcmdWithADoubleAndUnit("/    281   halfxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/halfx",this);
321   halfxCmd1->SetGuidance("Set x half length of    282   halfxCmd1->SetGuidance("Set x half length of source.");
322   halfxCmd1->SetParameterName("Halfx",false,fa    283   halfxCmd1->SetParameterName("Halfx",false,false);
323   halfxCmd1->SetDefaultUnit("cm");                284   halfxCmd1->SetDefaultUnit("cm");
324   // halfxCmd1->SetUnitCandidates("micron mm c << 285   //  halfxCmd1->SetUnitCandidates("micron mm cm m km");
325                                                   286 
326   halfyCmd1 = new G4UIcmdWithADoubleAndUnit("/    287   halfyCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/halfy",this);
327   halfyCmd1->SetGuidance("Set y half length of    288   halfyCmd1->SetGuidance("Set y half length of source.");
328   halfyCmd1->SetParameterName("Halfy",false,fa    289   halfyCmd1->SetParameterName("Halfy",false,false);
329   halfyCmd1->SetDefaultUnit("cm");                290   halfyCmd1->SetDefaultUnit("cm");
330   // halfyCmd1->SetUnitCandidates("micron mm c << 291   //  halfyCmd1->SetUnitCandidates("micron mm cm m km");
331                                                   292 
332   halfzCmd1 = new G4UIcmdWithADoubleAndUnit("/    293   halfzCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/halfz",this);
333   halfzCmd1->SetGuidance("Set z half length of    294   halfzCmd1->SetGuidance("Set z half length of source.");
334   halfzCmd1->SetParameterName("Halfz",false,fa    295   halfzCmd1->SetParameterName("Halfz",false,false);
335   halfzCmd1->SetDefaultUnit("cm");                296   halfzCmd1->SetDefaultUnit("cm");
336   // halfzCmd1->SetUnitCandidates("micron mm c << 297   //  halfzCmd1->SetUnitCandidates("micron mm cm m km");
337                                                   298 
338   radiusCmd1 = new G4UIcmdWithADoubleAndUnit("    299   radiusCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/radius",this);
339   radiusCmd1->SetGuidance("Set radius of sourc    300   radiusCmd1->SetGuidance("Set radius of source.");
340   radiusCmd1->SetParameterName("Radius",false,    301   radiusCmd1->SetParameterName("Radius",false,false);
341   radiusCmd1->SetDefaultUnit("cm");               302   radiusCmd1->SetDefaultUnit("cm");
342   // radiusCmd1->SetUnitCandidates("micron mm  << 303   //  radiusCmd1->SetUnitCandidates("micron mm cm m km");
343                                                   304 
344   radius0Cmd1 = new G4UIcmdWithADoubleAndUnit(    305   radius0Cmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/inner_radius",this);
345   radius0Cmd1->SetGuidance("Set inner radius o    306   radius0Cmd1->SetGuidance("Set inner radius of source when required.");
346   radius0Cmd1->SetParameterName("Radius0",fals    307   radius0Cmd1->SetParameterName("Radius0",false,false);
347   radius0Cmd1->SetDefaultUnit("cm");              308   radius0Cmd1->SetDefaultUnit("cm");
348   // radius0Cmd1->SetUnitCandidates("micron mm << 309   //  radius0Cmd1->SetUnitCandidates("micron mm cm m km");
349                                                   310 
350   possigmarCmd1 = new G4UIcmdWithADoubleAndUni    311   possigmarCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/sigma_r",this);
351   possigmarCmd1->SetGuidance("Set standard dev    312   possigmarCmd1->SetGuidance("Set standard deviation in radial of the beam positional profile");
352   possigmarCmd1->SetGuidance(" applicable to B    313   possigmarCmd1->SetGuidance(" applicable to Beam type source only");
353   possigmarCmd1->SetParameterName("Sigmar",fal    314   possigmarCmd1->SetParameterName("Sigmar",false,false);
354   possigmarCmd1->SetDefaultUnit("cm");            315   possigmarCmd1->SetDefaultUnit("cm");
355   // possigmarCmd1->SetUnitCandidates("micron  << 316   //  possigmarCmd1->SetUnitCandidates("micron mm cm m km");
356                                                   317 
357   possigmaxCmd1 = new G4UIcmdWithADoubleAndUni    318   possigmaxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/sigma_x",this);
358   possigmaxCmd1->SetGuidance("Set standard dev    319   possigmaxCmd1->SetGuidance("Set standard deviation of beam positional profile in x-dir");
359   possigmaxCmd1->SetGuidance(" applicable to B    320   possigmaxCmd1->SetGuidance(" applicable to Beam type source only");
360   possigmaxCmd1->SetParameterName("Sigmax",fal    321   possigmaxCmd1->SetParameterName("Sigmax",false,false);
361   possigmaxCmd1->SetDefaultUnit("cm");            322   possigmaxCmd1->SetDefaultUnit("cm");
362   // possigmaxCmd1->SetUnitCandidates("micron  << 323   //  possigmaxCmd1->SetUnitCandidates("micron mm cm m km");
363                                                   324 
364   possigmayCmd1 = new G4UIcmdWithADoubleAndUni    325   possigmayCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/sigma_y",this);
365   possigmayCmd1->SetGuidance("Set standard dev    326   possigmayCmd1->SetGuidance("Set standard deviation of beam positional profile in y-dir");
366   possigmayCmd1->SetGuidance(" applicable to B    327   possigmayCmd1->SetGuidance(" applicable to Beam type source only");
367   possigmayCmd1->SetParameterName("Sigmay",fal    328   possigmayCmd1->SetParameterName("Sigmay",false,false);
368   possigmayCmd1->SetDefaultUnit("cm");            329   possigmayCmd1->SetDefaultUnit("cm");
369   // possigmayCmd1->SetUnitCandidates("micron  << 330   //  possigmayCmd1->SetUnitCandidates("micron mm cm m km");
370                                                   331 
371   paralpCmd1 = new G4UIcmdWithADoubleAndUnit("    332   paralpCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/paralp",this);
372   paralpCmd1->SetGuidance("Angle from y-axis o    333   paralpCmd1->SetGuidance("Angle from y-axis of y' in Para");
373   paralpCmd1->SetParameterName("paralp",false,    334   paralpCmd1->SetParameterName("paralp",false,false);
374   paralpCmd1->SetDefaultUnit("rad");              335   paralpCmd1->SetDefaultUnit("rad");
375   // paralpCmd1->SetUnitCandidates("rad deg"); << 336   //  paralpCmd1->SetUnitCandidates("rad deg");
376                                                   337 
377   partheCmd1 = new G4UIcmdWithADoubleAndUnit("    338   partheCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/parthe",this);
378   partheCmd1->SetGuidance("Polar angle through    339   partheCmd1->SetGuidance("Polar angle through centres of z faces");
379   partheCmd1->SetParameterName("parthe",false,    340   partheCmd1->SetParameterName("parthe",false,false);
380   partheCmd1->SetDefaultUnit("rad");              341   partheCmd1->SetDefaultUnit("rad");
381   // partheCmd1->SetUnitCandidates("rad deg"); << 342   //  partheCmd1->SetUnitCandidates("rad deg");
382                                                   343 
383   parphiCmd1 = new G4UIcmdWithADoubleAndUnit("    344   parphiCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/parphi",this);
384   parphiCmd1->SetGuidance("Azimuth angle throu    345   parphiCmd1->SetGuidance("Azimuth angle through centres of z faces");
385   parphiCmd1->SetParameterName("parphi",false,    346   parphiCmd1->SetParameterName("parphi",false,false);
386   parphiCmd1->SetDefaultUnit("rad");              347   parphiCmd1->SetDefaultUnit("rad");
387   // parphiCmd1->SetUnitCandidates("rad deg"); << 348   //  parphiCmd1->SetUnitCandidates("rad deg");
388                                                   349 
389   confineCmd1 = new G4UIcmdWithAString("/gps/p    350   confineCmd1 = new G4UIcmdWithAString("/gps/pos/confine",this);
390   confineCmd1->SetGuidance("Confine source to     351   confineCmd1->SetGuidance("Confine source to volume (NULL to unset).");
391   confineCmd1->SetGuidance(" Usage: confine Vo << 352   confineCmd1->SetGuidance("usage: confine VolName");
392   confineCmd1->SetParameterName("VolName",fals    353   confineCmd1->SetParameterName("VolName",false,false);
393   confineCmd1->SetDefaultValue("NULL");           354   confineCmd1->SetDefaultValue("NULL");
394                                                   355 
                                                   >> 356   // old implementations
                                                   >> 357   typeCmd = new G4UIcmdWithAString("/gps/type",this);
                                                   >> 358   typeCmd->SetGuidance("Sets source distribution type. (obsolete!)");
                                                   >> 359   typeCmd->SetGuidance("Either Point, Beam, Plane, Surface or Volume");
                                                   >> 360   typeCmd->SetParameterName("DisType",false,false);
                                                   >> 361   typeCmd->SetDefaultValue("Point");
                                                   >> 362   typeCmd->SetCandidates("Point Beam Plane Surface Volume");
                                                   >> 363 
                                                   >> 364   shapeCmd = new G4UIcmdWithAString("/gps/shape",this);
                                                   >> 365   shapeCmd->SetGuidance("Sets source shape type.(obsolete!)");
                                                   >> 366   shapeCmd->SetParameterName("Shape",false,false);
                                                   >> 367   shapeCmd->SetDefaultValue("NULL");
                                                   >> 368   shapeCmd->SetCandidates("Circle Annulus Ellipse Square Rectangle Sphere Ellipsoid Cylinder Para");
                                                   >> 369 
                                                   >> 370   centreCmd = new G4UIcmdWith3VectorAndUnit("/gps/centre",this);
                                                   >> 371   centreCmd->SetGuidance("Set centre coordinates of source.(obsolete!)");
                                                   >> 372   centreCmd->SetParameterName("X","Y","Z",false,false);
                                                   >> 373   centreCmd->SetDefaultUnit("cm");
                                                   >> 374   //  centreCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 375 
                                                   >> 376   posrot1Cmd = new G4UIcmdWith3Vector("/gps/posrot1",this);
                                                   >> 377   posrot1Cmd->SetGuidance("Set rotation matrix of x'.(obsolete!)");
                                                   >> 378   posrot1Cmd->SetGuidance("Posrot1 does not need to be a unit vector.");
                                                   >> 379   posrot1Cmd->SetParameterName("R1x","R1y","R1z",false,false); 
                                                   >> 380   posrot1Cmd->SetRange("R1x != 0 || R1y != 0 || R1z != 0");
                                                   >> 381 
                                                   >> 382   posrot2Cmd = new G4UIcmdWith3Vector("/gps/posrot2",this);
                                                   >> 383   posrot2Cmd->SetGuidance("Set rotation matrix of y'.(obsolete!)");
                                                   >> 384   posrot2Cmd->SetGuidance("Posrot2 does not need to be a unit vector.");
                                                   >> 385   posrot2Cmd->SetParameterName("R2x","R2y","R2z",false,false); 
                                                   >> 386   posrot2Cmd->SetRange("R2x != 0 || R2y != 0 || R2z != 0");
                                                   >> 387 
                                                   >> 388   halfxCmd = new G4UIcmdWithADoubleAndUnit("/gps/halfx",this);
                                                   >> 389   halfxCmd->SetGuidance("Set x half length of source.(obsolete!)");
                                                   >> 390   halfxCmd->SetParameterName("Halfx",false,false);
                                                   >> 391   halfxCmd->SetDefaultUnit("cm");
                                                   >> 392   //  halfxCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 393 
                                                   >> 394   halfyCmd = new G4UIcmdWithADoubleAndUnit("/gps/halfy",this);
                                                   >> 395   halfyCmd->SetGuidance("Set y half length of source.(obsolete!)");
                                                   >> 396   halfyCmd->SetParameterName("Halfy",false,false);
                                                   >> 397   halfyCmd->SetDefaultUnit("cm");
                                                   >> 398   //  halfyCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 399 
                                                   >> 400   halfzCmd = new G4UIcmdWithADoubleAndUnit("/gps/halfz",this);
                                                   >> 401   halfzCmd->SetGuidance("Set z half length of source.(obsolete!)");
                                                   >> 402   halfzCmd->SetParameterName("Halfz",false,false);
                                                   >> 403   halfzCmd->SetDefaultUnit("cm");
                                                   >> 404   //  halfzCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 405 
                                                   >> 406   radiusCmd = new G4UIcmdWithADoubleAndUnit("/gps/radius",this);
                                                   >> 407   radiusCmd->SetGuidance("Set radius of source.(obsolete!)");
                                                   >> 408   radiusCmd->SetParameterName("Radius",false,false);
                                                   >> 409   radiusCmd->SetDefaultUnit("cm");
                                                   >> 410   //  radiusCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 411 
                                                   >> 412   radius0Cmd = new G4UIcmdWithADoubleAndUnit("/gps/radius0",this);
                                                   >> 413   radius0Cmd->SetGuidance("Set inner radius of source.(obsolete!)");
                                                   >> 414   radius0Cmd->SetParameterName("Radius0",false,false);
                                                   >> 415   radius0Cmd->SetDefaultUnit("cm");
                                                   >> 416   //  radius0Cmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 417 
                                                   >> 418   possigmarCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaposr",this);
                                                   >> 419   possigmarCmd->SetGuidance("Set standard deviation of beam position in radial(obsolete!)");
                                                   >> 420   possigmarCmd->SetParameterName("Sigmar",false,false);
                                                   >> 421   possigmarCmd->SetDefaultUnit("cm");
                                                   >> 422   // possigmarCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 423 
                                                   >> 424   possigmaxCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaposx",this);
                                                   >> 425   possigmaxCmd->SetGuidance("Set standard deviation of beam position in x-dir(obsolete!)");
                                                   >> 426   possigmaxCmd->SetParameterName("Sigmax",false,false);
                                                   >> 427   possigmaxCmd->SetDefaultUnit("cm");
                                                   >> 428   //  possigmaxCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 429 
                                                   >> 430   possigmayCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaposy",this);
                                                   >> 431   possigmayCmd->SetGuidance("Set standard deviation of beam position in y-dir(obsolete!)");
                                                   >> 432   possigmayCmd->SetParameterName("Sigmay",false,false);
                                                   >> 433   possigmayCmd->SetDefaultUnit("cm");
                                                   >> 434   //  possigmayCmd->SetUnitCandidates("micron mm cm m km");
                                                   >> 435 
                                                   >> 436   paralpCmd = new G4UIcmdWithADoubleAndUnit("/gps/paralp",this);
                                                   >> 437   paralpCmd->SetGuidance("Angle from y-axis of y' in Para(obsolete!)");
                                                   >> 438   paralpCmd->SetParameterName("paralp",false,false);
                                                   >> 439   paralpCmd->SetDefaultUnit("rad");
                                                   >> 440   //  paralpCmd->SetUnitCandidates("rad deg");
                                                   >> 441 
                                                   >> 442   partheCmd = new G4UIcmdWithADoubleAndUnit("/gps/parthe",this);
                                                   >> 443   partheCmd->SetGuidance("Polar angle through centres of z faces(obsolete!)");
                                                   >> 444   partheCmd->SetParameterName("parthe",false,false);
                                                   >> 445   partheCmd->SetDefaultUnit("rad");
                                                   >> 446   //  partheCmd->SetUnitCandidates("rad deg");
                                                   >> 447 
                                                   >> 448   parphiCmd = new G4UIcmdWithADoubleAndUnit("/gps/parphi",this);
                                                   >> 449   parphiCmd->SetGuidance("Azimuth angle through centres of z faces(obsolete!)");
                                                   >> 450   parphiCmd->SetParameterName("parphi",false,false);
                                                   >> 451   parphiCmd->SetDefaultUnit("rad");
                                                   >> 452   //  parphiCmd->SetUnitCandidates("rad deg");
                                                   >> 453 
                                                   >> 454   confineCmd = new G4UIcmdWithAString("/gps/confine",this);
                                                   >> 455   confineCmd->SetGuidance("Confine source to volume (NULL to unset)(obsolete!) .");
                                                   >> 456   confineCmd->SetGuidance("usage: confine VolName");
                                                   >> 457   confineCmd->SetParameterName("VolName",false,false);
                                                   >> 458   confineCmd->SetDefaultValue("NULL");
                                                   >> 459 
395   // Angular distribution commands                460   // Angular distribution commands
396   //                                           << 
397   angularDirectory = new G4UIdirectory("/gps/a    461   angularDirectory = new G4UIdirectory("/gps/ang/");
398   angularDirectory->SetGuidance("Angular comma    462   angularDirectory->SetGuidance("Angular commands sub-directory");
399                                                   463 
400   angtypeCmd1 = new G4UIcmdWithAString("/gps/a    464   angtypeCmd1 = new G4UIcmdWithAString("/gps/ang/type",this);
401   angtypeCmd1->SetGuidance("Sets angular sourc    465   angtypeCmd1->SetGuidance("Sets angular source distribution type");
402   angtypeCmd1->SetGuidance(" Possible variable << 466   angtypeCmd1->SetGuidance("Possible variables are: iso, cos, planar, beam1d, beam2d, focused or user");
403   angtypeCmd1->SetParameterName("AngDis",false    467   angtypeCmd1->SetParameterName("AngDis",false,false);
404   angtypeCmd1->SetDefaultValue("iso");            468   angtypeCmd1->SetDefaultValue("iso");
405   angtypeCmd1->SetCandidates("iso cos planar b    469   angtypeCmd1->SetCandidates("iso cos planar beam1d beam2d focused user");
406                                                   470 
407   angrot1Cmd1 = new G4UIcmdWith3Vector("/gps/a    471   angrot1Cmd1 = new G4UIcmdWith3Vector("/gps/ang/rot1",this);
408   angrot1Cmd1->SetGuidance("Sets the 1st vecto    472   angrot1Cmd1->SetGuidance("Sets the 1st vector for angular distribution rotation matrix");
409   angrot1Cmd1->SetGuidance(" Need not be a uni << 473   angrot1Cmd1->SetGuidance("Need not be a unit vector");
410   angrot1Cmd1->SetParameterName("AR1x","AR1y",    474   angrot1Cmd1->SetParameterName("AR1x","AR1y","AR1z",false,false);
411   angrot1Cmd1->SetRange("AR1x != 0 || AR1y !=     475   angrot1Cmd1->SetRange("AR1x != 0 || AR1y != 0 || AR1z != 0");
412                                                   476 
413   angrot2Cmd1 = new G4UIcmdWith3Vector("/gps/a    477   angrot2Cmd1 = new G4UIcmdWith3Vector("/gps/ang/rot2",this);
414   angrot2Cmd1->SetGuidance("Sets the 2nd vecto    478   angrot2Cmd1->SetGuidance("Sets the 2nd vector for angular distribution rotation matrix");
415   angrot2Cmd1->SetGuidance(" Need not be a uni << 479   angrot2Cmd1->SetGuidance("Need not be a unit vector");
416   angrot2Cmd1->SetParameterName("AR2x","AR2y",    480   angrot2Cmd1->SetParameterName("AR2x","AR2y","AR2z",false,false);
417   angrot2Cmd1->SetRange("AR2x != 0 || AR2y !=     481   angrot2Cmd1->SetRange("AR2x != 0 || AR2y != 0 || AR2z != 0");
418                                                   482 
419   minthetaCmd1 = new G4UIcmdWithADoubleAndUnit    483   minthetaCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/mintheta",this);
420   minthetaCmd1->SetGuidance("Set minimum theta    484   minthetaCmd1->SetGuidance("Set minimum theta");
421   minthetaCmd1->SetParameterName("MinTheta",tr << 485   minthetaCmd1->SetParameterName("MinTheta",false,false);
422   minthetaCmd1->SetDefaultValue(0.);              486   minthetaCmd1->SetDefaultValue(0.);
423   minthetaCmd1->SetDefaultUnit("rad");            487   minthetaCmd1->SetDefaultUnit("rad");
424   // minthetaCmd1->SetUnitCandidates("rad deg" << 488   //  minthetaCmd1->SetUnitCandidates("rad deg");
425                                                   489 
426   maxthetaCmd1 = new G4UIcmdWithADoubleAndUnit    490   maxthetaCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/maxtheta",this);
427   maxthetaCmd1->SetGuidance("Set maximum theta    491   maxthetaCmd1->SetGuidance("Set maximum theta");
428   maxthetaCmd1->SetParameterName("MaxTheta",tr << 492   maxthetaCmd1->SetParameterName("MaxTheta",false,false);
429   maxthetaCmd1->SetDefaultValue(pi);              493   maxthetaCmd1->SetDefaultValue(pi);
430   maxthetaCmd1->SetDefaultUnit("rad");            494   maxthetaCmd1->SetDefaultUnit("rad");
431   // maxthetaCmd1->SetUnitCandidates("rad deg" << 495   //  maxthetaCmd1->SetUnitCandidates("rad deg");
432                                                   496 
433   minphiCmd1 = new G4UIcmdWithADoubleAndUnit("    497   minphiCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/minphi",this);
434   minphiCmd1->SetGuidance("Set minimum phi");     498   minphiCmd1->SetGuidance("Set minimum phi");
435   minphiCmd1->SetParameterName("MinPhi",true,f << 499   minphiCmd1->SetParameterName("MinPhi",false,false);
436   minphiCmd1->SetDefaultValue(0.);             << 
437   minphiCmd1->SetDefaultUnit("rad");              500   minphiCmd1->SetDefaultUnit("rad");
438   // minphiCmd1->SetUnitCandidates("rad deg"); << 501   //  minphiCmd1->SetUnitCandidates("rad deg");
439                                                   502 
440   maxphiCmd1 = new G4UIcmdWithADoubleAndUnit("    503   maxphiCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/maxphi",this);
441   maxphiCmd1->SetGuidance("Set maximum phi");     504   maxphiCmd1->SetGuidance("Set maximum phi");
442   maxphiCmd1->SetParameterName("MaxPhi",true,f << 505   maxphiCmd1->SetParameterName("MaxPhi",false,false);
443   maxphiCmd1->SetDefaultValue(2.*pi);          << 506   maxphiCmd1->SetDefaultValue(pi);
444   maxphiCmd1->SetDefaultUnit("rad");              507   maxphiCmd1->SetDefaultUnit("rad");
445   // maxphiCmd1->SetUnitCandidates("rad deg"); << 508   //  maxphiCmd1->SetUnitCandidates("rad deg");
446                                                   509 
447   angsigmarCmd1 = new G4UIcmdWithADoubleAndUni    510   angsigmarCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/sigma_r",this);
448   angsigmarCmd1->SetGuidance("Set standard dev    511   angsigmarCmd1->SetGuidance("Set standard deviation in direction for 1D beam.");
449   angsigmarCmd1->SetParameterName("Sigmara",fa    512   angsigmarCmd1->SetParameterName("Sigmara",false,false);
450   angsigmarCmd1->SetDefaultUnit("rad");           513   angsigmarCmd1->SetDefaultUnit("rad");
451   // angsigmarCmd1->SetUnitCandidates("rad deg << 514   //  angsigmarCmd1->SetUnitCandidates("rad deg");
452                                                   515   
453   angsigmaxCmd1 = new G4UIcmdWithADoubleAndUni    516   angsigmaxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/sigma_x",this);
454   angsigmaxCmd1->SetGuidance("Set standard dev    517   angsigmaxCmd1->SetGuidance("Set standard deviation in direction in x-direc. for 2D beam");
455   angsigmaxCmd1->SetParameterName("Sigmaxa",fa    518   angsigmaxCmd1->SetParameterName("Sigmaxa",false,false);
456   angsigmaxCmd1->SetDefaultUnit("rad");           519   angsigmaxCmd1->SetDefaultUnit("rad");
457   // angsigmaxCmd1->SetUnitCandidates("rad deg << 520   //  angsigmaxCmd1->SetUnitCandidates("rad deg");
458                                                   521 
459   angsigmayCmd1 = new G4UIcmdWithADoubleAndUni    522   angsigmayCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/sigma_y",this);
460   angsigmayCmd1->SetGuidance("Set standard dev    523   angsigmayCmd1->SetGuidance("Set standard deviation in direction in y-direc. for 2D beam");
461   angsigmayCmd1->SetParameterName("Sigmaya",fa    524   angsigmayCmd1->SetParameterName("Sigmaya",false,false);
462   angsigmayCmd1->SetDefaultUnit("rad");           525   angsigmayCmd1->SetDefaultUnit("rad");
463   // angsigmayCmd1->SetUnitCandidates("rad deg << 526   //  angsigmayCmd1->SetUnitCandidates("rad deg");
464                                                   527 
465   angfocusCmd = new G4UIcmdWith3VectorAndUnit(    528   angfocusCmd = new G4UIcmdWith3VectorAndUnit("/gps/ang/focuspoint",this);
466   angfocusCmd->SetGuidance("Set the focusing p    529   angfocusCmd->SetGuidance("Set the focusing point for the beam");
467   angfocusCmd->SetParameterName("x","y","z",fa    530   angfocusCmd->SetParameterName("x","y","z",false,false);
468   angfocusCmd->SetDefaultUnit("cm");              531   angfocusCmd->SetDefaultUnit("cm");
469   // angfocusCmd->SetUnitCandidates("micron mm << 532   //  angfocusCmd->SetUnitCandidates("micron mm cm m km");
470                                                   533 
471   useuserangaxisCmd1 = new G4UIcmdWithABool("/    534   useuserangaxisCmd1 = new G4UIcmdWithABool("/gps/ang/user_coor",this);
472   useuserangaxisCmd1->SetGuidance("True for us << 535   useuserangaxisCmd1->SetGuidance("true for using user defined angular co-ordinates");
473   useuserangaxisCmd1->SetGuidance(" Default is << 536   useuserangaxisCmd1->SetGuidance("Default is false");
474   useuserangaxisCmd1->SetParameterName("useuse    537   useuserangaxisCmd1->SetParameterName("useuserangaxis",true);
475   useuserangaxisCmd1->SetDefaultValue(false);     538   useuserangaxisCmd1->SetDefaultValue(false);
476                                                   539 
477   surfnormCmd1 = new G4UIcmdWithABool("/gps/an    540   surfnormCmd1 = new G4UIcmdWithABool("/gps/ang/surfnorm",this);
478   surfnormCmd1->SetGuidance("Makes a user-defi    541   surfnormCmd1->SetGuidance("Makes a user-defined distribution with respect to surface normals rather than x,y,z axes.");
479   surfnormCmd1->SetGuidance(" Default is false << 542   surfnormCmd1->SetGuidance("Default is false");
480   surfnormCmd1->SetParameterName("surfnorm",tr    543   surfnormCmd1->SetParameterName("surfnorm",true);
481   surfnormCmd1->SetDefaultValue(false);           544   surfnormCmd1->SetDefaultValue(false);
482                                                   545 
                                                   >> 546   // old ones
                                                   >> 547   angtypeCmd = new G4UIcmdWithAString("/gps/angtype",this);
                                                   >> 548   angtypeCmd->SetGuidance("Sets angular source distribution type (obsolete!)");
                                                   >> 549   angtypeCmd->SetGuidance("Possible variables are: iso, cos planar beam1d beam2d or user");
                                                   >> 550   angtypeCmd->SetParameterName("AngDis",false,false);
                                                   >> 551   angtypeCmd->SetDefaultValue("iso");
                                                   >> 552   angtypeCmd->SetCandidates("iso cos planar beam1d beam2d user");
                                                   >> 553 
                                                   >> 554   angrot1Cmd = new G4UIcmdWith3Vector("/gps/angrot1",this);
                                                   >> 555   angrot1Cmd->SetGuidance("Sets the x' vector for angular distribution(obsolete!) ");
                                                   >> 556   angrot1Cmd->SetGuidance("Need not be a unit vector");
                                                   >> 557   angrot1Cmd->SetParameterName("AR1x","AR1y","AR1z",false,false);
                                                   >> 558   angrot1Cmd->SetRange("AR1x != 0 || AR1y != 0 || AR1z != 0");
                                                   >> 559 
                                                   >> 560   angrot2Cmd = new G4UIcmdWith3Vector("/gps/angrot2",this);
                                                   >> 561   angrot2Cmd->SetGuidance("Sets the y' vector for angular distribution (obsolete!)");
                                                   >> 562   angrot2Cmd->SetGuidance("Need not be a unit vector");
                                                   >> 563   angrot2Cmd->SetParameterName("AR2x","AR2y","AR2z",false,false);
                                                   >> 564   angrot2Cmd->SetRange("AR2x != 0 || AR2y != 0 || AR2z != 0");
                                                   >> 565 
                                                   >> 566   minthetaCmd = new G4UIcmdWithADoubleAndUnit("/gps/mintheta",this);
                                                   >> 567   minthetaCmd->SetGuidance("Set minimum theta (obsolete!)");
                                                   >> 568   minthetaCmd->SetParameterName("MinTheta",false,false);
                                                   >> 569   minthetaCmd->SetDefaultUnit("rad");
                                                   >> 570   //  minthetaCmd->SetUnitCandidates("rad deg");
                                                   >> 571 
                                                   >> 572   maxthetaCmd = new G4UIcmdWithADoubleAndUnit("/gps/maxtheta",this);
                                                   >> 573   maxthetaCmd->SetGuidance("Set maximum theta (obsolete!)");
                                                   >> 574   maxthetaCmd->SetParameterName("MaxTheta",false,false);
                                                   >> 575   maxthetaCmd->SetDefaultValue(3.1416);
                                                   >> 576   maxthetaCmd->SetDefaultUnit("rad");
                                                   >> 577   //  maxthetaCmd->SetUnitCandidates("rad deg");
                                                   >> 578 
                                                   >> 579   minphiCmd = new G4UIcmdWithADoubleAndUnit("/gps/minphi",this);
                                                   >> 580   minphiCmd->SetGuidance("Set minimum phi (obsolete!)");
                                                   >> 581   minphiCmd->SetParameterName("MinPhi",false,false);
                                                   >> 582   minphiCmd->SetDefaultUnit("rad");
                                                   >> 583   //  minphiCmd->SetUnitCandidates("rad deg");
                                                   >> 584 
                                                   >> 585   maxphiCmd = new G4UIcmdWithADoubleAndUnit("/gps/maxphi",this);
                                                   >> 586   maxphiCmd->SetGuidance("Set maximum phi(obsolete!)");
                                                   >> 587   maxphiCmd->SetParameterName("MaxPhi",false,false);
                                                   >> 588   maxphiCmd->SetDefaultUnit("rad");
                                                   >> 589   //  maxphiCmd->SetUnitCandidates("rad deg");
                                                   >> 590 
                                                   >> 591   angsigmarCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaangr",this);
                                                   >> 592   angsigmarCmd->SetGuidance("Set standard deviation of beam direction in radial(obsolete!).");
                                                   >> 593   angsigmarCmd->SetParameterName("Sigmara",false,false);
                                                   >> 594   angsigmarCmd->SetDefaultUnit("rad");
                                                   >> 595   //  angsigmarCmd->SetUnitCandidates("rad deg");
                                                   >> 596 
                                                   >> 597   angsigmaxCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaangx",this);
                                                   >> 598   angsigmaxCmd->SetGuidance("Set standard deviation of beam direction in x-direc(obsolete!).");
                                                   >> 599   angsigmaxCmd->SetParameterName("Sigmaxa",false,false);
                                                   >> 600   angsigmaxCmd->SetDefaultUnit("rad");
                                                   >> 601   //  angsigmaxCmd->SetUnitCandidates("rad deg");
                                                   >> 602 
                                                   >> 603   angsigmayCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaangy",this);
                                                   >> 604   angsigmayCmd->SetGuidance("Set standard deviation of beam direction in y-direc.(obsolete!)");
                                                   >> 605   angsigmayCmd->SetParameterName("Sigmaya",false,false);
                                                   >> 606   angsigmayCmd->SetDefaultUnit("rad");
                                                   >> 607   //  angsigmayCmd->SetUnitCandidates("rad deg");
                                                   >> 608 
                                                   >> 609   useuserangaxisCmd = new G4UIcmdWithABool("/gps/useuserangaxis",this);
                                                   >> 610   useuserangaxisCmd->SetGuidance("true for using user defined angular co-ordinates(obsolete!)");
                                                   >> 611   useuserangaxisCmd->SetGuidance("Default is false");
                                                   >> 612   useuserangaxisCmd->SetParameterName("useuserangaxis",true);
                                                   >> 613   useuserangaxisCmd->SetDefaultValue(false);
                                                   >> 614 
                                                   >> 615   surfnormCmd = new G4UIcmdWithABool("/gps/surfnorm",this);
                                                   >> 616   surfnormCmd->SetGuidance("Makes a user-defined distribution with respect to surface normals rather than x,y,z axes (obsolete!).");
                                                   >> 617   surfnormCmd->SetGuidance("Default is false");
                                                   >> 618   surfnormCmd->SetParameterName("surfnorm",true);
                                                   >> 619   surfnormCmd->SetDefaultValue(false);
                                                   >> 620 
483   // Energy commands                              621   // Energy commands
484   //                                           << 622 
485   energyDirectory = new G4UIdirectory("/gps/en    623   energyDirectory = new G4UIdirectory("/gps/ene/");
486   energyDirectory->SetGuidance("Spectral comma    624   energyDirectory->SetGuidance("Spectral commands sub-directory");
487                                                   625 
488   energytypeCmd1 = new G4UIcmdWithAString("/gp    626   energytypeCmd1 = new G4UIcmdWithAString("/gps/ene/type",this);
489   energytypeCmd1->SetGuidance("Sets energy dis    627   energytypeCmd1->SetGuidance("Sets energy distribution type");
490   energytypeCmd1->SetParameterName("EnergyDis"    628   energytypeCmd1->SetParameterName("EnergyDis",false,false);
491   energytypeCmd1->SetDefaultValue("Mono");        629   energytypeCmd1->SetDefaultValue("Mono");
492   energytypeCmd1->SetCandidates("Mono Lin Pow  << 630   energytypeCmd1->SetCandidates("Mono Lin Pow Exp Gauss Brem Bbody Cdg User Arb Epn");
493                                                   631 
494   eminCmd1 = new G4UIcmdWithADoubleAndUnit("/g    632   eminCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/min",this);
495   eminCmd1->SetGuidance("Sets minimum energy")    633   eminCmd1->SetGuidance("Sets minimum energy");
496   eminCmd1->SetParameterName("emin",false,fals    634   eminCmd1->SetParameterName("emin",false,false);
497   eminCmd1->SetDefaultUnit("keV");                635   eminCmd1->SetDefaultUnit("keV");
498   // eminCmd1->SetUnitCandidates("eV keV MeV G << 636   //  eminCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
499                                                   637 
500   emaxCmd1 = new G4UIcmdWithADoubleAndUnit("/g    638   emaxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/max",this);
501   emaxCmd1->SetGuidance("Sets maximum energy")    639   emaxCmd1->SetGuidance("Sets maximum energy");
502   emaxCmd1->SetParameterName("emax",false,fals    640   emaxCmd1->SetParameterName("emax",false,false);
503   emaxCmd1->SetDefaultUnit("keV");                641   emaxCmd1->SetDefaultUnit("keV");
504   // emaxCmd1->SetUnitCandidates("eV keV MeV G << 642   //  emaxCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
505                                                   643 
506   monoenergyCmd1 = new G4UIcmdWithADoubleAndUn    644   monoenergyCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/mono",this);
507   monoenergyCmd1->SetGuidance("Sets a monocrom    645   monoenergyCmd1->SetGuidance("Sets a monocromatic energy (same as  gps/energy)");
508   monoenergyCmd1->SetParameterName("monoenergy    646   monoenergyCmd1->SetParameterName("monoenergy",false,false);
509   monoenergyCmd1->SetDefaultUnit("keV");          647   monoenergyCmd1->SetDefaultUnit("keV");
510   // monoenergyCmd1->SetUnitCandidates("eV keV << 648   //  monoenergyCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
511                                                   649 
512   engsigmaCmd1 = new G4UIcmdWithADoubleAndUnit    650   engsigmaCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/sigma",this);
513   engsigmaCmd1->SetGuidance("Sets the standard    651   engsigmaCmd1->SetGuidance("Sets the standard deviation for Gaussian energy dist.");
514   engsigmaCmd1->SetParameterName("Sigmae",fals    652   engsigmaCmd1->SetParameterName("Sigmae",false,false);
515   engsigmaCmd1->SetDefaultUnit("keV");            653   engsigmaCmd1->SetDefaultUnit("keV");
516   // engsigmaCmd1->SetUnitCandidates("eV keV M << 654   //  engsigmaCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
517                                                   655 
518   alphaCmd1 = new G4UIcmdWithADouble("/gps/ene    656   alphaCmd1 = new G4UIcmdWithADouble("/gps/ene/alpha",this);
519   alphaCmd1->SetGuidance("Sets Alpha (index) f    657   alphaCmd1->SetGuidance("Sets Alpha (index) for power-law energy dist.");
520   alphaCmd1->SetParameterName("alpha",false,fa    658   alphaCmd1->SetParameterName("alpha",false,false);
521                                                   659   
522   tempCmd1 = new G4UIcmdWithADouble("/gps/ene/    660   tempCmd1 = new G4UIcmdWithADouble("/gps/ene/temp",this);
523   tempCmd1->SetGuidance("Sets the temperature     661   tempCmd1->SetGuidance("Sets the temperature for Brem and BBody distributions (in Kelvin)");
524   tempCmd1->SetParameterName("temp",false,fals    662   tempCmd1->SetParameterName("temp",false,false);
525                                                   663 
526   ezeroCmd1 = new G4UIcmdWithADouble("/gps/ene    664   ezeroCmd1 = new G4UIcmdWithADouble("/gps/ene/ezero",this);
527   ezeroCmd1->SetGuidance("Sets E_0 for exponen    665   ezeroCmd1->SetGuidance("Sets E_0 for exponential distribution (in MeV)");
528   ezeroCmd1->SetParameterName("ezero",false,fa    666   ezeroCmd1->SetParameterName("ezero",false,false);
529                                                   667 
530   gradientCmd1 = new G4UIcmdWithADouble("/gps/    668   gradientCmd1 = new G4UIcmdWithADouble("/gps/ene/gradient",this);
531   gradientCmd1->SetGuidance("Sets the gradient    669   gradientCmd1->SetGuidance("Sets the gradient for Lin distribution (in 1/MeV)");
532   gradientCmd1->SetParameterName("gradient",fa    670   gradientCmd1->SetParameterName("gradient",false,false);
533                                                   671 
534   interceptCmd1 = new G4UIcmdWithADouble("/gps    672   interceptCmd1 = new G4UIcmdWithADouble("/gps/ene/intercept",this);
535   interceptCmd1->SetGuidance("Sets the interce    673   interceptCmd1->SetGuidance("Sets the intercept for Lin distributions (in MeV)");
536   interceptCmd1->SetParameterName("intercept",    674   interceptCmd1->SetParameterName("intercept",false,false);
537                                                   675 
538   arbeintCmd1 = new G4UIcmdWithADouble("/gps/e    676   arbeintCmd1 = new G4UIcmdWithADouble("/gps/ene/biasAlpha",this);
539   arbeintCmd1->SetGuidance("Sets the power-law << 677   arbeintCmd1->SetGuidance("Set the power-law index for the energy sampling distri. )");
540   arbeintCmd1->SetParameterName("arbeint",fals    678   arbeintCmd1->SetParameterName("arbeint",false,false);
541                                                   679 
542   calculateCmd1 = new G4UIcmdWithoutParameter(    680   calculateCmd1 = new G4UIcmdWithoutParameter("/gps/ene/calculate",this);
543   calculateCmd1->SetGuidance("Calculates the d    681   calculateCmd1->SetGuidance("Calculates the distributions for Cdg and BBody");
544                                                   682 
545   energyspecCmd1 = new G4UIcmdWithABool("/gps/    683   energyspecCmd1 = new G4UIcmdWithABool("/gps/ene/emspec",this);
546   energyspecCmd1->SetGuidance("True for energy    684   energyspecCmd1->SetGuidance("True for energy and false for momentum spectra");
547   energyspecCmd1->SetParameterName("energyspec    685   energyspecCmd1->SetParameterName("energyspec",true);
548   energyspecCmd1->SetDefaultValue(true);          686   energyspecCmd1->SetDefaultValue(true);
549                                                   687 
550   diffspecCmd1 = new G4UIcmdWithABool("/gps/en    688   diffspecCmd1 = new G4UIcmdWithABool("/gps/ene/diffspec",this);
551   diffspecCmd1->SetGuidance("True for differen    689   diffspecCmd1->SetGuidance("True for differential and flase for integral spectra");
552   diffspecCmd1->SetParameterName("diffspec",tr    690   diffspecCmd1->SetParameterName("diffspec",true);
553   diffspecCmd1->SetDefaultValue(true);            691   diffspecCmd1->SetDefaultValue(true);
554                                                   692 
555   applyEnergyWeightCmd1 = new G4UIcmdWithABool << 693   //old ones
556   applyEnergyWeightCmd1->SetGuidance("Apply en << 694   energytypeCmd = new G4UIcmdWithAString("/gps/energytype",this);
557   applyEnergyWeightCmd1->SetGuidance("- Instea << 695   energytypeCmd->SetGuidance("Sets energy distribution type (obsolete!)");
558   applyEnergyWeightCmd1->SetGuidance(" energy  << 696   energytypeCmd->SetParameterName("EnergyDis",false,false);
559   applyEnergyWeightCmd1->SetGuidance(" used fo << 697   energytypeCmd->SetDefaultValue("Mono");
560   applyEnergyWeightCmd1->SetGuidance("- \"/gps << 698   energytypeCmd->SetCandidates("Mono Lin Pow Exp Gauss Brem Bbody Cdg User Arb Epn");
561   applyEnergyWeightCmd1->SetGuidance("- If thi << 699 
562   applyEnergyWeightCmd1->SetParameterName("fla << 700   eminCmd = new G4UIcmdWithADoubleAndUnit("/gps/emin",this);
563   applyEnergyWeightCmd1->SetDefaultValue(true) << 701   eminCmd->SetGuidance("Sets Emin (obsolete!)");
                                                   >> 702   eminCmd->SetParameterName("emin",false,false);
                                                   >> 703   eminCmd->SetDefaultUnit("keV");
                                                   >> 704   //  eminCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
                                                   >> 705 
                                                   >> 706   emaxCmd = new G4UIcmdWithADoubleAndUnit("/gps/emax",this);
                                                   >> 707   emaxCmd->SetGuidance("Sets Emax (obsolete!)");
                                                   >> 708   emaxCmd->SetParameterName("emax",false,false);
                                                   >> 709   emaxCmd->SetDefaultUnit("keV");
                                                   >> 710   //  emaxCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
                                                   >> 711 
                                                   >> 712   monoenergyCmd = new G4UIcmdWithADoubleAndUnit("/gps/monoenergy",this);
                                                   >> 713   monoenergyCmd->SetGuidance("Sets Monoenergy (obsolete, use gps/energy instead!)");
                                                   >> 714   monoenergyCmd->SetParameterName("monoenergy",false,false);
                                                   >> 715   monoenergyCmd->SetDefaultUnit("keV");
                                                   >> 716   //  monoenergyCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
                                                   >> 717 
                                                   >> 718   engsigmaCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmae",this);
                                                   >> 719   engsigmaCmd->SetGuidance("Sets the standard deviation for Gaussian energy dist.(obsolete!)");
                                                   >> 720   engsigmaCmd->SetParameterName("Sigmae",false,false);
                                                   >> 721   engsigmaCmd->SetDefaultUnit("keV");
                                                   >> 722   //  engsigmaCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
                                                   >> 723 
                                                   >> 724   alphaCmd = new G4UIcmdWithADouble("/gps/alpha",this);
                                                   >> 725   alphaCmd->SetGuidance("Sets Alpha (index) for power-law energy dist(obsolete!).");
                                                   >> 726   alphaCmd->SetParameterName("alpha",false,false);
                                                   >> 727   
                                                   >> 728   tempCmd = new G4UIcmdWithADouble("/gps/temp",this);
                                                   >> 729   tempCmd->SetGuidance("Sets the temperature for Brem and BBody (in Kelvin)(obsolete!)");
                                                   >> 730   tempCmd->SetParameterName("temp",false,false);
                                                   >> 731 
                                                   >> 732   ezeroCmd = new G4UIcmdWithADouble("/gps/ezero",this);
                                                   >> 733   ezeroCmd->SetGuidance("Sets ezero exponential distributions (in MeV)(obsolete!)");
                                                   >> 734   ezeroCmd->SetParameterName("ezero",false,false);
                                                   >> 735 
                                                   >> 736   gradientCmd = new G4UIcmdWithADouble("/gps/gradient",this);
                                                   >> 737   gradientCmd->SetGuidance("Sets the gradient for Lin distributions (in 1/MeV)(obsolete!)");
                                                   >> 738   gradientCmd->SetParameterName("gradient",false,false);
                                                   >> 739 
                                                   >> 740   interceptCmd = new G4UIcmdWithADouble("/gps/intercept",this);
                                                   >> 741   interceptCmd->SetGuidance("Sets the intercept for Lin distributions (in MeV)(obsolete!)");
                                                   >> 742   interceptCmd->SetParameterName("intercept",false,false);
                                                   >> 743 
                                                   >> 744   calculateCmd = new G4UIcmdWithoutParameter("/gps/calculate",this);
                                                   >> 745   calculateCmd->SetGuidance("Calculates distributions for Cdg and BBody(obsolete!)");
                                                   >> 746 
                                                   >> 747   energyspecCmd = new G4UIcmdWithABool("/gps/energyspec",this);
                                                   >> 748   energyspecCmd->SetGuidance("True for energy and false for momentum spectra(obsolete!)");
                                                   >> 749   energyspecCmd->SetParameterName("energyspec",true);
                                                   >> 750   energyspecCmd->SetDefaultValue(true);
                                                   >> 751 
                                                   >> 752   diffspecCmd = new G4UIcmdWithABool("/gps/diffspec",this);
                                                   >> 753   diffspecCmd->SetGuidance("True for differential and flase for integral spectra(obsolete!)");
                                                   >> 754   diffspecCmd->SetParameterName("diffspec",true);
                                                   >> 755   diffspecCmd->SetDefaultValue(true);
564                                                   756 
565   // Biasing + histograms in general              757   // Biasing + histograms in general
566   //                                           << 
567   histDirectory = new G4UIdirectory("/gps/hist    758   histDirectory = new G4UIdirectory("/gps/hist/");
568   histDirectory->SetGuidance("Histogram, biasi    759   histDirectory->SetGuidance("Histogram, biasing commands sub-directory");
569                                                   760 
570   histnameCmd1 = new G4UIcmdWithAString("/gps/    761   histnameCmd1 = new G4UIcmdWithAString("/gps/hist/type",this);
571   histnameCmd1->SetGuidance("Sets histogram ty    762   histnameCmd1->SetGuidance("Sets histogram type");
572   histnameCmd1->SetParameterName("HistType",fa    763   histnameCmd1->SetParameterName("HistType",false,false);
573   histnameCmd1->SetDefaultValue("biasx");         764   histnameCmd1->SetDefaultValue("biasx");
574   histnameCmd1->SetCandidates("biasx biasy bia    765   histnameCmd1->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
575                                                   766 
576   resethistCmd1 = new G4UIcmdWithAString("/gps    767   resethistCmd1 = new G4UIcmdWithAString("/gps/hist/reset",this);
577   resethistCmd1->SetGuidance("Reset (clean) th    768   resethistCmd1->SetGuidance("Reset (clean) the histogram ");
578   resethistCmd1->SetParameterName("HistType",f    769   resethistCmd1->SetParameterName("HistType",false,false);
579   resethistCmd1->SetDefaultValue("energy");       770   resethistCmd1->SetDefaultValue("energy");
580   resethistCmd1->SetCandidates("biasx biasy bi    771   resethistCmd1->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
581                                                   772 
582   histpointCmd1 = new G4UIcmdWith3Vector("/gps    773   histpointCmd1 = new G4UIcmdWith3Vector("/gps/hist/point",this);
583   histpointCmd1->SetGuidance("Allows user to d    774   histpointCmd1->SetGuidance("Allows user to define a histogram");
584   histpointCmd1->SetGuidance(" Enter: Ehi Weig << 775   histpointCmd1->SetGuidance("Enter: Ehi Weight");
585   histpointCmd1->SetParameterName("Ehi","Weigh    776   histpointCmd1->SetParameterName("Ehi","Weight","Junk",true,true);
586   histpointCmd1->SetRange("Ehi >= 0. && Weight    777   histpointCmd1->SetRange("Ehi >= 0. && Weight >= 0.");
587                                                   778 
588   histfileCmd1 = new G4UIcmdWithAString("/gps/    779   histfileCmd1 = new G4UIcmdWithAString("/gps/hist/file",this);
589   histfileCmd1->SetGuidance("Imports the arb e << 780   histfileCmd1->SetGuidance("import the arb energy hist in an ASCII file");
590   histfileCmd1->SetParameterName("HistFile",fa    781   histfileCmd1->SetParameterName("HistFile",false,false);
591                                                   782 
592   arbintCmd1 = new G4UIcmdWithAString("/gps/hi    783   arbintCmd1 = new G4UIcmdWithAString("/gps/hist/inter",this);
593   arbintCmd1->SetGuidance("Sets the interpolat    784   arbintCmd1->SetGuidance("Sets the interpolation method for arbitrary distribution.");
594   arbintCmd1->SetGuidance("Spline interpolatio << 
595   arbintCmd1->SetParameterName("int",false,fal    785   arbintCmd1->SetParameterName("int",false,false);
596   arbintCmd1->SetDefaultValue("Lin");             786   arbintCmd1->SetDefaultValue("Lin");
597   arbintCmd1->SetCandidates("Lin Log Exp Splin    787   arbintCmd1->SetCandidates("Lin Log Exp Spline");
                                                   >> 788 
                                                   >> 789   // old ones
                                                   >> 790   histnameCmd = new G4UIcmdWithAString("/gps/histname",this);
                                                   >> 791   histnameCmd->SetGuidance("Sets histogram type (obsolete!)");
                                                   >> 792   histnameCmd->SetParameterName("HistType",false,false);
                                                   >> 793   histnameCmd->SetDefaultValue("biasx");
                                                   >> 794   histnameCmd->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
                                                   >> 795 
                                                   >> 796   // re-set the histograms
                                                   >> 797   resethistCmd = new G4UIcmdWithAString("/gps/resethist",this);
                                                   >> 798   resethistCmd->SetGuidance("Re-Set the histogram (obsolete!)");
                                                   >> 799   resethistCmd->SetParameterName("HistType",false,false);
                                                   >> 800   resethistCmd->SetDefaultValue("energy");
                                                   >> 801   resethistCmd->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
                                                   >> 802 
                                                   >> 803   histpointCmd = new G4UIcmdWith3Vector("/gps/histpoint",this);
                                                   >> 804   histpointCmd->SetGuidance("Allows user to define a histogram (obsolete!)");
                                                   >> 805   histpointCmd->SetGuidance("Enter: Ehi Weight");
                                                   >> 806   histpointCmd->SetParameterName("Ehi","Weight","Junk",false,false);
                                                   >> 807   histpointCmd->SetRange("Ehi >= 0. && Weight >= 0.");
                                                   >> 808 
                                                   >> 809   arbintCmd = new G4UIcmdWithAString("/gps/arbint",this);
                                                   >> 810   arbintCmd->SetGuidance("Sets Arbitrary Interpolation type.(obsolete!) ");
                                                   >> 811   arbintCmd->SetParameterName("int",false,false);
                                                   >> 812   arbintCmd->SetDefaultValue("NULL");
                                                   >> 813   arbintCmd->SetCandidates("Lin Log Exp Spline");
                                                   >> 814 
598 }                                                 815 }
599                                                   816 
600 G4GeneralParticleSourceMessenger::~G4GeneralPa    817 G4GeneralParticleSourceMessenger::~G4GeneralParticleSourceMessenger()
601 {                                                 818 {
602   delete positionDirectory;                       819   delete positionDirectory;
                                                   >> 820   delete typeCmd;
                                                   >> 821   delete shapeCmd;
                                                   >> 822   delete centreCmd;
                                                   >> 823   delete posrot1Cmd;
                                                   >> 824   delete posrot2Cmd;
                                                   >> 825   delete halfxCmd;
                                                   >> 826   delete halfyCmd;
                                                   >> 827   delete halfzCmd;
                                                   >> 828   delete radiusCmd;
                                                   >> 829   delete radius0Cmd;
                                                   >> 830   delete possigmarCmd;
                                                   >> 831   delete possigmaxCmd;
                                                   >> 832   delete possigmayCmd;
                                                   >> 833   delete paralpCmd;
                                                   >> 834   delete partheCmd;
                                                   >> 835   delete parphiCmd;
                                                   >> 836   delete confineCmd;
603   delete typeCmd1;                                837   delete typeCmd1;
604   delete shapeCmd1;                               838   delete shapeCmd1;
605   delete centreCmd1;                              839   delete centreCmd1;
606   delete posrot1Cmd1;                             840   delete posrot1Cmd1;
607   delete posrot2Cmd1;                             841   delete posrot2Cmd1;
608   delete halfxCmd1;                               842   delete halfxCmd1;
609   delete halfyCmd1;                               843   delete halfyCmd1;
610   delete halfzCmd1;                               844   delete halfzCmd1;
611   delete radiusCmd1;                              845   delete radiusCmd1;
612   delete radius0Cmd1;                             846   delete radius0Cmd1;
613   delete possigmarCmd1;                           847   delete possigmarCmd1;
614   delete possigmaxCmd1;                           848   delete possigmaxCmd1;
615   delete possigmayCmd1;                           849   delete possigmayCmd1;
616   delete paralpCmd1;                              850   delete paralpCmd1;
617   delete partheCmd1;                              851   delete partheCmd1;
618   delete parphiCmd1;                              852   delete parphiCmd1;
619   delete confineCmd1;                             853   delete confineCmd1;
620                                                   854 
621   delete angularDirectory;                        855   delete angularDirectory;
                                                   >> 856   delete angtypeCmd;
                                                   >> 857   delete angrot1Cmd;
                                                   >> 858   delete angrot2Cmd;
                                                   >> 859   delete minthetaCmd;
                                                   >> 860   delete maxthetaCmd;
                                                   >> 861   delete minphiCmd;
                                                   >> 862   delete maxphiCmd;
                                                   >> 863   delete angsigmarCmd;
                                                   >> 864   delete angsigmaxCmd;
                                                   >> 865   delete angsigmayCmd;
                                                   >> 866   delete useuserangaxisCmd;
                                                   >> 867   delete surfnormCmd;
622   delete angtypeCmd1;                             868   delete angtypeCmd1;
623   delete angrot1Cmd1;                             869   delete angrot1Cmd1;
624   delete angrot2Cmd1;                             870   delete angrot2Cmd1;
625   delete minthetaCmd1;                            871   delete minthetaCmd1;
626   delete maxthetaCmd1;                            872   delete maxthetaCmd1;
627   delete minphiCmd1;                              873   delete minphiCmd1;
628   delete maxphiCmd1;                              874   delete maxphiCmd1;
629   delete angsigmarCmd1;                           875   delete angsigmarCmd1;
630   delete angsigmaxCmd1;                           876   delete angsigmaxCmd1;
631   delete angsigmayCmd1;                           877   delete angsigmayCmd1;
632   delete angfocusCmd;                             878   delete angfocusCmd;
633   delete useuserangaxisCmd1;                      879   delete useuserangaxisCmd1;
634   delete surfnormCmd1;                            880   delete surfnormCmd1;
635                                                   881 
636   delete energyDirectory;                         882   delete energyDirectory;
                                                   >> 883   delete energytypeCmd;
                                                   >> 884   delete eminCmd;
                                                   >> 885   delete emaxCmd;
                                                   >> 886   delete monoenergyCmd;
                                                   >> 887   delete engsigmaCmd;
                                                   >> 888   delete alphaCmd;
                                                   >> 889   delete tempCmd;
                                                   >> 890   delete ezeroCmd;
                                                   >> 891   delete gradientCmd;
                                                   >> 892   delete interceptCmd;
                                                   >> 893   delete calculateCmd;
                                                   >> 894   delete energyspecCmd;
                                                   >> 895   delete diffspecCmd;
637   delete energytypeCmd1;                          896   delete energytypeCmd1;
638   delete eminCmd1;                                897   delete eminCmd1;
639   delete emaxCmd1;                                898   delete emaxCmd1;
640   delete monoenergyCmd1;                          899   delete monoenergyCmd1;
641   delete engsigmaCmd1;                            900   delete engsigmaCmd1;
642   delete alphaCmd1;                               901   delete alphaCmd1;
643   delete tempCmd1;                                902   delete tempCmd1;
644   delete ezeroCmd1;                               903   delete ezeroCmd1;
645   delete gradientCmd1;                            904   delete gradientCmd1;
646   delete interceptCmd1;                           905   delete interceptCmd1;
647   delete arbeintCmd1;                             906   delete arbeintCmd1;
648   delete calculateCmd1;                           907   delete calculateCmd1;
649   delete energyspecCmd1;                          908   delete energyspecCmd1;
650   delete diffspecCmd1;                            909   delete diffspecCmd1;
651   delete applyEnergyWeightCmd1;                << 
652                                                   910 
653   delete histDirectory;                           911   delete histDirectory;
                                                   >> 912   delete histnameCmd;
                                                   >> 913   delete resethistCmd;
                                                   >> 914   delete histpointCmd;
                                                   >> 915   delete arbintCmd;
654   delete histnameCmd1;                            916   delete histnameCmd1;
655   delete resethistCmd1;                           917   delete resethistCmd1;
656   delete histpointCmd1;                           918   delete histpointCmd1;
657   delete histfileCmd1;                            919   delete histfileCmd1;
658   delete arbintCmd1;                              920   delete arbintCmd1;
659                                                   921 
660   delete verbosityCmd;                            922   delete verbosityCmd;
661   delete volChkCmd;                            << 
662                                                << 
663   delete ionCmd;                                  923   delete ionCmd;
664   delete ionLvlCmd;                               924   delete ionLvlCmd;
665   delete particleCmd;                             925   delete particleCmd;
666   delete timeCmd;                                 926   delete timeCmd;
667   delete polCmd;                                  927   delete polCmd;
668   delete numberCmd;                               928   delete numberCmd;
669   delete positionCmd;                             929   delete positionCmd;
670   delete directionCmd;                            930   delete directionCmd;
671   delete energyCmd;                               931   delete energyCmd;
672   delete listCmd;                                 932   delete listCmd;
673                                                   933 
674   delete sourceDirectory;                         934   delete sourceDirectory;
675   delete addsourceCmd;                            935   delete addsourceCmd;
676   delete listsourceCmd;                           936   delete listsourceCmd;
677   delete clearsourceCmd;                          937   delete clearsourceCmd;
678   delete getsourceCmd;                            938   delete getsourceCmd;
679   delete setsourceCmd;                            939   delete setsourceCmd;
680   delete setintensityCmd;                         940   delete setintensityCmd;
681   delete deletesourceCmd;                         941   delete deletesourceCmd;
682   delete multiplevertexCmd;                       942   delete multiplevertexCmd;
683   delete flatsamplingCmd;                         943   delete flatsamplingCmd;
684                                                   944 
685   delete gpsDirectory;                            945   delete gpsDirectory;
686   theInstance = nullptr;                       << 946   
687 }                                                 947 }
688                                                   948 
689 #define CHECKPG() { if (fParticleGun==nullptr) << 
690                       G4ExceptionDescription m << 
691                       msg << "Command "<< comm << 
692                       msg << command->GetComma << 
693                       msg << " used but no par << 
694                       msg <<" Add at least a s << 
695                       G4Exception("G4GeneralPa << 
696                                   FatalExcepti << 
697                   } }                          << 
698                                                << 
699 void G4GeneralParticleSourceMessenger::SetNewV    949 void G4GeneralParticleSourceMessenger::SetNewValue(G4UIcommand *command, G4String newValues)
700 {                                                 950 {
701 //  if(command == typeCmd)                     << 951   if(command == typeCmd)
702 //    {                                        << 
703 //      CHECKPG(); fParticleGun->GetPosDist()- << 
704 //      G4cout << " G4GeneralParticleSourceMes << 
705 //             << " The command is obsolete an << 
706 //             << " Please try to use the new  << 
707 //    }                                        << 
708 //  else if(command == shapeCmd)               << 
709 //    {                                        << 
710 //      CHECKPG(); fParticleGun->GetPosDist()- << 
711 //      G4cout << " G4GeneralParticleSourceMes << 
712 //             << " The command is obsolete an << 
713 //             << " Please try to use the new  << 
714 //    }                                        << 
715 //  else if(command == centreCmd)              << 
716 //    {                                        << 
717 //      CHECKPG(); fParticleGun->GetPosDist()- << 
718 //      G4cout << " G4GeneralParticleSourceMes << 
719 //             << " The command is obsolete an << 
720 //             << " Please try to use the new  << 
721 //    }                                        << 
722 //  else if(command == posrot1Cmd)             << 
723 //    {                                        << 
724 //      CHECKPG(); fParticleGun->GetPosDist()- << 
725 //      G4cout << " G4GeneralParticleSourceMes << 
726 //             << " The command is obsolete an << 
727 //             << " Please try to use the new  << 
728 //    }                                        << 
729 //  else if(command == posrot2Cmd)             << 
730 //    {                                        << 
731 //      CHECKPG(); fParticleGun->GetPosDist()- << 
732 //      G4cout << " G4GeneralParticleSourceMes << 
733 //             << " The command is obsolete an << 
734 //             << " Please try to use the new  << 
735 //    }                                        << 
736 //  else if(command == halfxCmd)               << 
737 //    {                                        << 
738 //      CHECKPG(); fParticleGun->GetPosDist()- << 
739 //      G4cout << " G4GeneralParticleSourceMes << 
740 //             << " The command is obsolete an << 
741 //             << " Please try to use the new  << 
742 //    }                                        << 
743 //  else if(command == halfyCmd)               << 
744 //    {                                        << 
745 //      CHECKPG(); fParticleGun->GetPosDist()- << 
746 //      G4cout << " G4GeneralParticleSourceMes << 
747 //             << " The command is obsolete an << 
748 //             << " Please try to use the new  << 
749 //    }                                        << 
750 //  else if(command == halfzCmd)               << 
751 //    {                                        << 
752 //      CHECKPG(); fParticleGun->GetPosDist()- << 
753 //      G4cout << " G4GeneralParticleSourceMes << 
754 //             << " The command is obsolete an << 
755 //             << " Please try to use the new  << 
756 //    }                                        << 
757 //  else if(command == radiusCmd)              << 
758 //    {                                        << 
759 //      CHECKPG(); fParticleGun->GetPosDist()- << 
760 //      G4cout << " G4GeneralParticleSourceMes << 
761 //             << " The command is obsolete an << 
762 //             << " Please try to use the new  << 
763 //    }                                        << 
764 //  else if(command == radius0Cmd)             << 
765 //    {                                        << 
766 //      CHECKPG(); fParticleGun->GetPosDist()- << 
767 //      G4cout << " G4GeneralParticleSourceMes << 
768 //             << " The command is obsolete an << 
769 //             << " Please try to use the new  << 
770 //    }                                        << 
771 //  else if(command == possigmarCmd)           << 
772 //    {                                        << 
773 //      CHECKPG(); fParticleGun->GetPosDist()- << 
774 //      G4cout << " G4GeneralParticleSourceMes << 
775 //             << " The command is obsolete an << 
776 //             << " Please try to use the new  << 
777 //    }                                        << 
778 //  else if(command == possigmaxCmd)           << 
779 //    {                                        << 
780 //      CHECKPG(); fParticleGun->GetPosDist()- << 
781 //      G4cout << " G4GeneralParticleSourceMes << 
782 //             << " The command is obsolete an << 
783 //             << " Please try to use the new  << 
784 //    }                                        << 
785 //  else if(command == possigmayCmd)           << 
786 //    {                                        << 
787 //      CHECKPG(); fParticleGun->GetPosDist()- << 
788 //      G4cout << " G4GeneralParticleSourceMes << 
789 //             << " The command is obsolete an << 
790 //             << " Please try to use the new  << 
791 //    }                                        << 
792 //  else if(command == paralpCmd)              << 
793 //    {                                        << 
794 //      CHECKPG(); fParticleGun->GetPosDist()- << 
795 //      G4cout << " G4GeneralParticleSourceMes << 
796 //             << " The command is obsolete an << 
797 //             << " Please try to use the new  << 
798 //    }                                        << 
799 //  else if(command == partheCmd)              << 
800 //    {                                        << 
801 //      CHECKPG(); fParticleGun->GetPosDist()- << 
802 //      G4cout << " G4GeneralParticleSourceMes << 
803 //             << " The command is obsolete an << 
804 //             << " Please try to use the new  << 
805 //    }                                        << 
806 //  else if(command == parphiCmd)              << 
807 //    {                                        << 
808 //      CHECKPG(); fParticleGun->GetPosDist()- << 
809 //      G4cout << " G4GeneralParticleSourceMes << 
810 //             << " The command is obsolete an << 
811 //             << " Please try to use the new  << 
812 //    }                                        << 
813 //  else if(command == confineCmd)             << 
814 //    {                                        << 
815 //      CHECKPG(); fParticleGun->GetPosDist()- << 
816 //      G4cout << " G4GeneralParticleSourceMes << 
817 //             << " The command is obsolete an << 
818 //             << " Please try to use the new  << 
819 //    }                                        << 
820 //  else if(command == angtypeCmd)             << 
821 //    {                                        << 
822 //      CHECKPG(); fParticleGun->GetAngDist()- << 
823 //      G4cout << " G4GeneralParticleSourceMes << 
824 //             << " The command is obsolete an << 
825 //             << " Please try to use the new  << 
826 //    }                                        << 
827 //  else if(command == angrot1Cmd)             << 
828 //    {                                        << 
829 //      CHECKPG();                             << 
830 //      G4String a = "angref1";                << 
831 //      fParticleGun->GetAngDist()->DefineAngR << 
832 //      G4cout << " G4GeneralParticleSourceMes << 
833 //             << " The command is obsolete an << 
834 //             << " Please try to use the new  << 
835 //    }                                        << 
836 //  else if(command == angrot2Cmd)             << 
837 //    {                                        << 
838 //      CHECKPG();                             << 
839 //      G4String a = "angref2";                << 
840 //      fParticleGun->GetAngDist()->DefineAngR << 
841 //      G4cout << " G4GeneralParticleSourceMes << 
842 //             << " The command is obsolete an << 
843 //             << " Please try to use the new  << 
844 //    }                                        << 
845 //  else if(command == minthetaCmd)            << 
846 //    {                                        << 
847 //      CHECKPG(); fParticleGun->GetAngDist()- << 
848 //      G4cout << " G4GeneralParticleSourceMes << 
849 //             << " The command is obsolete an << 
850 //             << " Please try to use the new  << 
851 //    }                                        << 
852 //  else if(command == minphiCmd)              << 
853 //    {                                        << 
854 //      CHECKPG(); fParticleGun->GetAngDist()- << 
855 //      G4cout << " G4GeneralParticleSourceMes << 
856 //             << " The command is obsolete an << 
857 //             << " Please try to use the new  << 
858 //    }                                        << 
859 //  else if(command == maxthetaCmd)            << 
860 //    {                                        << 
861 //      CHECKPG(); fParticleGun->GetAngDist()- << 
862 //      G4cout << " G4GeneralParticleSourceMes << 
863 //             << " The command is obsolete an << 
864 //             << " Please try to use the new  << 
865 //    }                                        << 
866 //  else if(command == maxphiCmd)              << 
867 //    {                                        << 
868 //      CHECKPG(); fParticleGun->GetAngDist()- << 
869 //      G4cout << " G4GeneralParticleSourceMes << 
870 //             << " The command is obsolete an << 
871 //             << " Please try to use the new  << 
872 //    }                                        << 
873 //  else if(command == angsigmarCmd)           << 
874 //    {                                        << 
875 //      CHECKPG(); fParticleGun->GetAngDist()- << 
876 //      G4cout << " G4GeneralParticleSourceMes << 
877 //             << " The command is obsolete an << 
878 //             << " Please try to use the new  << 
879 //    }                                        << 
880 //  else if(command == angsigmaxCmd)           << 
881 //    {                                        << 
882 //      CHECKPG(); fParticleGun->GetAngDist()- << 
883 //      G4cout << " G4GeneralParticleSourceMes << 
884 //             << " The command is obsolete an << 
885 //             << " Please try to use the new  << 
886 //    }                                        << 
887 //  else if(command == angsigmayCmd)           << 
888 //    {                                        << 
889 //      CHECKPG(); fParticleGun->GetAngDist()- << 
890 //      G4cout << " G4GeneralParticleSourceMes << 
891 //             << " The command is obsolete an << 
892 //             << " Please try to use the new  << 
893 //    }                                        << 
894 //  else if(command == useuserangaxisCmd)      << 
895 //    {                                        << 
896 //      CHECKPG(); fParticleGun->GetAngDist()- << 
897 //      G4cout << " G4GeneralParticleSourceMes << 
898 //             << " The command is obsolete an << 
899 //             << " Please try to use the new  << 
900 //    }                                        << 
901 //  else if(command == surfnormCmd)            << 
902 //    {                                        << 
903 //      CHECKPG(); fParticleGun->GetAngDist()- << 
904 //      G4cout << " G4GeneralParticleSourceMes << 
905 //             << " The command is obsolete an << 
906 //             << " Please try to use the new  << 
907 //    }                                        << 
908 //  else if(command == energytypeCmd)          << 
909 //    {                                        << 
910 //      CHECKPG(); fParticleGun->GetEneDist()- << 
911 //      G4cout << " G4GeneralParticleSourceMes << 
912 //             << " The command is obsolete an << 
913 //             << " Please try to use the new  << 
914 //    }                                        << 
915 //  else if(command == eminCmd)                << 
916 //    {                                        << 
917 //      CHECKPG(); fParticleGun->GetEneDist()- << 
918 //      G4cout << " G4GeneralParticleSourceMes << 
919 //             << " The command is obsolete an << 
920 //             << " Please try to use the new  << 
921 //    }                                        << 
922 //  else if(command == emaxCmd)                << 
923 //    {                                        << 
924 //      CHECKPG(); fParticleGun->GetEneDist()- << 
925 //      G4cout << " G4GeneralParticleSourceMes << 
926 //             << " The command is obsolete an << 
927 //             << " Please try to use the new  << 
928 //    }                                        << 
929 //  else if(command == monoenergyCmd)          << 
930 //    {                                        << 
931 //      CHECKPG(); fParticleGun->GetEneDist()- << 
932 //      G4cout << " G4GeneralParticleSourceMes << 
933 //             << " The command is obsolete an << 
934 //             << " Please try to use the new  << 
935 //    }                                        << 
936 //  else if(command == engsigmaCmd)            << 
937 //    {                                        << 
938 //      CHECKPG(); fParticleGun->GetEneDist()- << 
939 //      G4cout << " G4GeneralParticleSourceMes << 
940 //             << " The command is obsolete an << 
941 //             << " Please try to use the new  << 
942 //    }                                        << 
943 //  else if(command == alphaCmd)               << 
944 //    {                                        << 
945 //      CHECKPG(); fParticleGun->GetEneDist()- << 
946 //      G4cout << " G4GeneralParticleSourceMes << 
947 //             << " The command is obsolete an << 
948 //             << " Please try to use the new  << 
949 //    }                                        << 
950 //  else if(command == tempCmd)                << 
951 //    {                                        << 
952 //      CHECKPG(); fParticleGun->GetEneDist()- << 
953 //      G4cout << " G4GeneralParticleSourceMes << 
954 //             << " The command is obsolete an << 
955 //             << " Please try to use the new  << 
956 //    }                                        << 
957 //  else if(command == ezeroCmd)               << 
958 //    {                                        << 
959 //      CHECKPG(); fParticleGun->GetEneDist()- << 
960 //      G4cout << " G4GeneralParticleSourceMes << 
961 //             << " The command is obsolete an << 
962 //             << " Please try to use the new  << 
963 //    }                                        << 
964 //  else if(command == gradientCmd)            << 
965 //    {                                        << 
966 //      CHECKPG(); fParticleGun->GetEneDist()- << 
967 //      G4cout << " G4GeneralParticleSourceMes << 
968 //             << " The command is obsolete an << 
969 //             << " Please try to use the new  << 
970 //    }                                        << 
971 //  else if(command == interceptCmd)           << 
972 //    {                                        << 
973 //      CHECKPG(); fParticleGun->GetEneDist()- << 
974 //      G4cout << " G4GeneralParticleSourceMes << 
975 //             << " The command is obsolete an << 
976 //             << " Please try to use the new  << 
977 //    }                                        << 
978 //  else if(command == calculateCmd)           << 
979 //    {                                        << 
980 //      CHECKPG(); fParticleGun->GetEneDist()- << 
981 //      G4cout << " G4GeneralParticleSourceMes << 
982 //             << " The command is obsolete an << 
983 //             << " Please try to use the new  << 
984 //    }                                        << 
985 //  else if(command == energyspecCmd)          << 
986 //    {                                        << 
987 //      CHECKPG(); fParticleGun->GetEneDist()- << 
988 //      G4cout << " G4GeneralParticleSourceMes << 
989 //             << " The command is obsolete an << 
990 //             << " Please try to use the new  << 
991 //    }                                        << 
992 //  else if(command == diffspecCmd)            << 
993 //    {                                        << 
994 //      CHECKPG(); fParticleGun->GetEneDist()- << 
995 //      G4cout << " G4GeneralParticleSourceMes << 
996 //             << " The command is obsolete an << 
997 //             << " Please try to use the new  << 
998 //    }                                        << 
999 //  else if(command == histnameCmd)            << 
1000 //    {                                       << 
1001 //      histtype = newValues;                 << 
1002 //      G4cout << " G4GeneralParticleSourceMe << 
1003 //             << " The command is obsolete a << 
1004 //             << " Please try to use the new << 
1005 //    }                                       << 
1006 //  else                                      << 
1007 //      if(command == histpointCmd)           << 
1008 //    {                                       << 
1009 //      CHECKPG();                            << 
1010 //      if(histtype == "biasx")               << 
1011 //        fParticleGun->GetBiasRndm()->SetXBi << 
1012 //      if(histtype == "biasy")               << 
1013 //        fParticleGun->GetBiasRndm()->SetYBi << 
1014 //      if(histtype == "biasz")               << 
1015 //        fParticleGun->GetBiasRndm()->SetZBi << 
1016 //      if(histtype == "biast")               << 
1017 //        fParticleGun->GetBiasRndm()->SetThe << 
1018 //      if(histtype == "biasp")               << 
1019 //        fParticleGun->GetBiasRndm()->SetPhi << 
1020 //      if(histtype == "biase")               << 
1021 //        fParticleGun->GetBiasRndm()->SetEne << 
1022 //      if(histtype == "theta")               << 
1023 //        fParticleGun->GetAngDist()->UserDef << 
1024 //      if(histtype == "phi")                 << 
1025 //        fParticleGun->GetAngDist()->UserDef << 
1026 //      if(histtype == "energy")              << 
1027 //        fParticleGun->GetEneDist()->UserEne << 
1028 //      if(histtype == "arb")                 << 
1029 //        fParticleGun->GetEneDist()->ArbEner << 
1030 //      if(histtype == "epn")                 << 
1031 //        fParticleGun->GetEneDist()->EpnEner << 
1032 //      G4cout << " G4GeneralParticleSourceMe << 
1033 //    }                                       << 
1034 //  else if(command == resethistCmd)          << 
1035 //    {                                       << 
1036 //      CHECKPG();                            << 
1037 //      if(newValues == "theta" || newValues  << 
1038 //        fParticleGun->GetAngDist()->ReSetHi << 
1039 //      } else if (newValues == "energy" || n << 
1040 //        fParticleGun->GetEneDist()->ReSetHi << 
1041 //      } else {                              << 
1042 //        fParticleGun->GetBiasRndm()->ReSetH << 
1043 //      }                                     << 
1044 //      G4cout << " G4GeneralParticleSourceMe << 
1045 //             << " The command is obsolete a << 
1046 //             << " Please try to use the new << 
1047 //    }                                       << 
1048 //  else if(command == arbintCmd)             << 
1049 //    {                                       << 
1050 //      CHECKPG();                            << 
1051 //      fParticleGun->GetEneDist()->ArbInterp << 
1052 //      G4cout << " G4GeneralParticleSourceMe << 
1053 //             << " The command is obsolete a << 
1054 //             << " Please try to use the new << 
1055 //    }                                       << 
1056 // else                                       << 
1057        if( command==directionCmd )            << 
1058     {                                            952     {
1059       CHECKPG();                              << 953       fParticleGun->GetPosDist()->SetPosDisType(newValues);
1060       fParticleGun->GetAngDist()->SetAngDistT << 954       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
1061       fParticleGun->GetAngDist()->SetParticle << 955              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 956              << " Please try to use the new structured commands!" << G4endl;
1062     }                                            957     }
1063   else if( command==energyCmd )               << 958   else if(command == shapeCmd)
1064     {                                            959     {
1065       CHECKPG();                              << 960       fParticleGun->GetPosDist()->SetPosDisShape(newValues);
1066       fParticleGun->GetEneDist()->SetEnergyDi << 961       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
1067       fParticleGun->GetEneDist()->SetMonoEner << 962              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 963              << " Please try to use the new structured commands!" << G4endl;
1068     }                                            964     }
1069   else if( command==positionCmd )             << 965   else if(command == centreCmd)
1070     {                                            966     {
1071       CHECKPG();                              << 967       fParticleGun->GetPosDist()->SetCentreCoords(centreCmd->GetNew3VectorValue(newValues));
1072       fParticleGun->GetPosDist()->SetPosDisTy << 968       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
1073       fParticleGun->GetPosDist()->SetCentreCo << 969              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 970              << " Please try to use the new structured commands!" << G4endl;
1074     }                                            971     }
1075   else if(command == verbosityCmd)            << 972   else if(command == posrot1Cmd)
1076     {                                            973     {
1077       fGPS->SetVerbosity(verbosityCmd->GetNew << 974       fParticleGun->GetPosDist()->SetPosRot1(posrot1Cmd->GetNew3VectorValue(newValues));
1078       // CHECKPG();                           << 975       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
1079       // fParticleGun->SetVerbosity(verbosity << 976              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 977              << " Please try to use the new structured commands!" << G4endl;
1080     }                                            978     }
1081   else if( command==volChkCmd )               << 979   else if(command == posrot2Cmd)
1082     {                                            980     {
1083       fGPS->CheckInside(volChkCmd->GetNewBool << 981       fParticleGun->GetPosDist()->SetPosRot2(posrot2Cmd->GetNew3VectorValue(newValues));
                                                   >> 982       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 983              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 984              << " Please try to use the new structured commands!" << G4endl;
1084     }                                            985     }
1085   else if( command==particleCmd )             << 986   else if(command == halfxCmd)
1086     {                                            987     {
1087       if (newValues =="ion")                  << 988       fParticleGun->GetPosDist()->SetHalfX(halfxCmd->GetNewDoubleValue(newValues));
1088       {                                       << 989       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
1089         fShootIon = true;                     << 990              << " The command is obsolete and will be removed soon." << G4endl
1090       }                                       << 991              << " Please try to use the new structured commands!" << G4endl;
1091       else                                    << 
1092       {                                       << 
1093         fShootIon = false;                    << 
1094         G4ParticleDefinition* pd = particleTa << 
1095         if(pd != nullptr)                     << 
1096         {                                     << 
1097           CHECKPG();                          << 
1098           fParticleGun->SetParticleDefinition << 
1099         }                                     << 
1100       }                                       << 
1101     }                                            992     }
1102   else if( command==timeCmd )                 << 993   else if(command == halfyCmd)
1103     {                                            994     {
1104       CHECKPG();                              << 995       fParticleGun->GetPosDist()->SetHalfY(halfyCmd->GetNewDoubleValue(newValues));
1105       fParticleGun->SetParticleTime(timeCmd-> << 996       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 997              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 998              << " Please try to use the new structured commands!" << G4endl;
1106     }                                            999     }
1107   else if( command==polCmd )                  << 1000   else if(command == halfzCmd)
1108     {                                            1001     {
1109       CHECKPG();                              << 1002       fParticleGun->GetPosDist()->SetHalfZ(halfzCmd->GetNewDoubleValue(newValues));
1110       fParticleGun->SetParticlePolarization(p << 1003       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1004              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1005              << " Please try to use the new structured commands!" << G4endl;
1111     }                                            1006     }
1112   else if( command==numberCmd )               << 1007   else if(command == radiusCmd)
1113     {                                            1008     {
1114       CHECKPG();                              << 1009       fParticleGun->GetPosDist()->SetRadius(radiusCmd->GetNewDoubleValue(newValues));
1115       fParticleGun->SetNumberOfParticles(numb << 1010       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1011              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1012              << " Please try to use the new structured commands!" << G4endl;
1116     }                                            1013     }
1117   else if( command==ionCmd )                  << 1014   else if(command == radius0Cmd)
1118     {                                            1015     {
1119       IonCommand(newValues);                  << 1016       fParticleGun->GetPosDist()->SetRadius0(radius0Cmd->GetNewDoubleValue(newValues));
                                                   >> 1017       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1018              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1019              << " Please try to use the new structured commands!" << G4endl;
1120     }                                            1020     }
1121   else if( command==ionLvlCmd )               << 1021   else if(command == possigmarCmd)
                                                   >> 1022     {
                                                   >> 1023       fParticleGun->GetPosDist()->SetBeamSigmaInR(possigmarCmd->GetNewDoubleValue(newValues));
                                                   >> 1024       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1025              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1026              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1027     }
                                                   >> 1028   else if(command == possigmaxCmd)
                                                   >> 1029     {
                                                   >> 1030       fParticleGun->GetPosDist()->SetBeamSigmaInX(possigmaxCmd->GetNewDoubleValue(newValues));
                                                   >> 1031       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1032              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1033              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1034     }
                                                   >> 1035   else if(command == possigmayCmd)
                                                   >> 1036     {
                                                   >> 1037       fParticleGun->GetPosDist()->SetBeamSigmaInY(possigmayCmd->GetNewDoubleValue(newValues));
                                                   >> 1038       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1039              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1040              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1041     }
                                                   >> 1042   else if(command == paralpCmd)
                                                   >> 1043     {
                                                   >> 1044       fParticleGun->GetPosDist()->SetParAlpha(paralpCmd->GetNewDoubleValue(newValues));
                                                   >> 1045       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1046              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1047              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1048     }
                                                   >> 1049   else if(command == partheCmd)
                                                   >> 1050     {
                                                   >> 1051       fParticleGun->GetPosDist()->SetParTheta(partheCmd->GetNewDoubleValue(newValues));
                                                   >> 1052       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1053              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1054              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1055     }
                                                   >> 1056   else if(command == parphiCmd)
                                                   >> 1057     {
                                                   >> 1058       fParticleGun->GetPosDist()->SetParPhi(parphiCmd->GetNewDoubleValue(newValues));
                                                   >> 1059       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1060              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1061              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1062     }
                                                   >> 1063   else if(command == confineCmd)
                                                   >> 1064     {
                                                   >> 1065       fParticleGun->GetPosDist()->ConfineSourceToVolume(newValues);
                                                   >> 1066       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1067              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1068              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1069     }
                                                   >> 1070   else if(command == angtypeCmd)
                                                   >> 1071     {
                                                   >> 1072       fParticleGun->GetAngDist()->SetAngDistType(newValues);
                                                   >> 1073       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1074              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1075              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1076     }
                                                   >> 1077   else if(command == angrot1Cmd)
                                                   >> 1078     {
                                                   >> 1079       G4String a = "angref1";
                                                   >> 1080       fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot1Cmd->GetNew3VectorValue(newValues));
                                                   >> 1081       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1082              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1083              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1084     }
                                                   >> 1085   else if(command == angrot2Cmd)
                                                   >> 1086     {
                                                   >> 1087       G4String a = "angref2";
                                                   >> 1088       fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot2Cmd->GetNew3VectorValue(newValues));
                                                   >> 1089       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1090              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1091              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1092     }
                                                   >> 1093   else if(command == minthetaCmd)
                                                   >> 1094     {
                                                   >> 1095       fParticleGun->GetAngDist()->SetMinTheta(minthetaCmd->GetNewDoubleValue(newValues));
                                                   >> 1096       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1097              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1098              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1099     }
                                                   >> 1100   else if(command == minphiCmd)
                                                   >> 1101     {
                                                   >> 1102       fParticleGun->GetAngDist()->SetMinPhi(minphiCmd->GetNewDoubleValue(newValues));
                                                   >> 1103       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1104              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1105              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1106     }
                                                   >> 1107   else if(command == maxthetaCmd)
                                                   >> 1108     {
                                                   >> 1109       fParticleGun->GetAngDist()->SetMaxTheta(maxthetaCmd->GetNewDoubleValue(newValues));
                                                   >> 1110       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1111              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1112              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1113     }
                                                   >> 1114   else if(command == maxphiCmd)
                                                   >> 1115     {
                                                   >> 1116       fParticleGun->GetAngDist()->SetMaxPhi(maxphiCmd->GetNewDoubleValue(newValues));
                                                   >> 1117       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1118              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1119              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1120     }
                                                   >> 1121   else if(command == angsigmarCmd)
                                                   >> 1122     {
                                                   >> 1123       fParticleGun->GetAngDist()->SetBeamSigmaInAngR(angsigmarCmd->GetNewDoubleValue(newValues));
                                                   >> 1124       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1125              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1126              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1127     }
                                                   >> 1128   else if(command == angsigmaxCmd)
                                                   >> 1129     {
                                                   >> 1130       fParticleGun->GetAngDist()->SetBeamSigmaInAngX(angsigmaxCmd->GetNewDoubleValue(newValues));
                                                   >> 1131       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1132              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1133              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1134     }
                                                   >> 1135   else if(command == angsigmayCmd)
                                                   >> 1136     {
                                                   >> 1137       fParticleGun->GetAngDist()->SetBeamSigmaInAngY(angsigmayCmd->GetNewDoubleValue(newValues));
                                                   >> 1138       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1139              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1140              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1141     }
                                                   >> 1142   else if(command == useuserangaxisCmd)
                                                   >> 1143     {
                                                   >> 1144       fParticleGun->GetAngDist()->SetUseUserAngAxis(useuserangaxisCmd->GetNewBoolValue(newValues));
                                                   >> 1145       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1146              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1147              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1148     }
                                                   >> 1149   else if(command == surfnormCmd)
                                                   >> 1150     {
                                                   >> 1151       fParticleGun->GetAngDist()->SetUserWRTSurface(surfnormCmd->GetNewBoolValue(newValues));
                                                   >> 1152       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1153              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1154              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1155     }
                                                   >> 1156   else if(command == energytypeCmd)
                                                   >> 1157     {
                                                   >> 1158       fParticleGun->GetEneDist()->SetEnergyDisType(newValues);
                                                   >> 1159       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1160              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1161              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1162     }
                                                   >> 1163   else if(command == eminCmd)
                                                   >> 1164     {
                                                   >> 1165       fParticleGun->GetEneDist()->SetEmin(eminCmd->GetNewDoubleValue(newValues));
                                                   >> 1166       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1167              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1168              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1169     }
                                                   >> 1170   else if(command == emaxCmd)
1122     {                                            1171     {
1123       IonLvlCommand(newValues);               << 1172       fParticleGun->GetEneDist()->SetEmax(emaxCmd->GetNewDoubleValue(newValues));
                                                   >> 1173       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1174              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1175              << " Please try to use the new structured commands!" << G4endl;
1124     }                                            1176     }
1125   else if( command==listCmd )                 << 1177   else if(command == monoenergyCmd)
                                                   >> 1178     {
                                                   >> 1179       fParticleGun->GetEneDist()->SetMonoEnergy(monoenergyCmd->GetNewDoubleValue(newValues));
                                                   >> 1180       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1181              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1182              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1183     }
                                                   >> 1184   else if(command == engsigmaCmd)
                                                   >> 1185     {
                                                   >> 1186       fParticleGun->GetEneDist()->SetBeamSigmaInE(engsigmaCmd->GetNewDoubleValue(newValues));
                                                   >> 1187       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1188              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1189              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1190     }
                                                   >> 1191   else if(command == alphaCmd)
                                                   >> 1192     {
                                                   >> 1193       fParticleGun->GetEneDist()->SetAlpha(alphaCmd->GetNewDoubleValue(newValues));
                                                   >> 1194       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1195              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1196              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1197     }
                                                   >> 1198   else if(command == tempCmd)
                                                   >> 1199     {
                                                   >> 1200       fParticleGun->GetEneDist()->SetTemp(tempCmd->GetNewDoubleValue(newValues));
                                                   >> 1201       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1202              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1203              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1204     }
                                                   >> 1205   else if(command == ezeroCmd)
                                                   >> 1206     {
                                                   >> 1207       fParticleGun->GetEneDist()->SetEzero(ezeroCmd->GetNewDoubleValue(newValues));
                                                   >> 1208       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1209              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1210              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1211     }
                                                   >> 1212   else if(command == gradientCmd)
                                                   >> 1213     {
                                                   >> 1214       fParticleGun->GetEneDist()->SetGradient(gradientCmd->GetNewDoubleValue(newValues));
                                                   >> 1215       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1216              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1217              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1218     }
                                                   >> 1219   else if(command == interceptCmd)
                                                   >> 1220     {
                                                   >> 1221       fParticleGun->GetEneDist()->SetInterCept(interceptCmd->GetNewDoubleValue(newValues));
                                                   >> 1222       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1223              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1224              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1225     }
                                                   >> 1226   else if(command == calculateCmd)
                                                   >> 1227     {
                                                   >> 1228       fParticleGun->GetEneDist()->Calculate();
                                                   >> 1229       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1230              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1231              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1232     }
                                                   >> 1233   else if(command == energyspecCmd)
                                                   >> 1234     {
                                                   >> 1235       fParticleGun->GetEneDist()->InputEnergySpectra(energyspecCmd->GetNewBoolValue(newValues));
                                                   >> 1236       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1237              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1238              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1239     }
                                                   >> 1240   else if(command == diffspecCmd)
                                                   >> 1241     {
                                                   >> 1242       fParticleGun->GetEneDist()->InputDifferentialSpectra(diffspecCmd->GetNewBoolValue(newValues));
                                                   >> 1243       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1244              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1245              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1246     }
                                                   >> 1247   else if(command == histnameCmd)
                                                   >> 1248     {
                                                   >> 1249       histtype = newValues;
                                                   >> 1250       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1251              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1252              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1253     }
                                                   >> 1254   else if(command == histpointCmd)
                                                   >> 1255     {
                                                   >> 1256       if(histtype == "biasx")
                                                   >> 1257   fParticleGun->GetBiasRndm()->SetXBias(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1258       if(histtype == "biasy")
                                                   >> 1259   fParticleGun->GetBiasRndm()->SetYBias(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1260       if(histtype == "biasz")
                                                   >> 1261   fParticleGun->GetBiasRndm()->SetZBias(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1262       if(histtype == "biast")
                                                   >> 1263   fParticleGun->GetBiasRndm()->SetThetaBias(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1264       if(histtype == "biasp")
                                                   >> 1265   fParticleGun->GetBiasRndm()->SetPhiBias(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1266       if(histtype == "biase")
                                                   >> 1267   fParticleGun->GetBiasRndm()->SetEnergyBias(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1268       if(histtype == "theta")
                                                   >> 1269   fParticleGun->GetAngDist()->UserDefAngTheta(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1270       if(histtype == "phi")
                                                   >> 1271   fParticleGun->GetAngDist()->UserDefAngPhi(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1272       if(histtype == "energy")
                                                   >> 1273   fParticleGun->GetEneDist()->UserEnergyHisto(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1274       if(histtype == "arb")
                                                   >> 1275   fParticleGun->GetEneDist()->ArbEnergyHisto(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1276       if(histtype == "epn")
                                                   >> 1277   fParticleGun->GetEneDist()->EpnEnergyHisto(histpointCmd->GetNew3VectorValue(newValues));
                                                   >> 1278       G4cout << " G4GeneralParticleSourceMessenger - Warning: The command is obsolete and will be removed soon. Please try to use the new structured commands!" << G4endl;
                                                   >> 1279     }
                                                   >> 1280   else if(command == resethistCmd)
                                                   >> 1281     {
                                                   >> 1282       if(newValues == "theta" || newValues == "phi") {
                                                   >> 1283   fParticleGun->GetAngDist()->ReSetHist(newValues);
                                                   >> 1284       } else if (newValues == "energy" || newValues == "arb" || newValues == "epn") {
                                                   >> 1285   fParticleGun->GetEneDist()->ReSetHist(newValues);
                                                   >> 1286       } else {
                                                   >> 1287   fParticleGun->GetBiasRndm()->ReSetHist(newValues);
                                                   >> 1288       }
                                                   >> 1289       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1290              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1291              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1292     }
                                                   >> 1293   else if(command == arbintCmd)
                                                   >> 1294     {
                                                   >> 1295       fParticleGun->GetEneDist()->ArbInterpolate(newValues);
                                                   >> 1296       G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
                                                   >> 1297              << " The command is obsolete and will be removed soon." << G4endl
                                                   >> 1298              << " Please try to use the new structured commands!" << G4endl;
                                                   >> 1299     }
                                                   >> 1300   else if( command==directionCmd )
1126     {                                            1301     { 
1127       particleTable->DumpTable();             << 1302       fParticleGun->GetAngDist()->SetAngDistType("planar");
                                                   >> 1303       fParticleGun->GetAngDist()->SetParticleMomentumDirection(directionCmd->GetNew3VectorValue(newValues));
1128     }                                            1304     }
1129   else if( command==addsourceCmd )            << 1305   else if( command==energyCmd )
                                                   >> 1306     {    
                                                   >> 1307       fParticleGun->GetEneDist()->SetEnergyDisType("Mono");
                                                   >> 1308       fParticleGun->GetEneDist()->SetMonoEnergy(energyCmd->GetNewDoubleValue(newValues));
                                                   >> 1309     }
                                                   >> 1310   else if( command==positionCmd )
                                                   >> 1311     { 
                                                   >> 1312       fParticleGun->GetPosDist()->SetPosDisType("Point");    
                                                   >> 1313       fParticleGun->GetPosDist()->SetCentreCoords(positionCmd->GetNew3VectorValue(newValues));
                                                   >> 1314     }
                                                   >> 1315   else if(command == verbosityCmd)
1130     {                                            1316     {
                                                   >> 1317       fParticleGun->SetVerbosity(verbosityCmd->GetNewIntValue(newValues));
                                                   >> 1318     }
                                                   >> 1319   else if( command==particleCmd )
                                                   >> 1320     {
                                                   >> 1321       if (newValues =="ion") {
                                                   >> 1322   fShootIon = true;
                                                   >> 1323       } else {
                                                   >> 1324   fShootIon = false;
                                                   >> 1325   G4ParticleDefinition* pd = particleTable->FindParticle(newValues);
                                                   >> 1326   if(pd != NULL)
                                                   >> 1327     { fParticleGun->SetParticleDefinition( pd ); }
                                                   >> 1328       }
                                                   >> 1329     }
                                                   >> 1330   else if( command==timeCmd )
                                                   >> 1331     { fParticleGun->SetParticleTime(timeCmd->GetNewDoubleValue(newValues)); }
                                                   >> 1332   else if( command==polCmd )
                                                   >> 1333     { fParticleGun->SetParticlePolarization(polCmd->GetNew3VectorValue(newValues)); }
                                                   >> 1334   else if( command==numberCmd )
                                                   >> 1335     { fParticleGun->SetNumberOfParticles(numberCmd->GetNewIntValue(newValues)); }
                                                   >> 1336   else if( command==ionCmd )
                                                   >> 1337     { IonCommand(newValues); }
                                                   >> 1338   else if( command==ionLvlCmd )
                                                   >> 1339     { IonLvlCommand(newValues); }
                                                   >> 1340   else if( command==listCmd ){ 
                                                   >> 1341     particleTable->DumpTable(); 
                                                   >> 1342   }
                                                   >> 1343   else if( command==addsourceCmd )
                                                   >> 1344     { 
1131       fGPS->AddaSource(addsourceCmd->GetNewDo    1345       fGPS->AddaSource(addsourceCmd->GetNewDoubleValue(newValues));
1132     }                                            1346     }
1133   else if( command==listsourceCmd )              1347   else if( command==listsourceCmd )
1134     {                                            1348     { 
1135       fGPS->ListSource();                        1349       fGPS->ListSource();
1136     }                                            1350     }
1137   else if( command==clearsourceCmd )             1351   else if( command==clearsourceCmd )
1138     {                                            1352     { 
1139       fGPS->ClearAll();                          1353       fGPS->ClearAll();
1140       fParticleGun = nullptr;                 << 
1141     }                                            1354     }
1142   else if( command==getsourceCmd )               1355   else if( command==getsourceCmd )
1143     {                                            1356     { 
1144       G4cout << " Current source index:" << f    1357       G4cout << " Current source index:" << fGPS->GetCurrentSourceIndex() 
1145              << " ; Intensity:" << fGPS->GetC << 1358        << " ; Intensity:" << fGPS->GetCurrentSourceIntensity() << G4endl;
1146     }                                            1359     }
1147   else if( command==setsourceCmd )               1360   else if( command==setsourceCmd )
1148     {                                            1361     { 
1149       // NOTE: This will also sets fParticleG << 
1150       //       Not very clean, the GPS::SetCu << 
1151       //       SetParticleSource( G4ParticleS << 
1152       //       The point is that GPS has no p << 
1153       // TODO: Can we add this API?           << 
1154       const G4int sn = setsourceCmd->GetNewIn << 
1155       if ( sn >= fGPS->GetNumberofSource() )  << 
1156       {                                       << 
1157         G4ExceptionDescription msg;           << 
1158         msg << "Using command " << setsourceC << 
1159             << setsourceCmd->GetCommandName() << 
1160         msg << " is invalid " << fGPS->GetNum << 
1161             << " source(s) are defined.";     << 
1162         G4Exception("G4GeneralParticleSourceM << 
1163                     "G4GPS005", FatalExceptio << 
1164       }                                       << 
1165       fGPS->SetCurrentSourceto(setsourceCmd->    1362       fGPS->SetCurrentSourceto(setsourceCmd->GetNewIntValue(newValues));
1166     }                                            1363     }
1167   else if( command==setintensityCmd )            1364   else if( command==setintensityCmd )
1168     {                                            1365     { 
1169       fGPS->SetCurrentSourceIntensity(setinte    1366       fGPS->SetCurrentSourceIntensity(setintensityCmd->GetNewDoubleValue(newValues));
1170     }                                            1367     }
1171   else if( command==deletesourceCmd )            1368   else if( command==deletesourceCmd )
1172     {                                            1369     { 
1173       fGPS->DeleteaSource(deletesourceCmd->Ge    1370       fGPS->DeleteaSource(deletesourceCmd->GetNewIntValue(newValues));
1174     }                                            1371     }
1175   else if(command == multiplevertexCmd)          1372   else if(command == multiplevertexCmd)
1176     {                                            1373     {
1177       fGPS->SetMultipleVertex(multiplevertexC    1374       fGPS->SetMultipleVertex(multiplevertexCmd->GetNewBoolValue(newValues));
1178     }                                            1375     }
1179   else if(command == flatsamplingCmd)            1376   else if(command == flatsamplingCmd)
1180     {                                            1377     {
1181       fGPS->SetFlatSampling(flatsamplingCmd->    1378       fGPS->SetFlatSampling(flatsamplingCmd->GetNewBoolValue(newValues));
1182     }                                            1379     }
1183   //                                             1380   //
1184   // new implementations                         1381   // new implementations
1185   //                                             1382   //
                                                   >> 1383   //
1186   else if(command == typeCmd1)                   1384   else if(command == typeCmd1)
1187     {                                            1385     {
1188       CHECKPG();                              << 
1189       fParticleGun->GetPosDist()->SetPosDisTy    1386       fParticleGun->GetPosDist()->SetPosDisType(newValues);
1190     }                                            1387     }
1191   else if(command == shapeCmd1)                  1388   else if(command == shapeCmd1)
1192     {                                            1389     {
1193       CHECKPG();                              << 
1194       fParticleGun->GetPosDist()->SetPosDisSh    1390       fParticleGun->GetPosDist()->SetPosDisShape(newValues);
1195     }                                            1391     }
1196   else if(command == centreCmd1)                 1392   else if(command == centreCmd1)
1197     {                                            1393     {
1198       CHECKPG();                              << 
1199       fParticleGun->GetPosDist()->SetCentreCo    1394       fParticleGun->GetPosDist()->SetCentreCoords(centreCmd1->GetNew3VectorValue(newValues));
1200     }                                            1395     }
1201   else if(command == posrot1Cmd1)                1396   else if(command == posrot1Cmd1)
1202     {                                            1397     {
1203       CHECKPG();                              << 
1204       fParticleGun->GetPosDist()->SetPosRot1(    1398       fParticleGun->GetPosDist()->SetPosRot1(posrot1Cmd1->GetNew3VectorValue(newValues));
1205     }                                            1399     }
1206   else if(command == posrot2Cmd1)                1400   else if(command == posrot2Cmd1)
1207     {                                            1401     {
1208       CHECKPG();                              << 
1209       fParticleGun->GetPosDist()->SetPosRot2(    1402       fParticleGun->GetPosDist()->SetPosRot2(posrot2Cmd1->GetNew3VectorValue(newValues));
1210     }                                            1403     }
1211   else if(command == halfxCmd1)                  1404   else if(command == halfxCmd1)
1212     {                                            1405     {
1213       CHECKPG();                              << 
1214       fParticleGun->GetPosDist()->SetHalfX(ha    1406       fParticleGun->GetPosDist()->SetHalfX(halfxCmd1->GetNewDoubleValue(newValues));
1215     }                                            1407     }
1216   else if(command == halfyCmd1)                  1408   else if(command == halfyCmd1)
1217     {                                            1409     {
1218       CHECKPG();                              << 
1219       fParticleGun->GetPosDist()->SetHalfY(ha    1410       fParticleGun->GetPosDist()->SetHalfY(halfyCmd1->GetNewDoubleValue(newValues));
1220     }                                            1411     }
1221   else if(command == halfzCmd1)                  1412   else if(command == halfzCmd1)
1222     {                                            1413     {
1223       CHECKPG();                              << 
1224       fParticleGun->GetPosDist()->SetHalfZ(ha    1414       fParticleGun->GetPosDist()->SetHalfZ(halfzCmd1->GetNewDoubleValue(newValues));
1225     }                                            1415     }
1226   else if(command == radiusCmd1)                 1416   else if(command == radiusCmd1)
1227     {                                            1417     {
1228       CHECKPG();                              << 
1229       fParticleGun->GetPosDist()->SetRadius(r    1418       fParticleGun->GetPosDist()->SetRadius(radiusCmd1->GetNewDoubleValue(newValues));
1230     }                                            1419     }
1231   else if(command == radius0Cmd1)                1420   else if(command == radius0Cmd1)
1232     {                                            1421     {
1233       CHECKPG();                              << 
1234       fParticleGun->GetPosDist()->SetRadius0(    1422       fParticleGun->GetPosDist()->SetRadius0(radius0Cmd1->GetNewDoubleValue(newValues));
1235     }                                            1423     }
1236   else if(command == possigmarCmd1)              1424   else if(command == possigmarCmd1)
1237     {                                            1425     {
1238       CHECKPG();                              << 
1239       fParticleGun->GetPosDist()->SetBeamSigm    1426       fParticleGun->GetPosDist()->SetBeamSigmaInR(possigmarCmd1->GetNewDoubleValue(newValues));
1240     }                                            1427     }
1241   else if(command == possigmaxCmd1)              1428   else if(command == possigmaxCmd1)
1242     {                                            1429     {
1243       CHECKPG();                              << 
1244       fParticleGun->GetPosDist()->SetBeamSigm    1430       fParticleGun->GetPosDist()->SetBeamSigmaInX(possigmaxCmd1->GetNewDoubleValue(newValues));
1245     }                                            1431     }
1246   else if(command == possigmayCmd1)              1432   else if(command == possigmayCmd1)
1247     {                                            1433     {
1248       CHECKPG();                              << 
1249       fParticleGun->GetPosDist()->SetBeamSigm    1434       fParticleGun->GetPosDist()->SetBeamSigmaInY(possigmayCmd1->GetNewDoubleValue(newValues));
1250     }                                            1435     }
1251   else if(command == paralpCmd1)                 1436   else if(command == paralpCmd1)
1252     {                                            1437     {
1253       CHECKPG();                              << 
1254       fParticleGun->GetPosDist()->SetParAlpha    1438       fParticleGun->GetPosDist()->SetParAlpha(paralpCmd1->GetNewDoubleValue(newValues));
1255     }                                            1439     }
1256   else if(command == partheCmd1)                 1440   else if(command == partheCmd1)
1257     {                                            1441     {
1258       CHECKPG();                              << 
1259       fParticleGun->GetPosDist()->SetParTheta    1442       fParticleGun->GetPosDist()->SetParTheta(partheCmd1->GetNewDoubleValue(newValues));
1260     }                                            1443     }
1261   else if(command == parphiCmd1)                 1444   else if(command == parphiCmd1)
1262     {                                            1445     {
1263       CHECKPG();                              << 
1264       fParticleGun->GetPosDist()->SetParPhi(p    1446       fParticleGun->GetPosDist()->SetParPhi(parphiCmd1->GetNewDoubleValue(newValues));
1265     }                                            1447     }
1266   else if(command == confineCmd1)                1448   else if(command == confineCmd1)
1267     {                                            1449     {
1268       CHECKPG();                              << 
1269       fParticleGun->GetPosDist()->ConfineSour    1450       fParticleGun->GetPosDist()->ConfineSourceToVolume(newValues);
1270     }                                            1451     }
1271   else if(command == angtypeCmd1)                1452   else if(command == angtypeCmd1)
1272     {                                            1453     {
1273       CHECKPG();                              << 
1274       fParticleGun->GetAngDist()->SetAngDistT    1454       fParticleGun->GetAngDist()->SetAngDistType(newValues);
1275     }                                            1455     }
1276   else if(command == angrot1Cmd1)                1456   else if(command == angrot1Cmd1)
1277     {                                            1457     {
1278       CHECKPG();                              << 
1279       G4String a = "angref1";                    1458       G4String a = "angref1";
1280       fParticleGun->GetAngDist()->DefineAngRe    1459       fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot1Cmd1->GetNew3VectorValue(newValues));
1281     }                                            1460     }
1282   else if(command == angrot2Cmd1)                1461   else if(command == angrot2Cmd1)
1283     {                                            1462     {
1284       CHECKPG();                              << 
1285       G4String a = "angref2";                    1463       G4String a = "angref2";
1286       fParticleGun->GetAngDist()->DefineAngRe    1464       fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot2Cmd1->GetNew3VectorValue(newValues));
1287     }                                            1465     }
1288   else if(command == minthetaCmd1)               1466   else if(command == minthetaCmd1)
1289     {                                            1467     {
1290       CHECKPG();                              << 
1291       fParticleGun->GetAngDist()->SetMinTheta    1468       fParticleGun->GetAngDist()->SetMinTheta(minthetaCmd1->GetNewDoubleValue(newValues));
1292     }                                            1469     }
1293   else if(command == minphiCmd1)                 1470   else if(command == minphiCmd1)
1294     {                                            1471     {
1295       CHECKPG();                              << 
1296       fParticleGun->GetAngDist()->SetMinPhi(m    1472       fParticleGun->GetAngDist()->SetMinPhi(minphiCmd1->GetNewDoubleValue(newValues));
1297     }                                            1473     }
1298   else if(command == maxthetaCmd1)               1474   else if(command == maxthetaCmd1)
1299     {                                            1475     {
1300       CHECKPG();                              << 
1301       fParticleGun->GetAngDist()->SetMaxTheta    1476       fParticleGun->GetAngDist()->SetMaxTheta(maxthetaCmd1->GetNewDoubleValue(newValues));
1302     }                                            1477     }
1303   else if(command == maxphiCmd1)                 1478   else if(command == maxphiCmd1)
1304     {                                            1479     {
1305       CHECKPG();                              << 
1306       fParticleGun->GetAngDist()->SetMaxPhi(m    1480       fParticleGun->GetAngDist()->SetMaxPhi(maxphiCmd1->GetNewDoubleValue(newValues));
1307     }                                            1481     }
1308   else if(command == angsigmarCmd1)              1482   else if(command == angsigmarCmd1)
1309     {                                            1483     {
1310       CHECKPG();                              << 
1311       fParticleGun->GetAngDist()->SetBeamSigm    1484       fParticleGun->GetAngDist()->SetBeamSigmaInAngR(angsigmarCmd1->GetNewDoubleValue(newValues));
1312     }                                            1485     }
1313   else if(command == angsigmaxCmd1)              1486   else if(command == angsigmaxCmd1)
1314     {                                            1487     {
1315       CHECKPG();                              << 
1316       fParticleGun->GetAngDist()->SetBeamSigm    1488       fParticleGun->GetAngDist()->SetBeamSigmaInAngX(angsigmaxCmd1->GetNewDoubleValue(newValues));
1317     }                                            1489     }
1318   else if(command == angsigmayCmd1)              1490   else if(command == angsigmayCmd1)
1319     {                                            1491     {
1320       CHECKPG();                              << 
1321       fParticleGun->GetAngDist()->SetBeamSigm    1492       fParticleGun->GetAngDist()->SetBeamSigmaInAngY(angsigmayCmd1->GetNewDoubleValue(newValues));
1322     }                                            1493     }
1323   else if(command == angfocusCmd)                1494   else if(command == angfocusCmd)
1324     {                                            1495     {
1325       CHECKPG();                              << 
1326       fParticleGun->GetAngDist()->SetFocusPoi    1496       fParticleGun->GetAngDist()->SetFocusPoint(angfocusCmd->GetNew3VectorValue(newValues));
1327     }                                            1497     }
1328   else if(command == useuserangaxisCmd1)         1498   else if(command == useuserangaxisCmd1)
1329     {                                            1499     {
1330       CHECKPG();                              << 
1331       fParticleGun->GetAngDist()->SetUseUserA    1500       fParticleGun->GetAngDist()->SetUseUserAngAxis(useuserangaxisCmd1->GetNewBoolValue(newValues));
1332     }                                            1501     }
1333   else if(command == surfnormCmd1)               1502   else if(command == surfnormCmd1)
1334     {                                            1503     {
1335       CHECKPG();                              << 
1336       fParticleGun->GetAngDist()->SetUserWRTS    1504       fParticleGun->GetAngDist()->SetUserWRTSurface(surfnormCmd1->GetNewBoolValue(newValues));
1337     }                                            1505     }
1338   else if(command == energytypeCmd1)             1506   else if(command == energytypeCmd1)
1339     {                                            1507     {
1340       CHECKPG();                              << 1508       fParticleGun->GetEneDist()->SetEnergyDisType(newValues);
1341       if(newValues=="LW")                     << 
1342       {                                       << 
1343         fParticleGun->GetEneDist()->SetEnergy << 
1344         fParticleGun->GetEneDist()->SetGradie << 
1345         fParticleGun->GetEneDist()->SetInterC << 
1346         fParticleGun->GetEneDist()->ApplyEner << 
1347       }                                       << 
1348       else                                    << 
1349       {                                       << 
1350         fParticleGun->GetEneDist()->SetEnergy << 
1351         fParticleGun->GetEneDist()->ApplyEner << 
1352       }                                       << 
1353     }                                            1509     }
1354   else if(command == eminCmd1)                   1510   else if(command == eminCmd1)
1355     {                                            1511     {
1356       CHECKPG();                              << 
1357       fParticleGun->GetEneDist()->SetEmin(emi    1512       fParticleGun->GetEneDist()->SetEmin(eminCmd1->GetNewDoubleValue(newValues));
1358     }                                            1513     }
1359   else if(command == emaxCmd1)                   1514   else if(command == emaxCmd1)
1360     {                                            1515     {
1361       CHECKPG();                              << 
1362       fParticleGun->GetEneDist()->SetEmax(ema    1516       fParticleGun->GetEneDist()->SetEmax(emaxCmd1->GetNewDoubleValue(newValues));
1363     }                                            1517     }
1364   else if(command == monoenergyCmd1)             1518   else if(command == monoenergyCmd1)
1365     {                                            1519     {
1366       CHECKPG();                              << 
1367       fParticleGun->GetEneDist()->SetMonoEner    1520       fParticleGun->GetEneDist()->SetMonoEnergy(monoenergyCmd1->GetNewDoubleValue(newValues));
1368     }                                            1521     }
1369   else if(command == engsigmaCmd1)               1522   else if(command == engsigmaCmd1)
1370     {                                            1523     {
1371       CHECKPG();                              << 
1372       fParticleGun->GetEneDist()->SetBeamSigm    1524       fParticleGun->GetEneDist()->SetBeamSigmaInE(engsigmaCmd1->GetNewDoubleValue(newValues));
1373     }                                            1525     }
1374   else if(command == alphaCmd1)                  1526   else if(command == alphaCmd1)
1375     {                                            1527     {
1376       CHECKPG();                              << 
1377       fParticleGun->GetEneDist()->SetAlpha(al    1528       fParticleGun->GetEneDist()->SetAlpha(alphaCmd1->GetNewDoubleValue(newValues));
1378     }                                            1529     }
1379   else if(command == tempCmd1)                   1530   else if(command == tempCmd1)
1380     {                                            1531     {
1381       CHECKPG();                              << 
1382       fParticleGun->GetEneDist()->SetTemp(tem    1532       fParticleGun->GetEneDist()->SetTemp(tempCmd1->GetNewDoubleValue(newValues));
1383     }                                            1533     }
1384   else if(command == ezeroCmd1)                  1534   else if(command == ezeroCmd1)
1385     {                                            1535     {
1386       CHECKPG();                              << 
1387       fParticleGun->GetEneDist()->SetEzero(ez    1536       fParticleGun->GetEneDist()->SetEzero(ezeroCmd1->GetNewDoubleValue(newValues));
1388     }                                            1537     }
1389   else if(command == gradientCmd1)               1538   else if(command == gradientCmd1)
1390     {                                            1539     {
1391       CHECKPG();                              << 
1392       fParticleGun->GetEneDist()->SetGradient    1540       fParticleGun->GetEneDist()->SetGradient(gradientCmd1->GetNewDoubleValue(newValues));
1393     }                                            1541     }
1394   else if(command == interceptCmd1)              1542   else if(command == interceptCmd1)
1395     {                                            1543     {
1396       CHECKPG();                              << 
1397       fParticleGun->GetEneDist()->SetInterCep    1544       fParticleGun->GetEneDist()->SetInterCept(interceptCmd1->GetNewDoubleValue(newValues));
1398     }                                            1545     }
1399   else if(command == arbeintCmd1)                1546   else if(command == arbeintCmd1)
1400     {                                            1547     {
1401       CHECKPG();                              << 
1402       fParticleGun->GetEneDist()->SetBiasAlph    1548       fParticleGun->GetEneDist()->SetBiasAlpha(arbeintCmd1->GetNewDoubleValue(newValues));
1403     }                                            1549     }
1404   else if(command == calculateCmd1)              1550   else if(command == calculateCmd1)
1405     {                                            1551     {
1406       CHECKPG();                              << 
1407       fParticleGun->GetEneDist()->Calculate()    1552       fParticleGun->GetEneDist()->Calculate();
1408     }                                            1553     }
1409   else if(command == energyspecCmd1)             1554   else if(command == energyspecCmd1)
1410     {                                            1555     {
1411       CHECKPG();                              << 
1412       fParticleGun->GetEneDist()->InputEnergy    1556       fParticleGun->GetEneDist()->InputEnergySpectra(energyspecCmd1->GetNewBoolValue(newValues));
1413     }                                            1557     }
1414   else if(command == diffspecCmd1)               1558   else if(command == diffspecCmd1)
1415     {                                            1559     {
1416       CHECKPG();                              << 
1417       fParticleGun->GetEneDist()->InputDiffer    1560       fParticleGun->GetEneDist()->InputDifferentialSpectra(diffspecCmd1->GetNewBoolValue(newValues));
1418     }                                            1561     }
1419   else if(command == applyEnergyWeightCmd1)   << 
1420     {                                         << 
1421       CHECKPG();                              << 
1422       const auto& eDisType = fParticleGun->Ge << 
1423       if(eDisType != "Lin")                   << 
1424       {                                       << 
1425         G4ExceptionDescription ed;            << 
1426         ed << "Energy distribution is defined << 
1427         command->CommandFailed(ed);           << 
1428         return;                               << 
1429       }                                       << 
1430       fParticleGun->GetEneDist()->ApplyEnergy << 
1431     }                                         << 
1432   else if(command == histnameCmd1)               1562   else if(command == histnameCmd1)
1433     {                                            1563     {
1434       histtype = newValues;                      1564       histtype = newValues;
1435     }                                            1565     }
1436   else if(command == histfileCmd1)               1566   else if(command == histfileCmd1)
1437     {                                            1567     {
1438       histtype = "arb";                          1568       histtype = "arb";
1439       CHECKPG();                              << 
1440       fParticleGun->GetEneDist()->ArbEnergyHi    1569       fParticleGun->GetEneDist()->ArbEnergyHistoFile(newValues);
1441     }                                            1570     }
1442   else if(command == histpointCmd1)              1571   else if(command == histpointCmd1)
1443     {                                            1572     {
1444       CHECKPG();                              << 
1445       if(histtype == "biasx")                    1573       if(histtype == "biasx")
1446         fParticleGun->GetBiasRndm()->SetXBias << 1574   fParticleGun->GetBiasRndm()->SetXBias(histpointCmd1->GetNew3VectorValue(newValues));
1447       if(histtype == "biasy")                    1575       if(histtype == "biasy")
1448         fParticleGun->GetBiasRndm()->SetYBias << 1576   fParticleGun->GetBiasRndm()->SetYBias(histpointCmd1->GetNew3VectorValue(newValues));
1449       if(histtype == "biasz")                    1577       if(histtype == "biasz")
1450         fParticleGun->GetBiasRndm()->SetZBias << 1578   fParticleGun->GetBiasRndm()->SetZBias(histpointCmd1->GetNew3VectorValue(newValues));
1451       if(histtype == "biast")                    1579       if(histtype == "biast")
1452         fParticleGun->GetBiasRndm()->SetTheta << 1580   fParticleGun->GetBiasRndm()->SetThetaBias(histpointCmd1->GetNew3VectorValue(newValues));
1453       if(histtype == "biasp")                    1581       if(histtype == "biasp")
1454         fParticleGun->GetBiasRndm()->SetPhiBi << 1582   fParticleGun->GetBiasRndm()->SetPhiBias(histpointCmd1->GetNew3VectorValue(newValues));
1455       if(histtype == "biaspt")                   1583       if(histtype == "biaspt")
1456         fParticleGun->GetBiasRndm()->SetPosTh << 1584   fParticleGun->GetBiasRndm()->SetPosThetaBias(histpointCmd1->GetNew3VectorValue(newValues));
1457       if(histtype == "biaspp")                   1585       if(histtype == "biaspp")
1458         fParticleGun->GetBiasRndm()->SetPosPh << 1586   fParticleGun->GetBiasRndm()->SetPosPhiBias(histpointCmd1->GetNew3VectorValue(newValues));
1459       if(histtype == "biase")                    1587       if(histtype == "biase")
1460         fParticleGun->GetBiasRndm()->SetEnerg << 1588   fParticleGun->GetBiasRndm()->SetEnergyBias(histpointCmd1->GetNew3VectorValue(newValues));
1461       if(histtype == "theta")                    1589       if(histtype == "theta")
1462         fParticleGun->GetAngDist()->UserDefAn << 1590   fParticleGun->GetAngDist()->UserDefAngTheta(histpointCmd1->GetNew3VectorValue(newValues));
1463       if(histtype == "phi")                      1591       if(histtype == "phi")
1464         fParticleGun->GetAngDist()->UserDefAn << 1592   fParticleGun->GetAngDist()->UserDefAngPhi(histpointCmd1->GetNew3VectorValue(newValues));
1465       if(histtype == "energy")                   1593       if(histtype == "energy")
1466         fParticleGun->GetEneDist()->UserEnerg << 1594   fParticleGun->GetEneDist()->UserEnergyHisto(histpointCmd1->GetNew3VectorValue(newValues));
1467       if(histtype == "arb")                      1595       if(histtype == "arb")
1468         fParticleGun->GetEneDist()->ArbEnergy << 1596   fParticleGun->GetEneDist()->ArbEnergyHisto(histpointCmd1->GetNew3VectorValue(newValues));
1469       if(histtype == "epn")                      1597       if(histtype == "epn")
1470         fParticleGun->GetEneDist()->EpnEnergy << 1598   fParticleGun->GetEneDist()->EpnEnergyHisto(histpointCmd1->GetNew3VectorValue(newValues));
1471     }                                            1599     }
1472   else if(command == resethistCmd1)              1600   else if(command == resethistCmd1)
1473     {                                            1601     {
1474       CHECKPG();                              << 1602       if(newValues == "theta" || newValues == "phi") {
1475       if(newValues == "theta" || newValues == << 1603   fParticleGun->GetAngDist()->ReSetHist(newValues);
1476       {                                       << 1604       } else if (newValues == "energy" || newValues == "arb" || newValues == "epn") {
1477         fParticleGun->GetAngDist()->ReSetHist << 1605   fParticleGun->GetEneDist()->ReSetHist(newValues);
1478       }                                       << 1606       } else {
1479       else if (newValues == "energy" || newVa << 1607   fParticleGun->GetBiasRndm()->ReSetHist(newValues);
1480       {                                       << 
1481         fParticleGun->GetEneDist()->ReSetHist << 
1482       }                                       << 
1483       else                                    << 
1484       {                                       << 
1485         fParticleGun->GetBiasRndm()->ReSetHis << 
1486       }                                          1608       }
1487     }                                            1609     }
1488   else if(command == arbintCmd1)                 1610   else if(command == arbintCmd1)
1489     {                                            1611     {
1490       CHECKPG(); fParticleGun->GetEneDist()-> << 1612       fParticleGun->GetEneDist()->ArbInterpolate(newValues);
1491     }                                            1613     }
1492   else                                           1614   else 
1493     {                                            1615     {
1494       G4cout << "Error entering command" << G    1616       G4cout << "Error entering command" << G4endl;
1495     }                                            1617     }
1496 }                                                1618 }
1497                                                  1619 
1498 G4String G4GeneralParticleSourceMessenger::Ge << 1620 G4String G4GeneralParticleSourceMessenger::GetCurrentValue(G4UIcommand *)
1499 {                                                1621 {
1500   G4String cv;                                   1622   G4String cv;
1501                                                  1623   
1502   if( command==volChkCmd )                    << 
1503   { cv = volChkCmd->ConvertToString(fParticle << 
1504   else                                        << 
1505   {                                           << 
1506   //  if( command==directionCmd )                1624   //  if( command==directionCmd )
1507   //  { cv = directionCmd->ConvertToString(fP    1625   //  { cv = directionCmd->ConvertToString(fParticleGun->GetParticleMomentumDirection()); }
1508   //  else if( command==energyCmd )              1626   //  else if( command==energyCmd )
1509   //  { cv = energyCmd->ConvertToString(fPart    1627   //  { cv = energyCmd->ConvertToString(fParticleGun->GetParticleEnergy(),"GeV"); }
1510   //  else if( command==positionCmd )            1628   //  else if( command==positionCmd )
1511   //  { cv = positionCmd->ConvertToString(fPa    1629   //  { cv = positionCmd->ConvertToString(fParticleGun->GetParticlePosition(),"cm"); }
1512   //  else if( command==timeCmd )                1630   //  else if( command==timeCmd )
1513   //  { cv = timeCmd->ConvertToString(fPartic    1631   //  { cv = timeCmd->ConvertToString(fParticleGun->GetParticleTime(),"ns"); }
1514   //  else if( command==polCmd )                 1632   //  else if( command==polCmd )
1515   //  { cv = polCmd->ConvertToString(fParticl    1633   //  { cv = polCmd->ConvertToString(fParticleGun->GetParticlePolarization()); }
1516   //  else if( command==numberCmd )              1634   //  else if( command==numberCmd )
1517   //  { cv = numberCmd->ConvertToString(fPart    1635   //  { cv = numberCmd->ConvertToString(fParticleGun->GetNumberOfParticles()); }
1518                                                  1636   
1519   cv = "Not implemented yet";                    1637   cv = "Not implemented yet";
1520   }                                           << 
1521                                                  1638 
1522   return cv;                                     1639   return cv;
1523 }                                                1640 }
1524                                                  1641 
1525 void G4GeneralParticleSourceMessenger::IonCom << 1642 void G4GeneralParticleSourceMessenger::IonCommand(G4String newValues)
1526 {                                                1643 {
                                                   >> 1644   fShootIon = true;
                                                   >> 1645 
1527   if (fShootIon)                                 1646   if (fShootIon)
1528   {                                              1647   {
1529     G4Tokenizer next( newValues );               1648     G4Tokenizer next( newValues );
1530     // check argument                            1649     // check argument
1531     fAtomicNumber = StoI(next());                1650     fAtomicNumber = StoI(next());
1532     fAtomicMass = StoI(next());                  1651     fAtomicMass = StoI(next());
1533     G4String sQ = next();                        1652     G4String sQ = next();
1534     if (sQ.empty())                           << 1653     if (sQ.isNull())
1535     {                                            1654     {
1536       fIonCharge = fAtomicNumber;             << 1655   fIonCharge = fAtomicNumber;
1537     }                                            1656     }
1538     else                                         1657     else
1539     {                                            1658     {
1540       fIonCharge = StoI(sQ);                  << 1659   fIonCharge = StoI(sQ);
1541       sQ = next();                            << 1660   sQ = next();
1542       if (sQ.empty())                         << 1661   if (sQ.isNull())
1543       {                                          1662       {
1544         fIonExciteEnergy = 0.0;               << 1663     fIonExciteEnergy = 0.0;
1545       }                                          1664       }
1546       else                                       1665       else
1547       {                                          1666       {
1548         fIonExciteEnergy = StoD(sQ) * keV;    << 1667     fIonExciteEnergy = StoD(sQ) * keV;
1549       }                                          1668       }
1550     }                                            1669     }
1551     G4ParticleDefinition* ion = G4IonTable::G << 1670     G4ParticleDefinition* ion;
1552         ->GetIon(fAtomicNumber, fAtomicMass,  << 1671     ion =  particleTable->GetIon( fAtomicNumber, fAtomicMass, fIonExciteEnergy);
1553     if (ion==nullptr)                         << 1672     if (ion==0)
1554     {                                         << 1673     {
1555       G4ExceptionDescription ed;              << 1674       G4cout << "Ion with Z=" << fAtomicNumber;
1556       ed << "Ion with Z=" << fAtomicNumber;   << 1675       G4cout << " A=" << fAtomicMass << "is not be defined" << G4endl;    
1557       ed << " A=" << fAtomicMass << " is not  << 
1558       ionCmd->CommandFailed(ed);              << 
1559     }                                            1676     }
1560     else                                         1677     else
1561     {                                            1678     {
1562       fParticleGun->SetParticleDefinition(ion    1679       fParticleGun->SetParticleDefinition(ion);
1563       fParticleGun->SetParticleCharge(fIonCha    1680       fParticleGun->SetParticleCharge(fIonCharge*eplus);
1564     }                                            1681     }
1565   }                                              1682   }
1566   else                                           1683   else
1567   {                                              1684   {
1568     G4ExceptionDescription ed;                << 1685     G4cout << "Set /gps/particle to ion before using /gps/ion command";
1569     ed << "Set /gps/particle to ion before us << 1686     G4cout << G4endl; 
1570     ionCmd->CommandFailed(ed);                << 
1571   }                                              1687   }
1572 }                                                1688 }
1573                                                  1689 
1574 void G4GeneralParticleSourceMessenger::IonLvl << 1690 void G4GeneralParticleSourceMessenger::IonLvlCommand(G4String newValues)
1575 {                                                1691 {
1576   if (fShootIon)                              << 1692   fShootIonL = true;
1577   {                                           << 1693 
                                                   >> 1694   if (fShootIonL) {
1578     G4Tokenizer next(newValues);                 1695     G4Tokenizer next(newValues);
1579     // check argument                            1696     // check argument
1580     fAtomicNumberL = StoI(next());               1697     fAtomicNumberL = StoI(next());
1581     fAtomicMassL = StoI(next());                 1698     fAtomicMassL = StoI(next());
1582     G4String sQ = next();                        1699     G4String sQ = next();
1583     if (sQ.empty())                           << 1700     if (sQ.isNull()) {
1584     {                                         << 
1585       fIonChargeL = fAtomicNumberL;              1701       fIonChargeL = fAtomicNumberL;
1586     }                                         << 1702     } else {
1587     else                                      << 
1588     {                                         << 
1589       fIonChargeL = StoI(sQ);                    1703       fIonChargeL = StoI(sQ);
1590       sQ = next();                               1704       sQ = next();
1591       if (sQ.empty())                         << 1705       if (sQ.isNull()) {
1592       {                                       << 
1593         fIonEnergyLevel = 0;                     1706         fIonEnergyLevel = 0;
1594       }                                       << 1707       } else {
1595       else                                    << 
1596       {                                       << 
1597         fIonEnergyLevel = StoI(sQ);              1708         fIonEnergyLevel = StoI(sQ);
1598       }                                          1709       }
1599     }                                            1710     }
1600                                                  1711 
1601     G4ParticleDefinition* ion = G4IonTable::G << 1712     G4ParticleDefinition* ion;
1602         ->GetIon(fAtomicNumberL, fAtomicMassL << 1713     ion = particleTable->GetIon(fAtomicNumberL, fAtomicMassL, fIonEnergyLevel);
1603     if (ion == nullptr)                       << 1714     if (ion == 0) {
1604     {                                         << 1715       G4cout << "Ion with Z=" << fAtomicNumberL;
1605       G4ExceptionDescription ed;              << 1716       G4cout << " A=" << fAtomicMass << "is not be defined" << G4endl;
1606       ed << "Ion with Z=" << fAtomicNumberL;  << 1717     } else {
1607       ed << " A=" << fAtomicMassL << " is not << 
1608       ionLvlCmd->CommandFailed(ed);           << 
1609     }                                         << 
1610     else                                      << 
1611     {                                         << 
1612       fParticleGun->SetParticleDefinition(ion    1718       fParticleGun->SetParticleDefinition(ion);
1613       fParticleGun->SetParticleCharge(fIonCha    1719       fParticleGun->SetParticleCharge(fIonChargeL*eplus);
1614     }                                            1720     }
1615                                                  1721 
1616   }                                           << 1722   } else {
1617   else                                        << 1723     G4cout << "Set /gps/particle to ion before using /gps/ionLvl command";
1618   {                                           << 1724     G4cout << G4endl;
1619     G4ExceptionDescription ed;                << 
1620     ed << "Set /gps/particle to ion before us << 
1621     ionLvlCmd->CommandFailed(ed);             << 
1622   }                                              1725   }
1623 }                                                1726 }
                                                   >> 1727 
1624                                                  1728