phys-services C++ API Reference

class AxialCylinder : public I3Surfaces::SamplingSurface
#include <AxialCylinder.h>

A cylinder aligned with the incoming particle axis a la NuGen.

Public Functions

virtual ~AxialCylinder()
AxialCylinder(double length, double radius, I3Position center = I3Position(0, 0, 0))
AxialCylinder(double lengthBefore, double lengthAfter, double radius, I3Position center = I3Position(0, 0, 0))
virtual std::pair<double, double> GetIntersection(const I3Position &p, const I3Direction &dir) const

Find the points where a ray intersects the surface

Parameters:
  • p[in] The origin of the ray

  • dir[in] The direction of the ray

Returns:

a pair of distances from the origin of the ray to the intersections with the surface. A distance of NAN means that the ray never intersects the surface, and negative distances mean that the intersection in question is “behind” the origin.

virtual double GetArea(const I3Direction&) const

Calculate the projected area in m^2.

Parameters:

dir[in] The direction onto which to project the area

virtual double GetMaximumArea() const
virtual double GetAcceptance(double cosMin = 0, double cosMax = 1) const
virtual I3Direction SampleDirection(I3RandomService &rng, double cosMin = 0, double cosMax = 1) const
virtual I3Position SampleImpactPosition(const I3Direction &dir, I3RandomService &rng) const
std::ostream &Print(std::ostream &os) const

Private Functions

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

Private Members

std::pair<double, double> length_
double radius_
I3Position center_

Friends

friend class icecube::serialization::access
class Cup : public I3Surfaces::detail::CupBase<SamplingSurface>
#include <Cup.h>

A cup aligned with the z axis.

Public Functions

virtual ~Cup()
inline Cup(double olength, double oradius, double ilength, double iradius, I3Position center = I3Position(0, 0, 0))

Private Types

typedef detail::CupBase<SamplingSurface> Base

Private Functions

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

Friends

friend class icecube::serialization::access
template<typename Base>
class CupBase : public Base
#include <CupBase.h>

Public Functions

inline CupBase(double olength, double ilength, double oradius, double iradius, I3Position center = I3Position(0, 0, 0))
inline std::pair<double, double> GetIntersection(const I3Position &p, const I3Direction &dir) const
inline double GetArea(const I3Direction &dir) const
inline double GetMaximumArea() const
inline virtual double GetAcceptance(double cosMin = 0, double cosMax = 1) const
inline I3Direction SampleDirection(I3RandomService &rng, double cosMin = 0, double cosMax = 1) const
inline I3Position SampleImpactPosition(const I3Direction &dir, I3RandomService &rng) const
inline void SetLength(double v)
inline double GetLength() const
inline void SetRadius(double v)
inline double GetRadius() const
inline void SetCenter(const I3Position &v)
inline I3Position GetCenter() const

Protected Functions

inline CupBase()

Private Functions

inline double GetAreaForZenith(double coszen) const
template<typename Archive>
inline void serialize(Archive &ar, unsigned version)

Private Members

double olength_
double oradius_
double ilength_
double iradius_
I3Position center_

Friends

friend class icecube::serialization::access
class Cylinder : public I3Surfaces::detail::CylinderBase<SamplingSurface>
#include <Cylinder.h>

A cylinder aligned with the z axis.

Public Functions

virtual ~Cylinder()
inline Cylinder(double length, double radius, I3Position center = I3Position(0, 0, 0))
std::ostream &Print(std::ostream &os) const

Private Types

typedef detail::CylinderBase<SamplingSurface> Base

Private Functions

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

Friends

friend class icecube::serialization::access
template<typename Base>
class CylinderBase : public Base
#include <CylinderBase.h>

Public Functions

inline CylinderBase(double length, double radius, I3Position center = I3Position(0, 0, 0))
inline std::pair<double, double> GetIntersection(const I3Position &p, const I3Direction &dir) const
inline double GetArea(const I3Direction &dir) const
inline double GetMaximumArea() const
inline virtual double GetAcceptance(double cosMin = 0, double cosMax = 1) const
inline I3Direction SampleDirection(I3RandomService &rng, double cosMin = 0, double cosMax = 1) const
inline I3Position SampleImpactPosition(const I3Direction &dir, I3RandomService &rng) const
inline void SetLength(double v)
inline double GetLength() const
inline void SetRadius(double v)
inline double GetRadius() const
inline void SetCenter(const I3Position &v)
inline I3Position GetCenter() const

Protected Functions

inline CylinderBase()

Private Functions

inline double GetAreaForZenith(double coszen) const
template<typename Archive>
inline void serialize(Archive &ar, unsigned version)

Private Members

double length_
double radius_
I3Position center_

Friends

friend class icecube::serialization::access
class ExtrudedPolygon : public I3Surfaces::ExtrudedPolygonBase<SamplingSurface>
#include <ExtrudedPolygon.h>

Public Functions

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

Private Types

typedef ExtrudedPolygonBase<SamplingSurface> Base

Private Functions

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

Friends

friend class icecube::serialization::access
template<typename Base>
class ExtrudedPolygonBase : public Base

Public Functions

inline ExtrudedPolygonBase(const std::vector<I3Position> &points, double padding = 0.)
inline virtual std::pair<double, double> GetIntersection(const I3Position &p, const I3Direction &dir) const

Calculate distance to entry and exit points.

The distance to the entry point is the distance from vertex p along direction dir to the point where the ray defined by p and dir enters the (convex) surface. The exit point is defined similarly.

Returns:

a pair (entry, exit). If either is NaN, then the ray does not intersect the surface.

inline double GetArea(const I3Direction &dir) const
inline double GetMaximumArea() const
inline virtual double GetAcceptance(double cosMin = 0, double cosMax = 1) const
inline I3Position SampleImpactPosition(const I3Direction &dir, I3RandomService &rng) const
inline std::vector<double> GetX() const
inline std::vector<double> GetY() const
inline std::vector<double> GetZ() const

Protected Functions

inline ExtrudedPolygonBase()
inline double GetCapArea() const
inline double GetAverageSideArea() const
inline double GetLength() const
inline std::pair<double, double> GetZRange() const

Private Functions

inline void initWithHull(const std::vector<polygon::vec2> &hull, const std::pair<double, double> &zrange)
inline std::pair<double, double> GetDistanceToCaps(const I3Position &p, const I3Direction &dir) const

Get distances to the infinite horizontal planes that define the top and bottom of the surface.

The distance to the entry point is the distance from vertex p along direction dir to the point where the ray defined by p and dir crosses the top or the bottom plane, whichever comes first. The exit point is defined similary.

inline std::pair<double, double> GetDistanceToHull(const I3Position &pos, const I3Direction &dir) const

Get distances to sides of the of the surface.

The sides of the surface are defined by a polygon in the x-y plane, extended infinitely along the z axis. The distance to the entry point is the distance from vertex p along direction dir to the point where the ray defined by p and dir first crosses one of the line segments that define the x-y polygon. The exit point is the distance to the last such crossing.

inline bool PointInHull(const I3Position &pos) const

Test whether pos is in the x-y polygon.

inline double GetDistanceToCap(const I3Position &p, const I3Direction &dir, double cap_z) const
template<typename Archive>
inline void save(Archive &ar, unsigned version) const
template<typename Archive>
inline void load(Archive &ar, unsigned version)
I3_SERIALIZATION_SPLIT_MEMBER()

Private Members

std::vector<polygon::side> sides_
std::pair<double, double> z_range_
double cap_area_

Friends

friend class icecube::serialization::access
struct finalStateRecord
#include <I3CrossSection.h>

A single final state drawn from a differential cross section

Public Functions

inline finalStateRecord(double x, double y)

Public Members

double x

Bjorken x.

double y

Bjorken y.

struct FramePusher

Public Functions

inline FramePusher(I3SplitTriggerSelector *m, boost::shared_ptr<I3Frame> f)
inline ~FramePusher()

Public Members

I3SplitTriggerSelector *module
boost::shared_ptr<I3Frame> frame
struct gsl_rng_wrapper_state

An implementation of the I3RandomService interface.

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Uses the gsl library for the random numbers

Version

$Revision$

Date

$Date$

Author

pretz This is (the state for) a shim which allows us to count the calls to the RNG, but otherwise hands all work off to the real GSL implmentations.

Public Members

unsigned long int seed
uint64_t icalls
uint64_t dcalls
gsl_rng *rng
struct gsl_sprng_stream
#include <gsl-sprng.h>

SPRNG Implementation of the I3RandomService interface. This implementation uses a combination of SPRNG and GSL to generate statistically independent streams of pseudo-random number distributions. SPRNG (Scalable Pseudo-Random Number Generator) is a library developed by Michael Mascagni, et al at Florida State University, http://sprng.cs.fsu.edu.

gsl-sprng.h Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

The purpose of this implementation is to provide an I3RandomService that can be used in a distributed computing environment and ensuring little correlation between parallel streams of numbers.

The basic approach for this is based on code from Darren Wilkinson https://darrenjw.github.io/ who wrote an MPI simple interface that doesn’t make use of streams.

Todo:
Version

$Revision$

Date

$Date$

Author

juancarlos

Public Members

int seed
int streamnum
int nstreams
int *streamptr
char *savedstate
uint64_t icalls
uint64_t dcalls
class I3BadDOMAuditor : public I3Module

$Id$

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

Public Functions

I3BadDOMAuditor(const I3Context &context)
void Configure()
void Finish()
void DetectorStatus(I3FramePtr frame)
void DAQ(I3FramePtr frame)

Private Functions

void CheckResults()

Private Members

boost::shared_ptr<const I3Vector<OMKey>> bad_doms_
I3GeometryConstPtr geo_
std::vector<std::string> pulses_
std::vector<OMKey> ignore_oms_
std::string bad_dom_list_
std::map<OMKey, int> pulse_counts_
boost::shared_ptr<const I3Time> good_run_start_time_
boost::shared_ptr<const I3Time> good_run_end_time_
bool use_good_run_times_
bool out_of_good_time_range_
bool skip_check
bool bad_doms_dont_trigger_
bool icetop_always_triggers_
class I3CascadeCutValues : public I3CutValuesBase

A class to store the basic hit information for cascades from the event.

Public Functions

inline I3CascadeCutValues()
virtual void Calculate(const I3Particle &vertex, const I3Geometry &geometry, const I3Map<OMKey, std::vector<I3RecoPulse>> &pulsemap, const double &begTWindow = I3Constants::dt_window_l, const double &endTWindow = I3Constants::dt_window_h) override
virtual ~I3CascadeCutValues()
std::ostream &Print(std::ostream&) const override

Public Members

int Nchan
int Nhit
int N_1hit
int Nstring
int Ndir
int Nearly
int Nlate
I3Position cog

Private Functions

template<class Archive>
void serialize(Archive &ar, unsigned version)

Friends

friend class icecube::serialization::access
class I3CrossSection
#include <I3CrossSection.h>

Encapsulates cross section information for one physical process with a two-body final state.

Cross sections are stored as a pair of photospline objects: one spline for the differential cross section, and one for the total cross section. The latter could be derived from the former, but is included to avoid users having to repeatedly integrate the differential spline numerically.

The differential spline must have three dimensions:

  • log10 of incoming neutrino energy in GeV

  • log10 of final state x

  • log10 of final state y

The value of the spline must be the log10 of the cross section. The absolute value of the differential cross section is never used, so its units are not important, however it is advisable that it should be consistent with the total cross section (see below).

The total spline must have one dimension, which is log10 of incoming neutrino energy in GeV. The value of the spline must be the log10 of the total cross section in square meters.

Public Types

using splinetable_t = photospline::splinetable<>

Public Functions

inline I3CrossSection()

Create an instance with empty cross section splines.

inline I3CrossSection(const std::string &dd_crossSectionFile, const std::string &total_crossSectionFile)

Create an instance from cross section splines stored in FITS files.

Parameters:
  • dd_crossSectionFile[in] Path to the doubly-differential cross section spline to load

  • total_crossSectionFile[in] Path to the total cross section file to load

I3CrossSection(const I3CrossSection&) = default
I3CrossSection(I3CrossSection&&) = default
~I3CrossSection() = default
I3CrossSection &operator=(const I3CrossSection&) = default
I3CrossSection &operator=(I3CrossSection&&) = default
finalStateRecord sampleFinalState(double energy, I3Particle::ParticleType scatteredType, boost::shared_ptr<I3RandomService> random) const

Sample a final state.

Parameters:
  • energy[in] The energy of the incoming neutrino in GeV

  • scatteredType[in] The type of the outgoing lepton

  • random[in] A pseudo-random number generator

Returns:

The sampled final state

finalStateRecord sampleFinalState_DIS(double energy, I3Particle::ParticleType scatteredType, boost::shared_ptr<I3RandomService> random) const

Sample a final state.

Parameters:
  • energy – the energy of the incoming neutrino

  • scatteredType – the type of the outgoing lepton

  • random – a source of random numbers

finalStateRecord sampleFinalState_GR(double energy, I3Particle::ParticleType scatteredType, boost::shared_ptr<I3RandomService> random) const
double evaluateCrossSection(double energy, double x, double y, I3Particle::ParticleType scatteredType) const

Get the value of the doubly-differential cross section.

Parameters:
  • energy[in] The neutrino energy in GeV

  • x[in] Bjorken x (fraction of the nucleon momentum in the struck parton)

  • y[in] Bjorken y (fraction of incoming energy transferred to the nucleon)

  • scatteredType[in] The type of the outgoing lepton

Returns:

The doubly-differential cross section in square meters

double evaluateTotalCrossSection(double energy) const

Get the value of the total cross section.

Parameters:

energy[in] The neutrino energy in GeV

Returns:

The total cross section in square meters

inline const splinetable_t &getCrossSection() const
Returns:

Doubly-differential cross section spline

inline const splinetable_t &getTotalCrossSection() const
Returns:

Total cross section spline

void load(const std::string &dd_crossSectionFile, const std::string &total_crossSectionFile)

Load cross section splines stored in FITS files.

Parameters:
  • dd_crossSectionFile[in] Path to the doubly-differential cross section spline to load

  • total_crossSectionFile[in] Path to the total cross section file to load

inline double getQ2Min() const
Returns:

The minimum value of Q^2 for which the cross section was calculated

inline double getTargetMass() const
Returns:

The mass of the target nucleon for which the cross section was calculated

double getMinimumEnergy() const
Returns:

The minimum energy included in this cross section table

double getMaximumEnergy() const
Returns:

The maximum energy included in this cross section table

Private Members

std::shared_ptr<splinetable_t> crossSection_

Total cross section spline.

