G4ParticleGunMessenger Class Reference

#include <G4ParticleGunMessenger.hh>

Inheritance diagram for G4ParticleGunMessenger:

Public Member Functions
	G4ParticleGunMessenger (G4ParticleGun *fPtclGun)
	~G4ParticleGunMessenger ()
void	SetNewValue (G4UIcommand *command, G4String newValues)
G4String	GetCurrentValue (G4UIcommand *command)
Public Member Functions inherited from G4UImessenger
	G4UImessenger ()
	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
virtual	~G4UImessenger ()
virtual G4String	GetCurrentValue (G4UIcommand *command)
virtual void	SetNewValue (G4UIcommand *command, G4String newValue)
G4bool	operator== (const G4UImessenger &messenger) const
G4bool	operator!= (const G4UImessenger &messenger) const
G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)
G4String	DtoS (G4double a)
G4String	BtoS (G4bool b)
G4int	StoI (G4String s)
G4long	StoL (G4String s)
G4double	StoD (G4String s)
G4bool	StoB (G4String s)
void	AddUIcommand (G4UIcommand *newCommand)
void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
template<typename T >
T *	CreateCommand (const G4String &cname, const G4String &dsc)
Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr
G4String	baseDirName = ""
G4bool	commandsShouldBeInMaster = false

Detailed Description

Definition at line 52 of file G4ParticleGunMessenger.hh.

Constructor & Destructor Documentation

G4ParticleGunMessenger()

G4ParticleGunMessenger::G4ParticleGunMessenger

(

G4ParticleGun *

fPtclGun

)

