monopole-generator C++ API Reference

class I3MonopoleGenerator : public I3Module
#include <I3MonopoleGenerator.h>

Public Functions

I3MonopoleGenerator(const I3Context &ctx)
~I3MonopoleGenerator()
void Configure()
void DAQ(I3FramePtr frame)
void Finish()

Private Functions

I3MonopoleGenerator()
I3MonopoleGenerator(const I3MonopoleGenerator&)
I3MonopoleGenerator &operator=(const I3MonopoleGenerator&)
SET_LOGGER ("I3MonopoleGenerator")

Private Members

std::string treeName_
std::string infoName_
int Nevents_
double mass_
double beta_
double gamma_
double speed_
double energy_
bool useBetaRange_
double diskDist_
double diskRad_
double radOnDisk_
double aziOnDisk_
double startTime_
double weight_
double powerLawIndex_
double length_
double totalweight_
I3MapStringDoublePtr mpinfo_dict_config_
std::vector<double> betaRange_

Zenith and Azimuth follow convention defined in I3Direction.h Angle points to origin of particle, hence zenith=0 is down-going

std::vector<double> zenithRange_
std::vector<double> azimuthRange_
std::vector<double> shiftCenter_
std::vector<double> precalculated_betas_
bool need_precalculate_
class I3MonopolePropagator : public I3Module
#include <I3MonopolePropagator.h>

A module to convert Monopoles into a chain of propagated particles through the ice.

class: I3MonopolePropagator.h Copyright (c) 2008 IceCube Collaboration Version

Rcs

I3MonopolePropagator.h 124417 2014-10-10 15:16:00Z jacobi

Date 06 Feb 2008

Version

Rcs

124417

Date

Rcs

2014-10-10 10:16:00 -0500 (Fr, 10. Okt 2014)

Author

Brian Christy bchristy@icecube.umd.edu

Author

Alex Olivas olivas@icecube.umd.edu

Public Functions

I3MonopolePropagator(const I3Context &ctx)
~I3MonopolePropagator()
void Configure()
void DAQ(I3FramePtr frame)
void Finish()

Private Functions

I3MonopolePropagator()
I3MonopolePropagator(const I3MonopolePropagator&)
I3MonopolePropagator &operator=(const I3MonopolePropagator&)
SET_LOGGER ("I3MonopolePropagator")

Private Members

std::string inputTreeName_
std::string outputTreeName_
std::string infoName_
double betaThreshold_
bool calcEn_
bool calcDen_
double stepSize_
bool checkParticle_
double speedmin_
double maxlength_
double minlength_
double maxdistfromcenter_
bool profiling_
double meanFreePath_
bool useCorrectDecay_
bool scaleEnergy_
double energyScaleFactor_
double deltaEnergy_
namespace I3MonopoleGeneratorUtils

Namespace used to generate the position of the particle

Functions

double CalcSolidAngle(double, double, double, double)

Calculate the solid angle for the given configuration.

Utility Namespace for the I3MonopoleGenerator Module.

class: I3MonopoleGeneratorUtils.cxx Copyright (c) 2004 - 2014 IceCube Collaboration Version $Id$

Date

$Date$

Author

Brian Christy bchristy@icecube.umd.edu

Author

Alex Olivas olivas@icecube.umd.edu

Parameters:

  • zmin – minimum zenith angle

  • zmax – maximum zenith angle

  • amin – minimum azimuth angle

  • amax – maximum azimuth angle

Returns:

solid angle

double beta2gamma(double)

Calculate corresponding gamma for given beta.

Parameters:

beta – beta

Returns:

gamma

double gamma2beta(double)

Calculate corresponding beta for given gamma.

Parameters:

gamma – gamma

Returns:

beta

void CheckMass(const double&, std::vector<double>&)

Sanity checks for the mass parameter (1e5 GeV < mass < 1e17 GeV, mass needed for relativistic monopoles.)

Parameters:

  • mass –

  • betaRange –

void CheckAndSetBeta(std::vector<double>&, const double&)

Check which usecase (gamma only, beta range, only one beta), Set other variables accordingly and apply sanity checks (0 < beta < 1, 1 < gamma < 1000, etc.)

Parameters:

  • betaRange – vector containing the minimum and maximum beta value, Any NAN will be ignored. Single value or borders of beta range need to be set.

  • powerLawIndex – power law factor used if a beta range is defined. If NAN or 0, an uniform distribution will be applied.

void CheckDisk(const double&, const double&)

Sanity checks for the Disk Distance parameters.

Parameters:

  • diskDist –

  • diskRad –

void CheckAndSetLength(double&, const double&)

