MuonGun C++ API Reference¶

class BasicSurfaceScalingFunction : public I3MuonGun::SurfaceScalingFunction ¶

#include <EnergyDependentSurfaceInjector.h>

Public Functions

BasicSurfaceScalingFunction()¶

virtual ~BasicSurfaceScalingFunction()¶

virtual SamplingSurfacePtr GetSurface(double energy) const override¶: Propose a target surface for the given energy.

virtual bool operator==(const SurfaceScalingFunction&) const override¶: Compare for equality.

void SetCapScaling(double energyScale, double scale, double offset, double power)¶

void SetSideScaling(double energyScale, double scale, double offset, double power)¶

void SetRadiusBounds(double rmin, double rmax)¶

void SetZBounds(double zmin, double zmax)¶

void SetCenterMin(double x, double y)¶

void SetCenterMax(double x, double y)¶

Private Types

typedef std::pair<double, double> pair¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

double GetMargin(double logenergy, double scale, double offset, double power) const¶

Private Members

pair scale_¶

pair energyScale_¶

pair offset_¶

pair power_¶

pair rBounds_¶

pair zBounds_¶

std::pair<pair, pair> centerBounds_¶

Friends

friend class icecube::serialization::access

class BMSSEnergyDistribution : public I3MuonGun::EnergyDistribution ¶

#include <EnergyDistribution.h>

Public Functions

BMSSEnergyDistribution()¶

virtual double GetLog(double depth, double cos_theta, unsigned multiplicity, double radius, log_value log_energy) const¶

virtual std::vector<std::pair<double, double>> Generate(I3RandomService &rng, double depth, double cos_theta, unsigned multiplicity, unsigned samples) const¶: Sample samples (radius, energy) pairs.

virtual double GetMaxRadius() const override¶

virtual bool operator==(const EnergyDistribution&) const override¶

OffsetPowerLaw GetSpectrum(double depth, double cos_theta, unsigned m, double r) const¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

double beta_¶

double g0_¶

double g1_¶

double e0a_¶

double e0b_¶

double e1a_¶

double e1b_¶

double a0_¶

double a1_¶

double b0a_¶

double b0b_¶

double b1a_¶

double b1b_¶

double q0_¶

double q1_¶

double c0a_¶

double c0b_¶

double c1_¶

double d0a_¶

double d0b_¶

double d1a_¶

double d1b_¶

Friends

friend class icecube::serialization::access

class BMSSFlux : public I3MuonGun::Flux ¶

#include <Flux.h>

Total flux according to Becherini et al.

Public Functions

BMSSFlux()¶

virtual double GetLog(double depth, double cos_theta, unsigned multiplicity) const¶

virtual bool operator==(const Flux&) const override¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

double k0a_¶

double k0b_¶

double k1a_¶

double k1b_¶

double v0a_¶

double v0b_¶

double v0c_¶

double v1a_¶

double v1b_¶

Friends

friend class icecube::serialization::access

class BMSSRadialDistribution : public I3MuonGun::RadialDistribution ¶

#include <RadialDistribution.h>

Radial distribution according to Becherini et al.

Public Functions

BMSSRadialDistribution()¶

virtual double GetLog(double depth, double cos_theta, unsigned multiplicity, double radius) const¶

Calculate the logarithm of the probability of obtaining the given radial offset.

See also

operator()

virtual double Generate(I3RandomService &rng, double depth, double cos_theta, unsigned multiplicity) const¶

Draw a sample from the distribution of radii.

Parameters:

rng – [in] a random number generator
depth – [in] vertical depth in km
cos_theta – [in] cosine of zenith angle
multiplicity – [in] number of muons in the bundle

Returns:

a radius in m

virtual bool operator==(const RadialDistribution&) const override¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

double GetMeanRadius(double, double, unsigned) const¶

double GetShapeParameter(double, double, unsigned) const¶

double GetGenerationProbability(double, double, double) const¶

Private Members

double rho0a_¶

double rho0b_¶

double rho1_¶

double theta0_¶

double f_¶

double alpha0a_¶

double alpha0b_¶

double alpha1a_¶

double alpha1b_¶

double rmax_¶

Friends

friend class icecube::serialization::access

struct BundleEntry¶

#include <Generator.h>

The radial offset and energy of each muon in a bundle

Public Functions

inline BundleEntry(double r = 0., double e = 0.)¶

inline bool operator<(const BundleEntry &other) const¶

inline bool operator==(const BundleEntry &other) const¶

Public Members

double radius¶

double energy¶

struct BundleModel¶

#include <WeightCalculator.h>

Convenience struct to hold the components of a muon bundle flux model.

Public Functions

inline BundleModel(FluxPtr f, RadialDistributionPtr r, EnergyDistributionPtr e)¶

Public Members

FluxPtr flux¶

RadialDistributionPtr radius¶

EnergyDistributionPtr energy¶

struct Checkpoint¶

#include <Track.h>

A point at which the absolute energy of the particle is known.

Public Functions