std::shared_ptr<splinetable_t> totalCrossSection_

Doubly-differential cross section spline.

double Q2Min_

The minimum value of Q^2 for which the cross section was calculated.

double targetMass_

The mass of the target nucleon.

int interaction_

The interaction type, related to dimensionality of the.

class I3CutsModule : public I3ConditionalModule
#include <I3CutsModule.h>

$Id$ Copyright (c) 2005 IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause

Author

D.Turcan

Public Functions

I3CutsModule(const I3Context &ctx)
inline ~I3CutsModule()
void Configure()
void Physics(I3FramePtr frame)

Private Functions

I3CutsModule()
I3CutsModule(const I3CutsModule &source)
I3CutsModule &operator=(const I3CutsModule &source)
SET_LOGGER ("I3CutsModule")

Named stream for my logging messages. Allows my messages to be sent to a particular log file, to be set to a special threshold, etc.

Private Members

std::string particleName_

Parameter: name(s) of the I3Particle(s) that the module writes to tree(s). Multiple names can be included, separated by “,”. If no name is set, all of the I3Particles from the event will be written.

std::vector<std::string> particleNameList_

List of I3Particle names that the module writes to trees.

std::string hitsName_

Parameter: name of the hit series map to use in the calculation of the cut parameters.

std::string pulsesName_

Parameter: name of the pulse series map to use in the calculation of the cut parameters.

std::string nameTag_

Parameter: Optional tag for the name of the object inserted by this module into the frame.

std::vector<double> timeRange_

Parameter: time range for calculating direct hits.

class I3CutValues : public I3CutValuesBase
#include <I3CutValues.h>

A class to store the basic hit information from the event.

Public Functions

inline I3CutValues()
virtual void Calculate(const I3Particle &track, const I3Geometry &geometry, const I3Map<OMKey, std::vector<I3RecoPulse>> &pulsemap, const double &begTWindow = I3Constants::dt_window_l, const double &endTWindow = I3Constants::dt_window_h) override
virtual ~I3CutValues()
std::ostream &Print(std::ostream&) const override

Public Members

int Nchan
int Nhit
int Nstring
int Ndir
double Ldir
double Sdir
double Sall
I3Position cog

Private Functions

template<class Archive>
void serialize(Archive &ar, unsigned version)

Friends

friend class icecube::serialization::access
class I3CutValuesBase : public I3FrameObject
#include <I3CutValuesBase.h>

Subclassed by I3CascadeCutValues, I3CutValues

Public Functions

virtual void Calculate(const I3Particle &vertex, const I3Geometry &geometry, const I3Map<OMKey, std::vector<I3RecoPulse>> &pulsemap, const double &begTWindow = I3Constants::dt_window_l, const double &endTWindow = I3Constants::dt_window_h) = 0

Private Functions

template<class Archive>
void serialize(Archive &ar, unsigned version)

Friends

friend class icecube::serialization::access
class I3CutValuesConverter : public I3ConverterImplementation<I3CutValues>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Private Functions

I3TableRowDescriptionPtr CreateDescription(const I3CutValues &cv)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

size_t FillRows(const I3CutValues &cv, I3TableRowPtr rows)
class I3EventCounter : public I3Module
#include <I3EventCounter.h>

Public Functions

I3EventCounter(const I3Context &ctx)
inline ~I3EventCounter()
void Configure()
void Physics(I3FramePtr frame)
void DetectorStatus(I3FramePtr frame)
void Geometry(I3FramePtr frame)
void Calibration(I3FramePtr frame)
void Finish()

Private Functions

I3EventCounter()
I3EventCounter(const I3EventCounter &source)
I3EventCounter &operator=(const I3EventCounter &source)
SET_LOGGER ("I3EventCounter")

Private Members

unsigned int physCount_

Parameter: name of output histogram file

unsigned int statusCount_
unsigned int geometryCount_
unsigned int calibCount_
unsigned int counterStep_
unsigned int nevents_

Parameter: how many physics events to process

double systime_
double usertime_
I3MapStringDoublePtr summary_
bool dump_

Parameter: whether to dump current frame to screen

std::string path_
std::string fmt_
std::ostream *out
char buffer[200]
std::string eventHeaderName_
std::string physicsCounterName_
std::string geoCounterName_
std::string calibCounterName_
std::string statusCounterName_
template<class HitType>
class I3EventInfoConverter : public I3ConverterImplementation<I3Map<OMKey, std::vector<HitType>>>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

Private Functions

inline I3TableRowDescriptionPtr CreateDescription(const I3Map<OMKey, std::vector<HitType>> &hitmap)
inline size_t FillRows(const I3Map<OMKey, std::vector<HitType>> &hitmap, I3TableRowPtr rows)
class I3FileOMKey2MBID : public I3OMKey2MBID
#include <I3FileOMKey2MBID.h>

An implementation of I3OMKey2MBID that reads the conversions from a file.

Public Functions

explicit I3FileOMKey2MBID(const std::string &infile)

Constructor takes the name of the input file.

virtual ~I3FileOMKey2MBID()

Destructor.

inline bool OMKeyExists(long long int mbid) const
inline OMKey GetOMKey(long long int mbid) const
inline bool MBIDExists(OMKey key) const
inline long long int GetMBID(OMKey key) const
virtual void DumpAsXML(const std::string &outfile) const

Dump conversion table into XML file.

Note

This XML file can be used as input for I3XMLOMKey2MBID.

Parameters:

outfile – The filename.

Private Types

typedef std::map<OMKey, long long int> map_omkey2mbid
typedef std::map<long long int, OMKey> map_mbid2omkey

Private Functions

OMKey OMKeyize(const std::string &key)

Todo:

This is an ugly mess.

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

Private Members

map_omkey2mbid omkey2mbid_
map_mbid2omkey mbid2omkey_
class I3FileOMKey2MBIDFactory : public I3ServiceFactory

Public Functions

I3FileOMKey2MBIDFactory(const I3Context &context)
inline virtual ~I3FileOMKey2MBIDFactory()
bool InstallService(I3Context &services)
void Configure()

Private Functions

I3FileOMKey2MBIDFactory(const I3FileOMKey2MBIDFactory &rhs)
I3FileOMKey2MBIDFactory operator=(const I3FileOMKey2MBIDFactory &rhs)
SET_LOGGER ("I3FileOMKey2MBIDFactory")

Private Members

std::string infile_
I3OMKey2MBIDPtr service_
class I3GCDAuditor : public I3Module

$Id$

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

Public Functions

I3GCDAuditor(const I3Context &context)
void Configure()
void DetectorStatus(I3FramePtr frame)

Private Functions

bool CheckDOM(OMKey om, const I3OMGeo &omgeo, const I3DOMCalibration &cal, const I3DOMStatus &status)

Private Members

std::string bad_dom_list_
bool AMANDA_is_error_
bool max_paranoia_
class I3GCDFileCalibrationService : public I3CalibrationService
#include <I3GCDFileService.h>

A I3CalibrationOrigin which reads the geometry from a GCD File.

Public Functions

inline I3GCDFileCalibrationService(const std::string &icefile)
inline virtual ~I3GCDFileCalibrationService()
I3CalibrationConstPtr GetCalibration(I3Time time)

Private Members

std::string filename_
I3CalibrationConstPtr cal_
class I3GCDFileDetectorStatusService : public I3DetectorStatusService
#include <I3GCDFileService.h>

A I3DetectorStatusOrigin which reads the geometry from a GCD File.

Public Functions

inline I3GCDFileDetectorStatusService(const std::string &icefile)
inline virtual ~I3GCDFileDetectorStatusService()
I3DetectorStatusConstPtr GetDetectorStatus(I3Time time)

Private Members

std::string filename_
I3DetectorStatusConstPtr stat_
class I3GCDFileGeometryService : public I3GeometryService
#include <I3GCDFileService.h>

A I3GeometryOrigin which reads the geometry from a GCD File.

Public Functions

inline I3GCDFileGeometryService(const std::string &icefile)
inline virtual ~I3GCDFileGeometryService()
I3GeometryConstPtr GetGeometry(I3Time time)

Private Members

std::string filename_
I3GeometryConstPtr geo_
class I3GCDFileServiceFactory : public I3ServiceFactory

Public Functions

I3GCDFileServiceFactory(const I3Context &context)
virtual ~I3GCDFileServiceFactory()
virtual bool InstallService(I3Context &services)
virtual void Configure()

Private Functions

I3GCDFileServiceFactory(const I3GCDFileServiceFactory &rhs)
I3GCDFileServiceFactory operator=(const I3GCDFileServiceFactory &rhs)
SET_LOGGER ("I3GCDFileServiceFactory")

Private Members

boost::shared_ptr<I3GCDFileGeometryService> geometry_
boost::shared_ptr<I3GCDFileCalibrationService> calibration_
boost::shared_ptr<I3GCDFileDetectorStatusService> status_
std::string filename_
class I3GeometryDecomposer : public I3Module

Splits an I3Geometry object into its components (I3OMGeoMap, I3StationGeoMap and I3Time) and stores them in the Geometry frame.

$Id$

Copyright (C) 2012 Claudio Kopper ckopper@icecube.wisc.edu Copyright (C) 2012 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause While at it, this also generates an I3ModuleGeoMap.

Public Functions

I3GeometryDecomposer(const I3Context &context)
void Configure()
void Geometry(I3FramePtr frame)

Private Functions

I3ModuleGeoMapPtr GenerateI3ModuleGeo(const I3OMGeoMap &omgeo) const

Generates an I3ModuleGeoMap from a I3OMGeoMap.

I3MapModuleKeyStringPtr GenerateSubdetectorMap(const I3OMGeoMap &omgeo) const

distinguish between IceCube, IceTop and DeepCore by string number only

Private Members

bool deleteI3Geometry_
boost::python::object if_
bool use_if_
class I3GeometrySelectorService : public I3GeometryService

A I3GeometryOrigin which reads the default geometry and serves up a reduced geometry.

Public Functions

inline I3GeometrySelectorService(I3GeometryServicePtr g, double dx = 0., double dy = 0., double dz = 0.)
inline void ShiftToCenter(bool s)
inline void SetGoodStrings(std::vector<int> &v)
inline void SetGoodStations(std::vector<int> &v)
inline virtual ~I3GeometrySelectorService()
I3GeometryConstPtr GetGeometry(I3Time time)

Private Functions

SET_LOGGER ("I3GeometrySelectorService")

Private Members

std::vector<int> goodStrings_

A list of std::strings to use. This vector is constructed from the input parameters StringsToUse and StringsToExclude.

std::vector<int> goodStations_

A list of std::strings to use. This vector is constructed from the input parameters StringsToUse and StringsToExclude.

I3GeometryServicePtr geo_service_
double shiftX_
double shiftY_
double shiftZ_
bool shiftToCenter_
class I3GeometrySelectorServiceFactory : public I3ServiceFactory

IceTray module that selects the strings to use.

This module has only two parameters “StringsToUse” and “StringsToExclude” The default values for StringsToUse is the entire 80 string IceCube detector and AMANDA (i.e. “-19:80”). No strings are excluded by default.

Examples values for the parameters are…

1) Use only the IceCube detector. Either set StringsToUse to “1:80” or set StringsToExclude to “-19:0” (remember the default value for StringsToUse is “-19:80”).

2) Use the current geometry (as of mid Jan ‘06). Set StringsToUse to “21,29,30,38,39,-19:-1”

Public Functions

I3GeometrySelectorServiceFactory(const I3Context &ctx)
virtual ~I3GeometrySelectorServiceFactory()
virtual void Configure()

Checks the two parameters StringsToUse and StringsToExclude are valid.

virtual bool InstallService(I3Context &services)

Private Functions

I3GeometrySelectorServiceFactory()

default constructor, assignment operator, and copy constructor declared private to prevent use

I3GeometrySelectorServiceFactory(const I3GeometrySelectorServiceFactory &source)
I3GeometrySelectorServiceFactory &operator=(const I3GeometrySelectorServiceFactory &source)
SET_LOGGER ("I3GeometrySelectorServiceFactory")

Private Members

boost::shared_ptr<I3GeometrySelectorService> geometry_
std::string stringsToUse_

Parameter - The strings to use. Default value is “-19:80”.

std::string stringsToExclude_

Parameter - The strings to exclude. Default value is NULL.

std::string stationsToUse_

Parameter - The stations to use. Default value is “-19:80”.

std::string stationsToExclude_

Parameter - The stations to exclude. Default value is NULL.

double shiftX_

Distance in X to shift the detector

double shiftY_

Distance in Y to shift the detector

double shiftZ_

Distance in Z to shift the detector

bool shiftToCenter_

Shift to the center of the detector in X-Y

std::vector<int> goodStrings_

A list of strings to use. This vector is constructed from the input parameters StringsToUse and StringsToExclude.

std::vector<int> goodStations_

A list of strings to use. This vector is constructed from the input parameters StringsToUse and StringsToExclude.

std::string geoSelectorName_

Name of the new geometry service. The muxer needs this name.

std::string geoServiceName_

Name of the previous geometry service.

class I3GeoSelTestModule : public I3Module

IceTray module to test whether I3GeometrySelector is working properly. The two parameters stringsToUse_ and stringsToExclude_ should be set to the same values as the I3GeometrySelector. This test passes if the geometry contains only OMs that are in stringsToUse_ and does not contain any DOMs that are in stringsToExclude_.

Public Functions

I3GeoSelTestModule(const I3Context &ctx)
~I3GeoSelTestModule()
void Configure()

This module takes a configuration parameter and so it must be configured

void Geometry(I3FramePtr frame)

We’ll want to trim the geometry everytime it gets updated.

void Physics(I3FramePtr frame)

Private Functions

I3GeoSelTestModule()

default constructor, assignment operator, and copy constructor declared private to prevent use

I3GeoSelTestModule(const I3GeoSelTestModule &source)
I3GeoSelTestModule &operator=(const I3GeoSelTestModule &source)
SET_LOGGER ("I3GeoSelTestModule")

Private Members

std::string stringsToUse_

Takes the form of “i,j,n:m” and this will use strings i,j,n,n+1,…,m-1,m

std::string stringsToExclude_

Takes the form of “i,j,n:m” and this will exclude strings i,j,n,n+1,…,m-1,m

std::string stationsToUse_

Takes the form of “i,j,n:m” and this will use stations i,j,n,n+1,…,m-1,m

std::string stationsToExclude_

Takes the form of “i,j,n:m” and this will exclude stations i,j,n,n+1,…,m-1,m

double shiftX_
double shiftY_
double shiftZ_
bool detectorCentered_
std::vector<int> goodStrings_

