GGSGunGeneratorAction Class Reference

A single-particle generator. More...

#include <GGSGunGeneratorAction.h>

Inheritance diagram for GGSGunGeneratorAction:

Collaboration diagram for GGSGunGeneratorAction:

Public Member Functions
	GGSGunGeneratorAction ()
	Constructor.
	~GGSGunGeneratorAction ()
	Destructor.
void	GeneratePrimaries (G4Event *)
	GeneratePrimaries. More...
void	SetAcceptanceFlag (G4bool val)
	Set the acceptance control. More...
void	SetRndmMinEnergyFlag (G4bool val)
	Sets the min energy flag. More...
void	SetRndmMaxEnergyFlag (G4bool val)
	Sets the max energy flag. More...
void	SetSpectralIndexFlag (G4bool val)
	Sets the spectral index geeration. More...
void	SetEnergy (G4double val)
	Sets the particle's kinetic energy. More...
void	SetMinEnergy (G4double val)
	Sets the particle's min kinetic energy. More...
void	SetMaxEnergy (G4double val)
	Sets the particle's max kinetic energy. More...
void	SetSpectralIndex (G4double val)
	Sets the spectral index. More...
void	SetPosition (const G4ThreeVector &val)
	Sets the particle's generation position. More...
void	SetMinPosition (const G4ThreeVector &val)
	Sets the particle's minimum generation position. More...
void	SetMaxPosition (const G4ThreeVector &val)
	Sets the particle's maximum generation position. More...
void	SetSphereCenter (const G4ThreeVector &val)
	Sets the center of the spherical surface. More...
void	SetSphereCapPosition (const G4ThreeVector &val)
	Sets the position of the spherical cap on the sphere. More...
void	SetSphereCapExtension (G4double val)
	Sets the extension of the spherical cap. More...
void	SetTheta (G4double val)
	Sets the value for theta. More...
void	SetMinTheta (G4double val)
	Sets the minimum random value for theta. More...
void	SetMaxTheta (G4double val)
	Sets the maximum random value for theta. More...
void	SetPhi (G4double val)
	Sets the value for phi. More...
void	SetMinPhi (G4double val)
	Sets the minimum value for phi. More...
void	SetMaxPhi (G4double val)
	Sets the maximum value for phi. More...
void	SetGunParticle (const G4String &particle)
	Sets the particle to be used by G4ParticleGun. More...
Public Member Functions inherited from GGSGeneratorAction
	GGSGeneratorAction ()
	Constructor.
	~GGSGeneratorAction ()
	Destructor.
unsigned int	GetNDiscarded () const
	Returns the number of discarded events for the current event generation. More...

Additional Inherited Members
Protected Attributes inherited from GGSGeneratorAction
unsigned long int	_nDiscarded

Detailed Description

A single-particle generator.

This is a wrapper for the G4ParticleGun generator, with some custom features.

Definition at line 26 of file GGSGunGeneratorAction.h.

Member Function Documentation

void GGSGunGeneratorAction::GeneratePrimaries

(

G4Event *

anEvent

)

GeneratePrimaries.

This class defines the parameters of the projectile primary particles It is called at the beginning of each event.

