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 (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 (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 –

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:

• randPos – enables generation of random position on generation disk

• radOnDisk – radius in disk

• aziOnDik – 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

• powerlaw – powerlaw to be weighted by, only positive values are supported but interepreted as negativ

namespace I3MonopoleRelativisticUtils

Utility Namespace for the I3MonopolePropagator Module.

class: I3MonopolePropagatorUtils.h (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

• mctree – original mctree created by generator

• prop_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:

• nEnergy – starting energy of particle

• particleMass – mass of particle

• maxL – represents largest segment value allowed

• minL – represents 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:

• checkptr – 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

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_ – Wheter 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 (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 (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 (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 (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.