Definition at line 49 of file G4ParticleGunMessenger.cc.

  : fParticleGun(fPtclGun)
{
  particleTable = G4ParticleTable::GetParticleTable();
 
  gunDirectory = new G4UIdirectory("/gun/");
  gunDirectory->SetGuidance("Particle Gun control commands.");
 
  listCmd = new G4UIcmdWithoutParameter("/gun/List",this);
  listCmd->SetGuidance("List available particles.");
  listCmd->SetGuidance(" Invoke G4ParticleTable.");
 
  particleCmd = new G4UIcmdWithAString("/gun/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; 
  G4ParticleTable::G4PTblDicIterator* itr = particleTable->GetIterator();
  itr->reset();
  while( (*itr)() )
  {
    G4ParticleDefinition* pd = itr->value();
    if( !(pd->IsShortLived()) || pd->GetDecayTable() != nullptr )
    {
      candidateList += pd->GetParticleName();
      candidateList += " ";
    }
  }
  candidateList += "ion ";
  particleCmd->SetCandidates(candidateList);
 
  directionCmd = new G4UIcmdWith3Vector("/gun/direction",this);
  directionCmd->SetGuidance("Set momentum direction.");
  directionCmd->SetGuidance(" Direction needs not to be a unit vector.");
  directionCmd->SetParameterName("ex","ey","ez",true,true); 
  directionCmd->SetRange("ex != 0 || ey != 0 || ez != 0");
  
  energyCmd = new G4UIcmdWithADoubleAndUnit("/gun/energy",this);
  energyCmd->SetGuidance("Set kinetic energy.");
  energyCmd->SetParameterName("Energy",true,true);
  energyCmd->SetDefaultUnit("GeV");
  //energyCmd->SetUnitCategory("Energy");
  //energyCmd->SetUnitCandidates("eV keV MeV GeV TeV");
 
  momCmd = new G4UIcmdWith3VectorAndUnit("/gun/momentum",this);
  momCmd->SetGuidance("Set momentum. This command is equivalent to two commands");
  momCmd->SetGuidance(" /gun/direction and /gun/momentumAmp");
  momCmd->SetParameterName("px","py","pz",true,true); 
  momCmd->SetRange("px != 0 || py != 0 || pz != 0");
  momCmd->SetDefaultUnit("GeV");
 
  momAmpCmd = new G4UIcmdWithADoubleAndUnit("/gun/momentumAmp",this);
  momAmpCmd->SetGuidance("Set absolute value of momentum.");
  momAmpCmd->SetGuidance(" Direction should be set by /gun/direction command.");
  momAmpCmd->SetGuidance(" This command should be used alternatively with /gun/energy.");
  momAmpCmd->SetParameterName("Momentum",true,true);
  momAmpCmd->SetDefaultUnit("GeV");
 
  positionCmd = new G4UIcmdWith3VectorAndUnit("/gun/position",this);
  positionCmd->SetGuidance("Set starting position of the particle.");
  positionCmd->SetParameterName("X","Y","Z",true,true);
  positionCmd->SetDefaultUnit("cm");
  // positionCmd->SetUnitCategory("Length");
  // positionCmd->SetUnitCandidates("microm mm cm m km");
 
  timeCmd = new G4UIcmdWithADoubleAndUnit("/gun/time",this);
  timeCmd->SetGuidance("Set initial time of the particle.");
  timeCmd->SetParameterName("t0",true,true);
  timeCmd->SetDefaultUnit("ns");
  // timeCmd->SetUnitCategory("Time");
  // timeCmd->SetUnitCandidates("ns ms s");
  
  polCmd = new G4UIcmdWith3Vector("/gun/polarization",this);
  polCmd->SetGuidance("Set polarization.");
  polCmd->SetParameterName("Px","Py","Pz",true,true); 
  polCmd->SetRange("Px>=-1.&&Px<=1.&&Py>=-1.&&Py<=1.&&Pz>=-1.&&Pz<=1.");
 
  numberCmd = new G4UIcmdWithAnInteger("/gun/number",this);
  numberCmd->SetGuidance("Set number of particles to be generated.");
  numberCmd->SetParameterName("N",true,true);
  numberCmd->SetRange("N>0");
 
  ionCmd = new G4UIcommand("/gun/ion",this);
  ionCmd->SetGuidance("Set properties of ion to be generated.");
  ionCmd->SetGuidance("[usage] /gun/ion Z A [Q E flb]");
  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)");
  ionCmd->SetGuidance("        flb:(char) Floating level base");
  
  G4UIparameter* param;
  param = new G4UIparameter("Z",'i',false);
  ionCmd->SetParameter(param);
  param = new G4UIparameter("A",'i',false);
  ionCmd->SetParameter(param);
  param = new G4UIparameter("Q",'i',true);
  param->SetDefaultValue(-1);
  ionCmd->SetParameter(param);
  param = new G4UIparameter("E",'d',true);
  param->SetDefaultValue(0.0);
  ionCmd->SetParameter(param);
  param = new G4UIparameter("flb",'c',true);
  param->SetDefaultValue("noFloat");
  param->SetParameterCandidates("noFloat X Y Z U V W R S T A B C D E");
  ionCmd->SetParameter(param);
 
  ionLvlCmd = new G4UIcommand("/gun/ionL",this);
  ionLvlCmd->SetGuidance("THIS COMMAND IS DEPRECATED and will be removed in future releases.");
  ionLvlCmd->SetGuidance(" Use /gun/ion instead.");
  ionLvlCmd->SetGuidance(" Set properties of ion to be generated.");
  ionLvlCmd->SetGuidance(" [usage] /gun/ionL Z A [Q I]");
  ionLvlCmd->SetGuidance("        Z:(int) AtomicNumber");
  ionLvlCmd->SetGuidance("        A:(int) AtomicMass");
  ionLvlCmd->SetGuidance("        Q:(int) Charge of Ion (in unit of e)");
  ionLvlCmd->SetGuidance("        I:(int) Level number of metastable state (0 = ground)");
 
  G4UIparameter* paraml;
  paraml = new G4UIparameter("Z",'i',false);
  ionLvlCmd->SetParameter(paraml);
  paraml = new G4UIparameter("A",'i',false);
  ionLvlCmd->SetParameter(paraml);
  paraml = new G4UIparameter("Q",'i',true);
  paraml->SetDefaultValue(-1);
  ionLvlCmd->SetParameter(paraml);
  paraml = new G4UIparameter("I",'i',true);
  paraml->SetDefaultValue("0");
  ionLvlCmd->SetParameter(paraml);
 
  // Set initial value to G4ParticleGun
  //
  fParticleGun->SetParticleDefinition( G4Geantino::Geantino() );
  fParticleGun->SetParticleMomentumDirection( G4ThreeVector(1.0,0.0,0.0) );
  fParticleGun->SetParticleEnergy( 1.0*GeV );
  fParticleGun->SetParticlePosition(G4ThreeVector(0.0*cm, 0.0*cm, 0.0*cm));
  fParticleGun->SetParticleTime( 0.0*ns );
}

~G4ParticleGunMessenger()

G4ParticleGunMessenger::~G4ParticleGunMessenger

(

)

Definition at line 189 of file G4ParticleGunMessenger.cc.

{
  delete listCmd;
  delete particleCmd;
  delete directionCmd;
  delete energyCmd;
  delete momCmd;
  delete momAmpCmd;
  delete positionCmd;
  delete timeCmd;
  delete polCmd;
  delete numberCmd;
  delete ionCmd;
  delete ionLvlCmd;
  delete gunDirectory;
}

