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 ¶

#include <ExtrudedPolygonBase.h>

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¶

#include <I3GSLRandomService.h>

An implementation of the I3RandomService interface.

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.

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$

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 ¶

#include <I3CascadeCutValues.h>

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>

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>¶

#include <I3CutValuesConverter.h>

$Id$

Version: $Revision$
Date: $LastChangedDate$
Author: Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Private Functions

I3TableRowDescriptionPtr CreateDescription(const I3CutValues &cv)¶

$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>>>¶

#include <I3EventInfoConverter.h>

$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 ¶

#include <I3FileOMKey2MBIDFactory.h>

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$

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 ¶

#include <I3GCDFileServiceFactory.h>

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 ¶

#include <I3GeometrySelectorService.h>

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 ¶

#include <I3GeometrySelectorServiceFactory.h>

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 ¶

#include <I3GeoSelTestModule.h>

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 ¶

#include <I3GSLRandomService.h>

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 ¶

#include <I3GSLRandomServiceFactory.h>

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

#include <I3CascadeCutValues.h>

Author: mdagost
Author: dule

class I3MetaSynth : public I3Module ¶

$Id$

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>¶

#include <I3MTRandomService.h>

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 ¶

#include <I3MTRandomService.h>

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$

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$

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>¶

#include <I3RecoInfoConverter.h>

$Id$

Version: $Revision$
Date: $LastChangedDate$
Author: Eike Middell eike.middell@desy.de $LastChangedBy$

Public Functions

I3RecoInfoConverter()¶

I3RecoInfoConverter(std::string pulseMapName)¶

$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¶

#include <I3ScaleCalculator.h>

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

$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.

Subclassed by I3NullSplitter

Public Functions

I3Splitter(const I3Configuration &config)¶

$Id$

~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 ¶

#include <I3SPRNGRandomService.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. See gsl-sprng.h for more details.

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 ¶

#include <I3SPRNGRandomServiceFactory.h>

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 ¶

#include <I3StdRandomEngine.h>

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 ¶

#include <I3StringAdderService.h>

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 ¶

#include <I3StringAdderServiceFactory.h>

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.

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 ¶

#include <I3TextFileGeometryService.h>

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 ¶

#include <I3TextFileGeometryServiceFactory.h>

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 ¶

#include <I3VEMCalManipulator.h>

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 ¶

#include <I3VEMCalManipulatorFactory.h>

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 ¶

#include <I3XMLOMKey2MBIDFactory.h>

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 – — const reference to a track.
position – — Position of an OM.
IndexRefG – — Index of refraction (group), default=1.35634 (from I3Constants) This is used to define the speed of light through ice.
IndexRefP – — 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 – — Orientation of the OM.
chpos – — 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 – — 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 – — Distance between the point of origin of Cherenkov light and the input OM position.
changle – — 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)¶: ——NEW!——-— 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 – — Track used in calculation.
geometry – — Geometry object from the event.
pulsemap – — Map of I3RecoPulseSeries used in calculation.
t1 – — Lower edge of the time residual window for direct hits. Generally, this value is -15ns.
t2 – — Upper edge of the time residual window for direct hits. Generally, this value is 15ns..150ns.
Nchan – — The Nchan cut parameter: total number of hit channels.
Nhit – — The Nhit cut parameter: total number of hits.
Nstring – — The Nstring cut parameter: total number of strings.
Ndir – — The Ndir cut parameter: number of direct hits.
Ldir – — 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 – — The Smoothness parameter (based on all hits): how uniformly are the hit projections onto the track distributed along that track.
Sdir – — 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 – — Vertex used in calculation.
geometry – — Geometry object from the event.
pulsemap – — Map of I3RecoPulseSeries used in calculation.
t1 – — Lower edge of the time residual window for direct hits. Generally, this value is -15ns.
t2 – — Upper edge of the time residual window for direct hits. Generally, this value is 15ns..150ns.
Nchan – — The Nchan cut parameter: total number of hit channels.
Nhit – — The Nhit cut parameter: total number of hits.
N_1hit – — Number of channels with only 1 hit in them.
Nstring – — The Nstring cut parameter: total number of strings.
Ndir – — The Ndir cut parameter: number of direct hits.
Nearly – — The Nearly cut parameter: number of early hits.
Nlate – — 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 <phys-services/surfaces/AxialCylinder.h>

#include <phys-services/I3RandomService.h>

#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 <phys-services/surfaces/SamplingSurface.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

#include <phys-services/surfaces/Cup.h>

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

#include <phys-services/surfaces/SamplingSurface.h>

#include <phys-services/surfaces/detail/CupBase.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>

#include <phys-services/I3RandomService.h>

$Id$

$Revision$ $Date$

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

file Cylinder.cxx

#include <phys-services/surfaces/Cylinder.h>

$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

#include <phys-services/surfaces/SamplingSurface.h>

#include <phys-services/surfaces/detail/CylinderBase.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>

#include <phys-services/I3RandomService.h>

$Id$

$Revision$ $Date$

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

file ExtrudedPolygon.cxx

#include <phys-services/surfaces/ExtrudedPolygon.h>