inline Checkpoint(double l, double e = 0., size_t o = 0)¶

Public Members

double length¶

double energy¶

ptrdiff_t offset¶

class CompactTrack¶

#include <CompactTrack.h>

A compressed representation of a muon in a bundle.

Public Functions

inline CompactTrack()¶

CompactTrack(const I3Particle &track)¶

inline void SetRadius(double r)¶

inline double GetRadius() const¶

inline void SetEnergy(double r)¶

inline double GetEnergy() const¶

inline void SetTime(double r)¶

inline double GetTime() const¶

inline void SetType(I3Particle::ParticleType t)¶

inline I3Particle::ParticleType GetType() const¶

bool operator==(const CompactTrack&) const¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

double radius_¶

double energy_¶

double time_¶

I3Particle::ParticleType type_¶

Friends

friend class icecube::serialization::access

class ConstantSurfaceScalingFunction : public I3MuonGun::SurfaceScalingFunction ¶

#include <EnergyDependentSurfaceInjector.h>

Public Functions

ConstantSurfaceScalingFunction(SamplingSurfacePtr surface)¶

virtual ~ConstantSurfaceScalingFunction()¶

virtual SamplingSurfacePtr GetSurface(double energy) const override¶: Propose a target surface for the given energy.

virtual bool operator==(const SurfaceScalingFunction&) const override¶: Compare for equality.

Private Functions

ConstantSurfaceScalingFunction()¶

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

SamplingSurfacePtr surface_¶

Friends

friend class icecube::serialization::access

class CORSIKAGenerationProbability : public I3MuonGun::GenerationProbability ¶

#include <CORSIKAGenerationProbability.h>

A parametrization of the muon yield from direct air-shower simulation.

Public Functions

CORSIKAGenerationProbability(SamplingSurfacePtr, FluxPtr, RadialDistributionPtr, EnergyDistributionPtr)¶

inline SamplingSurfaceConstPtr GetSurface() const¶

inline FluxConstPtr GetFlux() const¶

inline RadialDistributionConstPtr GetRadialDistribution() const¶

inline EnergyDistributionConstPtr GetEnergyDistribution() const¶

inline virtual SamplingSurfaceConstPtr GetInjectionSurface() const override¶

Get the injection surface this generation scheme uses.

If generation schemes are combined, the injection surfaces must be identical!

virtual GenerationProbabilityPtr Clone() const¶: Copy self into a shared pointer

virtual bool IsCompatible(GenerationProbabilityConstPtr) const override¶

Compare to another GenerationProbability.

Returns:: true if the argument is identical to *this to within a scale factor, false otherwise.

Protected Functions

virtual double GetLogGenerationProbability(const I3Particle &axis, const BundleConfiguration &bundle) const¶

Calculate the differential probability per event that the given configuration was generated.

For single muons, this is \( \log(dP/dE) [\log(1/GeV)]\), for bundles \( \log(d^2P/dEdr) [\log(1/GeV m)]\)

Parameters:

axis – [in] the bundle axis
bundle – [in] the radial offset and energy of each muon in the bundle

Private Members

SamplingSurfacePtr surface_¶

FluxPtr flux_¶

RadialDistributionPtr radialDistribution_¶

EnergyDistributionPtr energyDistribution_¶

struct cosine¶

#include <histogram.h>

Bin edges linear in \( \cos{\theta} \).

Public Static Functions

static inline double map(double v)¶

static inline double imap(double v)¶

class Crust¶

#include <MuonPropagator.h>

A set of nested media layers.

Public Functions

inline Crust(boost::shared_ptr<MuonPropagator> defaultPropagator)¶

void AddLayer(I3Surfaces::SurfacePtr, boost::shared_ptr<MuonPropagator>)¶: Add an inner layer

I3Particle Ingest(const I3Particle &p)¶: Propagate a muon to the outer boundary of the innermost layer

Private Members

boost::shared_ptr<MuonPropagator> defaultPropagator_¶

std::vector<I3Surfaces::SurfacePtr> boundaries_¶

std::vector<boost::shared_ptr<MuonPropagator>> propagators_¶

class Cylinder : public I3MuonGun::detail::UprightSurface<I3Surfaces::detail::CylinderBase<SamplingSurface>>¶

#include <Cylinder.h>

A cylinder aligned with the z axis.

Public Functions

inline Cylinder(double length, double radius, I3Position center = I3Position(0, 0, 0))¶

bool operator==(const SamplingSurface&) const¶

inline virtual double GetLength() const¶

Protected Functions

virtual double GetTopArea() const¶

virtual double GetSideArea() const¶

virtual std::pair<double, double> GetZRange() const¶

Private Types

typedef I3Surfaces::detail::CylinderBase<SamplingSurface> CylinderBase¶

typedef detail::UprightSurface<CylinderBase> Base¶

Private Functions

inline Cylinder()¶

template<typename Archive> void serialize(Archive&, unsigned)¶

Friends

friend class icecube::serialization::access

class EnergyDependentSurfaceInjector : public I3MuonGun::StaticSurfaceInjector ¶

