ParticleGun Class Reference

Class to generate tracks in the particle gun and store them in a MCParticle graph. More...

#include <ParticleGun.h>

Collaboration diagram for ParticleGun:

Classes
struct	Parameters
	Struct to keep all necessary parameters for the particle gun. More...

Public Types
enum	EDistribution {   c_fixedValue,   c_uniformDistribution,   c_uniformPtDistribution,   c_uniformCosDistribution,   c_uniformLogDistribution,   c_uniformLogPtDistribution,   c_normalDistribution,   c_normalPtDistribution,   c_normalCosDistribution,   c_discreteSpectrum,   c_discretePtSpectrum,   c_inversePtDistribution,   c_polylineDistribution,   c_polylinePtDistribution,   c_polylineCosDistribution }
	enum containing all known distributions available for generation of values More...

Public Member Functions
	ParticleGun ()
	Default constructor.
	~ParticleGun ()
	Default destructor.
bool	generateEvent (MCParticleGraph &graph)
	Generate the next event and store the result in the given MCParticle graph. More...
bool	setParameters (const Parameters &parameters)
	Set the parameters for generating the Particles.

Protected Member Functions
double	generateValue (EDistribution dist, const std::vector< double > &params)
	Generate a value according to the given distribution with the given parameters.

Protected Attributes
Parameters	m_params
	All relevant parameters.

Detailed Description

Class to generate tracks in the particle gun and store them in a MCParticle graph.

The class supports multiple tracks per event, different PDGcodes and the range for track momenta, track angle and track origin is configurable.

Definition at line 36 of file ParticleGun.h.

Member Enumeration Documentation

EDistribution

enum EDistribution

enum containing all known distributions available for generation of values

Enumerator
c_fixedValue	Fixed value, no random generation at all, 1 parameter.
c_uniformDistribution	Uniform distribution, parameters are min and max value.
c_uniformPtDistribution	Uniform distribution of Pt, parameters are min and max value.
c_uniformCosDistribution	Uniform distribution of the cosine of the values, parameters are min and max value.
c_uniformLogDistribution	Uniform distribution of the logarithm of the values, parameters are min and max value.
c_uniformLogPtDistribution	Uniform distribution of the logarithm of the Pt, parameters are min and max value.
c_normalDistribution	Normal distribution, parameters are mean and sigma.
c_normalPtDistribution	Normal distribution of Pt, parameters are mean and sigma.
c_normalCosDistribution	Normal distribution of the cosinge, parameters are mean and sigma.
c_discreteSpectrum	Discrete spectrum, parameters are first the values and then the weights (non-negative) for each value.
c_discretePtSpectrum	Discrete pt spectrum, parameters are first the values and then the weights (non-negative) for each value.
c_inversePtDistribution	Distribution uniform in the inverse pt distribution, that is uniform in track curvature.
c_polylineDistribution	Distribution given as list of (x,y) points. The Distribution will follow the line connection all points. Parameters are first the x coordinates (sorted) and then the y coordinates (non-negative)
c_polylinePtDistribution	Same as polylineDistribution but for the transverse momentum.
c_polylineCosDistribution	Same as polylineDistribution but for the cosine of the angle.

Definition at line 39 of file ParticleGun.h.

                      {
      EDistribution momentumDist = c_fixedValue;
      EDistribution phiDist = c_fixedValue;

Member Function Documentation

generateEvent()

bool generateEvent

(

MCParticleGraph &

graph

)

Generate the next event and store the result in the given MCParticle graph.

Returns

true if the event was generated.

Definition at line 121 of file ParticleGun.cc.

{
  //generate the event vertex (possible the same for all particles in event)
  double vx = generateValue(m_params.xVertexDist, m_params.xVertexParams);
  double vy = generateValue(m_params.yVertexDist, m_params.yVertexParams);
  double vz = generateValue(m_params.zVertexDist, m_params.zVertexParams);
 
  // Time offset
  double timeOffset = generateValue(m_params.timeDist, m_params.timeParams);
 
  //Determine number of tracks
  int nTracks = static_cast<int>(m_params.nTracks);
  if (m_params.nTracks <= 0) {
    nTracks = m_params.pdgCodes.size();
  } else if (m_params.varyNumberOfTracks) {
    nTracks = gRandom->Poisson(m_params.nTracks);
  }
 
  //Make list of particles
  double firstMomentum;
  for (int i = 0; i < nTracks; ++i) {
    MCParticleGraph::GraphParticle& p = graph.addParticle();
    p.setStatus(MCParticle::c_PrimaryParticle);
    if (m_params.pdgCodes.size() == 1) {
      //only one PDGcode available, always take this one
      p.setPDG(m_params.pdgCodes[0]);
    } else if (m_params.nTracks <= 0) {
      //0 or negative nTracks, take the ids sequentially
      p.setPDG(m_params.pdgCodes[i]);
    } else {
      //else choose randomly one of the available codes
      int index = static_cast<int>(gRandom->Uniform(m_params.pdgCodes.size()));
      p.setPDG(m_params.pdgCodes[index]);
    }
    p.setMassFromPDG();
    p.setFirstDaughter(0);
    p.setLastDaughter(0);
 
    //lets generate the momentum vector:
    double momentum = generateValue(m_params.momentumDist, m_params.momentumParams);
    // if the fixed momentum option enabled, either store the generated momentum for the first
    // particle or reuse for all others
    if (m_params.fixedMomentumPerEvent) {
      i == 0 ? firstMomentum = momentum : momentum = firstMomentum;
    }
    double phi      = generateValue(m_params.phiDist, m_params.phiParams);
    double theta    = generateValue(m_params.thetaDist, m_params.thetaParams);
 
    double pt = momentum * sin(theta);
    if (m_params.momentumDist == c_uniformPtDistribution || m_params.momentumDist == c_normalPtDistribution ||
        m_params.momentumDist == c_inversePtDistribution || m_params.momentumDist == c_polylinePtDistribution ||
        m_params.momentumDist == c_uniformLogPtDistribution || m_params.momentumDist == c_discretePtSpectrum) {
      //this means we are actually generating the Pt and not the P, so exchange values
      pt = momentum;
      momentum = (sin(theta) > 0) ? (pt / sin(theta)) : numeric_limits<double>::max();
    }
 
    double pz = momentum * cos(theta);
    double px = pt * cos(phi);
    double py = pt * sin(phi);
    double m  = p.getMass();
    double e  = sqrt(momentum * momentum + m * m);
 
    p.setMomentum(px, py, pz);
    p.setEnergy(e);
    p.setProductionVertex(vx, vy, vz);
    p.addStatus(MCParticle::c_StableInGenerator);
    //Particle is stable in generator. We could use MCParticleGraph options to
    //do this automatically but setting it here makes the particle correct
    //independent of the options
    p.setDecayTime(numeric_limits<double>::infinity());
 
    // set time offset to check fit bias in e.g. the ECL waveform fits
    p.setProductionTime(timeOffset);
 
    if (m_params.independentVertices) {
      //If we have independent vertices, generate new vertex for next particle
      vx = generateValue(m_params.xVertexDist, m_params.xVertexParams);
      vy = generateValue(m_params.yVertexDist, m_params.yVertexParams);
      vz = generateValue(m_params.zVertexDist, m_params.zVertexParams);
    }
  }// end loop over particles in event
 
  return true;
}

---

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

• generators/particlegun/include/ParticleGun.h
• generators/particlegun/src/ParticleGun.cc