This is the list of strings to use

std::vector<int> goodStations_
class I3GSLRandomService : public I3RandomService

Public Functions

I3GSLRandomService()

default constructor

explicit I3GSLRandomService(unsigned long int seed, bool track_state = true)

constructor

virtual ~I3GSLRandomService()

destructor

virtual int Binomial(int ntot, double prob)

a number drawn from a binomial distribution

virtual double Exp(double tau)

A number from an Exponential distribution

virtual unsigned int Integer(unsigned int imax)

An integer drawn uniformly from [0,imax)

virtual uint32_t Integer32()

Generate an integer drawn uniformly from amongst all 32-bit integers, that is [0, 4294967295]

virtual int Poisson(double mean)

An integer drawn from a Poisson distribution

virtual double PoissonD(double mean)

A number drawn from a Poisson distribution, as a double

virtual double Uniform(double x1 = 1)

a double drawn from a uniform distribution (0,x1)

virtual double Uniform(double x1, double x2)

a double drawn from a uniform distribution (x1,x2)

virtual double Gaus(double mean, double stddev)

a double drawn from a Gaussian distribution with given mean and standard deviation

virtual I3FrameObjectPtr GetState() const

get all information necessary to restore the internal state of the generator

virtual void RestoreState(I3FrameObjectConstPtr state)

restore the internal state of the generator

Private Functions

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

Private Members

gsl_rng *r
bool track_state

Private Static Functions

static inline void construct(gsl_rng *&r)

Helper function which constructs our preferred GSL RNG.

static inline void construct_counted(gsl_rng *&r)

Helper function which constructs a GSL RNG wrapped with the counting shim

Friends

friend void gsl_wrapper_set(void *vstate, unsigned long int s)
class I3GSLRandomServiceFactory : public I3ServiceFactory

This class installs a I3GSLRandomService.

I3GSLRandomService supports two parameters: Seed, InstallServiceAs.

Version

$Id$

Author

pretz

Public Functions

I3GSLRandomServiceFactory(const I3Context &context)
virtual ~I3GSLRandomServiceFactory()
virtual bool InstallService(I3Context &services)

Installed this objects service into the specified services object.

Parameters:

services – the I3Context into which the service should be installed.

Returns:

true if the services is successfully installed.

virtual void Configure()

Configure service prior to installing it.

Private Functions

I3GSLRandomServiceFactory(const I3GSLRandomServiceFactory &rhs)
I3GSLRandomServiceFactory operator=(const I3GSLRandomServiceFactory &rhs)
SET_LOGGER ("I3GSLRandomServiceFactory")

Private Members

unsigned long seed_
bool track_state_
I3RandomServicePtr random_
std::string installServiceAs_
struct I3GSLRandomServiceState : public I3FrameObject

Public Functions

template<typename Archive>
inline void serialize(Archive &ar, unsigned version)
inline std::ostream &Print(std::ostream &os) const override

Public Members

std::string gsl_version_
std::string rng_type_
unsigned long int seed_
uint64_t icalls_
uint64_t dcalls_

Friends

friend class icecube::serialization::access
template<typename Key, typename Value>
struct I3Map

Copyright (C) 2005 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Copyright (C) 2005 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Author

mdagost

Author

dule

class I3MetaSynth : public I3Module

$Id$

Copyright (C) 2011 The IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

Public Functions

I3MetaSynth(const I3Context &context)
void Configure()
void Process()

Private Functions

void CheckGCDUpdate(I3Time event_time)

Private Members

I3GeometryConstPtr geometry_
I3CalibrationConstPtr calibration_
I3DetectorStatusConstPtr detectorstatus_
I3GeometryServicePtr geometryService_
I3CalibrationServicePtr calibrationService_
I3DetectorStatusServicePtr detectorStatusService_
class I3MTRandomService : public I3StdRandomEngine<I3MTRandomService>

An implementation of the I3RandomService interface using the C++ random number engine for MT19937.

This class is a wrapper for the standard C++11 random number generator. It implements the Mersenne Twister algorithm implemenation MT19937. This is the most widely used algorithm to generate a string of random numbers for statistical analysis: it has a period of 2^19937-1 and is indpendent in up to 623 dimensions.

Being a deterministic random number generator, it needs a seed to initilize the internal state. There are three differnt constructors which initilize the internal state in different ways: the default constructor, a single integer seed, and a vector of integers. The vector is can be used for distributed computing

The distribuitons from the parent class I3RandomService are all defined: Binonial, Exponential, Integer, Poisson, Uniform, and Gaussian.

The internal state can be saved and restored as an I3String representing the internals state as a string of 624 integers

Public Functions

I3MTRandomService()

default constructor uses the default seed as defined by the MT19937 paper. Equivelent to I3MTRandomService(5489)

I3MTRandomService(uint32_t seed)

Constructor initilizes the internal state of the random number generator using the state generating function defined in the MT19937 paper

explicit I3MTRandomService(std::vector<uint32_t> seed_vector)

Initilize random number generator with the specified seed vector. This uses the c++11 seed sequence to initilize the internal state of the random number generator. Similar seeds such as {0,0} and {0,1} will result in independent and uncorrelated random bit streams and are appropiate for distributed computing. For example passing {run_number,job_number} to each job submitted to a cluster will result in independent random bit streams for each job.

virtual ~I3MTRandomService()

destructor

virtual I3FrameObjectPtr GetState() const

Get all information necessary to restore the internal state of the generator.

virtual void RestoreState(I3FrameObjectConstPtr state)

Restore the internal state of the generator

inline std::mt19937 &engine()
inline const std::mt19937 &engine() const
SET_LOGGER ("I3MTRandomService")

Private Members

std::mt19937 engine_
class I3MTRandomServiceFactory : public I3ServiceFactory

This class installs a I3MTRandomService in the context.

I3MTRandomService takes two parameters: Seed, InstallServiceAs.

Public Functions

I3MTRandomServiceFactory(const I3Context &context)
virtual ~I3MTRandomServiceFactory()
virtual bool InstallService(I3Context &services)

Installed this objects service into the specified context

Parameters:

services – the I3Context into which the service should be installed.

Returns:

true if the services is successfully installed.

virtual void Configure()

Configure service prior to installing it.

Private Functions

I3MTRandomServiceFactory(const I3MTRandomServiceFactory &rhs)
I3MTRandomServiceFactory operator=(const I3MTRandomServiceFactory &rhs)
SET_LOGGER ("I3MTRandomServiceFactory")

Private Members

std::vector<std::uint32_t> seed_vector_

initilization vector to create the seed for the random number generator

std::string installServiceAs_

name with which to install this service in the context

I3RandomServicePtr random_

pointer to the random service

class I3NullSplitter : public I3ConditionalModule, public I3Splitter

$Id$

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

Public Functions

I3NullSplitter(const I3Context &context)
void Configure()
void DAQ(I3FramePtr frame)

Private Members

std::string input_
std::string output_
class I3OrphanQDropper : public I3PacketModule

$Id$

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

Public Functions

I3OrphanQDropper(const I3Context &context)
void FramePacket(std::vector<I3FramePtr> &packet)
class I3RandomService
#include <I3RandomService.h>

This class provides an interface to random numbers suitable for use by icetray modules.

This class is just the interface. The names chosen reflect ROOT’s TRandom interface. Indeed TRandom could be used to trivially fill this interface

Only one function here is required: Uniform(x1, x2) The rest have default implementations in terms of it. More complicated random number distributions than provided here can be obtained using the GSL bridge (GSLRng()).

NOTE: when using the GSL bridge, this file MUST be included AFTER gsl/gsl_rng.h

Subclassed by I3GSLRandomService, I3SPRNGRandomService, I3StdRandomEngine< Base >, I3StdRandomEngine< I3MTRandomService >

Public Types

typedef unsigned int result_type

The unsigned integer type produced when this class is used as a uniform random number generator

Public Functions

I3RandomService()

constructor

virtual ~I3RandomService()

destructor

virtual int Binomial(int ntot, double prob)

a number drawn from a binomial distribution

virtual double Exp(double tau)

A number from an Exponential distribution

virtual unsigned int Integer(unsigned int imax)

An integer drawn uniformly from [0,imax)

virtual uint32_t Integer32()

Generate an integer drawn uniformly from amongst all 32-bit integers, that is [0, 4294967295]

virtual int Poisson(double mean)

An integer drawn from a Poisson distribution

virtual double PoissonD(double mean)

A number drawn from a Poisson distribution, as a double

virtual double Uniform(double x1 = 1)

a double drawn from a uniform distribution [0,x1)

virtual double Uniform(double x1, double x2) = 0

a double drawn from a uniform distribution [x1,x2)

virtual double Gaus(double mean, double stddev)

a double drawn from a Gaussian distribution with given mean and standard deviation

inline virtual I3FrameObjectPtr GetState() const

get all information necessary to restore the internal state of the generator

inline virtual void RestoreState(I3FrameObjectConstPtr state)

restore the internal state of the generator

const gsl_rng_wrap *GSLRng() const

a gsl_rng that wraps this random service, for use with GSL random samplers and C APIs

inline result_type min() const

The minimum value produced when this object is used as a source of random integers

inline result_type max() const

The maximum value produced when this object is used as a source of random integers

inline result_type operator()()

Returns a value in the closed interval [min(), max()]

Public Static Attributes

static const bool has_fixed_range = false

Only necessary for compatibility with old versions of boost; this flag indicates that optional parts of the old boost interface for uniform random number generators have been omitted.

Private Functions

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

Private Members

gsl_rng_wrap *gsl_
class I3RecoInfoConverter : public I3ConverterImplementation<I3Particle>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

Public Functions

I3RecoInfoConverter()
I3RecoInfoConverter(std::string pulseMapName)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$ copied from Sebastian Panknin’s I3RecoInfoToTable in hdf-writer

I3RecoInfoConverter(std::string pulseMapName, int icecubeConf_, int icetopConf_)

Private Functions

I3TableRowDescriptionPtr CreateDescription(const I3Particle &reco)
size_t FillRows(const I3Particle &reco, I3TableRowPtr rows)
std::string generateDocString(std::string prefix, std::string identifier, bool muon)
void defineTimeWindows()
SET_LOGGER ("I3RecoInfoConverter")

Private Members

std::string pulseMapName_
int icecubeConf_
int icetopConf_
std::map<std::string, std::pair<double, double>> timeWindows_
std::map<std::string, std::pair<double, double>> muonTimeWindows_
class I3ScaleCalculator

The Scale object can calculate containment and scaling, knowing the geometry of the detector and using phys-service functions.

This file is the header file of the Scale class

Copyright (C) 2007 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Sebastian Panknin sebastian.panknin@desy.de Last changed by: $LastChangedBy$

Public Types

enum IceCubeConfig

Values:

enumerator IC_UNKNOWN
enumerator IC_GUESS
enumerator IC_EMPTY
enumerator IC_CUSTOM
enumerator IC79
enumerator IC86
enumerator IC79_STRICT
enumerator IC79_SMOOTH
enumerator IC86_STRICT
enumerator IC86_SMOOTH
enumerator DEEPCORE_ALL
enumerator DEEPCORE_BELOWDUST
enum IceTopConfig

Values:

enumerator IT_UNKNOWN
enumerator IT_GUESS
enumerator IT_EMPTY
enumerator IT_CUSTOM
enumerator IT73
enumerator IT81
enumerator IT73_STRICT
enumerator IT73_SMOOTH
enumerator IT81_STRICT
enumerator IT81_SMOOTH
enumerator IT_INFILL_STA2_STRICT
enumerator IT_INFILL_STA2_BIGOVAL
enumerator IT_INFILL_TRIANGLE

Public Functions

I3ScaleCalculator(I3GeometryConstPtr geo, IceCubeConfig iceConf = IC_GUESS, IceTopConfig topConf = IT_GUESS, std::vector<int> strings = std::vector<int>(), std::vector<int> stations = std::vector<int>(), int topDOMid = 1, int bottomDOMid = 60)
std::vector<int> GetOuterStrings() const
std::vector<int> GetOuterStations() const
void CalcOuterStringPositions(std::vector<double> &x, std::vector<double> &y, double &zMin, double &zMax) const
void CalcOuterStationPositions(std::vector<double> &x, std::vector<double> &y, double &z) const
double ScaleInIce(I3Particle part) const
double ScaleIceCubeDetectorPolygon(I3Particle part) const
double ScaleIceTop(I3Particle part) const
bool VertexIsInside(const I3Particle &part) const

Private Functions

SET_LOGGER ("I3ScaleCalculator")
IceCubeConfig GuessIceCubeConfig() const
IceTopConfig GuessIceTopConfig() const
double ScaleInIceMuon(I3Particle part) const
double ScaleInIceCascade(I3Particle part, bool areaonly) const
bool IsInside(double xp, double yp, const std::vector<double> &x, const std::vector<double> &y) const

Private Members

I3GeometryConstPtr geo_
IceCubeConfig iceConf_
IceTopConfig topConf_
std::vector<int> listOfBoundaryDeepStrings_
std::vector<int> listOfBoundarySurfaceStations_
int topDOMid_
int bottomDOMid_
class I3Splitter
#include <I3Splitter.h>

This class is meant to be a mix-in base for modules that split DAQ frames into multiple physics frames.

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

Subclassed by I3NullSplitter

Public Functions

I3Splitter(const I3Configuration &config)

$Id$

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

~I3Splitter()
I3FramePtr GetNextSubEvent(I3FramePtr daq)

Protected Attributes

std::string sub_event_stream_name_

The name of the SubEvent stream. This should be set by derived modules, which is why it’s protected.

Modules where this is used as a mix-in simply need to add the following lines to the constructor and Configure method, respectively:

AddParameter(“SubEventStreamName”, “The name of the SubEvent stream.”, “SplitSubStreamDefault”); GetParameter(“SubEventStreamName”, sub_event_stream_name_);

Private Members

I3FramePtr last_daq
const I3Configuration &config_
int last_subevent_id
bool print_warning_
class I3SplitTriggerSelector : public I3ConditionalModule

A counterpart to I3TriggerSplitter, which generates subsets of I3TriggerHierarchies for the subevents produced by other splitters.

Public Functions

inline I3SplitTriggerSelector(const I3Context &context)
inline void Configure()
inline void Physics(boost::shared_ptr<I3Frame> frame)

Private Functions

inline double LaunchTimeCorrection(const I3DOMCalibration &calib, const I3DOMStatus &status)
inline bool rangesOverlap(double start1, double stop1, double start2, double stop2)
inline void modifyTriggerSpan(I3Trigger &trig, double minTime, double maxTime)