Definition at line 227 of file GGSGunGeneratorAction.cpp.

                                                              {

  static const std::string routineName("GGSGunGeneratorAction::GeneratePrimaries");
  static const G4ThreeVector xDirection(1, 0, 0);
  static const G4ThreeVector yDirection(0, 1, 0);

  _nDiscarded = 0;

  // Initialize shooting parameters with default values
  G4ThreeVector position(_position);
  G4ThreeVector direction(_direction);
  G4double energy(_energy);

  bool acceptanceCheck = true;
  do { // Acceptance check loop

    // ++++++++++++++ Randomize direction ++++++++++++++
    // The random direction computed here is always referred to the shooting frame.
    // Since the shooting frame may depend on shooting point (eg., shooting
    // from a sphere) the transformation from shooting frame to absolute
    // frame is done after random position have been chosen.
    if (_rndmDirFlag) {
      G4double cosPhi(_cosPhi);
      G4double sinPhi(_sinPhi);
      if (_rndmMinPhiFlag && _rndmMaxPhiFlag) {
        double phi = CLHEP::RandFlat::shoot(_minPhi, _maxPhi); // (0,2pi) or (-2pi,2pi) if shooting along -Z or -X
        cosPhi = cos(phi);
        sinPhi = sin(phi);
      }

      G4double sinTheta(_sinTheta);
      G4double cosTheta(_cosTheta);
      if (_rndmMinThetaFlag && _rndmMaxThetaFlag) {
        if (_rndmFromFlat || _rndmFromSphere) {
          // To generate an isotropic flux from a flat surface, the random angle must be uniform in cos^2 theta
          float cos2Theta = CLHEP::RandFlat::shoot(_minCos2ThetaRand, _maxCos2ThetaRand);
          cosTheta = sqrt(cos2Theta);
          sinTheta = sqrt(1 - cos2Theta);
        }
        else {
          // This will sample a uniform theta distribution on the sphere. This formula comes from the inverse CDF
          // method. See eg. http://en.wikibooks.org/wiki/Mathematica/Uniform_Spherical_Distribution
          // The form reported here is slightly different but equivalent (it can be easily seen using the
          // identity (sin x/2)^2 = (1 - cos x)/2 ).
          cosTheta = 1 - 2 * CLHEP::RandFlat::shoot(_minThetaRand, _maxThetaRand);
          sinTheta = sqrt(1 - cosTheta * cosTheta);
        }

      }

      // Compute position std::vector and direction versor (Z is shoot axis in the shooting frame)
      direction[0] = -sinTheta * cosPhi;              // momentum direction (unitary vectors)
      direction[1] = -sinTheta * sinPhi;
      direction[2] = -cosTheta;
    }

    // ++++++++++++++ Randomize position ++++++++++++++
    if (_rndmPosFlag) {
      if (_rndmMinPositionFlag && _rndmMaxPositionFlag) {
        // This works for all "flat" domains (point, line, plane, parallelepiped)
        position[0] = CLHEP::RandFlat::shoot(_minPosition(0), _maxPosition(0));
        position[1] = CLHEP::RandFlat::shoot(_minPosition(1), _maxPosition(1));
        position[2] = CLHEP::RandFlat::shoot(_minPosition(2), _maxPosition(2));
        if (_rndmFromFlat) { // Transform shoot direction to absolute reference frame
          // Transform direction if shoot axis is not the Z axis.
          // 3rd coordinate is relative to shooting axis so it is x when shooting along X,
          // so the coordinate transformation to go to absolute reference frame is:
          // (y, z, x) -> (x, y, z) when shooting along X
          // (z, x, y) -> (x, y, z) when shooting along X
          if (_shootAxis == xDirection) {
            double buf = direction[0];
            direction[0] = direction[2];
            direction[2] = direction[1];
            direction[1] = buf;
          }
          else if (_shootAxis == yDirection) {
            double buf = direction[0];
            direction[0] = direction[1];
            direction[1] = direction[2];
            direction[2] = buf;
          }
        }
      }
      else if (_rndmFromSphere) {
        // Randomize position on the spherical cap (in the reference frame of the generation sphere).
        // Gamma and delta are the polar and azimuth angle of the position vector w.r.t. the
        // sphere center.
        float cosGamma = 1 - 2 * CLHEP::RandFlat::shoot(0., _rndmSphereCapExtRand);
        float delta = CLHEP::RandFlat::shoot(0., 2 * CLHEP::pi);
        float sinGamma = sqrt(1 - cosGamma * cosGamma);
        float sinDelta = sin(delta);
        float cosDelta = cos(delta);

        // Position vector in cap frame
        position[0] = _rndmSphereRadius * sinGamma * cosDelta;
        position[1] = _rndmSphereRadius * sinGamma * sinDelta;
        position[2] = _rndmSphereRadius * cosGamma;

        // Position vector in absolute (world) frame
        position *= _rndmSphereCapRotMat;
        position += _rndmSphereCenter;

        // Direction vector in absolute (world) frame
        // At this point, the direction vector is built so that the distribution of its polar angle with
        // respect to the normal incidence is flat in cos^2 (isotropic flux). The vector coordinates have
        // been constructed in the reference frame of the generation point on the sphere, so they must be
        // rotated to the reference frame of the cap center and then to the world reference frame, in this
        // order.
        direction *= _ComputeRotMatrix(cosGamma, sinGamma, cosDelta, sinDelta); // Direction
        direction *= _rndmSphereCapRotMat;
      }
    }

    // ++++++++++++++ Check acceptance ++++++++++++++
    if (_acceptanceFlag && (_rndmPosFlag || _rndmDirFlag)) {
      GGSDetectorConstruction *detConst =
          (GGSDetectorConstruction*) (GGSRunManager::GetRunManager()->GetUserDetectorConstruction());
      acceptanceCheck = detConst->GetGeometry()->IsInsideAcceptance(position, direction);
      if (!acceptanceCheck)
        _nDiscarded++;
    }

  } while (!acceptanceCheck);

  // ++++++++++++++ Randomize energy ++++++++++++++
  if (_rndmMinEnergyFlag && _rndmMaxEnergyFlag) {
    if (_spectralIndexFlag) {
      energy = _GenSpectrumPowerLaw(_minEnergy, _maxEnergy, _spectralIndex);
    }
    else {
      energy = CLHEP::RandFlat::shoot(_minEnergy, _maxEnergy);
    }
  }

  COUT(DEEPDEB) << "Generated primary:" << ENDL;
  CCOUT(DEEPDEB) << "  PDG code: " << _gunGenerator->GetParticleDefinition()->GetPDGEncoding() << ENDL;
  CCOUT(DEEPDEB) << "  position: " << position << ENDL;
  CCOUT(DEEPDEB) << "  direction: " << direction << ENDL;
  CCOUT(DEEPDEB) << "  energy: " << energy << ENDL;

  //
  // Set values for primary particle and shoot
  //
  _gunGenerator->SetParticlePosition(position);
  _gunGenerator->SetParticleMomentumDirection(direction);
  _gunGenerator->SetParticleEnergy(energy);

  // Shoot
  _gunGenerator->GeneratePrimaryVertex(anEvent);
}