#include <EnergyDependentSurfaceInjector.h>

A rejection-sampling Generator with energy-dependent sampling surface.

EnergyDependentSurfaceInjector samples bundle impact points, angles, multiplicities, and radial distributions at their natural frequencies, but scales the sampling surface based on the highest-energy muon in the bundle: dim, low-energy muons are targeted only at a small inner surface, while the surface scales up to full size for potentially bright muons. This technique can be used to efficiently simulate background for an event selection that requires a thick veto for dim events (where the rates are also highest) but becomes more accepting for bright events.

Public Functions

EnergyDependentSurfaceInjector(CylinderPtr surface = CylinderPtr(), FluxPtr flux = FluxPtr(), boost::shared_ptr<OffsetPowerLaw> energies = boost::shared_ptr<OffsetPowerLaw>(), RadialDistributionPtr radius = RadialDistributionPtr(), SurfaceScalingFunctionPtr scaling = boost::make_shared<BasicSurfaceScalingFunction>())¶

virtual double GetLogGenerationProbability(const I3Particle &axis, const BundleConfiguration &bundle) const override¶

Calculate the differential probability per event that the given configuration was generated.

For single muons, this is \( \log(dP/dE) [\log(1/GeV)]\), for bundles \( \log(d^2P/dEdr) [\log(1/GeV m)]\)

Parameters:

axis – [in] the bundle axis
bundle – [in] the radial offset and energy of each muon in the bundle

virtual GenerationProbabilityPtr Clone() const override¶: Copy self into a shared pointer

virtual bool IsCompatible(GenerationProbabilityConstPtr) const override¶

Compare to another GenerationProbability.

Returns:: true if the argument is identical to *this to within a scale factor, false otherwise.

virtual void Generate(I3RandomService &rng, I3MCTree &tree, BundleConfiguration &bundle) const¶

Generate a muon bundle.

Parameters:

rng – [in] A random number generator
tree – [out] An I3MCTree to fill the generated bundle in to. The bundle axis should be used as the primary, with its type set to I3Particle::unknown
bundle – [out] the radial offset and energy of each muon in the bundle

inline SurfaceScalingFunctionPtr GetScaling() const¶

inline void SetScaling(SurfaceScalingFunctionPtr &f)¶

SamplingSurfacePtr GetTargetSurface(double energy) const¶: Scale the sampling cylinder to a size appropriate for the given maximum muon energy by the given energy. This is not necessarily the fastest.

double GetTotalRate(SamplingSurfaceConstPtr surface) const¶: Integrate the flux to get the total rate on the surface. This is not necessarily the fastest.

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

SurfaceScalingFunctionPtr scalingFunction_¶

Friends

friend class icecube::serialization::access

class EnergyDistribution¶

#include <EnergyDistribution.h>

Normalized distribution of energies within a bundle.

The energy distribution \( dP/dE \,\, [GeV^{-1}] \) is parameterized in terms of vertical depth \( [km] \), cosine of the zenith angle, bundle multiplicity, perpendicular distance from the bundle axis \( [m] \), and energy \( [GeV] \).

Single muons are assumed to be colinear with the bundle axis.

Subclassed by I3MuonGun::BMSSEnergyDistribution, I3MuonGun::SplineEnergyDistribution

Public Types

typedef double result_type¶

Public Functions

inline EnergyDistribution()¶

virtual ~EnergyDistribution()¶

double operator()(double depth, double cos_theta, unsigned multiplicity, double radius, double energy) const¶

double Integrate(double depth, double cos_theta, unsigned multiplicity, double r_min, double r_max, double e_min, double e_max) const¶

virtual double GetLog(double depth, double cos_theta, unsigned multiplicity, double radius, log_value log_energy) const = 0¶

virtual std::vector<std::pair<double, double>> Generate(I3RandomService &rng, double depth, double cos_theta, unsigned multiplicity, unsigned samples) const = 0¶: Sample samples (radius, energy) pairs.

inline double GetMax() const¶

inline double GetMin() const¶

inline void SetMax(double v)¶

inline void SetMin(double v)¶

virtual double GetMaxRadius() const = 0¶

virtual bool operator==(const EnergyDistribution&) const = 0¶

template<typename Archive> void serialize (Archive &ar __attribute__((unused)), unsigned version __attribute__((unused)))

Protected Attributes

double minLog_¶

double maxLog_¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Friends

friend class icecube::serialization::access

template<typename Signature> class EnsembleSampler¶

#include <EnsembleSampler.h>

An affine invariant Markov chain Monte Carlo (MCMC) sampler.

Goodman & Weare, Ensemble Samplers With Affine Invariance Comm. App. Math. Comp. Sci., Vol. 5 (2010), No. 1, 65–80

This implementation is a simplified C++ port of emcee’s EnsembleSampler: http://dan.iel.fm/emcee/current/

Public Types

typedef detail::traits<Signature>::array_type array_type¶

Public Functions

inline EnsembleSampler(boost::function<Signature> log_posterior, const std::vector<array_type> &initial_ensemble)¶