Private Members

std::string subeventStream
std::string inputHierarchyName
std::string subsetPulsesName
std::string outputHierarchyName
bool physicsTriggersOnly
class I3SPRNGRandomService : public I3RandomService

SPRNG Implementation of the I3RandomService interface. This implementation uses a combination of SPRNG and GSL to generate statistically independent streams of pseudo-random number distributions. See gsl-sprng.h for more details.

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

NB : It’s important that you use the same seed for different jobs. Set nstreams to the number of jobs and use a different streamnum for each job. Otherwise you’ll get correlations between the RNG streams. I know this is counterintuitive, but this is how SPRNG works.

The code for this class is based on John Pretz’s implementation of I3GSLRandomService.

Todo:

Add ability to save state of rng after run is complete SPRNG has the functions:

 int pack_sprng(char *bytes); // returns size of bytes
 void unpack_sprng(char bytes[MAX_PACKED_LENGTH]);
Version

$Revision$

Date

$Date$

Author

juancarlos

which can be used to save and retrieve the state of an rng

Public Functions

I3SPRNGRandomService()

default constructor

I3SPRNGRandomService(int seed, int nstreams, int streamnum, std::string instatefile = std::string(), std::string outstatefile = std::string())

constructors

virtual ~I3SPRNGRandomService()

destructor

virtual int Binomial(int ntot, double prob)

Binomial distribution

virtual double Exp(double tau)

Exponential distribution

virtual unsigned int Integer(unsigned int imax)

Uniform int distribution with range [0,imax)

virtual int Poisson(double mean)

int Poisson distribution

virtual double PoissonD(double mean)

double Poisson distribution

virtual double Uniform(double x1 = 1)

double uniform distribution with range (0,x1)

virtual double Uniform(double x1, double x2)

double uniform distribution with range (x1,x2)

virtual double Gaus(double mean, double stddev)

double Gaussian distribution given mean and StdD

virtual I3FrameObjectPtr GetState() const

get all information necessary to restore the internal state of the generator

virtual void RestoreState(I3FrameObjectConstPtr state)

restore the internal state of the generator

Private Functions

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

Private Members

gsl_rng *rng_
std::string instatefile_
std::string outstatefile_
int seed_
int streamnum_
int nstreams_
class I3SPRNGRandomServiceFactory : public I3ServiceFactory

This class installs a I3SPRNGRandomService.

I3SPRNGRandomService supports six parameter: Seed, NStreams, StreamNum, inStateFile, outStateFile, InstallServiceAs.

Public Functions

I3SPRNGRandomServiceFactory(const I3Context &context)
virtual ~I3SPRNGRandomServiceFactory()
virtual bool InstallService(I3Context &services)

Installed this objects service into the specified services object.

Parameters:

services – the I3Context into which the service should be installed.

Returns:

true if the services is successfully installed.

virtual void Configure()

Configure service prior to installing it.

Private Functions

I3SPRNGRandomServiceFactory(const I3SPRNGRandomServiceFactory &rhs)
I3SPRNGRandomServiceFactory operator=(const I3SPRNGRandomServiceFactory &rhs)
SET_LOGGER ("I3SPRNGRandomServiceFactory")

Private Members

int seed_
int nstreams_
int streamnum_
std::string instatefile_
std::string outstatefile_
I3RandomServicePtr random_
std::string installServiceAs_
struct I3SPRNGRandomServiceState : public I3FrameObject

Public Functions

template<typename Archive>
inline void serialize(Archive &ar, unsigned version)
inline std::ostream &Print(std::ostream &os) const override

Public Members

int seed_
int nstreams_
int streamnum_
uint64_t icalls_
uint64_t dcalls_

Friends

friend class icecube::serialization::access
template<class Base>
class I3StdRandomEngine : public I3RandomService

An implementation of the I3RandomService interface using C++ random number engines.

The distribuitons from the parent class I3RandomService are all defined: Binonial, Exponential, Integer, Poisson, Uniform, and Gaussian.

Public Functions

inline virtual int Binomial(int ntot, double prob)

Generate a number drawn from a binomial distribution

inline virtual double Exp(double tau)

Generate a number from an Exponential distribution

inline virtual unsigned int Integer(unsigned int imax)

Generate an integer drawn uniformly from [0,imax)

inline virtual uint32_t Integer32()

Generate an integer drawn uniformly from amongst all 32-bit integers, that is [0, 4294967295]

inline virtual int Poisson(double mean)

Generate an integer drawn from a Poisson distribution

inline virtual double PoissonD(double mean)

Generate a number drawn from a Poisson distribution, return a double

inline virtual double Uniform(double x = 1)

Generate a double drawn from a uniform distribution [0,x)

inline virtual double Uniform(double x1, double x2)

Generate a double drawn from a uniform distribution [x1,x2)

inline virtual double Gaus(double mean, double stddev)

Generate a double drawn from a Gaussian distribution with given mean and standard deviation

class I3StringAdderService : public I3GeometryService

A I3GeometryOrigin which reads the default geometry and serves up a reduced geometry.

Public Functions

inline I3StringAdderService(I3GeometryServicePtr g)
inline virtual ~I3StringAdderService()
I3GeometryConstPtr GetGeometry(I3Time time)
inline void SetDOMSpacing(double s)
inline double GetDOMSpacing()
inline void SetNDOMsPerString(unsigned int n)
inline unsigned int GetNDOMsPerString()
inline void SetOMGeoList(std::vector<I3OMGeo> &v)
inline const std::vector<I3OMGeo> &GetOMGeoList() const

Private Functions

SET_LOGGER ("I3StringAdderService")

Private Members

double domSpacing_
unsigned int domsPerString_
std::vector<I3OMGeo> omGeoList_
I3GeometryServicePtr geo_service_
class I3StringAdderServiceFactory : public I3ServiceFactory

IceTray module that selects the strings to use.

This module has only two parameters “StringsToUse” and “StringsToExclude” The default values for StringsToUse is the entire 80 string IceCube detector and AMANDA (i.e. “-19:80”). No strings are excluded by default.

Examples values for the parameters are…

1) Use only the IceCube detector. Either set StringsToUse to “1:80” or set StringsToExclude to “-19:0” (remember the default value for StringsToUse is “-19:80”).

2) Use the current geometry (as of mid Jan ‘06). Set StringsToUse to “21,29,30,38,39,-19:-1”

Public Functions

I3StringAdderServiceFactory(const I3Context &ctx)
virtual ~I3StringAdderServiceFactory()
virtual void Configure()

Checks the two parameters StringsToUse and StringsToExclude are valid.

virtual bool InstallService(I3Context &services)

Private Functions

I3StringAdderServiceFactory()

default constructor, assignment operator, and copy constructor declared private to prevent use

I3StringAdderServiceFactory(const I3StringAdderServiceFactory &source)
I3StringAdderServiceFactory &operator=(const I3StringAdderServiceFactory &source)
SET_LOGGER ("I3StringAdderServiceFactory")

Private Members

boost::shared_ptr<I3StringAdderService> geometry_
std::vector<I3OMGeo> omGeoList_

List of top (i.e. OMNumber = 1) DOM positions. This will be built from the rest of the parameters.

std::vector<double> xPositions_

Parameter - List of x positions Default value is ‘empty’

std::vector<double> yPositions_

Parameter - List of y positions Default value is ‘empty’

double depth_

Parameter - Depth of the top DOMs Default value is +500 * I3Units::m

double domSpacing_

Parameter - Distance between the DOMs Default value is 17 * I3Units::m

unsigned int domsPerString_

Parameter - Number of DOMs per string Default value is 60

int domOrientation_

Parameter - Orientation of the DOM Default value is -1 (i.e. Down) Unspecified=0, Up=1, Down=-1

int domType_

Parameter - Type of DOM Default value is 20 (i.e. IceCube) AMANDA = 10, IceCube = 20, IceTop = 30

double area_

Parameter - Effective collection area Default value is .0444 * I3Units::m2 I don’t think this is used

double aziangle_

Parameter - relative rotation angle of DOM in azimuth Default value is 0. I don’t think this is used anywhere.

std::string geoSelectorName_

Name of the new geometry service. The muxer needs this name.

std::string geoServiceName_

Name of the previous geometry service.

class I3SummaryService : public I3Map<std::string, double>
#include <I3SummaryService.h>

This is an interface for services which allow modules to store runtimejob statistics that can then be written to external xml files for other programs to parse or upload values to a database, etc. useful for collecting statistics in production runs.

Copyright (C) 2007 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

juancarlos@icecube.wisc.edu

Public Functions

inline I3SummaryService()

constructor

inline virtual ~I3SummaryService()

destructor

virtual double &operator[](const std::string &key) = 0

Access dictionary entry

virtual void SetValue(std::string name, double value) = 0

Add a value to the value summary map

virtual double GetValue(std::string name) = 0

Get value from the value summary map

Private Functions

I3SummaryService(const I3SummaryService&)
const I3SummaryService &operator=(const I3SummaryService&)
SET_LOGGER ("I3SummaryService")
class I3TextFileGeometryService : public I3GeometryService

A I3GeometryOrigin which reads the geometry from two files, one for icecube and one for inice.

Public Functions

inline I3TextFileGeometryService(const std::string &amafile, const std::string &icefile)
inline virtual ~I3TextFileGeometryService()
I3GeometryConstPtr GetGeometry(I3Time time)

Private Functions

void Fatal(const std::string &message)
void FillGeometryFromFile(I3Geometry &geo)

Private Members

std::string fAmaGeoInputFile
std::string fI3GeoInputFile
class I3TextFileGeometryServiceFactory : public I3ServiceFactory

Public Functions

I3TextFileGeometryServiceFactory(const I3Context &context)
virtual ~I3TextFileGeometryServiceFactory()
virtual bool InstallService(I3Context &services)
virtual void Configure()

Private Functions

I3TextFileGeometryServiceFactory(const I3TextFileGeometryServiceFactory &rhs)
I3TextFileGeometryServiceFactory operator=(const I3TextFileGeometryServiceFactory &rhs)
SET_LOGGER ("I3TextFileGeometryServiceFactory")

Private Members

boost::shared_ptr<I3TextFileGeometryService> geometry_
std::string amandaFile_
std::string icecubeFile_
class I3VEMCalManipulator : public I3CalibrationService

This calibration service copies all the entries from a previous calibration service and replaces the VEM calibration by values from an XML file or by default values. XML files containing VEM calibration data can be found in the data warehouse.

Public Functions

I3VEMCalManipulator(I3CalibrationService &calService)
~I3VEMCalManipulator()
void LoadDirectory(std::string path)
void LoadFile(std::string filepath, bool forceIt = false)
inline void UseDefaults(bool useDefault)
I3CalibrationConstPtr GetCalibration(I3Time time)

Private Types

typedef std::map<OMKey, I3VEMCalibration> I3VEMCalMap
typedef std::map<I3Time, I3VEMCalMap> I3VEMCalList

Private Functions

bool AddVEMCalibration(const std::string &filename)
void SetVEMCalibration(I3Calibration &calib, const I3Time &time)
void CheckVEMCalibration(I3Calibration &calib)
SET_LOGGER ("I3VEMCalManipulator")

Private Members

I3CalibrationService &calService_
I3CalibrationPtr currentCalib_
std::string filepath_
bool forceFile_
bool useDefaults_
I3VEMCalList vemCalList_
class I3VEMCalManipulatorFactory : public I3ServiceFactory

Public Functions

I3VEMCalManipulatorFactory(const I3Context &context)
~I3VEMCalManipulatorFactory()
bool InstallService(I3Context &services)
void Configure()

Private Functions

SET_LOGGER ("I3VEMCalManipulatorFactory")

Private Members

boost::shared_ptr<I3VEMCalManipulator> vemCalService_
std::string inCalServiceName_
std::string outCalServiceName_
std::string path_
std::string file_
bool forceFile_
bool useDefaults_
class I3XMLOMKey2MBID : public I3OMKey2MBID
#include <I3XMLOMKey2MBID.h>

An implementation of I3OMKey2MBID that reads the conversions from a XML file.

Public Functions

explicit I3XMLOMKey2MBID(const std::string &infile)

Constructor.

Parameters:

infile – Name of the XML file.

virtual ~I3XMLOMKey2MBID()

Destructor.

inline bool OMKeyExists(long long int mbid) const
inline OMKey GetOMKey(long long int mbid) const
inline bool MBIDExists(OMKey key) const
inline long long int GetMBID(OMKey key) const

Public Static Functions

static void Dump(const std::string &outfile, const std::map<long long int, OMKey> &conversionTable)

Dump conversion table into XML file.

Note

This XML file can be used as input for I3XMLOMKey2MBID.

Parameters:
  • outfile – The filename.

  • conversionTable – The conversion table.

static inline void Merge(const std::string &outfile, const std::string &infile, const std::map<long long int, OMKey> &conversionTable)

Merge a XML file and a conversion table into a new XML file.

Parameters:
  • outfile – The name of the merged file.

  • infile – The name of the file that is merged…

  • conversionTable – …with this conversion table into outfile.

static inline void Merge(const std::string &outfile, const std::string &infile1, const std::string &infile2)

Merge two XML files into a new one that store(s) a conversion table.

Parameters:
  • outfile – The name of the merged file.

  • infile1 – The name of the file that is merged…

  • infile2 – …with this file into outfile.

Private Types

typedef std::map<OMKey, long long int> map_omkey2mbid
typedef std::map<long long int, OMKey> map_mbid2omkey

Private Functions

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

Private Members

map_omkey2mbid omkey2mbid_
map_mbid2omkey mbid2omkey_
class I3XMLOMKey2MBIDFactory : public I3ServiceFactory

This class installs an I3XMLOMKey2MBID service.

I3XMLOMKey2MBIDFactory supports two parameter:

  • Infile (the name of the file to get the mainboard ID list from) and

  • InstallServiceAs (install the service at the following location (default value is the value according to I3_DEFAULT_NAME)).

Public Functions

explicit I3XMLOMKey2MBIDFactory(const I3Context &context)

Constructor.

Parameters:

context – The context in which the service will exist.

virtual ~I3XMLOMKey2MBIDFactory()

Destructor.

bool InstallService(I3Context &services)
void Configure()

Private Functions

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

Private Members

I3OMKey2MBIDPtr service_
std::string infile_
std::string installServiceAs_
template<int d>
class Miniball
#include <Miniball.h>

Public Types

typedef std::list<Point<d>>::iterator It
typedef std::list<Point<d>>::const_iterator Cit

Public Functions