void GGSGunGeneratorAction::SetAcceptanceFlag ( G4bool  val )

inline

Set the acceptance control.

Acceptance must defined by the implementation of GGSVGeometryConstruction::IsInsideAcceptance in the current geometry. Events discarded by the acceptance check can be retrieved by means of the GetNDiscarded method defined in the mother class.

Parameters

val	If true, acceptance check will be performed for random events.

See Also

GGSGeneratorAction::GetNDiscarded

Definition at line 52 of file GGSGunGeneratorAction.h.

                                     {
    _acceptanceFlag = val;
  }

void GGSGunGeneratorAction::SetEnergy ( G4double  val )

inline

Sets the particle's kinetic energy.

This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The particle's energy.

Definition at line 102 of file GGSGunGeneratorAction.h.

                               {
    _energy = val;
  }

void GGSGunGeneratorAction::SetGunParticle

(

const G4String &

particle

)

Sets the particle to be used by G4ParticleGun.

Parameters

particle

The particle to shoot. A std::string value like "e+" or "proton".

Definition at line 63 of file GGSGunGeneratorAction.cpp.

                                                                   {
  if (particle == "C12") {
    //G4ParticleTable* pTable = G4ParticleTable::GetParticleTable();
    G4ParticleDefinition* c12 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(6, 12, 0.);
    ((G4ParticleGun*) _gunGenerator)->SetParticleDefinition(c12);
    ((G4ParticleGun*) _gunGenerator)->SetParticleCharge(6 * eplus);
  }
  else if (particle == "Fe56") {
    //G4ParticleTable* pTable = G4ParticleTable::GetParticleTable();
    G4ParticleDefinition* fe56 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(26, 56, 0.);
    ((G4ParticleGun*) _gunGenerator)->SetParticleDefinition(fe56);
    ((G4ParticleGun*) _gunGenerator)->SetParticleCharge(26 * eplus);
  }
  else
    G4UImanager::GetUIpointer()->ApplyCommand(G4String("/gun/particle ").append(particle));
}

void GGSGunGeneratorAction::SetMaxEnergy ( G4double  val )

inline

Sets the particle's max kinetic energy.

Sets the maximum value of randomized energy spectrum. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The particle's max energy.