Sanity checks for the length parameter and apply default value if length=-1.

Parameters:

  • length –

  • defaultValue – value of length if length was set to -1

void CheckAndSetAngle(const std::string&, const std::vector<double>&, const double&, const double&)

Only internally used to abstract CheckAndSetZenith and CheckAndSetAzimuth to a common function.

Parameters:

  • name – name used in logs, azimuth or zenith

  • range – vector of size 2 with minimum and maximum angle

  • validMin – minimum of range for sanity check

  • validMax – maximum of range for sanity check

void CheckAndSetZenith(const std::vector<double>&)

Applies sanity checks to the zenith and extracts the values from the vector the min/max variables.

Parameters:

zenithRange – vector of size 2 with minimum and maximum angle

void CheckAndSetAzimuth(const std::vector<double>&)

Applies sanity checks to the azimuth and extracts the values from the vector the min/max variables.

Parameters:

azimuthRange – vector of size 2 with minimum and maximum angle

void CheckShiftCenter(const std::vector<double>&)

Sanity checks for the shiftCenter parameter.

Parameters:

shiftCenter –

void CheckDiskPos(const double&, const double&, const double&)

Applies sanity checks to position on generation disk parameters depending on a set position or random position.

Parameters:

  • radOnDisk – radius in disk

  • aziOnDisk – azimuth on disk

  • diskRad – radius of disk

double RandomUniformSampled(I3RandomServicePtr, double const, double const)

Helper function for uniformal random numbers.

Parameters:

  • random – I3RandomServicePtr to randomness service

  • min – minimal value returned

  • max – maximal value returned

double RandomCosinusSampled(I3RandomServicePtr, double const, double const)

Helper function for cosinus weighted random numbers.

Parameters:

  • random – I3RandomServicePtr to randomness service

  • min_angle – minimal value returned

  • max_angle – maximal value returned

double RandomCircularSampled(I3RandomServicePtr, double const, double const)

Helper function for circular weighted random numbers (i.e. getting properly weighted radius of a circle)

Parameters:

  • random – I3RandomServicePtr to randomness service

  • min_radius – minimal value returned

  • max_radius – maximal value returned

double RandomPowerLawSampled(I3RandomServicePtr, double const, double const, double const)

Helper function for powerlaw weighted random numbers.

Parameters:

  • random – I3RandomServicePtr to randomness service

  • min – minimal value returned

  • max – maximal value returned

  • powerLawIndex – powerlaw to be weighted by, only positive values are supported but interpreted as negative

namespace I3MonopoleRelativisticUtils

Utility Namespace for the I3MonopolePropagator Module.

class: I3MonopolePropagatorUtils.h Copyright (c) 2004 IceCube Collaboration Version

Rcs

I3MonopoleRelativisticUtils.h 124988 2014-10-23 15:17:00Z jacobi

Date 20 Oct 2006

Coeff was found using [4Pi Ne(137/2)^2(e)^4]/(m_e c^2) where Ne = Na rho Z/A

Version

Rcs

124988

Date

Rcs

2014-10-23 10:17:00 -0500 (Do, 23. Okt 2014)

Author

Brian Christy bchristy@icecube.umd.edu

Author

Alex Olivas olivas@icecube.umd.eduPropagate Monopole assuming only ionization energy loss Used formula Eq 16 of Ahlen Phys Rev D Vol 17 # 1 “Stopping Power formula for magnetic monopoles” and used values of K and B for g = 137e/2

For Density Correction constants Used values from Table C.2 in Dima’s Thesis on mmc, which in turn came from https://web.archive.org/web/20070713230354/http://pdg.lbl.gov/AtomicNuclearProperties/substances/276.html

Functions

void PropagateFastMonopole(I3FramePtr, std::string, I3MCTreeConstPtr, I3MCTreePtr, double, double, double, bool, bool, double, double, bool, bool)

Propagate a fast monopole

Supervises the monopole propagation

Parameters:

  • frame – Instance of current frame

  • infoName_ – Name of info frame

  • input_tree – Original mctree created by generator

  • output_tree – Copy of mctree which you may adjust

  • stepSize_ – If set, will over-ride track length setting algorithm

  • minlength_ – If no step size set, this represents smallest segment value allowed

  • maxlength_ – If no step size set, this represents largest segment value allowed

  • calcEn_ – Whether to actually calculate energy loss or just segment track

  • calcDen_ – Whether to include density correction in energy loss

  • speedmin_ – If below that speed propagation stops

  • maxdistfromcenter_ – Propagation limit

  • checkParticle_ – Whether to include exhaustive checking

  • profiling_ – If profiling should be written into frame

