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...
GGSParameters	GetParameters () const
	Gets the generation parameters. 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 208 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 *= _ChangeOfBasisMatrix(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);
}

GGSParameters GGSGunGeneratorAction::GetParameters ( ) const

virtual

Gets the generation parameters.

The parameters exported by the GGSGunGeneratorAction are:

General

Name	Type	Description	Exported
generator	string	The name of the generator "gun"	Always
acceptanceCheck	bool	Flag for acceptance check	Always
particlePdgCode	int	the PDG code of the generated particle	Always

Generation position

Name	Type	Description	Exported
genPosition	string	Generation position: "point", "plane", "box", "sphere"	Always
minPosition	vector<double>	Coordinates of the minimum generation point [cm]	When genPosition is "plane" or "box"
maxPosition	vector<double>	Coordinates of the maximum generation point [cm]	When genPosition is "plane" or "box"
sphereCenter	vector<double>	Center of the generation sphere cap [cm]	When genPosition is "sphere"
sphereCapPosition	vector<double>	Position of the sphere cap w.r.t. the sphere center [cm]	When genPosition is "sphere"
sphereCapExtension	double	Angular extension of the sphere [rad]	When genPosition is "sphere"
position	vector<double>	Coordinates of the generation point [cm]	When genPosition is "point"

Generation direction

Name	Type	Description	Exported
genDirection	string	Generation direction: "fixed", "uniform", "isotropic"	Always
minPhi	double	Minimum azimuth angle [rad]	When genDirection is "uniform" or "isotropic"
maxPhi	double	Maximum azimuth angle [rad]	When genDirection is "uniform" or "isotropic"
minTheta	double	Minimum polar angle [rad]	When genDirection is "uniform" or "isotropic"
maxTheta	double	Maximum polar angle [rad]	When genDirection is "uniform" or "isotropic"
phi	double	Azimuth angle [rad]	When minPhi and maxPhi are not exported
theta	double	Polar angle [rad]	When minTheta and maxTheta are not exported

Notes: for generations from surfaces (i.e. genPosition == "point" or genPosition == "sphere") the polar and azimuth angles are always referred to the normal direction to the surface in the generation point.

Generation energy

Name	Type	Description	Exported
genSpectrum	string	Generation spectrum: "monochromatic", "flat", "powerLaw"	Always
minEnergy	double	Minimum kinetic energy [GeV]	When genSpectrum is "flat" or "powerLaw"
maxEnergy	double	Maximum kinetic energy [GeV]	When genSpectrum is "flat" or "powerLaw"
spectralIndex	double	Spectral index	When genSpectrum is "powerLaw"
energy	double	Kinetic energy [GeV]	When genSpectrum is "monochromatic"

Returns

The generation parameters object;

Reimplemented from GGSGeneratorAction.

Definition at line 354 of file GGSGunGeneratorAction.cpp.

                                                         {
  GGSParameters params;
  params.SetParam("generator", std::string("gun"));

  params.SetParam("acceptanceCheck", _acceptanceFlag);

  // Particle
  params.SetParam("particlePdgCode", _gunGenerator->GetParticleDefinition()->GetPDGEncoding());

  // Position
  if (_rndmPosFlag) {
    if (_rndmMinPositionFlag && _rndmMaxPositionFlag) {
      params.SetParam("minPosition", std::vector<double>{_minPosition[0] / CLHEP::cm, _minPosition[1] / CLHEP::cm,
                                                         _minPosition[2] / CLHEP::cm});
      params.SetParam("maxPosition", std::vector<double>{_maxPosition[0] / CLHEP::cm, _maxPosition[1] / CLHEP::cm,
                                                         _maxPosition[2] / CLHEP::cm});
      if (_rndmFromFlat) {
        params.SetParam("genPosition", std::string("plane"));
      } else {
        params.SetParam("genPosition", std::string("box"));
      }
    } else if (_rndmFromSphere) {
      params.SetParam("genPosition", std::string("sphere"));
      params.SetParam("sphereCenter",
                      std::vector<double>{_rndmSphereCenter[0] / CLHEP::cm, _rndmSphereCenter[1] / CLHEP::cm,
                                          _rndmSphereCenter[2] / CLHEP::cm});
      params.SetParam("sphereCapPosition",
                      std::vector<double>{_rndmSphereCapPosition[0] / CLHEP::cm, _rndmSphereCapPosition[1] / CLHEP::cm,
                                          _rndmSphereCapPosition[2] / CLHEP::cm});
      params.SetParam("sphereCapExtension", acos(-2. * _rndmSphereCapExtRand + 1) / CLHEP::rad);
    }
  } else {
    params.SetParam("genPosition", std::string("point"));
    params.SetParam("position",
                    std::vector<double>{_position[0] / CLHEP::cm, _position[1] / CLHEP::cm, _position[2] / CLHEP::cm});
  }

  // Direction
  if (_rndmDirFlag) {
    bool isotropic = false;
    if (_rndmMinPhiFlag && _rndmMaxPhiFlag) {
      params.SetParam("minPhi", _minPhi / CLHEP::rad);
      params.SetParam("maxPhi", _maxPhi / CLHEP::rad);
    }
    if (_rndmMinThetaFlag && _rndmMaxThetaFlag) {
      params.SetParam("minTheta", acos(-2. * _minThetaRand + 1) / CLHEP::rad);
      params.SetParam("maxTheta", acos(-2. * _maxThetaRand + 1) / CLHEP::rad);
      if (_rndmFromFlat || _rndmFromSphere) {
        isotropic = true;
      }
    }
    if (isotropic) {
      params.SetParam("genDirection", std::string("isotropic"));
    } else {
      params.SetParam("genDirection", std::string("uniform"));
    }
  } else {
    params.SetParam("genDirection", std::string("fixed"));
    params.SetParam("theta", acos(_cosTheta) / CLHEP::rad);
    params.SetParam("phi", acos(_cosPhi) / CLHEP::rad);
  }

  // Energy
  if (_rndmMinEnergyFlag && _rndmMaxEnergyFlag) {
    params.SetParam("minEnergy", _minEnergy / CLHEP::GeV);
    params.SetParam("maxEnergy", _maxEnergy / CLHEP::GeV);
    if (_spectralIndexFlag) {
      params.SetParam("genSpectrum", std::string("powerLaw"));
      params.SetParam("spectralIndex", _spectralIndex);
    } else {
      params.SetParam("genSpectrum", std::string("flat"));
    }
  } else {
    params.SetParam("genSpectrum", std::string("monochromatic"));
    params.SetParam("energy", _energy / CLHEP::GeV);
  }

  return params;
}

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 51 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 93 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 62 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 113 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 310 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 166 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 263 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 103 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 296 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 150 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 247 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 280 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 133 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 73 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 62 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 124 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 84 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 215 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 198 of file GGSGunGeneratorAction.h.

                                                      {
    _rndmSphereCapPosition = val;
    _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 182 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 229 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