inline void Reset()¶

inline const std::vector<sample> &Sample(I3RandomService &rng)¶

inline double GetAcceptanceRate() const¶

Private Functions

inline double LogProbability(const array_type &point)¶

inline void ProposeStretch(I3RandomService &rng, unsigned pos, unsigned offset)¶

inline double Stretch(I3RandomService &rng) const¶

Private Members

boost::function<Signature> log_posterior_¶

std::vector<sample> ensemble_¶

double stretch_scale_¶

double dimension_scale_¶

unsigned half_size_¶

unsigned total_samples_¶

unsigned accepted_samples_¶

class ExtrudedPolygon : public I3MuonGun::detail::UprightSurface<I3Surfaces::ExtrudedPolygonBase<SamplingSurface>>¶

#include <ExtrudedPolygon.h>

Public Functions

virtual ~ExtrudedPolygon()¶

inline ExtrudedPolygon(const std::vector<I3Position> &points, double padding = 0.)¶

inline virtual bool operator==(const SamplingSurface&) const¶

Protected Functions

inline virtual double GetTopArea() const¶

inline virtual double GetSideArea() const¶

inline virtual double GetLength() const¶

inline virtual std::pair<double, double> GetZRange() const¶

Private Types

typedef I3Surfaces::ExtrudedPolygonBase<SamplingSurface> ExtrudedPolygonBase¶

typedef detail::UprightSurface<ExtrudedPolygonBase> Base¶

Private Functions

inline ExtrudedPolygon()¶

template<typename Archive> void serialize(Archive&, unsigned)¶

Friends

friend class icecube::serialization::access

class Floodlight : public I3MuonGun::Generator ¶

#include <Floodlight.h>

Public Functions

Floodlight(SamplingSurfacePtr, boost::shared_ptr<OffsetPowerLaw>, double cosMin = -1, double cosMax = 1)¶

virtual void Generate(I3RandomService &rng, I3MCTree &tree, BundleConfiguration &bundle) const override¶

Generate a muon bundle.

Parameters:

rng – [in] A random number generator
tree – [out] An I3MCTree to fill the generated bundle in to. The bundle axis should be used as the primary, with its type set to I3Particle::unknown
bundle – [out] the radial offset and energy of each muon in the bundle

virtual GenerationProbabilityPtr Clone() const override¶: Copy self into a shared pointer

virtual bool IsCompatible(GenerationProbabilityConstPtr) const override¶

Compare to another GenerationProbability.

Returns:: true if the argument is identical to *this to within a scale factor, false otherwise.

virtual double GetLogGenerationProbability(const I3Particle &axis, const BundleConfiguration &bundle) const override¶

Calculate the differential probability per event that the given configuration was generated.

For single muons, this is \( \log(dP/dE) [\log(1/GeV)]\), for bundles \( \log(d^2P/dEdr) [\log(1/GeV m)]\)

Parameters:

axis – [in] the bundle axis
bundle – [in] the radial offset and energy of each muon in the bundle

inline virtual SamplingSurfaceConstPtr GetInjectionSurface() const override¶

Get the injection surface this generation scheme uses.

If generation schemes are combined, the injection surfaces must be identical!

Private Functions

inline Floodlight()¶

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

SamplingSurfacePtr surface_¶

boost::shared_ptr<OffsetPowerLaw> energyGenerator_¶

std::pair<double, double> zenith_range_¶

double log_acceptance_¶

Friends

friend class icecube::serialization::access

class Flux¶

#include <Flux.h>

A parameterization of the total muon-bundle flux.

The total flux (in units of \( [ m^{-2} sr^{-2} s^{-1} ]\)) is parameterized in terms of vertical depth \( km \), the cosine of the zenith angle, and bundle multiplicity.

Subclassed by I3MuonGun::BMSSFlux, I3MuonGun::SplineFlux

Public Types

typedef double result_type¶

Public Functions

Flux()¶

virtual ~Flux()¶

double operator()(double depth, double cos_theta, unsigned multiplicity) const¶

virtual double GetLog(double depth, double cos_theta, unsigned multiplicity) const = 0¶

inline unsigned GetMaxMultiplicity() const¶

inline unsigned GetMinMultiplicity() const¶

inline void SetMaxMultiplicity(unsigned m)¶

inline void SetMinMultiplicity(unsigned m)¶

virtual bool operator==(const Flux&) const¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

unsigned minMultiplicity_¶

unsigned maxMultiplicity_¶

Friends

friend class icecube::serialization::access

class general : public I3MuonGun::histogram::binning::scheme ¶

#include <histogram.h>

A non-equispaced binning scheme.

In the general case, the proper bin can be found in logarithmic time by binary search

Public Functions

inline general(const std::vector<double> &edges)¶: Construct a binning scheme from the given ordered list of bin edges, inserting under- and overflow bins as necessary

virtual ~general()¶

inline virtual long index(double value) const¶: Get the bin index of the given value

Public Static Functions