Definition at line 126 of file GGSGunGeneratorAction.h.

                                  {
    _maxEnergy = val;
  }

void GGSGunGeneratorAction::SetMaxPhi ( G4double  val )

inline

Sets the maximum value for phi.

For isotropic generation, this sets the maximum random value for phi. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The maximum random value for phi.

Definition at line 327 of file GGSGunGeneratorAction.h.

                               {
    _maxPhi = val;
    _rndmMaxPhiFlag = true;
    _SetRndmDirFlag();
  }

void GGSGunGeneratorAction::SetMaxPosition ( const G4ThreeVector &  val )

inline

Sets the particle's maximum generation position.

Random position generation is done inside a volume defined by specifying the "minimum" and "maximum" coordinates vectors. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The particle's max position.

Definition at line 183 of file GGSGunGeneratorAction.h.

                                                {
    _maxPosition = val;
    _rndmMaxPositionFlag = true;
    _SetRndmPosFlag();
    _SetRndmFromSurface(1);
  }

void GGSGunGeneratorAction::SetMaxTheta ( G4double  val )

inline

Sets the maximum random value for theta.

For isotropic generation, this sets the maximum random value for theta. From the theta value passed as parameter it computes and store the lower limit of the uniform distribution from which a random number will be extracted and subsequently transformed into theta by means of an inverse CDF technique.

Parameters

val	The maximum random value for theta.

Definition at line 280 of file GGSGunGeneratorAction.h.

                                 {
    _maxThetaRand = (1. - cos(val)) / 2.;
    _minCos2ThetaRand = cos(val);
    _minCos2ThetaRand *= _minCos2ThetaRand;
    _rndmMaxThetaFlag = true;
    _SetRndmDirFlag();
  }

void GGSGunGeneratorAction::SetMinEnergy ( G4double  val )

inline

Sets the particle's min kinetic energy.

Sets the minimum value of randomized energy spectrum. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The particle's min energy.

Definition at line 114 of file GGSGunGeneratorAction.h.

                                  {
    _minEnergy = val;
  }

void GGSGunGeneratorAction::SetMinPhi ( G4double  val )

inline

Sets the minimum value for phi.

For isotropic generation, this sets the minimum random value for phi. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The minimum random value for phi.

Definition at line 313 of file GGSGunGeneratorAction.h.

                               {
    _minPhi = val;
    _rndmMinPhiFlag = true;
    _SetRndmDirFlag();
  }

void GGSGunGeneratorAction::SetMinPosition ( const G4ThreeVector &  val )

inline

Sets the particle's minimum generation position.

Random position generation is done inside a volume defined by specifying the "minimum" and "maximum" coordinates vectors. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The particle's min position.

Definition at line 167 of file GGSGunGeneratorAction.h.

                                                {
    _minPosition = val;
    _rndmMinPositionFlag = true;
    _SetRndmPosFlag();
    _SetRndmFromSurface(1);
  }

void GGSGunGeneratorAction::SetMinTheta ( G4double  val )

inline

Sets the minimum random value for theta.

For isotropic generation, this sets the minimum random value for theta. From the theta value passed as parameter it computes and store the lower limit of the uniform distribution from which a random number will be extracted and subsequently transformed into theta by means of an inverse CDF technique. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The minimum random value for theta.

Definition at line 264 of file GGSGunGeneratorAction.h.

                                 {
    _minThetaRand = (1. - cos(val)) / 2.;
    _maxCos2ThetaRand = cos(val);
    _maxCos2ThetaRand *= _maxCos2ThetaRand;
    _rndmMinThetaFlag = true;
    _SetRndmDirFlag();
  }

void GGSGunGeneratorAction::SetPhi ( G4double  val )

inline

Sets the value for phi.

Phi is the azimuth angle, defined as zero for particles traveling along the X axis towards negative direction. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The value for phi.

Definition at line 297 of file GGSGunGeneratorAction.h.

                            {
    _sinPhi = sin(val);
    _cosPhi = cos(val);
    _rndmMinPhiFlag = _rndmMaxPhiFlag = false;
    _SetRndmDirFlag();
    _SetShootingDir();
  }

void GGSGunGeneratorAction::SetPosition ( const G4ThreeVector &  val )

inline

Sets the particle's generation position.