inline Miniball()
void check_in(const Point<d> &p)
void build()
Point<d> center() const
double squared_radius() const
int nr_points() const
Cit points_begin() const
Cit points_end() const
int nr_support_points() const
Cit support_points_begin() const
Cit support_points_end() const
double accuracy(double &slack) const
bool is_valid(double tolerance = 1e-15) const

Private Functions

void mtf_mb(It k)
void pivot_mb(It k)
void move_to_front(It j)
double max_excess(It t, It i, It &pivot) const

Private Members

std::list<Point<d>> L
Miniball_b<d> B
It support_end
template<int d>
class Miniball_b
#include <Miniball.h>

Public Functions

inline Miniball_b()
const double *center() const
double squared_radius() const
int size() const
int support_size() const
double excess(const Point<d> &p) const
void reset()
bool push(const Point<d> &p)
void pop()
double slack() const

Private Members

int m
int s
double q0[d]
double z[d + 1]
double f[d + 1]
double v[d + 1][d]
double a[d + 1][d]
double c[d + 1][d]
double sqr_r[d + 1]
double *current_c
double current_sqr_r
class MultiPMTCoincify : public I3ConditionalModule
#include <MultiPMTCoincify.h>

Code which produces a software local coincidence for Upgrade and Gen2 mult-PMT modules.

Author

Michael Larson mlarson@icecube.wisc.edu

Public Functions

MultiPMTCoincify(const I3Context &context)
MultiPMTCoincify(unsigned int moduleSpan, double moduleTime, double pmtTime, bool reset)
~MultiPMTCoincify()
void Configure()
I3RecoPulseSeriesMapPtr Coincify(I3RecoPulseSeriesMapConstPtr inputMap)
void DAQ(I3FramePtr frame)
void Finish()
SET_LOGGER ("MultiPMTCoincify")

Public Members

std::string pulsesName_
unsigned int moduleSpan_
float moduleTime_
float pmtTime_
bool reset_
template<int d>
class Point
#include <Miniball.h>

Public Functions

inline Point()
inline Point(const Point &p)
inline Point(const double *p)
inline Point &operator=(const Point &p)
inline double &operator[](int i)
inline const double &operator[](int i) const
inline const double *begin() const
inline const double *end() const

Private Members

double coord[d]
class SamplingSurface : public I3Surfaces::Surface
#include <SamplingSurface.h>

A surface that can sample from the distribution of impact positions and directions of rays from an isotropic flux.

Subclassed by I3Surfaces::detail::CupBase< SamplingSurface >, I3Surfaces::detail::CylinderBase< SamplingSurface >, I3Surfaces::ExtrudedPolygonBase< SamplingSurface >, I3Surfaces::AxialCylinder

Public Functions

virtual ~SamplingSurface()
virtual double GetArea(const I3Direction &dir) const = 0

Calculate the projected area in m^2.

Parameters:

dir[in] The direction onto which to project the area

virtual double GetMaximumArea() const = 0
virtual double GetAcceptance(double cosMin = 0, double cosMax = 1) const = 0
virtual I3Direction SampleDirection(I3RandomService &rng, double cosMin = 0, double cosMax = 1) const
virtual I3Position SampleImpactPosition(const I3Direction &dir, I3RandomService &rng) const = 0
virtual double SampleImpactRay(I3Position &pos, I3Direction &dir, I3RandomService &rng, double cosMin = 0, double cosMax = 1) const

Sample an impact point and direction from an isotropic flux

Parameters:
  • pos[out] Impact point

  • dir[out] direction

  • rng[in] Random number generator

  • cosMin[in] cosine of the maximum zenith angle to consider

  • cosMax[in] cosine of the minimum zenith angle to consider

Returns:

the projected area along the chosen zenith angle

Private Functions

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

Friends

friend class icecube::serialization::access
struct side
#include <polygon.h>

Public Functions

side(const vec2 &point, const vec2 &next_point)

Public Members

vec2 origin
vec2 vector
double length
I3Direction normal
class Sphere : public I3Surfaces::Surface
#include <Sphere.h>

A sphere with its origin at a given vertical depth.

Public Functions

virtual ~Sphere()
inline Sphere(double originDepth, double radius)
virtual std::pair<double, double> GetIntersection(const I3Position &p, const I3Direction &dir) const

Find the points where a ray intersects the surface

Parameters:
  • p[in] The origin of the ray

  • dir[in] The direction of the ray

Returns:

a pair of distances from the origin of the ray to the intersections with the surface. A distance of NAN means that the ray never intersects the surface, and negative distances mean that the intersection in question is “behind” the origin.

Private Functions

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

Private Members

double originDepth_
double radius_

Friends

friend class icecube::serialization::access
class Surface : public I3FrameObject
#include <Surface.h>

A closed surface.

Surface knows how to find the intersections of a ray with itself.

Subclassed by I3Surfaces::SamplingSurface, I3Surfaces::Sphere

Public Functions

virtual ~Surface()
virtual std::pair<double, double> GetIntersection(const I3Position &p, const I3Direction &dir) const = 0

Find the points where a ray intersects the surface

Parameters:
  • p[in] The origin of the ray

  • dir[in] The direction of the ray

Returns:

a pair of distances from the origin of the ray to the intersections with the surface. A distance of NAN means that the ray never intersects the surface, and negative distances mean that the intersection in question is “behind” the origin.

inline std::pair<double, double> no_intersection() const

Private Functions

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

Friends

friend class icecube::serialization::access
struct vec2
#include <polygon.h>

Public Functions

vec2(double xi, double yi)

Public Members

double x
double y

Public Static Functions

static vec2 from_I3Position(const I3Position &pos)
static vec2 normalized(double xi, double yi)

Private Functions

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

Friends

friend class icecube::serialization::access
namespace [anonymous]
namespace [anonymous]
namespace [anonymous]
namespace cupspace

Functions

inline void sort(std::pair<double, double> &pair)
inline double integrate_area(double a, double b, double ocap, double osides, double icap, double isides)
namespace geo_sel_utils

Utilities for parsing the input parameters for I3GeometrySelector.

Functions

const string COMMA (",")
const string COLON (":")
const string MINUS ("-")
const string SINGLE_DIGIT_INTEGERS ("0123456789")
template<class T>
bool exists(const T &value, const vector<T> &v)

checks whether an element (type T) exists in a std::vector Returns true if it does, false otherwise

template bool exists (const int &, const vector< int > &)
template<class T>
vector<T>::const_iterator exists_at(const T &value, const vector<T> &v)

checks whether an element (type T) exists in a std::vector Returns a const_iterator (i.e. postion), which is equal to ‘end’ if the element doesn’t exist

bool good_input(const string &input_string)

Checks to see whether a std::string contains characters other than signed integers, and the two delimiters used ‘,’ and ‘:’

vector<int> make_good_strings(string to_use, string to_exclude)

Takes in two std::strings. (strings to use and strings to include) The std::strings can take the form “i,j,n:m” (and any permutation) which would ex/include std::strings i,j, and n through m.

vector<int> parse_string_list(const string &string_list)

Takes in a std::string of the form “i,j,n:m” and returns a vector of integers whose elements are “i,j,n,n+1,n+2,…,m-1,m”

std::pair<double, double> detector_center(I3GeometryConstPtr geo, const vector<int> &goodStrings)

Calculates the center of the detector in X-Y. Returns a std::pair<double,double> where first is x and second is y.

template<class T>
boost::shared_ptr<I3Map<OMKey, T>> map_cleaner(boost::shared_ptr<const I3Map<OMKey, T>> m, vector<int> s)
template<class T>
std::vector<T>::const_iterator exists_at(const T&, const std::vector<T>&)

checks whether an element (type T) exists in a std::vector Returns a const_iterator (i.e. postion), which is equal to ‘end’ if the element doesn’t exist

namespace I3Calculator

This is a namespace, which provides a collection of stand-alone functions that calculate various quantites relating a track, a cascade, and an OM position. These quantities include a various distances between two points, angle difference between two directions, time of travel of light…

Many of the methods are wrapper methods, which are designed for ease of use, and internally call the main calculation methods. These can be used for simplicity. The expert user can just use the main calculation methods/functions.

Functions

void CherenkovCalc(const I3Particle &track, const I3Position &position, I3Position &chpos, double &chtime, double &chdist, double &changle, const double IndexRefG = I3Constants::n_ice_group, const double IndexRefP = I3Constants::n_ice_phase, const I3Direction &direction = I3Direction(0., 0., -1.))

The main calculation function, which calculates in one step the relevant quantities that relate a track to an OM position. If you are interested in all of these quantities (see Output Parameters), use this function.

INPUT:

OUTPUT:

Todo:

Currently, CherenkovCalc calculates “closest approach” AND “cherenkov distances”. This is good for simplicity and non-repetitiveness of the code, but it is not the most efficient. If processing time becomes an issue, we can make these things more efficient at the expence of complicating and repeating the code.

See also

I3Constants for refractive index (phase, group)

Parameters:
  • track – &#8212; const reference to a track.

  • position – &#8212; Position of an OM.

  • IndexRefG – &#8212; Index of refraction (group), default=1.35634 (from I3Constants) This is used to define the speed of light through ice.

  • IndexRefP – &#8212; Index of refraction (phase), default=1.3195 (from I3Constants) This is used to define the angle (w.r.t. the track) under which Cherenkov photons are emitted in ice.

  • direction – &#8212; Orientation of the OM.

  • chpos – &#8212; Position on the track, which is the origin of Cherenkov light that arrives at the input OM position (‘position’). If no Cherenkov light originating from the input track can arrive at the input OM position, ‘chpos’ will be a null I3Position.

  • chtime – &#8212; Time between the track’s nominal time and the time of the arrival of Cherenkov light at the input OM position. This ‘chtime’ includes the time (which could be negative) for the particle to travel (at speed c) from the track’s nominal time to the point of origin of Cherenkov light (‘chpos’) PLUS the time (which is always positive) it takes the Cherenkov light to travel (at speed c/n) from its point of origin to the input OM position. If no Cherenkov light originating from the input track can arrive at the input OM position, ‘chtime’ will be NAN.

  • chdist – &#8212; Distance between the point of origin of Cherenkov light and the input OM position.

  • changle – &#8212; Angle between the path of Cherenkov light originating from the input track (‘track’) and the z-axis of the input OM position (‘position’).

bool IsOnTrack(const I3Particle &track, const I3Position &position, const double Precision = 0.1 * I3Units::meter)

Check if the input position (‘position’) lies on the input track (‘track’) within the given Precision. The default Precision is 10cm.

Todo:

IsOnTrack uses CherenkovCalc for calculating “distance of closest

approach”. This method is not the most efficient, but makes the code much simpler. If processing time becomes an issue, we can make these routines more efficient.

void ClosestApproachCalc(const I3Particle &track, const I3Position &position, I3Position &appos_inf, double &apdist_inf, I3Position &appos_stopstart, double &apdist_stopstart)

—&#8212;NEW!——-&#8212; Function which does the legwork for computing things related to the distance of closest approach of a track to a point. Used by CherenkovCalc, and also by the convenience functions ClosestApproachPosition and ClosestApproachDistance. Originally inside CherenkovCalc, but useful enough to bring outside. Returns two sets of closest-approach results: one “purely geometrical” and one which takes into account stopping/starting points of track.

I3Position ClosestApproachPosition(const I3Particle &particle, const I3Position &position)

A convenience function that calls CherenkovCalc() and returns the position of closest approach from (an I3Position) between the input track and OM position. If you are interested in more than one quantity from CherenkovCalc(), use the CherenkovCalc() function directly, in order to save multiple calls to the function.

double ClosestApproachDistance(const I3Particle &particle, const I3Position &position)

A convenience function that calls CherenkovCalc() and returns the distance of closest approach (a double) between the input track and OM position. If you are interested in more than one quantity from CherenkovCalc(), use the CherenkovCalc() function directly, in order to save multiple calls to the function.

double DistanceAlongTrack(const I3Particle &track, const I3Position &ompos)

Small useful function which computes the distance along a track from its vertex to the place where an OM position is perpendicular. (Used to be inside CutsCalc, but heck, it’s a useful function for other stuff too!)

I3Position CherenkovPosition(const I3Particle &particle, const I3Position &position, const double IndexRefG = I3Constants::n_ice_group, const double IndexRefP = I3Constants::n_ice_phase)

A convenience function that calls CherenkovCalc() and returns the position on the input track, which is the point of origin of Cherenkov light which arrives at the input OM position. If no Cherenkov light from the track can reach the OM, the function returns a null I3Position. If you are interested in more than one quantity from CherenkovCalc(), use the CherenkovCalc() function directly, in order to save multiple calls to the function.

double CherenkovTime(const I3Particle &particle, const I3Position &position, const double IndexRefG = I3Constants::n_ice_group, const double IndexRefP = I3Constants::n_ice_phase)

A convenience function that calls CherenkovCalc() and returns the time between the track’s nominal time and the time of arrival of Cherenkov light at the input OM position. If no Cherenkov light from the track can reach the OM, the function returns a NAN. If you are interested in more than one quantity from CherenkovCalc(), use the CherenkovCalc() function directly, in order to save multiple calls to the function.

double CherenkovDistance(const I3Particle &particle, const I3Position &position, const double IndexRefG = I3Constants::n_ice_group, const double IndexRefP = I3Constants::n_ice_phase)

A convenience function that calls CherenkovCalc() and returns the distance from origin of Cherenkov light on the input track to the input OM position. If you are interested in more than one quantity from CherenkovCalc(), use the CherenkovCalc() function directly, in order to save multiple calls to the function.

double CherenkovApproachAngle(const I3Particle &particle, const I3Position &position, const I3Direction &direction = I3Direction(0., 0., -1.), const double IndexRefG = I3Constants::n_ice_group, const double IndexRefP = I3Constants::n_ice_phase)

A convenience function that calls CherenkovCalc() and returns the angle between the path of Cherenkov light from the input track and the z-axis of the input OM position. An optional input is the direction of the OM (default = Down). If you are interested in more than one quantity from CherenkovCalc(), use the CherenkovCalc() function directly, in order to save multiple calls to the function.

double TimeResidual(const I3Particle &particle, const I3Position &hitpos, const double hittime, const double IndexRefG = I3Constants::n_ice_group, const double IndexRefP = I3Constants::n_ice_phase)

A convenience function that calls CherenkovTime() and calculates the time residual between a hit and a track. A time residual is defined as the difference between the measured hit time and the expected time of arrival of a photon from the track.

double Angle(const I3Particle &p1, const I3Particle &p2)

Returns the spatial angle between two input particles.