static inline boost::shared_ptr<general> create(const std::vector<double> &edges)¶

class GenerationProbability : public I3FrameObject ¶

#include <Generator.h>

A muon bundle generation scheme.

GenerationProbability represents the normalization required for WeightCalculator

Subclassed by I3MuonGun::CORSIKAGenerationProbability, I3MuonGun::GenerationProbabilityCollection, I3MuonGun::Generator

Public Functions

inline GenerationProbability()¶

virtual ~GenerationProbability()¶

inline void SetTotalEvents(double n)¶

inline double GetTotalEvents() const¶

double GetLogGeneratedEvents(const I3Particle &axis, const BundleConfiguration &bundle) const¶

Calculate the logarithm of the differential number of events that should have been generated by the represented scheme.

Parameters:

axis – [in] the bundle axis
bundle – [in] the radial offset and energy of each muon in the bundle

Returns:

The logarithm of a number whose units depend on the number of muons in the bundle. For single muons, this is \( dN/dA d\Omega dP/dE \) and has units of \( [ 1/GeV m^2 sr ] \). For multi-muon bundles it contains an additional doubly differential probability in radius and energy for each muon in the bundle.

double GetGeneratedEvents(const I3Particle &axis, const BundleConfiguration &bundle) const¶: Call GetLogGeneratedEvents and exponential the result.

virtual SamplingSurfaceConstPtr GetInjectionSurface() const = 0¶

Get the injection surface this generation scheme uses.

If generation schemes are combined, the injection surfaces must be identical!

virtual GenerationProbabilityPtr Clone() const = 0¶: Copy self into a shared pointer

virtual bool IsCompatible(GenerationProbabilityConstPtr) const = 0¶

Compare to another GenerationProbability.

Returns:: true if the argument is identical to *this to within a scale factor, false otherwise.

Protected Functions

virtual double GetLogGenerationProbability(const I3Particle &axis, const BundleConfiguration &bundle) const = 0¶

Calculate the differential probability per event that the given configuration was generated.

For single muons, this is \( \log(dP/dE) [\log(1/GeV)]\), for bundles \( \log(d^2P/dEdr) [\log(1/GeV m)]\)

Parameters:

axis – [in] the bundle axis
bundle – [in] the radial offset and energy of each muon in the bundle

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

double numEvents_¶: The total number of events that should be generated.

Friends

friend class icecube::serialization::access

class GenerationProbabilityCollection : public I3MuonGun::GenerationProbability, public std::vector<GenerationProbabilityPtr>¶

#include <Generator.h>

A collection of muon bundle generation schemes.

Public Functions

GenerationProbabilityCollection(GenerationProbabilityPtr, GenerationProbabilityPtr)¶

void push_back(const GenerationProbabilityPtr&)¶

virtual GenerationProbabilityPtr Clone() const override¶: Copy self into a shared pointer

virtual SamplingSurfaceConstPtr GetInjectionSurface() const override¶

Get the injection surface this generation scheme uses.

If generation schemes are combined, the injection surfaces must be identical!

virtual bool IsCompatible(GenerationProbabilityConstPtr) const override¶

Compare to another GenerationProbability.

Returns:: true if the argument is identical to *this to within a scale factor, false otherwise.

Protected Functions

virtual double GetLogGenerationProbability(const I3Particle &axis, const BundleConfiguration &bundle) const override¶: Calculate the total probability that the given configuration was generated by any of the distributions in the colleciton.

Private Functions

inline GenerationProbabilityCollection()¶

template<typename Archive> void serialize(Archive&, unsigned)¶

Friends

friend class icecube::serialization::access

class Generator : public I3MuonGun::GenerationProbability ¶

#include <Generator.h>

A muon bundle generator.

Generators know both how to draw muon bundles from some distribution and how to calculate the probability that they would have drawn some arbitrary bundle from that same distribution.

Subclassed by I3MuonGun::Floodlight, I3MuonGun::NaturalRateInjector, I3MuonGun::StaticSurfaceInjector

Public Functions

virtual ~Generator()¶

virtual void Generate(I3RandomService &rng, I3MCTree &tree, BundleConfiguration &bundle) const = 0¶

Generate a muon bundle.

Parameters:

rng – [in] A random number generator
tree – [out] An I3MCTree to fill the generated bundle in to. The bundle axis should be used as the primary, with its type set to I3Particle::unknown
bundle – [out] the radial offset and energy of each muon in the bundle

Public Static Functions

static I3Particle CreateParallelTrack(double radius, double azimuth, const I3Surfaces::Surface &surface, const I3Particle &axis)¶

Place a muon at a given radial offset and rotation with respect to the shower axis.

Parameters:

radius – [in] perpendicular distance from the shower axis
azimuth – [in] rotation about the shower axis
surface – [in] place the muon on this surface, with timing adjusted so that it remains in the shower plane
axis – [in] the shower axis

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Friends

friend class icecube::serialization::access

class GeneratorModule : public I3Module ¶

Interface between Generator and IceTray.

Public Functions