$Id$

$Revision$ $Date$

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

Functions

I3_SERIALIZABLE(I3Surfaces::ExtrudedPolygon)¶

file ExtrudedPolygon.h

#include <phys-services/surfaces/SamplingSurface.h>

#include <phys-services/surfaces/detail/ExtrudedPolygonBase.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 <phys-services/surfaces/detail/polygon.h>

#include <phys-services/I3RandomService.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 “phys-services/geo-selector/GeoSelUtils.h”

#include “icetray/I3Logging.h”

#include <string>

#include <iostream>

#include <sstream>

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>

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: #include “phys-services/I3Calculator.h”

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”

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/I3CascadeCutValues.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 <phys-services/I3CutValuesBase.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 “phys-services/I3CrossSection.h”

#include <array>

#include <cmath>

#include <icetray/I3Logging.h>

Implementation of class for spline-interpolated cross section model

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>

#include <phys-services/I3RandomService.h>

Definition of class for spline-interpolated cross section model

Date: $Date$
Author: cweaver

file I3Cuts.cxx

#include “phys-services/I3Cuts.h”

#include “dataclasses/I3Constants.h”

#include “phys-services/I3Calculator.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 “phys-services/I3CutValues.h”

#include “phys-services/I3CascadeCutValues.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 “phys-services/I3CutValues.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 <phys-services/I3CutValuesBase.h>

#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>

#include <phys-services/I3CutValues.h>

file I3EventCounter.cxx

#include <sstream>

#include <fstream>

#include “phys-services/I3EventCounter.h”

#include “dataclasses/physics/I3EventHeader.h”

Functions

I3_MODULE(I3EventCounter)¶

file I3EventCounter.h: #include “icetray/I3TrayHeaders.h”

#include “icetray/I3Module.h”

#include “phys-services/I3SummaryService.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 <phys-services/I3FileOMKey2MBID.h>

#include <fstream>

#include <sstream>

#include <cassert>

#include <phys-services/I3XMLOMKey2MBID.h>

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>

Version: $Revision:$
Date: $Date$
Author: pretz

Functions

I3_POINTER_TYPEDEFS(I3FileOMKey2MBID)¶

file I3FileOMKey2MBIDFactory.cxx

#include “phys-services/I3FileOMKey2MBIDFactory.h”

#include “phys-services/I3FileOMKey2MBID.h”

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 “phys-services/source/I3GCDFileService.h”

#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>

Version: $Revision$
Date: $Date$
Author: pretz

file I3GCDFileServiceFactory.cxx

#include “phys-services/source/I3GCDFileServiceFactory.h”

#include “phys-services/source/I3GCDFileService.h”

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 “phys-services/geo-selector/I3GeometrySelectorService.h”

#include “icetray/I3Units.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “icetray/I3TrayHeaders.h”

#include “phys-services/geo-selector/GeoSelUtils.h”

file I3GeometrySelectorService.h

#include <vector>

#include <string>

#include <fstream>

#include <boost/shared_ptr.hpp>

#include <interfaces/I3GeometryService.h>

#include “icetray/I3Context.h”

Version: $Revision$
Date: $Date$
Author: olivas

Functions

I3_POINTER_TYPEDEFS(I3GeometrySelectorService)¶

file I3GeometrySelectorServiceFactory.cxx

#include “phys-services/geo-selector/I3GeometrySelectorServiceFactory.h”

#include “phys-services/geo-selector/I3GeometrySelectorService.h”

#include “phys-services/geo-selector/GeoSelUtils.h”

Functions

I3_SERVICE_FACTORY(I3GeometrySelectorServiceFactory)¶

file I3GeometrySelectorServiceFactory.h: #include “icetray/I3ServiceFactory.h”

file I3GeoSelTestModule.h

#include “icetray/I3Module.h”

Version: $Revision$
Date: $Date$
Author: olivas

file I3GeoTrimmers.cxx

#include <utility>

#include <vector>

#include <map>

#include “phys-services/geo-selector/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”

#include “Miniball.h”

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 “phys-services/I3GSLRandomService.h”

#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 “phys-services/I3RandomService.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

#include “phys-services/I3GSLRandomServiceFactory.h”

#include “phys-services/I3GSLRandomService.h”

Functions

I3_SERVICE_FACTORY(I3GSLRandomServiceFactory)¶

file I3GSLRandomServiceFactory.h: #include <string>

#include “icetray/I3ServiceFactory.h”

#include “phys-services/I3RandomService.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 “phys-services/I3MTRandomService.h”

#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”

#include “phys-services/I3StdRandomEngine.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 <phys-services/I3Splitter.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>

#include <phys-services/I3RandomService.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/I3ScaleCalculator.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/I3ScaleCalculator.h”

#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>

#include “phys-services/I3Splitter.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 “phys-services/I3SPRNGRandomService.h”

#include “phys-services/gsl-sprng.h”

#include <string>

#include <fstream>

#include <cassert>

#include <sys/stat.h>

Functions

I3_CLASS_VERSION (I3SPRNGRandomServiceState, 0)