I3ParticlePtr AddMonopole(I3Particle, double, bool, bool, bool, double, double, double)

Generates monopole at end of given segment

Generates monopole at end of given segment

Parameters:

  • mp – the starting monopole particle

  • monopoleMass – the mass of the starting monopole particle

  • calcEn – whether to actually calculate energy loss or just segment track

  • calcDen – whether to include density correction in energy loss

  • checkParticle – whether to include exhaustive checking

  • stepSize – if set, will over-ride track length setting algorithm

  • maxlength – if no step size set, this represents largest segment value allowed

  • minlength – if no step size set, this represents smallest segment value allowed

Returns:

The next monopole at the end of the starting monopole segment

double CalculateEnergyLoss(double, double, bool)

Responsible for taking a given segment of the Monopole and calculating the energy loss due to Ionization (with Density Correction on/off option)

Responsible for taking a given segment of the Monopole and calculating the energy loss due to Ionization (with Density Correction on/off option)

Parameters:

  • sBeta – starting beta value of monopole

  • tLength – length of segment to calculate energy loss over

  • cDensityCorrection – whether to include density correction calculation

Returns:

the Ionization energy loss for the given segment and starting speed

double CalculateDensityCorrection(double)

Calculates the density correction part of the Ionization energy loss for a given speed

Calculates the density correction part of the Ionization energy loss for a given speed

Parameters:

betaPrime – starting beta used to calculate density correction

Returns:

density correction

double CalculateNextLength(double, double, double, double, double)

Determines length to use for newly generated monopole by estimating how far it could travel before losing 0.1% of its kinetic energy

Determines length to use for newly generated monopole by estimating how far it could travel before losing 0.1% of its kinetic energy

Parameters:

  • stepSize –

  • nextEnergy – Starting energy of particle

  • particleMass – Mass of particle

  • maxLength – Largest segment value allowed

  • minLength – Smallest segment value allowed

Returns:

A length over which a monopole would lose roughly 0.1% of its KE within user defined boundaries

double EnergyToBeta(double, double)

Helper function - got tired of writing function over and over

Helper function - got tired of writing function over and over

Parameters:

  • energy – energy of particle

  • mass – mass of particle

Returns:

beta of particle

void CheckParticle(I3Particle&, double)

Responsible for performing extensive sanity checks on particle result to ensure nothing went horribly wrong

Responsible for performing extensive sanity checks on particle result to ensure nothing went horribly wrong

Parameters:

  • particle – Particle to check

  • checkmass – Mass of particle to check

void UpdateMPInfoDict(I3MCTreeConstPtr, I3MapStringDoublePtr)

Update the dictionary created by the monopole generator

Update the dictionary created by the monopole generator

Parameters:

  • mctree – the monopoles mctree

  • mpinfo – pointer to the dictionary(I3MapStringDouble) to update

void MPSpeedProfile(I3MCTreeConstPtr, I3VectorDoublePtr)

Extract the speed profile of the monopole from the MCTree

Extract the speed profile of the monopole from the MCTree.

Parameters:

  • mctree – the monopoles mctree

  • speed_prof – pointer to the vector storing the profile

namespace I3MonopoleSlowUtils

Functions

void PropagateSlowMonopole(I3FramePtr, std::string, I3MCTreeConstPtr, I3MCTreePtr, I3RandomServicePtr, double, bool, double)

Propagate slow monopoles.

I3MonopoleSlowUtils.cxx

Propagating slow monopoles using the Rubakov Callan Effect

Supervises the monopole propagation

Version

Rcs

125103

Date

Rcs

2014-10-27 10:25:33 -0500 (Mo, 27. Okt 2014)

Parameters:

  • frame – instance of current frame

  • infoName_ – name of info frame

  • mctree – original mctree created by generator

  • prop_tree – copy of mctree which you may adjust

  • random – pointer to random number service

  • meanFreePath_ – mean free path

  • useCorrectDecay_ – Whether to simulate 2 opposite cascades ( 2 * ~ 500 MeV) instead of 1 GeV

  • deltaEnergy_ – Energy lost after meanFreePath? I am not sure (fhl)

namespace std

STL namespace.

file I3MonopoleGenerator.cxx
#include “monopole-generator/I3MonopoleGenerator.h”

Implementation of a module to generate a magnetic monopole particle.

A Monopole Generator Module Copyright (c) 2004-2014 IceCube Collaboration Version $Id$

Date

$Date$

Author

jacobi

Author

bchristy

Author

olivas

Author

flauber

Functions