inline GeneratorModule(const I3Context &ctx)¶

inline void Configure()¶

inline void DAQ(I3FramePtr frame)¶

void Finish()¶

Private Members

GeneratorPtr generator_¶

I3RandomServicePtr rng_¶

size_t maxEvents_¶

size_t numEvents_¶

std::string mctreeName_¶

bool firstFrame_¶

template<size_t N, typename T = double> class histogram : public I3MuonGun::histogram::histogram_base ¶

#include <histogram.h>

An N-dimensional histogram.

Template Parameters:

N – number of dimensions
T – type weight stored in the histogram

Public Types

typedef boost::array<boost::variant<std::vector<double>, boost::shared_ptr<binning::scheme>>, N> bin_specification¶

Public Functions

inline histogram(const boost::array<std::vector<double>, N> &edges)¶: Construct with non-uniform bins in all dimensions

inline histogram(const boost::array<boost::shared_ptr<binning::scheme>, N> &schemes)¶: Construct with uniform bins in all dimensions

inline histogram(const boost::array<boost::variant<std::vector<double>, boost::shared_ptr<binning::scheme>>, N> &schemes)¶: Construct with a mix of uniform and non-uniform bins in different dimensions

inline void fill(const boost::array<double, N> &values, T weight = 1)¶

Add a sample to the histogram

Parameters:

values – [in] value of the sample in each dimension
weight – [in] weight to assign to the sample

inline const boost::array<std::vector<double>, N> &edges() const¶

inline const T *bincontent() const¶

inline const T *squaredweights() const¶

inline virtual const char *raw_bincontent() const¶: Get a pointer to the memory backing the bin contents

inline virtual const char *raw_squaredweights() const¶: Get a pointer to the memory backing the sum of squared weights

inline virtual std::vector<std::vector<double>> binedges() const¶: Get the bin edges

inline virtual size_type ndim() const¶: Get the dimensionality of the histogram

inline virtual std::vector<size_type> shape() const¶: Get the number of elements along each dimension

inline virtual std::vector<index> strides() const¶: Get the stride required to move sequentially along each dimension

Private Types

typedef boost::multi_array<T, N> datacube_type¶

Private Functions

inline void make_datacube()¶

Private Members

boost::array<scheme_ptr, N> binners_¶

boost::array<std::vector<double>, N> edges_¶

datacube_type bincontent_¶

datacube_type squaredweights_¶

class histogram_base¶

#include <histogram.h>

A base class for histograms of arbitrary type and dimensionality.

Subclassed by I3MuonGun::histogram::histogram< N, T >

Public Types

typedef boost::multi_array_types::index index¶

typedef boost::multi_array_types::size_type size_type¶

Public Functions

virtual ~histogram_base()¶

virtual const char *raw_bincontent() const = 0¶: Get a pointer to the memory backing the bin contents

virtual const char *raw_squaredweights() const = 0¶: Get a pointer to the memory backing the sum of squared weights

virtual std::vector<std::vector<double>> binedges() const = 0¶: Get the bin edges

virtual size_type ndim() const = 0¶: Get the dimensionality of the histogram

virtual std::vector<size_type> shape() const = 0¶: Get the number of elements along each dimension

virtual std::vector<index> strides() const = 0¶: Get the stride required to move sequentially along each dimension

struct identity¶

#include <histogram.h>

Trivial linear mapping.

Public Static Functions

static inline double map(double v)¶

static inline double imap(double v)¶

struct log10¶

#include <histogram.h>

Bin edges linear in \( \log_{10}{x} \).

Public Static Functions

static inline double map(double v)¶

static inline double imap(double v)¶

struct log_value¶

#include <EnergyDistribution.h>

A tag type to enforce units.

Public Functions

inline explicit log_value(double v)¶

inline operator double() const¶

Public Members

double value_¶

struct LossSum¶

#include <Track.h>

The sum of stochastic energy losses since the last checkpoint.

Public Functions

inline LossSum(double l, double e = 0.)¶

Public Members

double length¶

double energy¶

class MuonBundleConverter : public I3ConverterImplementation<I3MCTree>¶

#include <WeightCalculator.h>

Public Functions

MuonBundleConverter(size_t maxMultiplicity = 25, SamplingSurfaceConstPtr surface = SamplingSurfaceConstPtr())¶

I3TableRowDescriptionPtr CreateDescription(const I3MCTree&)¶

size_t FillRows(const I3MCTree&, I3TableRowPtr)¶

Private Functions

SET_LOGGER ("I3MuonGun::WeightCalculator")

Private Members

size_t maxMultiplicity_¶

SamplingSurfaceConstPtr surface_¶

class MuonGunBackgroundService : public I3GeneratorService ¶

#include <MuonGunBackgroundService.h>

Service Generator for MuonGun.

Public Functions

inline MuonGunBackgroundService()¶

MuonGunBackgroundService(I3MuonGun::GeneratorPtr generator, I3RandomServicePtr rng)¶

void SetRate(double rate)¶

void SetMCTreeName(std::string mctreeName)¶