Member Function Documentation

GetCurrentValue()

G4String G4ParticleGunMessenger::GetCurrentValue ( G4UIcommand *  command )

virtual

Reimplemented from G4UImessenger.

Definition at line 283 of file G4ParticleGunMessenger.cc.

{
  G4String cv;
  
  if( command==directionCmd )
  { cv = directionCmd->ConvertToString(fParticleGun->GetParticleMomentumDirection()); }
  else if( command==particleCmd )
  { cv = fParticleGun->GetParticleDefinition()->GetParticleName(); }
  else if( command==energyCmd )
  {
    G4double ene = fParticleGun->GetParticleEnergy();
    if(ene == 0.)
    { G4cerr << " G4ParticleGun:  was defined in terms of momentum." << G4endl; }
    else
    { cv = energyCmd->ConvertToString(ene,"GeV"); }
  }
  else if( command==momCmd || command==momAmpCmd )
  {
    G4double mom = fParticleGun->GetParticleMomentum();
    if(mom == 0.)
    {
      G4cerr << " G4ParticleGun:  was defined in terms of kinetic energy."
             << G4endl;
    }
    else
    {
      if( command==momCmd )
      { cv = momCmd->ConvertToString(mom*(fParticleGun->GetParticleMomentumDirection()),"GeV"); }
      else
      { cv = momAmpCmd->ConvertToString(mom,"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()); }
  else if( command==ionCmd )
  { 
    if (fShootIon)
    {
      cv = ItoS(fAtomicNumber) + " " + ItoS(fAtomicMass) + " ";
      cv += ItoS(fIonCharge);
    }
    else
    {
      cv = "";
    }  
  }    
  return cv;
}

SetNewValue()

void G4ParticleGunMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValues  )

virtual

Reimplemented from G4UImessenger.

Definition at line 206 of file G4ParticleGunMessenger.cc.

{
  G4ExceptionDescription ed;
  if (command==listCmd)
  {
    particleTable->DumpTable();
  }
  else if (command==particleCmd)
  {
    if (newValues =="ion")
    {
      fShootIon = true;
    }
    else
    {
      fShootIon = false;
      G4ParticleDefinition* pd = particleTable->FindParticle(newValues);
      if(pd != nullptr)
      {
        fParticleGun->SetParticleDefinition( pd );
      }
      else
      {
        ed << "Particle [" << newValues << "] is not found.";
        command->CommandFailed(ed);
      }
    }
 
  } else if( command==directionCmd )
  { fParticleGun->SetParticleMomentumDirection(directionCmd->GetNew3VectorValue(newValues)); }
  else if( command==energyCmd )
  { fParticleGun->SetParticleEnergy(energyCmd->GetNewDoubleValue(newValues)); }
  else if( command==momCmd )
  { fParticleGun->SetParticleMomentum(momCmd->GetNew3VectorValue(newValues)); }
  else if( command==momAmpCmd )
  { fParticleGun->SetParticleMomentum(momAmpCmd->GetNewDoubleValue(newValues)); }
  else if( command==positionCmd )
  { fParticleGun->SetParticlePosition(positionCmd->GetNew3VectorValue(newValues)); }
  else if( command==timeCmd )
  { fParticleGun->SetParticleTime(timeCmd->GetNewDoubleValue(newValues)); }
  else if( command==polCmd )
  { fParticleGun->SetParticlePolarization(polCmd->GetNew3VectorValue(newValues)); }
  else if( command==numberCmd )
  { fParticleGun->SetNumberOfParticles(numberCmd->GetNewIntValue(newValues)); }
  else if( command==ionCmd ) 
  {
    if (fShootIon)
    {
      IonCommand(newValues);
    }
    else
    {
      ed << "Set /gun/particle to ion before using /gun/ion command";
      command->CommandFailed(ed);
    }
  }
  else if( command==ionLvlCmd ) 
  {
    G4ExceptionDescription depWarn; 
    depWarn << "\nCommand /gun/ionL is deprecated and will be removed in future releases.\n"
            << "Use /gun/ion instead.\n";
    G4Exception("G4ParticleGunMessenger::SetNewValue", "IonLWarn",
                JustWarning, depWarn);
 
    if (fShootIon)
    {
      IonLevelCommand(newValues);
    }
    else
    {
      ed << "Set /gun/particle to ion before using /gun/ion command";
      command->CommandFailed(ed);
    }
  }
}

---

The documentation for this class was generated from the following files:

• G4ParticleGunMessenger.hh
• G4ParticleGunMessenger.cc