I3_MODULE(I3MonopoleGenerator)
file I3MonopoleGenerator.h
#include <string>
#include <cmath>
#include “icetray/I3Module.h”
#include “icetray/I3Frame.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3MCTree.h”
#include “dataclasses/physics/I3MCTreeUtils.h”
#include “monopole-generator/I3MonopoleGeneratorUtils.h”

A module to generate a magnetic monopole particle.

A Monopole Generator Module Copyright (c) 2004 - 2014 IceCube Collaboration Version $Id$

Date

$Date$

Author

jacobi

Author

bchristy

Author

olivas

Author

flauber

file I3MonopoleGeneratorUtils.cxx
#include “I3MonopoleGeneratorUtils.h”
#include <cmath>
file I3MonopoleGeneratorUtils.h
#include “dataclasses/I3Constants.h”
#include “icetray/I3Units.h”
#include “dataclasses/I3Position.h”
#include “dataclasses/I3Direction.h”
#include “phys-services/I3RandomService.h”

Utility namespace for the I3MonopoleGenerator module.

A Monopole Generator Module Copyright (c) 2004 - 2014 IceCube Collaboration Version $Id$

Date

$Date$

Author

bchristy

Author

olivas

file I3MonopolePropagator.cxx
#include “monopole-generator/I3MonopolePropagator.h”
#include “I3MonopoleRelativisticUtils.h”
#include “I3MonopoleSlowUtils.h”
#include “icetray/I3Frame.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3MCTree.h”
#include “dataclasses/physics/I3MCTreeUtils.h”

Functions

I3_MODULE(I3MonopolePropagator)

A module to convert Monopoles into a chain of propagated.

class: I3MonopolePropagator.cxx Copyright (c) 2008 IceCube Collaboration Version

Rcs

I3MonopolePropagator.cxx 141809 2016-02-13 17:31:29Z anna.obertacke

Date 06 Feb 2008

particles through the ice

Version

Rcs

141809

Date

Rcs

2016-02-13 11:31:29 -0600 (Sa, 13. Feb 2016)

Author

Brian Christy bchristy@icecube.umd.edu

Author

Alex Olivas olivas@icecube.umd.edu

file I3MonopolePropagator.h
#include “icetray/I3Module.h”
#include <string>
#include “dataclasses/physics/I3MCTreeUtils.h”
file I3MonopoleRelativisticUtils.cxx
#include “I3MonopoleRelativisticUtils.h”
#include <icetray/I3Units.h>
#include <dataclasses/I3Constants.h>
#include <dataclasses/physics/I3MCTreeUtils.h>
#include <phys-services/I3Calculator.h>
#include <cmath>

Variables

const double MASS_E = 5.11e-4
const double ION_LOSS = 7.5e-8
const double DENSITY = 9.17e5
const double Z_OVER_A = 0.55509
const double CHARGE_E_SQRD = 1.439964459e-18
const double COEFF1 = (4 * I3Constants::pi * I3Constants::NA * DENSITY * Z_OVER_A)
const double COEFF2 = pow(0.5 * 137.0 * CHARGE_E_SQRD, 2)
const double COEFF3 = MASS_E
const double COEFF = COEFF1 * COEFF2 / COEFF3
const double BLOCH_CORR = 0.248
const double QED_CORR = 0.406
const double A_DC = 0.09116
const double X0 = 0.240
const double X1 = 2.8004
const double M_DC = 3.477
const double C_BAR = 3.5017
const double AVG_ENERGY_LOSS = 1200.0
file I3MonopoleRelativisticUtils.h
#include <dataclasses/I3Map.h>
#include <dataclasses/I3Constants.h>
#include <dataclasses/physics/I3Particle.h>
#include <dataclasses/physics/I3MCTree.h>
#include “icetray/I3Frame.h”
file I3MonopoleSlowUtils.cxx
#include <dataclasses/I3Constants.h>
#include “I3MonopoleSlowUtils.h”
file I3MonopoleSlowUtils.h
#include <phys-services/I3RandomService.h>
#include <dataclasses/physics/I3MCTreeUtils.h>
file index.dox
dir icetray
dir monopole-generator
dir monopole-generator
dir monopole-generator
dir private
dir public
page index

Author

A. Olivas olivas@icecube.umd.edu

Author

B. Christy bchristy@icecube.umd.edu

Author

J. Posselt jposselt@uni-wuppertal.de

Author

A. Obertacke anna.obertacke@uni-wuppertal.de

Author

T. Gluesenkamp thorsten.gluesenkamp@desy.de

Author

E. Jacobi emanuel.jacobi@desy.de

Author

F. Lauber lauber@uni-wuppertal.de

Overview

The documentation can be found here.