void SetRNG(I3RandomServicePtr rng)¶

void SetGenerator(I3MuonGun::GeneratorPtr generator)¶

virtual void Init()¶

virtual double GetRate()¶

virtual I3MCTreePtr GetNextEvent()¶

virtual I3FramePtr GetNextFrame()¶

Private Members

I3MuonGun::GeneratorPtr generator_¶

I3RandomServicePtr rng_¶

double rate_¶

std::string mctreeName_¶

bool configured_¶

class Muonitron : public I3Module ¶

#include <Muonitron.h>

a utility module for recording the state of a muon bundle as it propagates to depth

Public Functions

Muonitron(const I3Context&)¶

void Configure()¶

void DAQ(I3FramePtr)¶

Public Static Functions

static double GetOverburden(double z, double d = OriginDepth, double r = SurfaceRadius)¶

static double GetSurfaceZenith(double z, double d = OriginDepth, double r = SurfaceRadius)¶

static double GetGeocentricZenith(double z, double d = OriginDepth, double r = SurfaceRadius)¶

static double GetDetectorZenith(double z, double d = OriginDepth, double r = SurfaceRadius)¶

static I3Direction RotateToZenith(const I3Direction&, const I3Direction&)¶

static I3Position RotateToZenith(const I3Direction&, const I3Position&)¶

static I3Particle RotateToZenith(const I3Particle&, const I3Particle&)¶

static I3Position Impact(const I3Particle&)¶

Private Functions

bool PropagateTrack(I3Particle &target, double depth)¶

Private Members

boost::shared_ptr<I3MuonGun::MuonPropagator> bulkPropagator_¶

boost::shared_ptr<I3MuonGun::Crust> crust_¶

I3Surfaces::Sphere iceWorld_¶

std::vector<double> depths_¶

class MuonPropagator¶

#include <MuonPropagator.h>

A simple muon energy-loss calculator.

This hides the nasty details of PROPOSAL (a C++ translation of MMC)

Public Functions

MuonPropagator(const std::string &medium, double ecut = -1, double vcut = -1, double rho = 1.0)¶

Parameters:

medium – [in] The name of the medium, e.g. “ice”
ecut – [in] Absolute energy above which an energy loss is considered stochastic \( [MeV] \)
vcut – [in] Proportion of the current muon energy above which an energy loss is considered stochastic
rho – [in] Density adjustment factor for the medium

~MuonPropagator()¶

I3Particle propagate(const I3Particle &p, double distance, boost::shared_ptr<std::vector<I3Particle>> losses = boost::shared_ptr<std::vector<I3Particle>>())¶

Parameters:

p – [in] Muon to propagate
distance – [in] Maximum distance to propagate

Returns:

an I3Particle representing the muon at the end of propagation. If the muon stopped before the given distance, the energy will be set to zero. The length of the output I3Particle is the distance traveled to reach its current position from the position given as input.

double GetStochasticRate(double energy, double fraction, I3Particle::ParticleType type = I3Particle::MuMinus) const¶: Differential stochastic rate: d^2N/dv/dx [1/m]

double GetTotalStochasticRate(double energy, I3Particle::ParticleType type = I3Particle::MuMinus) const¶: total stochastic rate: dN/dx [1/m]

Public Static Functions

static void SetSeed(int seed)¶: Set the (global) state of the random number generator used in the implementation.

static std::string GetName(const I3Particle &p)¶: Get the internal MMC name associated with a particle type

Private Functions

I3Particle::ParticleType GenerateI3Type(const PROPOSAL::DynamicData &secondary)¶: Get the internal MMC name associated with a particle type

I3Particle GenerateI3Particle(const PROPOSAL::DynamicData &proposal_particle)¶

Private Members

PROPOSAL::Propagator *propagator_¶

class NaturalRateInjector : public I3MuonGun::Generator ¶

#include <NaturalRateInjector.h>

A natural-rate Generator.

NaturalRateInjector samples bundle impact points, angles, multiplicities, and radius/energy distributions at their natural frequencies on a fixed surface using a brain-dead acceptance/rejection technique. This is to MUPAGE, except that the flux parameterizations can be swapped out and the events can be combined with biased generation and reweighted to a different parameterization after the fact.

Public Functions

NaturalRateInjector()¶

NaturalRateInjector(SamplingSurfacePtr surface, FluxPtr flux, EnergyDistributionPtr edist)¶

virtual void Generate(I3RandomService &rng, I3MCTree &tree, BundleConfiguration &bundle) const¶

Generate a muon bundle.

Parameters:

rng – [in] A random number generator
tree – [out] An I3MCTree to fill the generated bundle in to. The bundle axis should be used as the primary, with its type set to I3Particle::unknown
bundle – [out] the radial offset and energy of each muon in the bundle

virtual GenerationProbabilityPtr Clone() const¶: Copy self into a shared pointer

virtual bool IsCompatible(GenerationProbabilityConstPtr) const¶

Compare to another GenerationProbability.