double Distance(const I3Particle &p1, const I3Particle &p2)

Returns the distance between two input particles.

double FourDistance(const I3Particle &p1, const I3Particle &p2)

Returns the 4-distance between two input particles (using both distance and time)

I3Position InTrackSystem(const I3Direction &direction, const I3Position &pos)

Transform the input position into the coordinate system of the input track. Effectively, the track is now in the z-dir.

I3Direction InTrackSystem(const I3Direction &direction, const I3Direction &dir)

Transform the input position into the coordinate system of the input track. Effectively, the track is now in the z-dir.

I3Position InTrackSystem(const I3Particle &track, const I3Position &pos)

Convenience function overload that extracts the direction out of a track and then calls the regular InTrackSystem().

I3Direction InTrackSystem(const I3Particle &track, const I3Direction &dir)

Convenience function overload that extracts the direction out of a track and then calls the regular InTrackSystem().

I3Position InNominalSystem(const I3Direction &direction, const I3Position &pos)

Transform the input position out of the coordinate system of the input track. Effectively, the track is now in its original direction.

I3Direction InNominalSystem(const I3Direction &direction, const I3Direction &dir)

Transform the input position out of the coordinate system of the input track. Effectively, the track is now in its original direction.

I3Position InNominalSystem(const I3Particle &track, const I3Position &pos)

Convenience function overload that extracts the direction out of a track and then calls the regular InNominalSystem().

I3Direction InNominalSystem(const I3Particle &track, const I3Direction &dir)

Convenience function overload that extracts the direction out of a track and then calls the regular InNominalSystem().

std::pair<I3Direction, I3Direction> GetTransverseDirections(const I3Direction &dir)

Utility function, produces two directions perpendicular to the input direction. Should maybe be included in the I3Calculator:: namespace in phys-services.

I3Direction GetReverseDirection(const I3Direction &dir)

Utility function, produces one directions opposite to the input direction. Should maybe be included in the I3Calculator:: namespace in phys-services.

void Rotate(const I3Direction &axis, I3Direction &dir, double angle)

Utility function, rotates a direction around an axis. Should maybe be included in the I3Calculator:: namespace in phys-services.

I3Position InShowerSystem(const I3Particle &shower, const I3Position &pos)

Transform the input position into the shower coordinate system (SCS). Our SCS has its origin in the shower core, a z-direction parallel to the direction of shower origin, and the x-axis anti-parallel to the time flow of signals appearing in the event, meaning that early hits are located at x > 0, late hits at x < 0. The y-axis is parallel to the ground plane and perpendicular to the time flow of signals.

I3Position InShowerSystem(const I3Position &core, const I3Direction &axis, const I3Position &pos)

Same as InShowerSystem, but with core and propagation direction axis explicitly given.

namespace I3Constants
namespace I3Cuts

The I3Cuts namespace is a collection of functions that calculate various cut parameters for reconstruction. These include things like Ndir, Ldir, and Smoothness.

Todo:

So far we have Ndir, Ldir, and Smoothness, but other cut parameters will and should be added as we have move more into an analysis phase of the experiment.

Functions

void CutsCalc(const I3Particle &track, const I3Geometry &geometry, const I3Map<OMKey, std::vector<I3RecoPulse>> &pulsemap, const double t1, const double t2, int &Nchan, int &Nhit, int &Nstring, int &Ndir, double &Ldir, double &Sdir, double &Sall)

Main function that does the actual calculation of all of the cut parameters. First, it loops over all hits (or pulses), makes “projections” of the hits onto the input track, and calculates the time residual for each hit (difference between the expected and actual time of arrival of the Cherenkov photon from the given track and the OM). If the time residual is within some set time window, then the hit is tagged as “direct hit”. Then, based on the times and distances of the direct (or all) hits, it calculates the 3 quantities, according to their individual algorithms.

INPUT:

OUTPUT:

Todo:

Think about making the code more efficient…

Parameters:
  • track – &#8212; Track used in calculation.

  • geometry – &#8212; Geometry object from the event.

  • pulsemap – &#8212; Map of I3RecoPulseSeries used in calculation.

  • t1 – &#8212; Lower edge of the time residual window for direct hits. Generally, this value is -15ns.

  • t2 – &#8212; Upper edge of the time residual window for direct hits. Generally, this value is 15ns..150ns.

  • Nchan – &#8212; The Nchan cut parameter: total number of hit channels.

  • Nhit – &#8212; The Nhit cut parameter: total number of hits.

  • Nstring – &#8212; The Nstring cut parameter: total number of strings.

  • Ndir – &#8212; The Ndir cut parameter: number of direct hits.

  • Ldir – &#8212; The Ldir cut parameter (based on direct hits): “length” of the event. This is the length between the two most extreme projections of the direct hits onto the track.

  • Sall – &#8212; The Smoothness parameter (based on all hits): how uniformly are the hit projections onto the track distributed along that track.

  • Sdir – &#8212; The Smoothness parameter (based on direct hits): how uniformly are the hit projections onto the track distributed along that track.

void CascadeCutsCalc(const I3Particle &vertex, const I3Geometry &geometry, const I3Map<OMKey, std::vector<I3RecoPulse>> &pulsemap, const double t1, const double t2, int &Nchan, int &Nhit, int &N_1hit, int &Nstring, int &Ndir, int &Nearly, int &Nlate)

Main function that does the actual calculation of all of the cut parameters. It loops over all hitseries it finds in the hitseriesmap, calculating the cut parameters.

INPUT:

OUTPUT:

Todo:

Think about making the code more efficient…

Parameters:
  • vertex – &#8212; Vertex used in calculation.

  • geometry – &#8212; Geometry object from the event.

  • pulsemap – &#8212; Map of I3RecoPulseSeries used in calculation.

  • t1 – &#8212; Lower edge of the time residual window for direct hits. Generally, this value is -15ns.

  • t2 – &#8212; Upper edge of the time residual window for direct hits. Generally, this value is 15ns..150ns.

  • Nchan – &#8212; The Nchan cut parameter: total number of hit channels.

  • Nhit – &#8212; The Nhit cut parameter: total number of hits.

  • N_1hit – &#8212; Number of channels with only 1 hit in them.

  • Nstring – &#8212; The Nstring cut parameter: total number of strings.

  • Ndir – &#8212; The Ndir cut parameter: number of direct hits.

  • Nearly – &#8212; The Nearly cut parameter: number of early hits.

  • Nlate – &#8212; The Nlate cut parameter: number of late hits.

I3Position COG(const I3Geometry &geometry, const I3Map<OMKey, std::vector<I3RecoPulse>> &pulsemap)

A function which calculates the center of gravity of the hits. It takes a I3RecoPulseSeries map and the geometry, and returns an I3Position of the COG.