This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The particle's position.

Definition at line 150 of file GGSGunGeneratorAction.h.

                                             {
    _position = val;
    // Reset random position generation
    _rndmMinPositionFlag = _rndmMaxPositionFlag = false;
    _SetRndmPosFlag();
    _SetRndmFromSurface(0);
  }

void GGSGunGeneratorAction::SetRndmMaxEnergyFlag ( G4bool  val )

inline

Sets the max energy flag.

If both min energy and max energy flags are set to true, energy will be randomized. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The flag value.

Definition at line 78 of file GGSGunGeneratorAction.h.

                                        {
    _rndmMaxEnergyFlag = val;
  }

void GGSGunGeneratorAction::SetRndmMinEnergyFlag ( G4bool  val )

inline

Sets the min energy flag.

If both min energy and max energy flags are set to true, energy will be randomized. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The flag value.

Definition at line 65 of file GGSGunGeneratorAction.h.

                                        {
    _rndmMinEnergyFlag = val;
  }

void GGSGunGeneratorAction::SetSpectralIndex ( G4double  val )

inline

Sets the spectral index.

If spectral index flag is set, this method specifies the value of the index to generate a power law spectrum. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The spectral index value.

Definition at line 139 of file GGSGunGeneratorAction.h.

                                      {
    _spectralIndex = val;
  }

void GGSGunGeneratorAction::SetSpectralIndexFlag ( G4bool  val )

inline

Sets the spectral index geeration.

If set to true, the eventually randomized energies will be extracted to generate a power law spectrum. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The flag value.

Definition at line 91 of file GGSGunGeneratorAction.h.

                                        {
    _spectralIndexFlag = val;
  }

void GGSGunGeneratorAction::SetSphereCapExtension ( G4double  val )

inline

Sets the extension of the spherical cap.

The angular width of the spherical cap is set by this method. By "angular width" we mean the angle between the cap position std::vector (set by SetSphereCapPosition) and the position std::vector of a point on the cap's border (both the vectors are relative to the sphere center).

Parameters

val	The angular extension of the spherical cap.

Definition at line 231 of file GGSGunGeneratorAction.h.

                                           {
    _rndmSphereCapExtRand = (1. - cos(val)) / 2.;
    _SetRndmFromSurface(2);
  }

void GGSGunGeneratorAction::SetSphereCapPosition ( const G4ThreeVector &  val )

inline

Sets the position of the spherical cap on the sphere.

The position of the spherical cap from which the particles will be randomly generated can be set by means of this method. The position std::vector is relative to the sphere center and not to the absolute frame. The width of the cap can be set using SetSphereCapExtension. The modulus of the specified position std::vector of the spherical cap will be used as the sphere radius.

Parameters

val

Definition at line 215 of file GGSGunGeneratorAction.h.

                                                      {
    _rndmSphereRadius = val.mag();
    _rndmSphereCapAlpha = acos(val[2] / _rndmSphereRadius);
    _rndmSphereCapBeta = atan2(val[1], val[0]);
    _SetRndmFromSurface(2);
  }

void GGSGunGeneratorAction::SetSphereCenter ( const G4ThreeVector &  val )

inline

Sets the center of the spherical surface.

This method sets the center of the sphere from which particles will be randomly generated. Actually, the generation is not done on the whole sphere but on a cap.

See Also

SetSphereCapPosition

Parameters

val	The center of the sphere.

Definition at line 199 of file GGSGunGeneratorAction.h.

                                                 {
    _rndmSphereCenter = val;
    _SetRndmFromSurface(2);
  }

void GGSGunGeneratorAction::SetTheta ( G4double  val )

inline

Sets the value for theta.

Theta is the altitude angle, defined as zero for particles traveling along the Z axis towards negative direction. This function is called by the messenger. Has effect only on gun generator.

Parameters

val	The value for theta.

Definition at line 245 of file GGSGunGeneratorAction.h.

                              {
    _sinTheta = sin(val);
    _cosTheta = cos(val);
    _rndmMinThetaFlag = _rndmMaxThetaFlag = false;
    _SetRndmDirFlag();
    _SetShootingDir();

  }

---

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

• GGSGunGeneratorAction.h
• GGSGunGeneratorAction.cpp