Returns:: true if the argument is identical to *this to within a scale factor, false otherwise.

virtual double GetLogGenerationProbability(const I3Particle &axis, const BundleConfiguration &bundle) const¶

Calculate the differential probability per event that the given configuration was generated.

For single muons, this is \( \log(dP/dE) [\log(1/GeV)]\), for bundles \( \log(d^2P/dEdr) [\log(1/GeV m)]\)

Parameters:

axis – [in] the bundle axis
bundle – [in] the radial offset and energy of each muon in the bundle

inline virtual SamplingSurfaceConstPtr GetInjectionSurface() const¶

Get the injection surface this generation scheme uses.

If generation schemes are combined, the injection surfaces must be identical!

void SetSurface(SamplingSurfacePtr p)¶

inline SamplingSurfacePtr GetSurface()¶

void SetFlux(FluxPtr p)¶

inline FluxPtr GetFlux()¶

void SetEnergyDistribution(EnergyDistributionPtr e)¶

inline EnergyDistributionPtr GetEnergyDistribution()¶

double GetTotalRate() const¶

Integrate the configured flux over the sampling surface, summing over all allowed multiplicities.

Returns:: a rate in units of \( [s^{-1}] \)

Protected Functions

void GenerateAxis(I3RandomService &rng, std::pair<I3Particle, unsigned> &axis) const¶

Draw a sample from the distribution of shower impact points

The shower axis and multiplcity are filled into the axis

void FillMCTree(I3RandomService &rng, const std::pair<I3Particle, unsigned> &axis, I3MCTree&, BundleConfiguration&) const¶: Distribute the given number of muons in the transverse plane and draw an energy for each

Protected Attributes

SamplingSurfacePtr surface_¶

FluxPtr flux_¶

EnergyDistributionPtr energyDistribution_¶

mutable double totalRate_¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Friends

friend class icecube::serialization::access

class NeutrinoBinner¶

#include <TrackBinner.h>

Public Types

typedef histogram::histogram<3> hist¶

typedef boost::shared_ptr<hist> histptr¶

typedef std::map<int, std::vector<histptr>> histmap¶

Public Functions

NeutrinoBinner()¶

void Consume(boost::shared_ptr<const TrackBundle> tracks, I3MCTreeConstPtr tree, I3MapI3ParticleIDDoubleConstPtr particle_weights, double weight)¶

Public Members

histmap histograms_¶

class OffsetPowerLaw¶

#include <EnergyDistribution.h>

An approximate form for the underground muon energy spectrum.

The deep underground muon spectrum very nearly follows a power law with a break at low energies caused by pile-up of minimum-ionizing muons. While the details of the spectrum depend on depth, zenith angle, distance from the bundle axis, etc., this approximate form can still be used to efficiently generate plausible energies that can later be weighted to reflect their frequency under a more precise model.

Public Types

typedef double result_type¶

Public Functions

OffsetPowerLaw()¶

OffsetPowerLaw(double gamma, double offset, double emin, double emax)¶

Create an offset power-law energy distribution of the form \( dP/dE_{\mu} \propto (E_{\mu} + b)^{-\gamma} \)

Parameters:

gamma – [in] The power law index (positive)
offset – [in] The offset in \( (E_{\mu} + b) \)
emin – [in] minimum generated energy
emax – [in] maximum generated energy

double operator()(double energy) const¶: Calculate the probability that the given energy was generated

double GetLog(double energy) const¶

double GetLog(EnergyDistribution::log_value log_energy) const¶

double Generate(I3RandomService &rng) const¶: Draw an energy from the distribution

double InverseSurvivalFunction(double p) const¶

inline const double GetMin() const¶

inline const double GetMax() const¶

bool operator==(const OffsetPowerLaw &other) const¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

double gamma_¶

double offset_¶

double emin_¶

double emax_¶

double nmin_¶

double nmax_¶

double norm_¶

double lognorm_¶

Friends

friend class icecube::serialization::access

template<int N> struct power¶

#include <histogram.h>

Bin edges linear in \( x^N \).

Template Parameters:: N – the exponent of the power law

Public Static Functions

static inline double map(double v)¶

static inline double imap(double v)¶

class RadialDistribution¶

#include <RadialDistribution.h>

The distribution of distance between a muon and the bundle axis.

Subclassed by I3MuonGun::BMSSRadialDistribution, I3MuonGun::SplineRadialDistribution

Public Functions

virtual ~RadialDistribution()¶

double operator()(double depth, double cos_theta, unsigned multiplicity, double radius) const¶

Calculate the probability of obtaining the given radial offset.

Parameters:

depth – [in] vertical depth in km
cos_theta – [in] cosine of zenith angle
multiplicity – [in] number of muons in the bundle
radius – [in] distance to bundle axis

Returns:

a properly normalized propability \( dP/dr \,\, [m^{-1}] \)

virtual double GetLog(double depth, double cos_theta, unsigned multiplicity, double radius) const = 0¶

Calculate the logarithm of the probability of obtaining the given radial offset.

MuonGun C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page