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