lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2cce0e189df02c66f78a459a9a5a5d477f738c02
geant4/source/event/src/G4GeneralParticleSourceMessenger.cc
T
Gabriele Cosmo 4ec577e5c4 Import Geant4 10.3.0.beta source tree
2016-06-30 14:12:05 +02:00

1831 lines
78 KiB
C++
Raw Blame History

//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
///////////////////////////////////////////////////////////////////////////////
//
// MODULE: G4GeneralParticleSourceMessenger.cc
//
// Version: 2.0
// Date: 5/02/04
// Author: Fan Lei
// Organisation: QinetiQ ltd.
// Customer: ESA/ESTEC
//
///////////////////////////////////////////////////////////////////////////////
//
// CHANGE HISTORY
// --------------
//
// Version 2.0, 05/02/2004, Fan Lei, Created.
// After changes to version 1.1 as in Geant4 v6.0
// - Mutilple particle source definition
// - Re-structured commands
// - old commands have been retained for backward compatibility, will be
// removed in the future.
//
//
// 20/03/2014, Andrew Green - Modifications for MT
// - Added a check to force only one thread to parse the macro file
// This information is fed into the GPS which now has a split mechanism for the large data (hence need to only read in 1 thread)
// - Thread ID used is 0, so *should* work under interactive mode as well - may need checking, or the may be another way...
///////////////////////////////////////////////////////////////////////////////
//
#include "G4GeneralParticleSourceMessenger.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4Geantino.hh"
#include "G4ThreeVector.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithoutParameter.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWith3Vector.hh"
#include "G4UIcmdWith3VectorAndUnit.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithABool.hh"
#include "G4ios.hh"
#include "G4Tokenizer.hh"
#include "G4SingleParticleSource.hh"
#include "G4GeneralParticleSource.hh"
#include "G4AutoLock.hh"
namespace {
G4Mutex creationM = G4MUTEX_INITIALIZER;
G4GeneralParticleSourceMessenger* theInstance = 0;
}
G4GeneralParticleSourceMessenger* G4GeneralParticleSourceMessenger::GetInstance(G4GeneralParticleSource* psc)
{
G4AutoLock l(&creationM);
if ( theInstance == 0 ) theInstance = new G4GeneralParticleSourceMessenger(psc);
return theInstance;
}
void G4GeneralParticleSourceMessenger::Destroy() {
G4AutoLock l(&creationM);
if ( theInstance != 0 ) {
delete theInstance;
theInstance = 0;
}
}
///////////////////////////////////////////////////////////////////////////////
//
G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger
(G4GeneralParticleSource *fPtclGun)
: fGPS(fPtclGun),fParticleGun(0),fShootIon(false),
fAtomicNumber(0),fAtomicMass(0),fIonCharge(0),fIonExciteEnergy(0.),
fShootIonL(0),fAtomicNumberL(0),fAtomicMassL(0),fIonChargeL(0),fIonEnergyLevel(0)
{
//A.Dotti - 10th October 2014
//This messenger is special: it is instantiated in a user action but (e.g. in
// a thread).
//the UI commands it defines should be executed by the *master* thread because
//they operate on shared resources and we want the UI commands to take
//effect BEFORE the threads do some work (so all data are properly initialized)
//To achieve this behavior we set to true a base calss protected
//data member. Since it makes no sense to have more than one instance
//of the messenger we check that we actually have only one.
//Note that the logic of implementing, in a given worker thread only one
//messenger is deletefated to the creator
commandsShouldBeInMaster = true;
particleTable = G4ParticleTable::GetParticleTable();
histtype = "biasx";
//UI Commands only for master
G4bool broadcast = false;
gpsDirectory = new G4UIdirectory("/gps/",broadcast);
gpsDirectory->SetGuidance("General Paricle Source control commands.");
// gpsDirectory->SetGuidance(" The first 9 commands are the same as in G4ParticleGun ");
// now the commands for mutiple sources
sourceDirectory = new G4UIdirectory("/gps/source/");
sourceDirectory->SetGuidance("Multiple source control sub-directory");
addsourceCmd = new G4UIcmdWithADouble("/gps/source/add",this);
addsourceCmd->SetGuidance("add a new source defintion to the particle gun with the specified intensity");
addsourceCmd->SetParameterName("addsource",false,false);
addsourceCmd->SetRange("addsource > 0.");
listsourceCmd = new G4UIcmdWithoutParameter("/gps/source/list",this);
listsourceCmd->SetGuidance("List the defined particle sources");
clearsourceCmd = new G4UIcmdWithoutParameter("/gps/source/clear",this);
clearsourceCmd->SetGuidance("Remove all the defined particle sources");
getsourceCmd = new G4UIcmdWithoutParameter("/gps/source/show",this);
getsourceCmd->SetGuidance("Show the current source index and intensity");
setsourceCmd = new G4UIcmdWithAnInteger("/gps/source/set",this);
setsourceCmd->SetGuidance("set the indexed source as the current one");
setsourceCmd->SetGuidance(" so one can change its source definition");
setsourceCmd->SetParameterName("setsource",false,false);
setsourceCmd->SetRange("setsource >= 0");
deletesourceCmd = new G4UIcmdWithAnInteger("/gps/source/delete",this);
deletesourceCmd->SetGuidance("delete the indexed source from the list");
deletesourceCmd->SetParameterName("deletesource",false,false);
deletesourceCmd->SetRange("deletesource > 0");
setintensityCmd = new G4UIcmdWithADouble("/gps/source/intensity",this);
setintensityCmd->SetGuidance("reset the current source to the specified intensity");
setintensityCmd->SetParameterName("setintensity",false,false);
setintensityCmd->SetRange("setintensity > 0.");
multiplevertexCmd = new G4UIcmdWithABool("/gps/source/multiplevertex",this);
multiplevertexCmd->SetGuidance("true for simulaneous generation mutiple vertex");
multiplevertexCmd->SetGuidance("Default is false");
multiplevertexCmd->SetParameterName("multiplevertex",true);
multiplevertexCmd->SetDefaultValue(false);
flatsamplingCmd = new G4UIcmdWithABool("/gps/source/flatsampling",this);
flatsamplingCmd->SetGuidance("true for applying flat (biased) sampling among the sources");
flatsamplingCmd->SetGuidance("Default is false");
flatsamplingCmd->SetParameterName("flatsampling",true);
flatsamplingCmd->SetDefaultValue(false);
// below we reproduce commands awailable in G4Particle Gun
listCmd = new G4UIcmdWithoutParameter("/gps/List",this);
listCmd->SetGuidance("List available particles.");
listCmd->SetGuidance(" Invoke G4ParticleTable.");
particleCmd = new G4UIcmdWithAString("/gps/particle",this);
particleCmd->SetGuidance("Set particle to be generated.");
particleCmd->SetGuidance(" (geantino is default)");
particleCmd->SetGuidance(" (ion can be specified for shooting ions)");
particleCmd->SetParameterName("particleName",true);
particleCmd->SetDefaultValue("geantino");
G4String candidateList;
G4int nPtcl = particleTable->entries();
for(G4int i=0;i<nPtcl;i++)
{
candidateList += particleTable->GetParticleName(i);
candidateList += " ";
}
candidateList += "ion ";
particleCmd->SetCandidates(candidateList);
directionCmd = new G4UIcmdWith3Vector("/gps/direction",this);
directionCmd->SetGuidance("Set momentum direction.");
directionCmd->SetGuidance("Direction needs not to be a unit vector.");
directionCmd->SetGuidance("Angular distribution type is set to planar.");
directionCmd->SetParameterName("Px","Py","Pz",false,false);
directionCmd->SetRange("Px != 0 || Py != 0 || Pz != 0");
energyCmd = new G4UIcmdWithADoubleAndUnit("/gps/energy",this);
energyCmd->SetGuidance("Set kinetic energy.");
energyCmd->SetParameterName("Energy",false,false);
energyCmd->SetDefaultUnit("GeV");
//energyCmd->SetUnitCategory("Energy");
//energyCmd->SetUnitCandidates("eV keV MeV GeV TeV");
positionCmd = new G4UIcmdWith3VectorAndUnit("/gps/position",this);
positionCmd->SetGuidance("Set starting position of the particle for a Point like source.");
positionCmd->SetGuidance("Same effect as the two /gps/pos/type Point /gps/pos/centre commands.");
positionCmd->SetParameterName("X","Y","Z",false,false);
positionCmd->SetDefaultUnit("cm");
//positionCmd->SetUnitCategory("Length");
//positionCmd->SetUnitCandidates("microm mm cm m km");
ionCmd = new G4UIcommand("/gps/ion",this);
ionCmd->SetGuidance("Set properties of ion to be generated.");
ionCmd->SetGuidance("[usage] /gps/ion Z A Q E");
ionCmd->SetGuidance(" Z:(int) AtomicNumber");
ionCmd->SetGuidance(" A:(int) AtomicMass");
ionCmd->SetGuidance(" Q:(int) Charge of Ion (in unit of e)");
ionCmd->SetGuidance(" E:(double) Excitation energy (in keV)");
G4UIparameter* param;
param = new G4UIparameter("Z",'i',false);
param->SetDefaultValue("1");
ionCmd->SetParameter(param);
param = new G4UIparameter("A",'i',false);
param->SetDefaultValue("1");
ionCmd->SetParameter(param);
param = new G4UIparameter("Q",'i',true);
param->SetDefaultValue("0");
ionCmd->SetParameter(param);
param = new G4UIparameter("E",'d',true);
param->SetDefaultValue("0.0");
ionCmd->SetParameter(param);
ionLvlCmd = new G4UIcommand("/gps/ionLvl",this);
ionLvlCmd->SetGuidance("Set properties of ion to be generated.");
ionLvlCmd->SetGuidance("[usage] /gps/ion Z A Q Lvl");
ionLvlCmd->SetGuidance(" Z:(int) AtomicNumber");
ionLvlCmd->SetGuidance(" A:(int) AtomicMass");
ionLvlCmd->SetGuidance(" Q:(int) Charge of Ion (in unit of e)");
ionLvlCmd->SetGuidance(" Lvl:(int) Number of metastable state excitation level (0-9)");
G4UIparameter* paramL;
paramL = new G4UIparameter("Z",'i',false);
paramL->SetDefaultValue("1");
ionLvlCmd->SetParameter(paramL);
paramL = new G4UIparameter("A",'i',false);
paramL->SetDefaultValue("1");
ionLvlCmd->SetParameter(paramL);
paramL = new G4UIparameter("Q",'i',true);
paramL->SetDefaultValue("0");
ionLvlCmd->SetParameter(paramL);
paramL = new G4UIparameter("Lvl",'i',true);
paramL->SetDefaultValue("0.0");
ionLvlCmd->SetParameter(paramL);
timeCmd = new G4UIcmdWithADoubleAndUnit("/gps/time",this);
timeCmd->SetGuidance("Set initial time of the particle.");
timeCmd->SetParameterName("t0",false,false);
timeCmd->SetDefaultUnit("ns");
//timeCmd->SetUnitCategory("Time");
//timeCmd->SetUnitCandidates("ns ms s");
polCmd = new G4UIcmdWith3Vector("/gps/polarization",this);
polCmd->SetGuidance("Set polarization.");
polCmd->SetParameterName("Px","Py","Pz",false,false);
polCmd->SetRange("Px>=-1.&&Px<=1.&&Py>=-1.&&Py<=1.&&Pz>=-1.&&Pz<=1.");
numberCmd = new G4UIcmdWithAnInteger("/gps/number",this);
numberCmd->SetGuidance("Set number of particles to be generated per vertex.");
numberCmd->SetParameterName("N",false,false);
numberCmd->SetRange("N>0");
// verbosity
verbosityCmd = new G4UIcmdWithAnInteger("/gps/verbose",this);
verbosityCmd->SetGuidance("Set Verbose level for GPS");
verbosityCmd->SetGuidance(" 0 : Silent");
verbosityCmd->SetGuidance(" 1 : Limited information");
verbosityCmd->SetGuidance(" 2 : Detailed information");
verbosityCmd->SetParameterName("level",false);
verbosityCmd->SetRange("level>=0 && level <=2");
// now extended commands
// Positional ones:
positionDirectory = new G4UIdirectory("/gps/pos/");
positionDirectory->SetGuidance("Positional commands sub-directory");
typeCmd1 = new G4UIcmdWithAString("/gps/pos/type",this);
typeCmd1->SetGuidance("Sets source distribution type.");
typeCmd1->SetGuidance("Either Point, Beam, Plane, Surface or Volume");
typeCmd1->SetParameterName("DisType",false,false);
typeCmd1->SetDefaultValue("Point");
typeCmd1->SetCandidates("Point Beam Plane Surface Volume");
shapeCmd1 = new G4UIcmdWithAString("/gps/pos/shape",this);
shapeCmd1->SetGuidance("Sets source shape for Plan, Surface or Volume type source.");
shapeCmd1->SetParameterName("Shape",false,false);
shapeCmd1->SetDefaultValue("NULL");
shapeCmd1->SetCandidates("Circle Annulus Ellipse Square Rectangle Sphere Ellipsoid Cylinder Para");
centreCmd1 = new G4UIcmdWith3VectorAndUnit("/gps/pos/centre",this);
centreCmd1->SetGuidance("Set centre coordinates of source.");
//centreCmd1->SetGuidance(" same effect as the /gps/position command");
centreCmd1->SetParameterName("X","Y","Z",false,false);
centreCmd1->SetDefaultUnit("cm");
// centreCmd1->SetUnitCandidates("micron mm cm m km");
posrot1Cmd1 = new G4UIcmdWith3Vector("/gps/pos/rot1",this);
posrot1Cmd1->SetGuidance("Set the 1st vector defining the rotation matrix'.");
posrot1Cmd1->SetGuidance("It does not need to be a unit vector.");
posrot1Cmd1->SetParameterName("R1x","R1y","R1z",false,false);
posrot1Cmd1->SetRange("R1x != 0 || R1y != 0 || R1z != 0");
posrot2Cmd1 = new G4UIcmdWith3Vector("/gps/pos/rot2",this);
posrot2Cmd1->SetGuidance("Set the 2nd vector defining the rotation matrix'.");
posrot2Cmd1->SetGuidance("It does not need to be a unit vector.");
posrot2Cmd1->SetParameterName("R2x","R2y","R2z",false,false);
posrot2Cmd1->SetRange("R2x != 0 || R2y != 0 || R2z != 0");
halfxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/halfx",this);
halfxCmd1->SetGuidance("Set x half length of source.");
halfxCmd1->SetParameterName("Halfx",false,false);
halfxCmd1->SetDefaultUnit("cm");
// halfxCmd1->SetUnitCandidates("micron mm cm m km");
halfyCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/halfy",this);
halfyCmd1->SetGuidance("Set y half length of source.");
halfyCmd1->SetParameterName("Halfy",false,false);
halfyCmd1->SetDefaultUnit("cm");
// halfyCmd1->SetUnitCandidates("micron mm cm m km");
halfzCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/halfz",this);
halfzCmd1->SetGuidance("Set z half length of source.");
halfzCmd1->SetParameterName("Halfz",false,false);
halfzCmd1->SetDefaultUnit("cm");
// halfzCmd1->SetUnitCandidates("micron mm cm m km");
radiusCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/radius",this);
radiusCmd1->SetGuidance("Set radius of source.");
radiusCmd1->SetParameterName("Radius",false,false);
radiusCmd1->SetDefaultUnit("cm");
// radiusCmd1->SetUnitCandidates("micron mm cm m km");
radius0Cmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/inner_radius",this);
radius0Cmd1->SetGuidance("Set inner radius of source when required.");
radius0Cmd1->SetParameterName("Radius0",false,false);
radius0Cmd1->SetDefaultUnit("cm");
// radius0Cmd1->SetUnitCandidates("micron mm cm m km");
possigmarCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/sigma_r",this);
possigmarCmd1->SetGuidance("Set standard deviation in radial of the beam positional profile");
possigmarCmd1->SetGuidance(" applicable to Beam type source only");
possigmarCmd1->SetParameterName("Sigmar",false,false);
possigmarCmd1->SetDefaultUnit("cm");
// possigmarCmd1->SetUnitCandidates("micron mm cm m km");
possigmaxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/sigma_x",this);
possigmaxCmd1->SetGuidance("Set standard deviation of beam positional profile in x-dir");
possigmaxCmd1->SetGuidance(" applicable to Beam type source only");
possigmaxCmd1->SetParameterName("Sigmax",false,false);
possigmaxCmd1->SetDefaultUnit("cm");
// possigmaxCmd1->SetUnitCandidates("micron mm cm m km");
possigmayCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/sigma_y",this);
possigmayCmd1->SetGuidance("Set standard deviation of beam positional profile in y-dir");
possigmayCmd1->SetGuidance(" applicable to Beam type source only");
possigmayCmd1->SetParameterName("Sigmay",false,false);
possigmayCmd1->SetDefaultUnit("cm");
// possigmayCmd1->SetUnitCandidates("micron mm cm m km");
paralpCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/paralp",this);
paralpCmd1->SetGuidance("Angle from y-axis of y' in Para");
paralpCmd1->SetParameterName("paralp",false,false);
paralpCmd1->SetDefaultUnit("rad");
// paralpCmd1->SetUnitCandidates("rad deg");
partheCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/parthe",this);
partheCmd1->SetGuidance("Polar angle through centres of z faces");
partheCmd1->SetParameterName("parthe",false,false);
partheCmd1->SetDefaultUnit("rad");
// partheCmd1->SetUnitCandidates("rad deg");
parphiCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/pos/parphi",this);
parphiCmd1->SetGuidance("Azimuth angle through centres of z faces");
parphiCmd1->SetParameterName("parphi",false,false);
parphiCmd1->SetDefaultUnit("rad");
// parphiCmd1->SetUnitCandidates("rad deg");
confineCmd1 = new G4UIcmdWithAString("/gps/pos/confine",this);
confineCmd1->SetGuidance("Confine source to volume (NULL to unset).");
confineCmd1->SetGuidance("usage: confine VolName");
confineCmd1->SetParameterName("VolName",false,false);
confineCmd1->SetDefaultValue("NULL");
// old implementations
// typeCmd = new G4UIcmdWithAString("/gps/type",this);
// typeCmd->SetGuidance("Sets source distribution type. (obsolete!)");
// typeCmd->SetGuidance("Either Point, Beam, Plane, Surface or Volume");
// typeCmd->SetParameterName("DisType",false,false);
// typeCmd->SetDefaultValue("Point");
// typeCmd->SetCandidates("Point Beam Plane Surface Volume");
// shapeCmd = new G4UIcmdWithAString("/gps/shape",this);
// shapeCmd->SetGuidance("Sets source shape type.(obsolete!)");
// shapeCmd->SetParameterName("Shape",false,false);
// shapeCmd->SetDefaultValue("NULL");
// shapeCmd->SetCandidates("Circle Annulus Ellipse Square Rectangle Sphere Ellipsoid Cylinder Para");
// centreCmd = new G4UIcmdWith3VectorAndUnit("/gps/centre",this);
// centreCmd->SetGuidance("Set centre coordinates of source.(obsolete!)");
// centreCmd->SetParameterName("X","Y","Z",false,false);
// centreCmd->SetDefaultUnit("cm");
// centreCmd->SetUnitCandidates("micron mm cm m km");
// posrot1Cmd = new G4UIcmdWith3Vector("/gps/posrot1",this);
// posrot1Cmd->SetGuidance("Set rotation matrix of x'.(obsolete!)");
// posrot1Cmd->SetGuidance("Posrot1 does not need to be a unit vector.");
// posrot1Cmd->SetParameterName("R1x","R1y","R1z",false,false);
// posrot1Cmd->SetRange("R1x != 0 || R1y != 0 || R1z != 0");
//
// posrot2Cmd = new G4UIcmdWith3Vector("/gps/posrot2",this);
// posrot2Cmd->SetGuidance("Set rotation matrix of y'.(obsolete!)");
// posrot2Cmd->SetGuidance("Posrot2 does not need to be a unit vector.");
// posrot2Cmd->SetParameterName("R2x","R2y","R2z",false,false);
// posrot2Cmd->SetRange("R2x != 0 || R2y != 0 || R2z != 0");
// halfxCmd = new G4UIcmdWithADoubleAndUnit("/gps/halfx",this);
// halfxCmd->SetGuidance("Set x half length of source.(obsolete!)");
// halfxCmd->SetParameterName("Halfx",false,false);
// halfxCmd->SetDefaultUnit("cm");
// halfxCmd->SetUnitCandidates("micron mm cm m km");
// halfyCmd = new G4UIcmdWithADoubleAndUnit("/gps/halfy",this);
// halfyCmd->SetGuidance("Set y half length of source.(obsolete!)");
// halfyCmd->SetParameterName("Halfy",false,false);
// halfyCmd->SetDefaultUnit("cm");
// halfyCmd->SetUnitCandidates("micron mm cm m km");
// halfzCmd = new G4UIcmdWithADoubleAndUnit("/gps/halfz",this);
// halfzCmd->SetGuidance("Set z half length of source.(obsolete!)");
// halfzCmd->SetParameterName("Halfz",false,false);
// halfzCmd->SetDefaultUnit("cm");
// halfzCmd->SetUnitCandidates("micron mm cm m km");
// radiusCmd = new G4UIcmdWithADoubleAndUnit("/gps/radius",this);
// radiusCmd->SetGuidance("Set radius of source.(obsolete!)");
// radiusCmd->SetParameterName("Radius",false,false);
// radiusCmd->SetDefaultUnit("cm");
// radiusCmd->SetUnitCandidates("micron mm cm m km");
// radius0Cmd = new G4UIcmdWithADoubleAndUnit("/gps/radius0",this);
// radius0Cmd->SetGuidance("Set inner radius of source.(obsolete!)");
// radius0Cmd->SetParameterName("Radius0",false,false);
// radius0Cmd->SetDefaultUnit("cm");
// radius0Cmd->SetUnitCandidates("micron mm cm m km");
// possigmarCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaposr",this);
// possigmarCmd->SetGuidance("Set standard deviation of beam position in radial(obsolete!)");
// possigmarCmd->SetParameterName("Sigmar",false,false);
// possigmarCmd->SetDefaultUnit("cm");
// possigmarCmd->SetUnitCandidates("micron mm cm m km");
// possigmaxCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaposx",this);
// possigmaxCmd->SetGuidance("Set standard deviation of beam position in x-dir(obsolete!)");
// possigmaxCmd->SetParameterName("Sigmax",false,false);
// possigmaxCmd->SetDefaultUnit("cm");
// possigmaxCmd->SetUnitCandidates("micron mm cm m km");
// possigmayCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaposy",this);
// possigmayCmd->SetGuidance("Set standard deviation of beam position in y-dir(obsolete!)");
// possigmayCmd->SetParameterName("Sigmay",false,false);
// possigmayCmd->SetDefaultUnit("cm");
// possigmayCmd->SetUnitCandidates("micron mm cm m km");
// paralpCmd = new G4UIcmdWithADoubleAndUnit("/gps/paralp",this);
// paralpCmd->SetGuidance("Angle from y-axis of y' in Para(obsolete!)");
// paralpCmd->SetParameterName("paralp",false,false);
// paralpCmd->SetDefaultUnit("rad");
// paralpCmd->SetUnitCandidates("rad deg");
// partheCmd = new G4UIcmdWithADoubleAndUnit("/gps/parthe",this);
// partheCmd->SetGuidance("Polar angle through centres of z faces(obsolete!)");
// partheCmd->SetParameterName("parthe",false,false);
// partheCmd->SetDefaultUnit("rad");
// partheCmd->SetUnitCandidates("rad deg");
// parphiCmd = new G4UIcmdWithADoubleAndUnit("/gps/parphi",this);
// parphiCmd->SetGuidance("Azimuth angle through centres of z faces(obsolete!)");
// parphiCmd->SetParameterName("parphi",false,false);
// parphiCmd->SetDefaultUnit("rad");
// parphiCmd->SetUnitCandidates("rad deg");
// confineCmd = new G4UIcmdWithAString("/gps/confine",this);
// confineCmd->SetGuidance("Confine source to volume (NULL to unset)(obsolete!) .");
// confineCmd->SetGuidance("usage: confine VolName");
// confineCmd->SetParameterName("VolName",false,false);
// confineCmd->SetDefaultValue("NULL");
// Angular distribution commands
angularDirectory = new G4UIdirectory("/gps/ang/");
angularDirectory->SetGuidance("Angular commands sub-directory");
angtypeCmd1 = new G4UIcmdWithAString("/gps/ang/type",this);
angtypeCmd1->SetGuidance("Sets angular source distribution type");
angtypeCmd1->SetGuidance("Possible variables are: iso, cos, planar, beam1d, beam2d, focused or user");
angtypeCmd1->SetParameterName("AngDis",false,false);
angtypeCmd1->SetDefaultValue("iso");
angtypeCmd1->SetCandidates("iso cos planar beam1d beam2d focused user");
angrot1Cmd1 = new G4UIcmdWith3Vector("/gps/ang/rot1",this);
angrot1Cmd1->SetGuidance("Sets the 1st vector for angular distribution rotation matrix");
angrot1Cmd1->SetGuidance("Need not be a unit vector");
angrot1Cmd1->SetParameterName("AR1x","AR1y","AR1z",false,false);
angrot1Cmd1->SetRange("AR1x != 0 || AR1y != 0 || AR1z != 0");
angrot2Cmd1 = new G4UIcmdWith3Vector("/gps/ang/rot2",this);
angrot2Cmd1->SetGuidance("Sets the 2nd vector for angular distribution rotation matrix");
angrot2Cmd1->SetGuidance("Need not be a unit vector");
angrot2Cmd1->SetParameterName("AR2x","AR2y","AR2z",false,false);
angrot2Cmd1->SetRange("AR2x != 0 || AR2y != 0 || AR2z != 0");
minthetaCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/mintheta",this);
minthetaCmd1->SetGuidance("Set minimum theta");
minthetaCmd1->SetParameterName("MinTheta",false,false);
minthetaCmd1->SetDefaultValue(0.);
minthetaCmd1->SetDefaultUnit("rad");
// minthetaCmd1->SetUnitCandidates("rad deg");
maxthetaCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/maxtheta",this);
maxthetaCmd1->SetGuidance("Set maximum theta");
maxthetaCmd1->SetParameterName("MaxTheta",false,false);
maxthetaCmd1->SetDefaultValue(pi);
maxthetaCmd1->SetDefaultUnit("rad");
// maxthetaCmd1->SetUnitCandidates("rad deg");
minphiCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/minphi",this);
minphiCmd1->SetGuidance("Set minimum phi");
minphiCmd1->SetParameterName("MinPhi",false,false);
minphiCmd1->SetDefaultUnit("rad");
// minphiCmd1->SetUnitCandidates("rad deg");
maxphiCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/maxphi",this);
maxphiCmd1->SetGuidance("Set maximum phi");
maxphiCmd1->SetParameterName("MaxPhi",false,false);
maxphiCmd1->SetDefaultValue(pi);
maxphiCmd1->SetDefaultUnit("rad");
// maxphiCmd1->SetUnitCandidates("rad deg");
angsigmarCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/sigma_r",this);
angsigmarCmd1->SetGuidance("Set standard deviation in direction for 1D beam.");
angsigmarCmd1->SetParameterName("Sigmara",false,false);
angsigmarCmd1->SetDefaultUnit("rad");
// angsigmarCmd1->SetUnitCandidates("rad deg");
angsigmaxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/sigma_x",this);
angsigmaxCmd1->SetGuidance("Set standard deviation in direction in x-direc. for 2D beam");
angsigmaxCmd1->SetParameterName("Sigmaxa",false,false);
angsigmaxCmd1->SetDefaultUnit("rad");
// angsigmaxCmd1->SetUnitCandidates("rad deg");
angsigmayCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ang/sigma_y",this);
angsigmayCmd1->SetGuidance("Set standard deviation in direction in y-direc. for 2D beam");
angsigmayCmd1->SetParameterName("Sigmaya",false,false);
angsigmayCmd1->SetDefaultUnit("rad");
// angsigmayCmd1->SetUnitCandidates("rad deg");
angfocusCmd = new G4UIcmdWith3VectorAndUnit("/gps/ang/focuspoint",this);
angfocusCmd->SetGuidance("Set the focusing point for the beam");
angfocusCmd->SetParameterName("x","y","z",false,false);
angfocusCmd->SetDefaultUnit("cm");
// angfocusCmd->SetUnitCandidates("micron mm cm m km");
useuserangaxisCmd1 = new G4UIcmdWithABool("/gps/ang/user_coor",this);
useuserangaxisCmd1->SetGuidance("true for using user defined angular co-ordinates");
useuserangaxisCmd1->SetGuidance("Default is false");
useuserangaxisCmd1->SetParameterName("useuserangaxis",true);
useuserangaxisCmd1->SetDefaultValue(false);
surfnormCmd1 = new G4UIcmdWithABool("/gps/ang/surfnorm",this);
surfnormCmd1->SetGuidance("Makes a user-defined distribution with respect to surface normals rather than x,y,z axes.");
surfnormCmd1->SetGuidance("Default is false");
surfnormCmd1->SetParameterName("surfnorm",true);
surfnormCmd1->SetDefaultValue(false);
// old ones
// angtypeCmd = new G4UIcmdWithAString("/gps/angtype",this);
// angtypeCmd->SetGuidance("Sets angular source distribution type (obsolete!)");
// angtypeCmd->SetGuidance("Possible variables are: iso, cos planar beam1d beam2d or user");
// angtypeCmd->SetParameterName("AngDis",false,false);
// angtypeCmd->SetDefaultValue("iso");
// angtypeCmd->SetCandidates("iso cos planar beam1d beam2d user");
// angrot1Cmd = new G4UIcmdWith3Vector("/gps/angrot1",this);
// angrot1Cmd->SetGuidance("Sets the x' vector for angular distribution(obsolete!) ");
// angrot1Cmd->SetGuidance("Need not be a unit vector");
// angrot1Cmd->SetParameterName("AR1x","AR1y","AR1z",false,false);
// angrot1Cmd->SetRange("AR1x != 0 || AR1y != 0 || AR1z != 0");
// angrot2Cmd = new G4UIcmdWith3Vector("/gps/angrot2",this);
// angrot2Cmd->SetGuidance("Sets the y' vector for angular distribution (obsolete!)");
// angrot2Cmd->SetGuidance("Need not be a unit vector");
// angrot2Cmd->SetParameterName("AR2x","AR2y","AR2z",false,false);
// angrot2Cmd->SetRange("AR2x != 0 || AR2y != 0 || AR2z != 0");
// minthetaCmd = new G4UIcmdWithADoubleAndUnit("/gps/mintheta",this);
// minthetaCmd->SetGuidance("Set minimum theta (obsolete!)");
// minthetaCmd->SetParameterName("MinTheta",false,false);
// minthetaCmd->SetDefaultUnit("rad");
// minthetaCmd->SetUnitCandidates("rad deg");
// maxthetaCmd = new G4UIcmdWithADoubleAndUnit("/gps/maxtheta",this);
// maxthetaCmd->SetGuidance("Set maximum theta (obsolete!)");
// maxthetaCmd->SetParameterName("MaxTheta",false,false);
// maxthetaCmd->SetDefaultValue(3.1416);
// maxthetaCmd->SetDefaultUnit("rad");
// maxthetaCmd->SetUnitCandidates("rad deg");
// minphiCmd = new G4UIcmdWithADoubleAndUnit("/gps/minphi",this);
// minphiCmd->SetGuidance("Set minimum phi (obsolete!)");
// minphiCmd->SetParameterName("MinPhi",false,false);
// minphiCmd->SetDefaultUnit("rad");
// minphiCmd->SetUnitCandidates("rad deg");
// maxphiCmd = new G4UIcmdWithADoubleAndUnit("/gps/maxphi",this);
// maxphiCmd->SetGuidance("Set maximum phi(obsolete!)");
// maxphiCmd->SetParameterName("MaxPhi",false,false);
// maxphiCmd->SetDefaultUnit("rad");
// maxphiCmd->SetUnitCandidates("rad deg");
// angsigmarCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaangr",this);
// angsigmarCmd->SetGuidance("Set standard deviation of beam direction in radial(obsolete!).");
// angsigmarCmd->SetParameterName("Sigmara",false,false);
// angsigmarCmd->SetDefaultUnit("rad");
// angsigmarCmd->SetUnitCandidates("rad deg");
// angsigmaxCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaangx",this);
// angsigmaxCmd->SetGuidance("Set standard deviation of beam direction in x-direc(obsolete!).");
// angsigmaxCmd->SetParameterName("Sigmaxa",false,false);
// angsigmaxCmd->SetDefaultUnit("rad");
// angsigmaxCmd->SetUnitCandidates("rad deg");
// angsigmayCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmaangy",this);
// angsigmayCmd->SetGuidance("Set standard deviation of beam direction in y-direc.(obsolete!)");
// angsigmayCmd->SetParameterName("Sigmaya",false,false);
// angsigmayCmd->SetDefaultUnit("rad");
// angsigmayCmd->SetUnitCandidates("rad deg");
// useuserangaxisCmd = new G4UIcmdWithABool("/gps/useuserangaxis",this);
// useuserangaxisCmd->SetGuidance("true for using user defined angular co-ordinates(obsolete!)");
// useuserangaxisCmd->SetGuidance("Default is false");
// useuserangaxisCmd->SetParameterName("useuserangaxis",true);
// useuserangaxisCmd->SetDefaultValue(false);
// surfnormCmd = new G4UIcmdWithABool("/gps/surfnorm",this);
// surfnormCmd->SetGuidance("Makes a user-defined distribution with respect to surface normals rather than x,y,z axes (obsolete!).");
// surfnormCmd->SetGuidance("Default is false");
// surfnormCmd->SetParameterName("surfnorm",true);
// surfnormCmd->SetDefaultValue(false);
// Energy commands
energyDirectory = new G4UIdirectory("/gps/ene/");
energyDirectory->SetGuidance("Spectral commands sub-directory");
energytypeCmd1 = new G4UIcmdWithAString("/gps/ene/type",this);
energytypeCmd1->SetGuidance("Sets energy distribution type");
energytypeCmd1->SetParameterName("EnergyDis",false,false);
energytypeCmd1->SetDefaultValue("Mono");
energytypeCmd1->SetCandidates("Mono Lin Pow Exp Gauss Brem Bbody Cdg User Arb Epn");
eminCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/min",this);
eminCmd1->SetGuidance("Sets minimum energy");
eminCmd1->SetParameterName("emin",false,false);
eminCmd1->SetDefaultUnit("keV");
// eminCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
emaxCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/max",this);
emaxCmd1->SetGuidance("Sets maximum energy");
emaxCmd1->SetParameterName("emax",false,false);
emaxCmd1->SetDefaultUnit("keV");
// emaxCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
monoenergyCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/mono",this);
monoenergyCmd1->SetGuidance("Sets a monocromatic energy (same as gps/energy)");
monoenergyCmd1->SetParameterName("monoenergy",false,false);
monoenergyCmd1->SetDefaultUnit("keV");
// monoenergyCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
engsigmaCmd1 = new G4UIcmdWithADoubleAndUnit("/gps/ene/sigma",this);
engsigmaCmd1->SetGuidance("Sets the standard deviation for Gaussian energy dist.");
engsigmaCmd1->SetParameterName("Sigmae",false,false);
engsigmaCmd1->SetDefaultUnit("keV");
// engsigmaCmd1->SetUnitCandidates("eV keV MeV GeV TeV PeV");
alphaCmd1 = new G4UIcmdWithADouble("/gps/ene/alpha",this);
alphaCmd1->SetGuidance("Sets Alpha (index) for power-law energy dist.");
alphaCmd1->SetParameterName("alpha",false,false);
tempCmd1 = new G4UIcmdWithADouble("/gps/ene/temp",this);
tempCmd1->SetGuidance("Sets the temperature for Brem and BBody distributions (in Kelvin)");
tempCmd1->SetParameterName("temp",false,false);
ezeroCmd1 = new G4UIcmdWithADouble("/gps/ene/ezero",this);
ezeroCmd1->SetGuidance("Sets E_0 for exponential distribution (in MeV)");
ezeroCmd1->SetParameterName("ezero",false,false);
gradientCmd1 = new G4UIcmdWithADouble("/gps/ene/gradient",this);
gradientCmd1->SetGuidance("Sets the gradient for Lin distribution (in 1/MeV)");
gradientCmd1->SetParameterName("gradient",false,false);
interceptCmd1 = new G4UIcmdWithADouble("/gps/ene/intercept",this);
interceptCmd1->SetGuidance("Sets the intercept for Lin distributions (in MeV)");
interceptCmd1->SetParameterName("intercept",false,false);
arbeintCmd1 = new G4UIcmdWithADouble("/gps/ene/biasAlpha",this);
arbeintCmd1->SetGuidance("Set the power-law index for the energy sampling distri. )");
arbeintCmd1->SetParameterName("arbeint",false,false);
calculateCmd1 = new G4UIcmdWithoutParameter("/gps/ene/calculate",this);
calculateCmd1->SetGuidance("Calculates the distributions for Cdg and BBody");
energyspecCmd1 = new G4UIcmdWithABool("/gps/ene/emspec",this);
energyspecCmd1->SetGuidance("True for energy and false for momentum spectra");
energyspecCmd1->SetParameterName("energyspec",true);
energyspecCmd1->SetDefaultValue(true);
diffspecCmd1 = new G4UIcmdWithABool("/gps/ene/diffspec",this);
diffspecCmd1->SetGuidance("True for differential and flase for integral spectra");
diffspecCmd1->SetParameterName("diffspec",true);
diffspecCmd1->SetDefaultValue(true);
//old ones
// energytypeCmd = new G4UIcmdWithAString("/gps/energytype",this);
// energytypeCmd->SetGuidance("Sets energy distribution type (obsolete!)");
// energytypeCmd->SetParameterName("EnergyDis",false,false);
// energytypeCmd->SetDefaultValue("Mono");
// energytypeCmd->SetCandidates("Mono Lin Pow Exp Gauss Brem Bbody Cdg User Arb Epn");
// eminCmd = new G4UIcmdWithADoubleAndUnit("/gps/emin",this);
// eminCmd->SetGuidance("Sets Emin (obsolete!)");
// eminCmd->SetParameterName("emin",false,false);
// eminCmd->SetDefaultUnit("keV");
// eminCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
// emaxCmd = new G4UIcmdWithADoubleAndUnit("/gps/emax",this);
// emaxCmd->SetGuidance("Sets Emax (obsolete!)");
// emaxCmd->SetParameterName("emax",false,false);
// emaxCmd->SetDefaultUnit("keV");
// emaxCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
// monoenergyCmd = new G4UIcmdWithADoubleAndUnit("/gps/monoenergy",this);
// monoenergyCmd->SetGuidance("Sets Monoenergy (obsolete, use gps/energy instead!)");
// monoenergyCmd->SetParameterName("monoenergy",false,false);
// monoenergyCmd->SetDefaultUnit("keV");
// monoenergyCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
// engsigmaCmd = new G4UIcmdWithADoubleAndUnit("/gps/sigmae",this);
// engsigmaCmd->SetGuidance("Sets the standard deviation for Gaussian energy dist.(obsolete!)");
// engsigmaCmd->SetParameterName("Sigmae",false,false);
// engsigmaCmd->SetDefaultUnit("keV");
// engsigmaCmd->SetUnitCandidates("eV keV MeV GeV TeV PeV");
// alphaCmd = new G4UIcmdWithADouble("/gps/alpha",this);
// alphaCmd->SetGuidance("Sets Alpha (index) for power-law energy dist(obsolete!).");
// alphaCmd->SetParameterName("alpha",false,false);
// tempCmd = new G4UIcmdWithADouble("/gps/temp",this);
// tempCmd->SetGuidance("Sets the temperature for Brem and BBody (in Kelvin)(obsolete!)");
// tempCmd->SetParameterName("temp",false,false);
// ezeroCmd = new G4UIcmdWithADouble("/gps/ezero",this);
// ezeroCmd->SetGuidance("Sets ezero exponential distributions (in MeV)(obsolete!)");
// ezeroCmd->SetParameterName("ezero",false,false);
//
// gradientCmd = new G4UIcmdWithADouble("/gps/gradient",this);
// gradientCmd->SetGuidance("Sets the gradient for Lin distributions (in 1/MeV)(obsolete!)");
// gradientCmd->SetParameterName("gradient",false,false);
//
// interceptCmd = new G4UIcmdWithADouble("/gps/intercept",this);
// interceptCmd->SetGuidance("Sets the intercept for Lin distributions (in MeV)(obsolete!)");
// interceptCmd->SetParameterName("intercept",false,false);
//
// calculateCmd = new G4UIcmdWithoutParameter("/gps/calculate",this);
// calculateCmd->SetGuidance("Calculates distributions for Cdg and BBody(obsolete!)");
//
// energyspecCmd = new G4UIcmdWithABool("/gps/energyspec",this);
// energyspecCmd->SetGuidance("True for energy and false for momentum spectra(obsolete!)");
// energyspecCmd->SetParameterName("energyspec",true);
// energyspecCmd->SetDefaultValue(true);
//
// diffspecCmd = new G4UIcmdWithABool("/gps/diffspec",this);
// diffspecCmd->SetGuidance("True for differential and flase for integral spectra(obsolete!)");
// diffspecCmd->SetParameterName("diffspec",true);
// diffspecCmd->SetDefaultValue(true);
// Biasing + histograms in general
histDirectory = new G4UIdirectory("/gps/hist/");
histDirectory->SetGuidance("Histogram, biasing commands sub-directory");
histnameCmd1 = new G4UIcmdWithAString("/gps/hist/type",this);
histnameCmd1->SetGuidance("Sets histogram type");
histnameCmd1->SetParameterName("HistType",false,false);
histnameCmd1->SetDefaultValue("biasx");
histnameCmd1->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
resethistCmd1 = new G4UIcmdWithAString("/gps/hist/reset",this);
resethistCmd1->SetGuidance("Reset (clean) the histogram ");
resethistCmd1->SetParameterName("HistType",false,false);
resethistCmd1->SetDefaultValue("energy");
resethistCmd1->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
histpointCmd1 = new G4UIcmdWith3Vector("/gps/hist/point",this);
histpointCmd1->SetGuidance("Allows user to define a histogram");
histpointCmd1->SetGuidance("Enter: Ehi Weight");
histpointCmd1->SetParameterName("Ehi","Weight","Junk",true,true);
histpointCmd1->SetRange("Ehi >= 0. && Weight >= 0.");
histfileCmd1 = new G4UIcmdWithAString("/gps/hist/file",this);
histfileCmd1->SetGuidance("import the arb energy hist in an ASCII file");
histfileCmd1->SetParameterName("HistFile",false,false);
arbintCmd1 = new G4UIcmdWithAString("/gps/hist/inter",this);
arbintCmd1->SetGuidance("Sets the interpolation method for arbitrary distribution.");
arbintCmd1->SetParameterName("int",false,false);
arbintCmd1->SetDefaultValue("Lin");
arbintCmd1->SetCandidates("Lin Log Exp Spline");
// old ones
// histnameCmd = new G4UIcmdWithAString("/gps/histname",this);
// histnameCmd->SetGuidance("Sets histogram type (obsolete!)");
// histnameCmd->SetParameterName("HistType",false,false);
// histnameCmd->SetDefaultValue("biasx");
// histnameCmd->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
//
// // re-set the histograms
// resethistCmd = new G4UIcmdWithAString("/gps/resethist",this);
// resethistCmd->SetGuidance("Re-Set the histogram (obsolete!)");
// resethistCmd->SetParameterName("HistType",false,false);
// resethistCmd->SetDefaultValue("energy");
// resethistCmd->SetCandidates("biasx biasy biasz biast biasp biase biaspt biaspp theta phi energy arb epn");
//
// histpointCmd = new G4UIcmdWith3Vector("/gps/histpoint",this);
// histpointCmd->SetGuidance("Allows user to define a histogram (obsolete!)");
// histpointCmd->SetGuidance("Enter: Ehi Weight");
// histpointCmd->SetParameterName("Ehi","Weight","Junk",false,false);
// histpointCmd->SetRange("Ehi >= 0. && Weight >= 0.");
//
// arbintCmd = new G4UIcmdWithAString("/gps/arbint",this);
// arbintCmd->SetGuidance("Sets Arbitrary Interpolation type.(obsolete!) ");
// arbintCmd->SetParameterName("int",false,false);
// arbintCmd->SetDefaultValue("NULL");
// arbintCmd->SetCandidates("Lin Log Exp Spline");
}
G4GeneralParticleSourceMessenger::~G4GeneralParticleSourceMessenger()
{
delete positionDirectory;
// delete typeCmd;
// delete shapeCmd;
// delete centreCmd;
// delete posrot1Cmd;
// delete posrot2Cmd;
// delete halfxCmd;
// delete halfyCmd;
// delete halfzCmd;
// delete radiusCmd;
// delete radius0Cmd;
// delete possigmarCmd;
// delete possigmaxCmd;
// delete possigmayCmd;
// delete paralpCmd;
// delete partheCmd;
// delete parphiCmd;
// delete confineCmd;
delete typeCmd1;
delete shapeCmd1;
delete centreCmd1;
delete posrot1Cmd1;
delete posrot2Cmd1;
delete halfxCmd1;
delete halfyCmd1;
delete halfzCmd1;
delete radiusCmd1;
delete radius0Cmd1;
delete possigmarCmd1;
delete possigmaxCmd1;
delete possigmayCmd1;
delete paralpCmd1;
delete partheCmd1;
delete parphiCmd1;
delete confineCmd1;
delete angularDirectory;
// delete angtypeCmd;
// delete angrot1Cmd;
// delete angrot2Cmd;
// delete minthetaCmd;
// delete maxthetaCmd;
// delete minphiCmd;
// delete maxphiCmd;
// delete angsigmarCmd;
// delete angsigmaxCmd;
// delete angsigmayCmd;
// delete useuserangaxisCmd;
// delete surfnormCmd;
delete angtypeCmd1;
delete angrot1Cmd1;
delete angrot2Cmd1;
delete minthetaCmd1;
delete maxthetaCmd1;
delete minphiCmd1;
delete maxphiCmd1;
delete angsigmarCmd1;
delete angsigmaxCmd1;
delete angsigmayCmd1;
delete angfocusCmd;
delete useuserangaxisCmd1;
delete surfnormCmd1;
delete energyDirectory;
// delete energytypeCmd;
// delete eminCmd;
// delete emaxCmd;
// delete monoenergyCmd;
// delete engsigmaCmd;
// delete alphaCmd;
// delete tempCmd;
// delete ezeroCmd;
// delete gradientCmd;
// delete interceptCmd;
// delete calculateCmd;
// delete energyspecCmd;
// delete diffspecCmd;
delete energytypeCmd1;
delete eminCmd1;
delete emaxCmd1;
delete monoenergyCmd1;
delete engsigmaCmd1;
delete alphaCmd1;
delete tempCmd1;
delete ezeroCmd1;
delete gradientCmd1;
delete interceptCmd1;
delete arbeintCmd1;
delete calculateCmd1;
delete energyspecCmd1;
delete diffspecCmd1;
delete histDirectory;
//delete histnameCmd;
//delete resethistCmd;
//delete histpointCmd;
//delete arbintCmd;
delete histnameCmd1;
delete resethistCmd1;
delete histpointCmd1;
delete histfileCmd1;
delete arbintCmd1;
delete verbosityCmd;
delete ionCmd;
delete ionLvlCmd;
delete particleCmd;
delete timeCmd;
delete polCmd;
delete numberCmd;
delete positionCmd;
delete directionCmd;
delete energyCmd;
delete listCmd;
delete sourceDirectory;
delete addsourceCmd;
delete listsourceCmd;
delete clearsourceCmd;
delete getsourceCmd;
delete setsourceCmd;
delete setintensityCmd;
delete deletesourceCmd;
delete multiplevertexCmd;
delete flatsamplingCmd;
delete gpsDirectory;
theInstance = 0;
}
#define CHECKPG() { if (fParticleGun==NULL) { \
G4ExceptionDescription msg; \
msg << "Command "<< command->GetCommandPath()<<"/";\
msg<<command->GetCommandName() << " used but no particle sources are set.";\
msg <<" Add at least a source with: /gps/source/add.";\
G4Exception("G4GeneralParticleSourceMessenger::SetNewValue","G4GPS003",\
FatalException,msg); return;\
} }
void G4GeneralParticleSourceMessenger::SetNewValue(G4UIcommand *command, G4String newValues)
{
// if(command == typeCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetPosDisType(newValues);
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == shapeCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetPosDisShape(newValues);
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == centreCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetCentreCoords(centreCmd->GetNew3VectorValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == posrot1Cmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetPosRot1(posrot1Cmd->GetNew3VectorValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == posrot2Cmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetPosRot2(posrot2Cmd->GetNew3VectorValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == halfxCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetHalfX(halfxCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == halfyCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetHalfY(halfyCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == halfzCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetHalfZ(halfzCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == radiusCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetRadius(radiusCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == radius0Cmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetRadius0(radius0Cmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == possigmarCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetBeamSigmaInR(possigmarCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == possigmaxCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetBeamSigmaInX(possigmaxCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == possigmayCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetBeamSigmaInY(possigmayCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == paralpCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetParAlpha(paralpCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == partheCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetParTheta(partheCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == parphiCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->SetParPhi(parphiCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == confineCmd)
// {
// CHECKPG(); fParticleGun->GetPosDist()->ConfineSourceToVolume(newValues);
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == angtypeCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetAngDistType(newValues);
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == angrot1Cmd)
// {
// CHECKPG();
// G4String a = "angref1";
// fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot1Cmd->GetNew3VectorValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == angrot2Cmd)
// {
// CHECKPG();
// G4String a = "angref2";
// fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot2Cmd->GetNew3VectorValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == minthetaCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetMinTheta(minthetaCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == minphiCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetMinPhi(minphiCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == maxthetaCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetMaxTheta(maxthetaCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == maxphiCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetMaxPhi(maxphiCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == angsigmarCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetBeamSigmaInAngR(angsigmarCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == angsigmaxCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetBeamSigmaInAngX(angsigmaxCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == angsigmayCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetBeamSigmaInAngY(angsigmayCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == useuserangaxisCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetUseUserAngAxis(useuserangaxisCmd->GetNewBoolValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == surfnormCmd)
// {
// CHECKPG(); fParticleGun->GetAngDist()->SetUserWRTSurface(surfnormCmd->GetNewBoolValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == energytypeCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetEnergyDisType(newValues);
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == eminCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetEmin(eminCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == emaxCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetEmax(emaxCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == monoenergyCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetMonoEnergy(monoenergyCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == engsigmaCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetBeamSigmaInE(engsigmaCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == alphaCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetAlpha(alphaCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == tempCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetTemp(tempCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == ezeroCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetEzero(ezeroCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == gradientCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetGradient(gradientCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == interceptCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->SetInterCept(interceptCmd->GetNewDoubleValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == calculateCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->Calculate();
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == energyspecCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->InputEnergySpectra(energyspecCmd->GetNewBoolValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == diffspecCmd)
// {
// CHECKPG(); fParticleGun->GetEneDist()->InputDifferentialSpectra(diffspecCmd->GetNewBoolValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == histnameCmd)
// {
// histtype = newValues;
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else
// if(command == histpointCmd)
// {
// CHECKPG();
// if(histtype == "biasx")
// fParticleGun->GetBiasRndm()->SetXBias(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "biasy")
// fParticleGun->GetBiasRndm()->SetYBias(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "biasz")
// fParticleGun->GetBiasRndm()->SetZBias(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "biast")
// fParticleGun->GetBiasRndm()->SetThetaBias(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "biasp")
// fParticleGun->GetBiasRndm()->SetPhiBias(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "biase")
// fParticleGun->GetBiasRndm()->SetEnergyBias(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "theta")
// fParticleGun->GetAngDist()->UserDefAngTheta(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "phi")
// fParticleGun->GetAngDist()->UserDefAngPhi(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "energy")
// fParticleGun->GetEneDist()->UserEnergyHisto(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "arb")
// fParticleGun->GetEneDist()->ArbEnergyHisto(histpointCmd->GetNew3VectorValue(newValues));
// if(histtype == "epn")
// fParticleGun->GetEneDist()->EpnEnergyHisto(histpointCmd->GetNew3VectorValue(newValues));
// G4cout << " G4GeneralParticleSourceMessenger - Warning: The command is obsolete and will be removed soon. Please try to use the new structured commands!" << G4endl;
// }
// else if(command == resethistCmd)
// {
// CHECKPG();
// if(newValues == "theta" || newValues == "phi") {
// fParticleGun->GetAngDist()->ReSetHist(newValues);
// } else if (newValues == "energy" || newValues == "arb" || newValues == "epn") {
// fParticleGun->GetEneDist()->ReSetHist(newValues);
// } else {
// fParticleGun->GetBiasRndm()->ReSetHist(newValues);
// }
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else if(command == arbintCmd)
// {
// CHECKPG();
// fParticleGun->GetEneDist()->ArbInterpolate(newValues);
// G4cout << " G4GeneralParticleSourceMessenger - Warning:" << G4endl
// << " The command is obsolete and will be removed soon." << G4endl
// << " Please try to use the new structured commands!" << G4endl;
// }
// else
if( command==directionCmd )
{
CHECKPG();
fParticleGun->GetAngDist()->SetAngDistType("planar");
fParticleGun->GetAngDist()->SetParticleMomentumDirection(directionCmd->GetNew3VectorValue(newValues));
}
else if( command==energyCmd )
{
CHECKPG();
fParticleGun->GetEneDist()->SetEnergyDisType("Mono");
fParticleGun->GetEneDist()->SetMonoEnergy(energyCmd->GetNewDoubleValue(newValues));
}
else if( command==positionCmd )
{
CHECKPG();
fParticleGun->GetPosDist()->SetPosDisType("Point");
fParticleGun->GetPosDist()->SetCentreCoords(positionCmd->GetNew3VectorValue(newValues));
}
else if(command == verbosityCmd)
{
fGPS->SetVerbosity(verbosityCmd->GetNewIntValue(newValues));
//CHECKPG();
//fParticleGun->SetVerbosity(verbosityCmd->GetNewIntValue(newValues));
}
else if( command==particleCmd )
{
if (newValues =="ion") {
fShootIon = true;
} else {
fShootIon = false;
G4ParticleDefinition* pd = particleTable->FindParticle(newValues);
if(pd != NULL)
{ CHECKPG(); fParticleGun->SetParticleDefinition( pd ); }
}
}
else if( command==timeCmd )
{ CHECKPG(); fParticleGun->SetParticleTime(timeCmd->GetNewDoubleValue(newValues)); }
else if( command==polCmd )
{ CHECKPG(); fParticleGun->SetParticlePolarization(polCmd->GetNew3VectorValue(newValues)); }
else if( command==numberCmd )
{ CHECKPG(); fParticleGun->SetNumberOfParticles(numberCmd->GetNewIntValue(newValues)); }
else if( command==ionCmd )
{ IonCommand(newValues); }
else if( command==ionLvlCmd )
{ IonLvlCommand(newValues); }
else if( command==listCmd ){
particleTable->DumpTable();
}
else if( command==addsourceCmd )
{
fGPS->AddaSource(addsourceCmd->GetNewDoubleValue(newValues));
}
else if( command==listsourceCmd )
{
fGPS->ListSource();
}
else if( command==clearsourceCmd )
{
fGPS->ClearAll();
fParticleGun = 0;
}
else if( command==getsourceCmd )
{
G4cout << " Current source index:" << fGPS->GetCurrentSourceIndex()
<< " ; Intensity:" << fGPS->GetCurrentSourceIntensity() << G4endl;
}
else if( command==setsourceCmd )
{
//NOTE: This will also sets fParticleGun to the courrent source
// Not very clean, the GPS::SetCurrentSourceto will call:
// this::SetParticleSource( G4ParticleSource* )
// The point is that GPS has no public API to get a source by
// index
//TODO: Can we add this API?
const G4int sn = setsourceCmd->GetNewIntValue(newValues);
if ( sn >= fGPS->GetNumberofSource() )
{
G4ExceptionDescription msg;
msg << "Using command "<<setsourceCmd->GetCommandPath()<<"/"<<setsourceCmd->GetCommandName()<<" "<<sn;
msg << " is invalid "<<fGPS->GetNumberofSource()<<" source(s) are defined.";
G4Exception("G4GeneralParticleSourceMessenger::SetNewValue","G4GPS005",FatalException,msg);
}
fGPS->SetCurrentSourceto(setsourceCmd->GetNewIntValue(newValues));
}
else if( command==setintensityCmd )
{
fGPS->SetCurrentSourceIntensity(setintensityCmd->GetNewDoubleValue(newValues));
}
else if( command==deletesourceCmd )
{
fGPS->DeleteaSource(deletesourceCmd->GetNewIntValue(newValues));
}
else if(command == multiplevertexCmd)
{
fGPS->SetMultipleVertex(multiplevertexCmd->GetNewBoolValue(newValues));
}
else if(command == flatsamplingCmd)
{
fGPS->SetFlatSampling(flatsamplingCmd->GetNewBoolValue(newValues));
}
//
// new implementations
//
//
else if(command == typeCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetPosDisType(newValues);
}
else if(command == shapeCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetPosDisShape(newValues);
}
else if(command == centreCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetCentreCoords(centreCmd1->GetNew3VectorValue(newValues));
}
else if(command == posrot1Cmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetPosRot1(posrot1Cmd1->GetNew3VectorValue(newValues));
}
else if(command == posrot2Cmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetPosRot2(posrot2Cmd1->GetNew3VectorValue(newValues));
}
else if(command == halfxCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetHalfX(halfxCmd1->GetNewDoubleValue(newValues));
}
else if(command == halfyCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetHalfY(halfyCmd1->GetNewDoubleValue(newValues));
}
else if(command == halfzCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetHalfZ(halfzCmd1->GetNewDoubleValue(newValues));
}
else if(command == radiusCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetRadius(radiusCmd1->GetNewDoubleValue(newValues));
}
else if(command == radius0Cmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetRadius0(radius0Cmd1->GetNewDoubleValue(newValues));
}
else if(command == possigmarCmd1)
{
CHECKPG();
fParticleGun->GetPosDist()->SetBeamSigmaInR(possigmarCmd1->GetNewDoubleValue(newValues));
}
else if(command == possigmaxCmd1)
{
CHECKPG(); fParticleGun->GetPosDist()->SetBeamSigmaInX(possigmaxCmd1->GetNewDoubleValue(newValues));
}
else if(command == possigmayCmd1)
{
CHECKPG(); fParticleGun->GetPosDist()->SetBeamSigmaInY(possigmayCmd1->GetNewDoubleValue(newValues));
}
else if(command == paralpCmd1)
{
CHECKPG(); fParticleGun->GetPosDist()->SetParAlpha(paralpCmd1->GetNewDoubleValue(newValues));
}
else if(command == partheCmd1)
{
CHECKPG(); fParticleGun->GetPosDist()->SetParTheta(partheCmd1->GetNewDoubleValue(newValues));
}
else if(command == parphiCmd1)
{
CHECKPG(); fParticleGun->GetPosDist()->SetParPhi(parphiCmd1->GetNewDoubleValue(newValues));
}
else if(command == confineCmd1)
{
CHECKPG(); fParticleGun->GetPosDist()->ConfineSourceToVolume(newValues);
}
else if(command == angtypeCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetAngDistType(newValues);
}
else if(command == angrot1Cmd1)
{
CHECKPG();
G4String a = "angref1";
fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot1Cmd1->GetNew3VectorValue(newValues));
}
else if(command == angrot2Cmd1)
{
CHECKPG();
G4String a = "angref2";
fParticleGun->GetAngDist()->DefineAngRefAxes(a,angrot2Cmd1->GetNew3VectorValue(newValues));
}
else if(command == minthetaCmd1)
{
CHECKPG();
fParticleGun->GetAngDist()->SetMinTheta(minthetaCmd1->GetNewDoubleValue(newValues));
}
else if(command == minphiCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetMinPhi(minphiCmd1->GetNewDoubleValue(newValues));
}
else if(command == maxthetaCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetMaxTheta(maxthetaCmd1->GetNewDoubleValue(newValues));
}
else if(command == maxphiCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetMaxPhi(maxphiCmd1->GetNewDoubleValue(newValues));
}
else if(command == angsigmarCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetBeamSigmaInAngR(angsigmarCmd1->GetNewDoubleValue(newValues));
}
else if(command == angsigmaxCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetBeamSigmaInAngX(angsigmaxCmd1->GetNewDoubleValue(newValues));
}
else if(command == angsigmayCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetBeamSigmaInAngY(angsigmayCmd1->GetNewDoubleValue(newValues));
}
else if(command == angfocusCmd)
{
CHECKPG(); fParticleGun->GetAngDist()->SetFocusPoint(angfocusCmd->GetNew3VectorValue(newValues));
}
else if(command == useuserangaxisCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetUseUserAngAxis(useuserangaxisCmd1->GetNewBoolValue(newValues));
}
else if(command == surfnormCmd1)
{
CHECKPG(); fParticleGun->GetAngDist()->SetUserWRTSurface(surfnormCmd1->GetNewBoolValue(newValues));
}
else if(command == energytypeCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetEnergyDisType(newValues);
}
else if(command == eminCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetEmin(eminCmd1->GetNewDoubleValue(newValues));
}
else if(command == emaxCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetEmax(emaxCmd1->GetNewDoubleValue(newValues));
}
else if(command == monoenergyCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetMonoEnergy(monoenergyCmd1->GetNewDoubleValue(newValues));
}
else if(command == engsigmaCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetBeamSigmaInE(engsigmaCmd1->GetNewDoubleValue(newValues));
}
else if(command == alphaCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetAlpha(alphaCmd1->GetNewDoubleValue(newValues));
}
else if(command == tempCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetTemp(tempCmd1->GetNewDoubleValue(newValues));
}
else if(command == ezeroCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetEzero(ezeroCmd1->GetNewDoubleValue(newValues));
}
else if(command == gradientCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetGradient(gradientCmd1->GetNewDoubleValue(newValues));
}
else if(command == interceptCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetInterCept(interceptCmd1->GetNewDoubleValue(newValues));
}
else if(command == arbeintCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->SetBiasAlpha(arbeintCmd1->GetNewDoubleValue(newValues));
}
else if(command == calculateCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->Calculate();
}
else if(command == energyspecCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->InputEnergySpectra(energyspecCmd1->GetNewBoolValue(newValues));
}
else if(command == diffspecCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->InputDifferentialSpectra(diffspecCmd1->GetNewBoolValue(newValues));
}
else if(command == histnameCmd1)
{
histtype = newValues;
}
else if(command == histfileCmd1)
{
histtype = "arb";
CHECKPG(); fParticleGun->GetEneDist()->ArbEnergyHistoFile(newValues);
}
else if(command == histpointCmd1)
{
CHECKPG();
if(histtype == "biasx")
fParticleGun->GetBiasRndm()->SetXBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biasy")
fParticleGun->GetBiasRndm()->SetYBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biasz")
fParticleGun->GetBiasRndm()->SetZBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biast")
fParticleGun->GetBiasRndm()->SetThetaBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biasp")
fParticleGun->GetBiasRndm()->SetPhiBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biaspt")
fParticleGun->GetBiasRndm()->SetPosThetaBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biaspp")
fParticleGun->GetBiasRndm()->SetPosPhiBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "biase")
fParticleGun->GetBiasRndm()->SetEnergyBias(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "theta")
fParticleGun->GetAngDist()->UserDefAngTheta(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "phi")
fParticleGun->GetAngDist()->UserDefAngPhi(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "energy")
fParticleGun->GetEneDist()->UserEnergyHisto(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "arb")
fParticleGun->GetEneDist()->ArbEnergyHisto(histpointCmd1->GetNew3VectorValue(newValues));
if(histtype == "epn")
fParticleGun->GetEneDist()->EpnEnergyHisto(histpointCmd1->GetNew3VectorValue(newValues));
}
else if(command == resethistCmd1)
{
CHECKPG();
if(newValues == "theta" || newValues == "phi") {
fParticleGun->GetAngDist()->ReSetHist(newValues);
} else if (newValues == "energy" || newValues == "arb" || newValues == "epn") {
fParticleGun->GetEneDist()->ReSetHist(newValues);
} else {
fParticleGun->GetBiasRndm()->ReSetHist(newValues);
}
}
else if(command == arbintCmd1)
{
CHECKPG(); fParticleGun->GetEneDist()->ArbInterpolate(newValues);
}
else
{
G4cout << "Error entering command" << G4endl;
}
}
G4String G4GeneralParticleSourceMessenger::GetCurrentValue(G4UIcommand *)
{
G4String cv;
// if( command==directionCmd )
// { cv = directionCmd->ConvertToString(fParticleGun->GetParticleMomentumDirection()); }
// else if( command==energyCmd )
// { cv = energyCmd->ConvertToString(fParticleGun->GetParticleEnergy(),"GeV"); }
// else if( command==positionCmd )
// { cv = positionCmd->ConvertToString(fParticleGun->GetParticlePosition(),"cm"); }
// else if( command==timeCmd )
// { cv = timeCmd->ConvertToString(fParticleGun->GetParticleTime(),"ns"); }
// else if( command==polCmd )
// { cv = polCmd->ConvertToString(fParticleGun->GetParticlePolarization()); }
// else if( command==numberCmd )
// { cv = numberCmd->ConvertToString(fParticleGun->GetNumberOfParticles()); }
cv = "Not implemented yet";
return cv;
}
void G4GeneralParticleSourceMessenger::IonCommand(G4String newValues)
{
fShootIon = true;
if (fShootIon)
{
G4Tokenizer next( newValues );
// check argument
fAtomicNumber = StoI(next());
fAtomicMass = StoI(next());
G4String sQ = next();
if (sQ.isNull())
{
fIonCharge = fAtomicNumber;
}
else
{
fIonCharge = StoI(sQ);
sQ = next();
if (sQ.isNull())
{
fIonExciteEnergy = 0.0;
}
else
{
fIonExciteEnergy = StoD(sQ) * keV;
}
}
G4ParticleDefinition* ion;
ion = G4IonTable::GetIonTable()->GetIon( fAtomicNumber, fAtomicMass, fIonExciteEnergy);
if (ion==0)
{
G4cout << "Ion with Z=" << fAtomicNumber;
G4cout << " A=" << fAtomicMass << " is not defined" << G4endl;
}
else
{
fParticleGun->SetParticleDefinition(ion);
fParticleGun->SetParticleCharge(fIonCharge*eplus);
}
}
else
{
G4cout << "Set /gps/particle to ion before using /gps/ion command";
G4cout << G4endl;
}
}
void G4GeneralParticleSourceMessenger::IonLvlCommand(G4String newValues)
{
fShootIonL = true;
if (fShootIonL) {
G4Tokenizer next(newValues);
// check argument
fAtomicNumberL = StoI(next());
fAtomicMassL = StoI(next());
G4String sQ = next();
if (sQ.isNull()) {
fIonChargeL = fAtomicNumberL;
} else {
fIonChargeL = StoI(sQ);
sQ = next();
if (sQ.isNull()) {
fIonEnergyLevel = 0;
} else {
fIonEnergyLevel = StoI(sQ);
}
}
G4ParticleDefinition* ion;
ion = G4IonTable::GetIonTable()->GetIon(fAtomicNumberL, fAtomicMassL, fIonEnergyLevel);
if (ion == 0) {
G4cout << "Ion with Z=" << fAtomicNumberL;
G4cout << " A=" << fAtomicMassL << " is not defined" << G4endl;
} else {
fParticleGun->SetParticleDefinition(ion);
fParticleGun->SetParticleCharge(fIonChargeL*eplus);
}
} else {
G4cout << "Set /gps/particle to ion before using /gps/ionLvl command";
G4cout << G4endl;
}
}
Reference in New Issue View Git Blame Copy Permalink