int Nchan(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the total number of channels (hit OMs) in the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int Nhit(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the total number of hits in the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int N_1hit(const I3Particle &vertex, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the total number of hits in the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int Nstring(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the total number of strings in the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int Ndir(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the number of direct hits from a given track. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int CascadeNdir(const I3Particle &vertex, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the number of direct hits from a given track. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int Nearly(const I3Particle &vertex, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the number of direct hits from a given track. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

int Nlate(const I3Particle &vertex, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the number of direct hits from a given track. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

double Ldir(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the “direct-hits length” of the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

double SmoothDir(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the “direct-hits smoothness” of the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function, directly in order to save multiple calls to the function.

double SmoothAll(const I3Particle &track, const I3Geometry &geom, const I3Map<OMKey, std::vector<I3RecoPulse>> &hitmap, double t1 = I3Constants::dt_window_l, double t2 = I3Constants::dt_window_h)

A convenience function that calls CutsCalc() and returns the “all-hits smoothness” of the event. If you are interested in more than one quantity from CutsCalc(), use the CutsCalc() function directly, in order to save multiple calls to the function.

double CylinderSize(const I3Particle &track, double H0, double R0, double center)

Computes the size of the “cylinder of closest approach”, which is the amount by which one must expand a “reference cylinder” (such as the volume of the in-ice detector) in order to just barely contain the track. For grusome defail, see Kath’s thesis appendix A.

“H0” = height of reference cylinder “R0” = radius of reference cylinder “center” = z-coordinate of center of reference cylinder (the x- and y-coordinates are assumed to be at zero)

This is useful, for instance, for making cuts on whether a track goes through the physical volume of the in-ice detector, close to the center, or outside of it.

void IntersectionOfTwoLines(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, double *xi, double *yi)

A helper function for doing 2-D geometry: the intersection of two lines. One line is defined by coordinates (x1,y1) and (x2, y2), The second line is defined by coordinates (x3, y3) and (x4, y4).

I3Position IntersectionOfLineAndPlane(const I3Particle &t, I3Position A, I3Position B, I3Position C)

A helper function for doing 3-D geometry: the intersection of a line and a plane. The line is defined by a track I3Particle, and the plane is defined by three I3Positions.

void CMPolygon(std::vector<double> x, std::vector<double> y, double *xresult, double *yresult)

A helper function for doing 2-D geometry: the center of mass of a 2-D arbitrary shape (n-gon or polygon). This function takes as inputs: vectors representing the x and y coordinates of points which define the corners of the shape. (Could, for instance, find the CM of the IceTop-16 array.)

void PutPointsInOrder(std::vector<double> *xinput, std::vector<double> *yinput, double xcenter, double ycenter, bool justcheck)

A helper function which re-orders the “boundary” points of a polygon, so that they are in order (either cw or ccw around a central point

bool CCW(double ang1, double ang2, bool exact)

A helper function which quickly says whether ang2 is counter-clockwise from ang1 (by less than 180 degrees) or not.

double TriangleExpansionFactor(double xcm, double ycm, double x1, double y1, double x2, double y2, double xprime, double yprime)

A helper function which, given a center (xcm,ycm), two triangle endpoints, and a “question point” (xprime, yprime), computes the factor by which a line would have to expand outwards from the center in order to intersect the question point. (This is part of ContainmentAreaSize.)

double ContainmentVolumeSize(const I3Particle &track, std::vector<double> x, std::vector<double> y, double zhigh, double zlow)

Computes the size of the “containment volume of closest approach”, Analogous to “CylinderSize”, above, but for a general shape (not necessarily a cylinder… could be the IC-9 prism for instance)

Must be a prism shape… defined by (x,y) coordinates, and limits of z in the vertical dimension

double ContainmentAreaSize(const I3Particle &track, std::vector<double> x, std::vector<double> y, double z)

Computes the size of the “containment area of closest approach”, Similar to “ContainmentVolumeSize”, above, but the 2-dimensional (rather than 3-dimensional) problem for a general shaped area rather than a volume. (Could, for instance, be the IceTop-16 array.)

namespace I3GeoTrimmers

Functions

void AddMeToTheMap(OMKey mykey, I3OMGeo me, I3OMGeoMapPtr themap)

Utility function.

template<class omdatamap>
I3OMGeoMapPtr GeoFromEventData(const I3OMGeoMap &input_geo, const omdatamap &datamap)

Create a reduced geometry containing only the hit OMs. Currently use OMs which appear as keys in pulseseries_; maybe it should be made possible to use DOMLaunchSeries or AMANDAAnalogReadout maps instead…

XYZ.

Create a reduced geometry containing only the hit OMs. Currently use OMs which appear as keys in pulseseries_; maybe it should be made possible to use DOMLaunchSeries or AMANDAAnalogReadout maps instead…

I3OMGeoMapPtr GeoFromPulseSeries(const I3OMGeoMap &input_geo, const I3RecoPulseSeriesMap &psm)
I3OMGeoMapPtr GeoFromDOMLaunchSeries(const I3OMGeoMap &input_geo, const I3DOMLaunchSeriesMap &dlsm)
I3OMGeoMapPtr GeoFromWFSeries(const I3OMGeoMap &input_geo, const I3WaveformSeriesMap &wfsm)
I3OMGeoMapPtr GeoFromAMANDAAnalogReadout(const I3OMGeoMap &input_geo, const I3AMANDAAnalogReadoutMap &aarm)
I3OMGeoMapPtr GeoFromPulseSeriesWithNeighbors(I3OMGeoMap input_geo, I3RecoPulseSeriesMap psm)

Create a reduced geometry containing only the hit OMs. Currently use OMs which appear as keys in pulseseries_; maybe it should be made possible to use DOMLaunchSeries or AMANDAAnalogReadout maps instead…

I3OMGeoMapPtr GeoWithoutBadOMs(I3OMGeoMap input_geo, I3VectorOMKey badomlist)

Create a reduced geometry in which Bad OM’s have been removed.

I3OMGeoMapPtr GeoWithoutBadOMs(I3OMGeoMap input_geo, std::vector<OMKey> badomlist)

Create a reduced geometry in which Bad OM’s have been removed.

I3OMGeoMapPtr GeoWithoutIceTop(I3OMGeoMap input_geo)

Create a reduced geometry in which all IceTop DOM’s have been removed.

I3OMGeoMapPtr GeoIceTopOnly(I3OMGeoMap input_geo)

Create a reduced geometry in which only IceTop DOM’s are included.

I3GeometryPtr GeoFromPulseSeries(I3Geometry input_geo, I3RecoPulseSeriesMap psm)
I3GeometryPtr GeoFromPulseSeriesWithNeighbors(I3Geometry input_geo, I3RecoPulseSeriesMap psm)
I3GeometryPtr GeoWithoutBadOMs(I3Geometry input_geo, I3VectorOMKey badomlist)
I3GeometryPtr GeoWithoutIceTop(I3Geometry input_geo)
I3GeometryPtr GeoIceTopOnly(I3Geometry input_geo)
I3OMGeoMapPtr GetMinBallGeometry(const I3OMGeoMap &input_geo, const I3OMGeoMap &subgeo, double margin = 0.)

Get geomap of all DOMs in a minimum ball around a subgeometry. The implementation of this method uses GPL code written by Bernd Gaertner (not a member of IceCube).

template<class omdatamap>
I3OMGeoMapPtr GetMinBallGeometryFromData(const I3OMGeoMap &input_geo, const omdatamap &datamap, double margin = 0.)

Get geomap of all DOMs in a minimum ball around a subgeometry. The subgeometry is obtained from data (DOMs which actually have data) and then the GetMinBallGeometry method is used to obtain the geomap of the minimum surrounding ball.

namespace I3Surfaces

Functions

I3_POINTER_TYPEDEFS(AxialCylinder)
I3_POINTER_TYPEDEFS(Cup)
I3_POINTER_TYPEDEFS(Cylinder)
I3_POINTER_TYPEDEFS(ExtrudedPolygon)
I3_POINTER_TYPEDEFS(SamplingSurface)
I3_POINTER_TYPEDEFS(Sphere)
I3_POINTER_TYPEDEFS(Surface)
namespace [anonymous]
namespace detail
namespace polygon

Functions

std::vector<vec2> convex_hull(const std::vector<I3Position> &positions)

Lifted from http://code.icecube.wisc.edu/svn/sandbox/ckopper/eventinjector/python/util/__init__.py.

Computes the convex hull of a set of 2D points. Input: an iterable sequence of (x, y) pairs representing the points. Output: a list of vertices of the convex hull in counter-clockwise order, starting from the vertex with the lexicographically smallest coordinates. Implements Andrew’s monotone chain algorithm. O(n log n) complexity.

std::vector<vec2> expand_polygon(const std::vector<vec2> &hull, double padding)

Expand the x-y footprint by moving each edge out by a distance padding.

A convex polygon can be offset by moving each vertex parallel to the edges by a distance that is inversely proportional to the sine of the counterclockwise angle between the edges that meet at each vertex. This breaks down for edges that are [anti]parallel or, but neither case should occur for maximally simplified polygons.

bool operator<(const vec2 &a, const vec2 &b)
namespace [anonymous]
namespace I3Units
namespace miniball

Functions

inline double mb_sqr(double r)
template<int d>
std::ostream &operator<<(std::ostream &os, const Point<d> &p)
namespace std

STL namespace.

file AxialCylinder.cxx
#include <dataclasses/I3Direction.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

std::ostream &operator<<(std::ostream &oss, const I3Surfaces::AxialCylinder &p)
I3_SERIALIZABLE(I3Surfaces::AxialCylinder)
file AxialCylinder.h
#include <dataclasses/I3Position.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

std::ostream &operator<<(std::ostream &oss, const I3Surfaces::AxialCylinder &p)
I3_CLASS_VERSION (I3Surfaces::AxialCylinder, 0)
file Cup.cxx

Rcs

Cylinder.cxx 137064 2015-08-31 18:24:47Z jvansanten

Author

Jakob van Santen vansanten@wisc.edu

Rcs

137064

Rcs

2015-08-31 13:24:47 -0500 (Mon, 31 Aug 2015)

Functions

I3_SERIALIZABLE(I3Surfaces::Cup)
file Cup.h

Rcs

Cylinder.h 146654 2016-06-01 18:31:33Z cweaver

Author

Jakob van Santen jakob.van.santen@desy.de

Rcs

146654

Rcs

2016-06-01 13:31:33 -0500 (Wed, 01 Jun 2016)

Functions

I3_CLASS_VERSION (I3Surfaces::Cup, 0)
file CupBase.h
#include <dataclasses/I3Position.h>
#include <dataclasses/I3Direction.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

file Cylinder.cxx

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

std::ostream &operator<<(std::ostream &oss, const I3Surfaces::Cylinder &p)
I3_SERIALIZABLE(I3Surfaces::Cylinder)
file Cylinder.h

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

Functions

std::ostream &operator<<(std::ostream &oss, const I3Surfaces::Cylinder &p)
I3_CLASS_VERSION (I3Surfaces::Cylinder, 0)
file CylinderBase.h
#include <dataclasses/I3Position.h>
#include <dataclasses/I3Direction.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

file ExtrudedPolygon.cxx

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

Functions

I3_SERIALIZABLE(I3Surfaces::ExtrudedPolygon)
file ExtrudedPolygon.h

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

Functions

I3_CLASS_VERSION (I3Surfaces::ExtrudedPolygon, 0)
file ExtrudedPolygonBase.h
#include <dataclasses/I3Direction.h>
#include <boost/foreach.hpp>
#include <boost/next_prior.hpp>
#include <cmath>

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

file GeoSelUtils.cxx
#include “icetray/I3Logging.h”
#include <string>
#include <iostream>
#include <sstream>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

This class shows how to add a Selection to the event.

Version

$Revision$

Date

$Date$

Author

olivas

file GeoSelUtils.h
#include <vector>
#include <string>
#include “dataclasses/geometry/I3Geometry.h”
#include <dataclasses/I3Map.h>

Copyright (C) 2004 the IceCube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

olivas

file gsl-sprng.h
#include <sprng/sprng.h>

Functions

static void sprng_set(void *vstate, unsigned long int s)
static unsigned long sprng_get(void *vstate)
static double sprng_get_double(void *vstate)
inline gsl_rng *gsl_sprng_init(int seed, int nstreams, int streamnum, char *state = NULL, uint64_t icalls = 0, uint64_t dcalls = 0)
inline int gsl_sprng_pack(gsl_rng *rng, char **state)

save the current state of the RNG to an array of characters

Parameters:
  • rng – gsl_rng struct

  • state – array to store state in

Returns:

size of state array

inline void gsl_sprng_free(gsl_rng *r)

Free memory for RNG

Parameters:

r – gsl_rng struct

Variables

static const gsl_rng_type gsl_rng_sprng20 = {"sprng20", 0x7fffffffUL, 0, 0, &sprng_set, &sprng_get, &sprng_get_double}
file I3BadDOMAuditor.cxx
#include <icetray/I3Module.h>
#include <icetray/I3Units.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3EventHeader.h>
#include <dataclasses/I3Time.h>
#include <boost/foreach.hpp>

Defines

bad_dom(...)

Functions

I3_MODULE(I3BadDOMAuditor)
file I3Calculator.cxx
file I3Calculator.h
#include <cmath>
#include <utility>
#include “dataclasses/physics/I3Particle.h”
#include “icetray/I3Units.h”
#include “dataclasses/I3Constants.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “dataclasses/I3Direction.h”

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

pretz, dule, ehrlich

file I3CascadeCutValues.cxx
#include “icetray/serialization.h”
#include “icetray/I3FrameObject.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “phys-services/I3Cuts.h

Functions

I3_CLASS_VERSION(I3CascadeCutValues, current_i3cascadecutvalues_version)
I3_SERIALIZABLE(I3CascadeCutValues)
std::ostream &operator<<(std::ostream &os, const I3CascadeCutValues &cv)

Variables

static const unsigned int current_i3cascadecutvalues_version = 1
file I3CascadeCutValues.h
#include <dataclasses/I3Constants.h>
#include <dataclasses/I3Position.h>

Functions

std::ostream &operator<<(std::ostream&, const I3CascadeCutValues&)
I3_POINTER_TYPEDEFS(I3CascadeCutValues)
file I3CrossSection.cxx
#include <array>
#include <cmath>
#include <icetray/I3Logging.h>

Implementation of class for spline-interpolated cross section model

Copyright (c) 2016 the IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Date

$Date$

Author

cweaver

file I3CrossSection.h
#include <memory>
#include <string>
#include <boost/shared_ptr.hpp>
#include <photospline/splinetable.h>
#include <dataclasses/physics/I3Particle.h>

Definition of class for spline-interpolated cross section model

Copyright (c) 2016 the IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Date

$Date$

Author

cweaver

file I3Cuts.cxx
#include “phys-services/I3Cuts.h
#include “dataclasses/I3Constants.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/I3Position.h”
#include <vector>
#include <cassert>
#include <cmath>
#include <float.h>

Functions

static void crossproduct(double c[3], double a[3], double b[3])
static double dotproduct(double a[3], double b[3])
static void rotate(double a[3], double delphi, int axis)
void CutsCalcImpl(const I3Particle &track, const I3Geometry &geometry, const I3RecoPulseSeriesMap &hitmap, const double t1, const double t2, int &Nchan, int &Nhit, int &Nstring, int &Ndir, double &Ldir, double &Sdir, double &Sall)
void CascadeCutsCalcImpl(const I3Particle &vertex, const I3Geometry &geometry, const I3RecoPulseSeriesMap &hitmap, const double t1, const double t2, int &Nchan, int &Nhit, int &N_1hit, int &Nstring, int &Ndir, int &Nearly, int &Nlate)
I3Position COGImpl(const I3Geometry &geometry, const I3RecoPulseSeriesMap &hitmap)
file I3Cuts.h
#include “dataclasses/I3Constants.h”
#include <vector>

Defines

CONTAINMENT_FUNCTIONS_AVAILABLE
file I3CutsModule.cxx
#include “icetray/I3TrayHeaders.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “I3CutsModule.h
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/foreach.hpp>

Functions

I3_MODULE(I3CutsModule)
file I3CutsModule.h
#include <icetray/I3ConditionalModule.h>
#include “icetray/I3Tray.h”
#include “dataclasses/physics/I3Particle.h”
file I3CutValues.cxx
#include “icetray/serialization.h”
#include “icetray/I3FrameObject.h”
#include “phys-services/I3Cuts.h
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/geometry/I3Geometry.h”

Functions

I3_CLASS_VERSION(I3CutValues, current_i3cutvalues_version)
I3_SERIALIZABLE(I3CutValues)
std::ostream &operator<<(std::ostream &os, const I3CutValues &cv)
I3_CLASS_VERSION (I3CutValuesBase, 0)
I3_SERIALIZABLE(I3CutValuesBase)

Variables

static const unsigned int current_i3cutvalues_version = 2
file I3CutValues.h
#include <vector>
#include <dataclasses/I3Constants.h>
#include <dataclasses/I3Position.h>

Functions

std::ostream &operator<<(std::ostream&, const I3CutValues&)
I3_POINTER_TYPEDEFS(I3CutValues)
file I3CutValuesBase.h
#include <icetray/I3FrameObject.h>
#include <dataclasses/I3Constants.h>
#include <dataclasses/Utility.h>

Functions

I3_POINTER_TYPEDEFS(I3CutValuesBase)
file I3CutValuesConverter.cxx
#include “I3CutValuesConverter.h
file I3CutValuesConverter.h
#include <tableio/I3Converter.h>
file I3EventCounter.cxx
#include <sstream>
#include <fstream>
#include “dataclasses/physics/I3EventHeader.h”

Functions

I3_MODULE(I3EventCounter)
file I3EventCounter.h
#include “icetray/I3TrayHeaders.h”
#include “icetray/I3Module.h”
#include <fstream>
file I3EventInfoConverter.cxx
#include “I3EventInfoConverter.h
file I3EventInfoConverter.h
#include <tableio/I3Converter.h>
#include <dataclasses/physics/I3MCHit.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3DOMLaunch.h>
#include <dataclasses/physics/I3Waveform.h>

Typedefs

typedef I3EventInfoConverter<I3RecoPulse> I3EventInfoConverterFromRecoPulses
file I3FileOMKey2MBID.cxx
#include <fstream>
#include <sstream>
#include <cassert>
file I3FileOMKey2MBID.h
#include <map>
#include <string>
#include <icetray/I3Logging.h>
#include <icetray/I3PointerTypedefs.h>
#include <interfaces/I3OMKey2MBID.h>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/type_traits/remove_const.hpp>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision:$

Date

$Date$

Author

pretz

Functions

I3_POINTER_TYPEDEFS(I3FileOMKey2MBID)
file I3FileOMKey2MBIDFactory.cxx

Functions

I3_SERVICE_FACTORY(I3FileOMKey2MBIDFactory)
file I3FileOMKey2MBIDFactory.h
#include <string>
#include <icetray/I3ServiceFactory.h>
#include <interfaces/I3OMKey2MBID.h>
file I3GCDAuditor.cxx
#include <icetray/I3Module.h>
#include <icetray/I3Units.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <dataclasses/status/I3DetectorStatus.h>
#include <dataclasses/I3DOMFunctions.h>

Defines

paranoia(...)
bad_dom(...)
bad_dom(...)
sim_bad_dom(...)

Functions

I3_MODULE(I3GCDAuditor)
file I3GCDFileService.cxx
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/calibration/I3Calibration.h”
#include “dataclasses/status/I3DetectorStatus.h”
#include “dataclasses/I3Time.h”
#include “icetray/I3Frame.h”
#include <iostream>
#include <fstream>
#include <icetray/open.h>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/device/file.hpp>
#include <boost/iostreams/filter/gzip.hpp>

Functions

template<class T>
T GetFromFile(I3Frame::Stream stop, std::string filename)
file I3GCDFileService.h
#include <string>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <interfaces/I3GeometryService.h>
#include <interfaces/I3CalibrationService.h>
#include <interfaces/I3DetectorStatusService.h>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

pretz

file I3GCDFileServiceFactory.cxx

Functions

I3_SERVICE_FACTORY(I3GCDFileServiceFactory)
file I3GCDFileServiceFactory.h
#include “icetray/I3ServiceFactory.h”
file I3GeometryDecomposer.cxx
#include <icetray/I3Module.h>
#include <icetray/I3Units.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/geometry/I3OMGeo.h>
#include <dataclasses/geometry/I3TankGeo.h>
#include <dataclasses/geometry/I3ModuleGeo.h>
#include <dataclasses/I3Time.h>
#include <dataclasses/I3Double.h>
#include <dataclasses/I3Orientation.h>
#include <boost/foreach.hpp>

Functions

I3_MODULE(I3GeometryDecomposer)
file I3GeometrySelectorService.cxx
#include <vector>
#include “icetray/I3Units.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “icetray/I3TrayHeaders.h”
file I3GeometrySelectorService.h
#include <vector>
#include <string>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <interfaces/I3GeometryService.h>
#include “icetray/I3Context.h”

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

olivas

Functions

I3_POINTER_TYPEDEFS(I3GeometrySelectorService)
file I3GeometrySelectorServiceFactory.cxx

Functions

I3_SERVICE_FACTORY(I3GeometrySelectorServiceFactory)
file I3GeometrySelectorServiceFactory.h
#include “icetray/I3ServiceFactory.h”
file I3GeoSelTestModule.h
#include “icetray/I3Module.h”

Copyright (C) 2004 the IceCube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

olivas

file I3GeoTrimmers.cxx
#include <utility>
#include <vector>
#include <map>
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/I3Vector.h”
#include “icetray/OMKey.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/physics/I3DOMLaunch.h”
#include “dataclasses/physics/I3Waveform.h”
#include “dataclasses/physics/I3AMANDAAnalogReadout.h”
#include “Miniball.h

Copyright (C) 2007 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

David Boersma boersma@icecube.wisc.edu

file I3GeoTrimmers.h
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/I3Vector.h”
#include “icetray/OMKey.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/physics/I3DOMLaunch.h”
#include “dataclasses/physics/I3Waveform.h”
#include “dataclasses/physics/I3AMANDAAnalogReadout.h”

Defines

NEW_GEOTRIMMERS

This file contains tools for manipulating Geometries, to take out various bad/good/desired/notdesired OM’s.

file I3GSLRandomService.cxx
#include <cstring>
#include <cassert>
#include <gsl/gsl_version.h>

Functions

I3_CLASS_VERSION (I3GSLRandomServiceState, 0)
I3_SERIALIZABLE(I3GSLRandomServiceState)
void gsl_wrapper_set(void *vstate, unsigned long int s)
unsigned long gsl_wrapper_get(void *vstate)
double gsl_wrapper_get_double(void *vstate)

Variables

const gsl_rng_type gsl_rng_counting_wrapper = {"counting_wrapper", 0xffffffffUL, 0, sizeof(gsl_rng_wrapper_state), &gsl_wrapper_set, &gsl_wrapper_get, &gsl_wrapper_get_double}
file I3GSLRandomService.h
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_test.h>

Functions

I3_POINTER_TYPEDEFS(I3GSLRandomService)

Variables

const gsl_rng_type gsl_rng_counting_wrapper
file I3GSLRandomServiceFactory.cxx

Functions

I3_SERVICE_FACTORY(I3GSLRandomServiceFactory)
file I3GSLRandomServiceFactory.h
#include <string>
#include “icetray/I3ServiceFactory.h”
file I3MetaSynth.cxx
#include <icetray/I3Frame.h>
#include <icetray/I3Module.h>
#include <dataclasses/I3Time.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <dataclasses/status/I3DetectorStatus.h>
#include <dataclasses/physics/I3EventHeader.h>
#include <interfaces/I3GeometryService.h>
#include <interfaces/I3CalibrationService.h>
#include <interfaces/I3DetectorStatusService.h>

Functions

I3_MODULE(I3MetaSynth)
file I3MTRandomService.cxx
#include “dataclasses/I3String.h”

Copyright

Copyright (c) 2017 The IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause

Author

Kevin Meagher

Date

December 2017

Functions

I3_SERVICE_FACTORY(I3MTRandomServiceFactory)
file I3MTRandomService.h
#include “icetray/I3ServiceFactory.h”

Copyright

Copyright (c) 2017 The IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause

Author

Kevin Meagher

Date

December 2017

Functions

I3_POINTER_TYPEDEFS(I3MTRandomService)
file I3NullSplitter.cxx
#include <icetray/I3ConditionalModule.h>
#include <dataclasses/I3MapOMKeyMask.h>
#include <string>

Functions

I3_MODULE(I3NullSplitter)
file I3OrphanQDropper.cxx
#include <icetray/I3PacketModule.h>
#include <boost/foreach.hpp>

Functions

I3_MODULE(I3OrphanQDropper)
file I3RandomService.cxx
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>

Functions

static unsigned long i3random_get(void *state)
static void i3random_set(void *state, unsigned long int s)
static double i3random_get_double(void *state)
file I3RandomService.h
#include “dataclasses/Utility.h”
#include <icetray/I3DefaultName.h>
#include <icetray/I3FrameObject.h>

Functions

I3_DEFAULT_NAME(I3RandomService)
I3_POINTER_TYPEDEFS(I3RandomService)
file I3RecoInfoConverter.cxx
#include “I3RecoInfoConverter.h
#include “phys-services/I3Cuts.h
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <boost/foreach.hpp>
file I3RecoInfoConverter.h
#include <tableio/I3Converter.h>
#include <dataclasses/physics/I3Particle.h>
file I3ScaleCalculator.cxx
#include “phys-services/I3Cuts.h
#include <boost/foreach.hpp>
#include <vector>
#include <map>
#include <set>
#include <limits>

Defines

Z_TOP
file I3ScaleCalculator.h
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/geometry/I3Geometry.h”
file I3Splitter.cxx
#include <icetray/I3Frame.h>
#include <icetray/I3Context.h>
#include <icetray/I3Configuration.h>
#include <dataclasses/physics/I3EventHeader.h>
file I3Splitter.h
#include <icetray/I3Configuration.h>
#include <icetray/I3Frame.h>
#include <string>
file I3SplitTriggerSelector.cxx
#include <icetray/I3ConditionalModule.h>
#include <limits>
#include <icetray/I3Units.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <dataclasses/status/I3DetectorStatus.h>
#include <dataclasses/physics/I3EventHeader.h>
#include <dataclasses/physics/I3Trigger.h>
#include <dataclasses/physics/I3TriggerHierarchy.h>
#include <dataclasses/physics/I3RecoPulse.h>

Defines

AlwaysPush(frame)

Functions

I3_MODULE(I3SplitTriggerSelector)
file I3SPRNGRandomService.cxx
#include <string>
#include <fstream>
#include <cassert>
#include <sys/stat.h>

Functions

I3_CLASS_VERSION (I3SPRNGRandomServiceState, 0)
I3_SERIALIZABLE(I3SPRNGRandomServiceState)
file I3SPRNGRandomService.h
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_test.h>
#include <string>

Functions

I3_POINTER_TYPEDEFS(I3SPRNGRandomService)
file I3SPRNGRandomServiceFactory.cxx
#include <sys/stat.h>

Functions

I3_SERVICE_FACTORY(I3SPRNGRandomServiceFactory)
file I3SPRNGRandomServiceFactory.h
#include <string>
#include “icetray/I3ServiceFactory.h”
file I3StdRandomEngine.h
#include <random>
#include “dataclasses/I3String.h”

Copyright

Copyright (c) 2017 The IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause

Author

Kevin Meagher

Date

December 2017

file I3StringAdderService.cxx
#include “icetray/I3Units.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “icetray/I3TrayHeaders.h”
#include <boost/foreach.hpp>
file I3StringAdderService.h
#include <vector>
#include <string>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <interfaces/I3GeometryService.h>
#include “icetray/I3Context.h”

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

olivas

Functions

I3_POINTER_TYPEDEFS(I3StringAdderService)
file I3StringAdderServiceFactory.cxx
#include <vector>
#include “dataclasses/geometry/I3OMGeo.h”
#include “icetray/I3Units.h”

Functions

I3_SERVICE_FACTORY(I3StringAdderServiceFactory)
const double DEFAULT_DEPTH (500.*I3Units::m)
const double DEFAULT_DOM_SPACING (17.*I3Units::m)
const unsigned int DEFAULT_DOMS_PER_STRING (60)
const int DEFAULT_ORIENTATION (-1)
const int DEFAULT_TYPE (20)
const double DEFAULT_AREA (0.0444 *I3Units::m2)
const double DEFAULT_REL_ANGLE (0.*I3Units::degree)
file I3StringAdderServiceFactory.h
#include “icetray/I3ServiceFactory.h”
file I3SummaryService.h
#include <icetray/I3Logging.h>
#include <icetray/I3DefaultName.h>
#include <icetray/I3PointerTypedefs.h>
#include <dataclasses/I3Map.h>

Functions

I3_DEFAULT_NAME(I3SummaryService)
I3_POINTER_TYPEDEFS(I3SummaryService)
file I3TextFileGeometryService.cxx
#include “icetray/I3Units.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “icetray/I3TrayHeaders.h”
#include <dataclasses/I3Time.h>
#include <dataclasses/geometry/I3Geometry.h>
file I3TextFileGeometryService.h
#include <string>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <interfaces/I3GeometryService.h>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

pretz

Typedefs

typedef boost::shared_ptr<I3TextFileGeometryService> I3TextFileGeometryServicePtr
file I3TextFileGeometryServiceFactory.cxx

Functions

I3_SERVICE_FACTORY(I3TextFileGeometryServiceFactory)
file I3TextFileGeometryServiceFactory.h
#include “icetray/I3ServiceFactory.h”
file I3VEMCalManipulator.cxx
#include <fstream>
#include <math.h>
#include <dirent.h>
file I3VEMCalManipulator.h
#include <interfaces/I3CalibrationService.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <map>

Copyright (C) 2008 The IceCube collaboration SPDX-License-Identifier: BSD-2-Clause ID: $Id$

Version

$Revision$

Date

$Date$

Author

$Author$

file I3VEMCalManipulatorFactory.cxx

Functions

I3_SERVICE_FACTORY(I3VEMCalManipulatorFactory)
file I3VEMCalManipulatorFactory.h
#include <icetray/I3ServiceFactory.h>

Copyright (C) 2008 The IceCube collaboration SPDX-License-Identifier: BSD-2-Clause ID: $Id$

Version

$Revision$

Date

$Date$

Author

$Author$

file I3XMLOMKey2MBID.cxx
#include <icetray/open.h>
#include <utility>
#include <archive/xml_iarchive.hpp>
#include <archive/xml_oarchive.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <serialization/map.hpp>
#include <serialization/utility.hpp>

implementation of the I3XMLOMKey2MBID class

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

tschmidt

file I3XMLOMKey2MBID.h
#include <map>
#include <string>
#include <icetray/I3Logging.h>
#include <icetray/I3PointerTypedefs.h>
#include <icetray/OMKey.h>
#include <interfaces/I3OMKey2MBID.h>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

tschmidt

Functions

I3_POINTER_TYPEDEFS(I3XMLOMKey2MBID)
file I3XMLOMKey2MBIDFactory.cxx
#include <icetray/I3Context.h>
#include <icetray/I3DefaultName.h>

implementation of the I3XMLOMKey2MBIDFactory class

Copyright (c) 2005 the IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

tschmidt

Functions

I3_SERVICE_FACTORY(I3XMLOMKey2MBIDFactory)
file I3XMLOMKey2MBIDFactory.h
#include <string>
#include <icetray/I3Logging.h>
#include <icetray/I3ServiceFactory.h>
#include <interfaces/I3OMKey2MBID.h>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Author

tschmidt

file CreateXMLOMKey2MBIDConversionTable/main.cxx
#include <stdexcept>
#include <string>
#include <boost/program_options.hpp>

Copyright (C) 2004 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Functions

int main(int argc, char **argv)
file MergeXMLOMKey2MBIDConversionTables/main.cxx
#include <stdexcept>
#include <string>
#include <vector>
#include <boost/program_options.hpp>

Copyright (C) 2022 the icecube collaboration SPDX-License-Identifier: BSD-2-Clause $Id$

Version

$Revision$

Date

$Date$

Functions

int main(int argc, char **argv)
file Miniball.h
#include <cstdlib>
#include <cassert>
#include <cmath>
#include <iostream>
#include <list>
file MultiPMTCoincify.cxx
#include <boost/foreach.hpp>
#include <icetray/I3Units.h>

class: MultiPMTCoincify

Version

Rcs

Copyright (c) 2022 IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause

Date

Rcs
Author

mlarson

Functions

I3_MODULE(MultiPMTCoincify)
file MultiPMTCoincify.h
#include <string>
#include <map>
#include <vector>
#include “icetray/I3ConditionalModule.h”
#include “icetray/OMKey.h”
#include “dataclasses/ModuleKey.h”
#include <dataclasses/physics/I3RecoPulse.h>
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “dataclasses/geometry/I3ModuleGeo.h”
file omkey2mbidformat.dox
file polygon.cxx
#include <boost/next_prior.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/utility.hpp>

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

Functions

I3_SERIALIZABLE(I3Surfaces::polygon::vec2)
file polygon.h
#include <dataclasses/I3Direction.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen jakob.van.santen@desy.de

file SamplingSurface.cxx
#include <dataclasses/I3Position.h>
#include <dataclasses/I3Direction.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

I3_SERIALIZABLE(I3Surfaces::SamplingSurface)
file SamplingSurface.h

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

I3_CLASS_VERSION (I3Surfaces::SamplingSurface, 0)
file Sphere.cxx
#include <dataclasses/I3Position.h>
#include <dataclasses/I3Direction.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

I3_SERIALIZABLE(I3Surfaces::Sphere)
file Sphere.h

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

I3_CLASS_VERSION (I3Surfaces::Sphere, 0)
file Surface.cxx

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

I3_SERIALIZABLE(I3Surfaces::Surface)
file Surface.h
#include <icetray/I3PointerTypedefs.h>
#include <icetray/I3FrameObject.h>
#include <icetray/serialization.h>

$Id$

$Revision$ $Date$

Author

Jakob van Santen vansanten@wisc.edu

Functions

I3_CLASS_VERSION (I3Surfaces::Surface, 1)
page omkey2mbidformat

Following is an example of the format expected by the I3FileOMKey2MBID service. Note that lines beginning with ‘#’ are interpreted as comments.


page todo

Class gsl_sprng_stream

Member I3Calculator::CherenkovCalc  (const I3Particle &track, const I3Position &position, I3Position &chpos, double &chtime, double &chdist, double &changle, const double IndexRefG=I3Constants::n_ice_group, const double IndexRefP=I3Constants::n_ice_phase, const I3Direction &direction=I3Direction(0., 0.,-1.))

Currently, CherenkovCalc calculates “closest approach” AND “cherenkov distances”. This is good for simplicity and non-repetitiveness of the code, but it is not the most efficient. If processing time becomes an issue, we can make these things more efficient at the expence of complicating and repeating the code.

Member I3Calculator::IsOnTrack  (const I3Particle &track, const I3Position &position, const double Precision=0.1 *I3Units::meter)

IsOnTrack uses CherenkovCalc for calculating “distance of closest

approach”. This method is not the most efficient, but makes the code much simpler. If processing time becomes an issue, we can make these routines more efficient.

Namespace I3Cuts

So far we have Ndir, Ldir, and Smoothness, but other cut parameters will and should be added as we have move more into an analysis phase of the experiment.

Member I3Cuts::CascadeCutsCalc  (const I3Particle &vertex, const I3Geometry &geometry, const I3Map< OMKey, std::vector< I3RecoPulse > > &pulsemap, const double t1, const double t2, int &Nchan, int &Nhit, int &N_1hit, int &Nstring, int &Ndir, int &Nearly, int &Nlate)

Think about making the code more efficient…

Member I3Cuts::CutsCalc  (const I3Particle &track, const I3Geometry &geometry, const I3Map< OMKey, std::vector< I3RecoPulse > > &pulsemap, const double t1, const double t2, int &Nchan, int &Nhit, int &Nstring, int &Ndir, double &Ldir, double &Sdir, double &Sall)

Think about making the code more efficient…

Member I3FileOMKey2MBID::OMKeyize  (const std::string &key)

This is an ugly mess.

Class I3SPRNGRandomService

Add ability to save state of rng after run is complete SPRNG has the functions:

dir converter
dir CreateXMLOMKey2MBIDConversionTable
dir detail
dir geo-selector
dir geo-selector
dir icetray
dir MergeXMLOMKey2MBIDConversionTables
dir phys-services
dir phys-services
dir phys-services
dir phys-source
dir private
dir public
dir source
dir surfaces
dir surfaces