I3_SERIALIZABLE(I3SPRNGRandomServiceState)¶

file I3SPRNGRandomService.h

#include “phys-services/I3RandomService.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 “phys-services/I3SPRNGRandomServiceFactory.h”

#include “phys-services/I3SPRNGRandomService.h”

#include <sys/stat.h>

Functions

I3_SERVICE_FACTORY(I3SPRNGRandomServiceFactory)¶

file I3SPRNGRandomServiceFactory.h: #include <string>

#include “icetray/I3ServiceFactory.h”

#include “phys-services/I3RandomService.h”

file I3StdRandomEngine.h

#include <random>

#include “dataclasses/I3String.h”

#include “phys-services/I3RandomService.h”

Copyright: Copyright (c) 2017 The IceCube Collaboration SPDX-License-Identifier: BSD-2-Clause
Author: Kevin Meagher
Date: December 2017

file I3StringAdderService.cxx: #include “phys-services/geo-selector/I3StringAdderService.h”

#include “icetray/I3Units.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “icetray/I3TrayHeaders.h”

#include “phys-services/geo-selector/GeoSelUtils.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”

Version: $Revision$
Date: $Date$
Author: olivas

Functions

I3_POINTER_TYPEDEFS(I3StringAdderService)¶

file I3StringAdderServiceFactory.cxx

#include <vector>

#include “phys-services/geo-selector/I3StringAdderServiceFactory.h”

#include “phys-services/geo-selector/I3StringAdderService.h”

#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 “phys-services/source/I3TextFileGeometryService.h”

#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>

Version: $Revision$
Date: $Date$
Author: pretz

Typedefs

typedef boost::shared_ptr<I3TextFileGeometryService> I3TextFileGeometryServicePtr¶

file I3TextFileGeometryServiceFactory.cxx

#include “phys-services/source/I3TextFileGeometryServiceFactory.h”

#include “phys-services/source/I3TextFileGeometryService.h”

Functions

I3_SERVICE_FACTORY(I3TextFileGeometryServiceFactory)¶

file I3TextFileGeometryServiceFactory.h: #include “icetray/I3ServiceFactory.h”

file I3VEMCalManipulator.cxx: #include <phys-services/I3VEMCalManipulator.h>

#include <fstream>

#include <math.h>

#include <dirent.h>

file I3VEMCalManipulator.h

#include <interfaces/I3CalibrationService.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <map>

Version: $Revision$
Date: $Date$
Author: $Author$

file I3VEMCalManipulatorFactory.cxx

#include <phys-services/I3VEMCalManipulatorFactory.h>

Functions

I3_SERVICE_FACTORY(I3VEMCalManipulatorFactory)¶

file I3VEMCalManipulatorFactory.h

#include <icetray/I3ServiceFactory.h>

#include <phys-services/I3VEMCalManipulator.h>

Version: $Revision$
Date: $Date$
Author: $Author$

file I3XMLOMKey2MBID.cxx

#include <phys-services/I3XMLOMKey2MBID.h>

#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

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>

Version: $Revision$
Date: $Date$
Author: tschmidt

Functions

I3_POINTER_TYPEDEFS(I3XMLOMKey2MBID)¶

file I3XMLOMKey2MBIDFactory.cxx

#include <phys-services/I3XMLOMKey2MBIDFactory.h>

#include <icetray/I3Context.h>

#include <icetray/I3DefaultName.h>

#include <phys-services/I3XMLOMKey2MBID.h>

implementation of the I3XMLOMKey2MBIDFactory class

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>

Version: $Revision$
Date: $Date$
Author: tschmidt

file CreateXMLOMKey2MBIDConversionTable/main.cxx

#include <stdexcept>

#include <string>

#include <boost/program_options.hpp>

#include <phys-services/I3FileOMKey2MBID.h>

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>

#include <phys-services/I3XMLOMKey2MBID.h>

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 <phys-services/MultiPMTCoincify.h>

#include <icetray/I3Units.h>

class: MultiPMTCoincify

Version

Rcs

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 “phys-services/I3RandomService.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 <phys-services/surfaces/detail/polygon.h>

#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 <phys-services/surfaces/SamplingSurface.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/I3Direction.h>

#include <phys-services/I3RandomService.h>

$Id$

$Revision$ $Date$

Author: Jakob van Santen vansanten@wisc.edu

Functions

I3_SERIALIZABLE(I3Surfaces::SamplingSurface)¶

file SamplingSurface.h

#include <phys-services/surfaces/Surface.h>

$Id$

$Revision$ $Date$

Author: Jakob van Santen vansanten@wisc.edu

Functions

I3_CLASS_VERSION (I3Surfaces::SamplingSurface, 0)

file Sphere.cxx

#include <phys-services/surfaces/Sphere.h>

#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

#include <phys-services/surfaces/Surface.h>

$Id$

$Revision$ $Date$

Author: Jakob van Santen vansanten@wisc.edu

Functions

I3_CLASS_VERSION (I3Surfaces::Sphere, 0)

file Surface.cxx

#include <phys-services/surfaces/Surface.h>

$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

phys-services C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page