VHESelfVeto C++ API Reference

class BadStringRemover : public I3PacketModule

Public Functions

BadStringRemover(const I3Context&)

void Configure()

void FramePacket(std::vector<I3FramePtr> &frames)

void Physics(I3FramePtr frame)

Private Members

I3GeometryConstPtr currentGeo_

std::string badDOMs_

std::string pulses_

std::string outpulses_

std::string outgeo_

std::string nBadStrings_

double badDOMFraction_

bool ignoreDeepCore_

class Clipper : public virtual ClipperLib::ClipperBase

#include <clipper.h>

Public Functions

Clipper()

~Clipper()

bool Execute(ClipType clipType, Polygons &solution, PolyFillType subjFillType = pftEvenOdd, PolyFillType clipFillType = pftEvenOdd)

bool Execute(ClipType clipType, ExPolygons &solution, PolyFillType subjFillType = pftEvenOdd, PolyFillType clipFillType = pftEvenOdd)

virtual void Clear()

inline bool ReverseSolution()

inline void ReverseSolution(bool value)

Protected Functions

virtual void Reset()

virtual bool ExecuteInternal(bool fixHoleLinkages)

Private Functions

void DisposeScanbeamList()

void SetWindingCount(TEdge &edge)

bool IsEvenOddFillType(const TEdge &edge) const

bool IsEvenOddAltFillType(const TEdge &edge) const

void InsertScanbeam(const long64 Y)

long64 PopScanbeam()

void InsertLocalMinimaIntoAEL(const long64 botY)

void InsertEdgeIntoAEL(TEdge *edge)

void AddEdgeToSEL(TEdge *edge)

void CopyAELToSEL()

void DeleteFromSEL(TEdge *e)

void DeleteFromAEL(TEdge *e)

void UpdateEdgeIntoAEL(TEdge *&e)

void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2)

bool IsContributing(const TEdge &edge) const

bool IsTopHorz(const long64 XPos)

void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2)

void DoMaxima(TEdge *e, long64 topY)

void ProcessHorizontals()

void ProcessHorizontal(TEdge *horzEdge)

void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt)

void AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt)

void AppendPolygon(TEdge *e1, TEdge *e2)

void DoEdge1(TEdge *edge1, TEdge *edge2, const IntPoint &pt)

void DoEdge2(TEdge *edge1, TEdge *edge2, const IntPoint &pt)

void DoBothEdges(TEdge *edge1, TEdge *edge2, const IntPoint &pt)

void IntersectEdges(TEdge *e1, TEdge *e2, const IntPoint &pt, IntersectProtects protects)

OutRec *CreateOutRec()

void AddOutPt(TEdge *e, const IntPoint &pt)

void DisposeBottomPt(OutRec &outRec)

void DisposeAllPolyPts()

void DisposeOutRec(PolyOutList::size_type index)

bool ProcessIntersections(const long64 botY, const long64 topY)

void AddIntersectNode(TEdge *e1, TEdge *e2, const IntPoint &pt)

void BuildIntersectList(const long64 botY, const long64 topY)

void ProcessIntersectList()

void ProcessEdgesAtTopOfScanbeam(const long64 topY)

void BuildResult(Polygons &polys)

void BuildResultEx(ExPolygons &polys)

void SetHoleState(TEdge *e, OutRec *OutRec)

void DisposeIntersectNodes()

bool FixupIntersections()

void FixupOutPolygon(OutRec &outRec)

bool IsHole(TEdge *e)

void FixHoleLinkage(OutRec *outRec)

void CheckHoleLinkages1(OutRec *outRec1, OutRec *outRec2)

void CheckHoleLinkages2(OutRec *outRec1, OutRec *outRec2)

void AddJoin(TEdge *e1, TEdge *e2, int e1OutIdx = -1, int e2OutIdx = -1)

void ClearJoins()

void AddHorzJoin(TEdge *e, int idx)

void ClearHorzJoins()

void JoinCommonEdges(bool fixHoleLinkages)

Private Members

PolyOutList m_PolyOuts

JoinList m_Joins

HorzJoinList m_HorizJoins

ClipType m_ClipType

Scanbeam *m_Scanbeam

TEdge *m_ActiveEdges

TEdge *m_SortedEdges

IntersectNode *m_IntersectNodes

bool m_ExecuteLocked

PolyFillType m_ClipFillType

PolyFillType m_SubjFillType

bool m_ReverseOutput

class ClipperBase

#include <clipper.h>

Subclassed by ClipperLib::Clipper

Public Functions

ClipperBase()

virtual ~ClipperBase()

bool AddPolygon(const Polygon &pg, PolyType polyType)

bool AddPolygons(const Polygons &ppg, PolyType polyType)

virtual void Clear()

IntRect GetBounds()

Protected Functions

void DisposeLocalMinimaList()

TEdge *AddBoundsToLML(TEdge *e)

void PopLocalMinima()

virtual void Reset()

void InsertLocalMinima(LocalMinima *newLm)

Protected Attributes

LocalMinima *m_CurrentLM

LocalMinima *m_MinimaList

bool m_UseFullRange

EdgeList m_edges

class clipperException : public std::exception

#include <clipper.h>

Public Functions

inline clipperException(const char *description)

inline virtual ~clipperException()

inline virtual const char *what() const

Private Members

std::string m_descr

class DetectorShrinker : public I3PacketModule

Public Functions

DetectorShrinker(const I3Context&)

void Configure()

void FramePacket(std::vector<I3FramePtr> &frames)

void Physics(I3FramePtr frame)

Private Members

double topBoundaryWidth_

double bottomBoundaryWidth_

I3GeometryConstPtr currentGeo_

std::string pulses_

std::string outpulses_

std::string outgeo_

std::string ingeo_

struct DoublePoint

Public Functions

inline DoublePoint(double x = 0, double y = 0)

Public Members

double X

double Y

struct ExPolygon

#include <clipper.h>

Public Members

Polygon outer

Polygons holes

class FiducialVolumeEntryPointFinder : public I3ConditionalModule

Public Functions

FiducialVolumeEntryPointFinder(const I3Context&)

void Configure()

void DAQ(I3FramePtr frame)

void Geometry(I3FramePtr frame)

inline void DetectorStatus(I3FramePtr frame)

Private Members

double topBoundaryWidth_

double bottomBoundaryWidth_

double sideBoundaryWidth_

bool assumeMuonTracksAreInfinite_

std::string mcTreeName_

std::string particleIntersectionsName_

VHESelfVetoUtils::reducedgeo_t reducedgeoNoBorders_

std::string geoName_

I3GeometryConstPtr geo_

class HomogenizedQTot : public I3ConditionalModule

Public Functions

HomogenizedQTot(const I3Context&)

void Configure()

void Physics(I3FramePtr frame)

Private Members

std::string pulses_

std::string outputName_

std::string vertexTimeName_

struct HorzJoinRec

#include <clipper.h>

Public Members

TEdge *edge

int savedIdx

class Int128

Public Functions

inline Int128(long64 _lo = 0)

inline Int128(const Int128 &val)

inline long64 operator=(const long64 &val)

inline bool operator==(const Int128 &val) const

inline bool operator!=(const Int128 &val) const

inline bool operator>(const Int128 &val) const

inline bool operator<(const Int128 &val) const

inline bool operator>=(const Int128 &val) const

inline bool operator<=(const Int128 &val) const

inline Int128 &operator+=(const Int128 &rhs)

inline Int128 operator+(const Int128 &rhs) const

inline Int128 &operator-=(const Int128 &rhs)

inline Int128 operator-(const Int128 &rhs) const

inline Int128 operator*(const Int128 &rhs) const

inline Int128 operator/(const Int128 &rhs) const

inline double AsDouble() const

Private Members

long64 hi

long64 lo

Private Static Functions

static inline void Negate(Int128 &val)

struct IntersectNode

#include <clipper.h>

Public Members

TEdge *edge1

TEdge *edge2

IntPoint pt

IntersectNode *next

struct IntPoint

#include <clipper.h>

Public Functions

inline IntPoint(long64 x = 0, long64 y = 0)

Public Members

long64 X

long64 Y

Friends

friend std::ostream &operator<<(std::ostream &s, IntPoint &p)

struct IntRect

#include <clipper.h>

Public Members

long64 left

long64 top

long64 right

long64 bottom

struct JoinRec

#include <clipper.h>

Public Members

IntPoint pt1a

IntPoint pt1b

int poly1Idx

IntPoint pt2a

IntPoint pt2b

int poly2Idx

class LayerVeto : public I3ConditionalModule

Public Functions

LayerVeto(const I3Context&)

void Configure()

void Physics(I3FramePtr)

void Geometry(I3FramePtr)

void Calibration(I3FramePtr)

void DetectorStatus(I3FramePtr)

Private Types

typedef std::set<OMKey> DOMSet

Private Functions

double GetVetoCharge(const I3RecoPulseSeriesMap&, std::vector<I3RecoPulseSeriesMap>&, double&)

void ConstructVetoLayers()

Private Members

std::vector<DOMSet> vetoLayers_

std::set<OMKey> badDOMList_

I3GeometryConstPtr geometry_

I3CalibrationConstPtr calibration_

I3DetectorStatusConstPtr status_

std::string pulseName_

std::string badDOMListName_

std::string geometryName_

std::string outputName_

double qmax_

double qmin_

double qscale_

double timeWindow_

double tagThreshold_

python::object layerConstructor_

struct LocalMinima

#include <clipper.h>

Public Members

long64 Y

TEdge *leftBound

TEdge *rightBound

LocalMinima *next

struct OutPt

#include <clipper.h>

Public Members

int idx

IntPoint pt

OutPt *next

OutPt *prev

struct OutRec

#include <clipper.h>

Public Members

int idx

bool isHole

OutRec *FirstLeft

OutRec *AppendLink

OutPt *pts

OutPt *bottomPt

OutPt *bottomFlag

EdgeSide sides

class PolyOffsetBuilder

Public Functions

inline PolyOffsetBuilder(const Polygons &in_polys, Polygons &out_polys, double delta, JoinType jointype, double MiterLimit)

Private Functions

inline void AddPoint(const IntPoint &pt)

inline void DoSquare(double mul = 1.0)

inline void DoMiter()

inline void DoRound()

Private Members

Polygons m_p

Polygon *m_curr_poly

std::vector<DoublePoint> normals

double m_delta

double m_RMin

double m_R

size_t m_i

size_t m_j

size_t m_k

JoinType m_jointype

Private Static Attributes

static const int buffLength = 128

struct reducedgeo_t

#include <VHESelfVetoUtils.h>

A representation of the boundary of the detector geometry as an extruded polygon, aligned with the z-axis.

Public Members

double maxz

The top of the extruded polygon.

double minz

The bottom of the extruded polygon.

std::vector<std::pair<double, double>> polygon

The ordered collection of x,y coordinate pairs which define the horizontal boundary polygon.

double topBoundaryWidth

The distance by which a point must be beneath maxz to be considered inside the detector.

double bottomBoundaryWidth

The distance by which a point must be above minz to be considered inside the detector.

double sideBoundaryWidth

The distance by which a point must be inside the polygon to be considered inside the detector.

struct Scanbeam

#include <clipper.h>

Public Members

long64 Y

Scanbeam *next

class TauGeneratesMuon : public I3ConditionalModule

Public Functions

TauGeneratesMuon(const I3Context&)

void Configure()

void Physics(I3FramePtr frame)

Private Members

std::string mcTreeName_

std::string outputBoolName_

std::string outgoingMuonName_

struct TEdge

#include <clipper.h>

Public Members

long64 xbot

long64 ybot

long64 xcurr

long64 ycurr

long64 xtop

long64 ytop

double dx

long64 tmpX

PolyType polyType

EdgeSide side

int windDelta

int windCnt

int windCnt2

int outIdx

TEdge *next

TEdge *prev

TEdge *nextInLML

TEdge *nextInAEL

TEdge *prevInAEL

TEdge *nextInSEL

TEdge *prevInSEL

class VertexInFiducialVolume : public I3ConditionalModule

Public Functions

VertexInFiducialVolume(const I3Context&)

void Configure()

void Physics(I3FramePtr frame)

void Geometry(I3FramePtr frame)

inline void DetectorStatus(I3FramePtr frame)

Private Functions

bool IsPositionBad(const I3Position &position)

Private Members

double topBoundaryWidth_

double bottomBoundaryWidth_

double sideBoundaryWidth_

double dustLayer_

double dustLayerWidth_

std::string mcTreeName_

std::string outputBoolName_

std::string vertexPosName_

std::string vertexTimeName_

std::string vertexIncomingNeutrinoName_

std::string vertexOutgoingLeptonName_

std::string vertexOutgoingHadronName_

std::string numVerticesName_

VHESelfVetoUtils::reducedgeo_t reducedgeo_

std::string geoName_

I3GeometryConstPtr geo_

class VHESelfVeto : public I3ConditionalModule

Public Functions

VHESelfVeto(const I3Context&)

void Configure()

void Physics(I3FramePtr frame)

void Geometry(I3FramePtr frame)

inline void DetectorStatus(I3FramePtr frame)

Private Functions

bool IsPositionBad(const I3Position &position)

Private Members

double topBoundaryWidth_

double bottomBoundaryWidth_

double dustLayer_

double dustLayerWidth_

double timeWindow_

double vertexThreshold_

double vetoThreshold_

std::string pulses_

std::string outputBoolName_

std::string outputTimeName_

std::string outputPosName_

VHESelfVetoUtils::reducedgeo_t reducedgeo_

std::string geoName_

I3GeometryConstPtr geo_

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace ClipperLib

Typedefs

typedef int64_t long64

typedef uint64_t ulong64

typedef std::vector<IntPoint> Polygon

typedef std::vector<Polygon> Polygons

typedef std::vector<ExPolygon> ExPolygons

typedef std::vector<OutRec*> PolyOutList

typedef std::vector<TEdge*> EdgeList

typedef std::vector<JoinRec*> JoinList

typedef std::vector<HorzJoinRec*> HorzJoinList

Enums

enum Direction

Values:

enumerator dRightToLeft

enumerator dLeftToRight

enum ClipType

Values:

enumerator ctIntersection

enumerator ctUnion

enumerator ctDifference

enumerator ctXor

enum PolyType

Values:

enumerator ptSubject

enumerator ptClip

enum PolyFillType

Values:

enumerator pftEvenOdd

enumerator pftNonZero

enumerator pftPositive

enumerator pftNegative

enum JoinType

Values:

enumerator jtSquare

enumerator jtRound

enumerator jtMiter

enum EdgeSide

Values:

enumerator esNeither

enumerator esLeft

enumerator esRight

enumerator esBoth

enum IntersectProtects

Values:

enumerator ipNone

enumerator ipLeft

enumerator ipRight

enumerator ipBoth

Functions

inline long64 Abs(long64 val)

bool FullRangeNeeded(const Polygon &pts)

bool Orientation(const Polygon &poly)

inline bool PointsEqual(const IntPoint &pt1, const IntPoint &pt2)

bool Orientation(OutRec *outRec, bool UseFullInt64Range)

double Area(const Polygon &poly)

double Area(const OutRec &outRec, bool UseFullInt64Range)

bool PointIsVertex(const IntPoint &pt, OutPt *pp)

bool PointInPolygon(const IntPoint &pt, OutPt *pp, bool UseFullInt64Range)

bool SlopesEqual(TEdge &e1, TEdge &e2, bool UseFullInt64Range)

bool SlopesEqual(const IntPoint pt1, const IntPoint pt2, const IntPoint pt3, bool UseFullInt64Range)

bool SlopesEqual(const IntPoint pt1, const IntPoint pt2, const IntPoint pt3, const IntPoint pt4, bool UseFullInt64Range)

double GetDx(const IntPoint pt1, const IntPoint pt2)

void SetDx(TEdge &e)

void SwapSides(TEdge &edge1, TEdge &edge2)

void SwapPolyIndexes(TEdge &edge1, TEdge &edge2)

inline long64 Round(double val)

long64 TopX(TEdge &edge, const long64 currentY)

long64 TopX(const IntPoint pt1, const IntPoint pt2, const long64 currentY)

bool IntersectPoint(TEdge &edge1, TEdge &edge2, IntPoint &ip, bool UseFullInt64Range)

void ReversePolyPtLinks(OutPt &pp)

void DisposeOutPts(OutPt *&pp)

void InitEdge(TEdge *e, TEdge *eNext, TEdge *ePrev, const IntPoint &pt, PolyType polyType)

inline void SwapX(TEdge &e)

void SwapPoints(IntPoint &pt1, IntPoint &pt2)

bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a, IntPoint pt2b, IntPoint &pt1, IntPoint &pt2)

bool FirstIsBottomPt(const OutPt *btmPt1, const OutPt *btmPt2)

OutPt *GetBottomPt(OutPt *pp)

bool FindSegment(OutPt *&pp, IntPoint &pt1, IntPoint &pt2)

bool Pt3IsBetweenPt1AndPt2(const IntPoint pt1, const IntPoint pt2, const IntPoint pt3)

OutPt *InsertPolyPtBetween(OutPt *p1, OutPt *p2, const IntPoint pt)

bool PolySort(OutRec *or1, OutRec *or2)

OutRec *FindAppendLinkEnd(OutRec *outRec)

OutRec *GetLowermostRec(OutRec *outRec1, OutRec *outRec2)

bool Param1RightOfParam2(OutRec *outRec1, OutRec *outRec2)

bool IsMinima(TEdge *e)

bool IsMaxima(TEdge *e, const long64 Y)

bool IsIntermediate(TEdge *e, const long64 Y)

TEdge *GetMaximaPair(TEdge *e)

TEdge *GetNextInAEL(TEdge *e, Direction dir)

bool ProcessParam1BeforeParam2(IntersectNode &node1, IntersectNode &node2)

void SwapIntersectNodes(IntersectNode &int1, IntersectNode &int2)

bool E2InsertsBeforeE1(TEdge &e1, TEdge &e2)

void ReversePolygon(Polygon &p)

void ReversePolygons(Polygons &p)

Polygon BuildArc(const IntPoint &pt, const double a1, const double a2, const double r)

DoublePoint GetUnitNormal(const IntPoint &pt1, const IntPoint &pt2)

void OffsetPolygons(const Polygons &in_polys, Polygons &out_polys, double delta, JoinType jointype, double MiterLimit)

void SimplifyPolygon(const Polygon &in_poly, Polygons &out_polys, PolyFillType fillType)

void SimplifyPolygons(const Polygons &in_polys, Polygons &out_polys, PolyFillType fillType)

void SimplifyPolygons(Polygons &polys, PolyFillType fillType)

std::ostream &operator<<(std::ostream &s, IntPoint &p)

std::ostream &operator<<(std::ostream &s, Polygon &p)

std::ostream &operator<<(std::ostream &s, Polygons &p)

Variables

static long64 const loRange = 0x3FFFFFFF

static long64 const hiRange = 0x3FFFFFFFFFFFFFFFLL

static double const pi = 3.141592653589793238

namespace std

STL namespace.

namespace VHESelfVetoUtils

Functions

bool IsInReducedGeometry(const I3Position &pos, const reducedgeo_t &reducedgeo)

bool IsInReducedGeometryPolygon(const I3Position &pos, const reducedgeo_t &reducedgeo)

I3GeometryPtr TrimI3Geometry(const I3Geometry &geo, const reducedgeo_t &reducedgeo)

I3GeometryPtr TrimI3Geometry(const I3Geometry &geo, const std::set<int> &badStrings)

reducedgeo_t FindReducedGeometry(const I3Geometry &geo, I3DetectorStatusConstPtr status, double topBoundaryWidth, double bottomBoundaryWidth, double sideBoundaryWidth)

reducedgeo_t RemoveBoundariesFromReducedGeometry(const reducedgeo_t &input)

std::vector<I3Position> FindIntersectionsWithReducedGeometryBoundary(const VHESelfVetoUtils::reducedgeo_t &reducedgeo, const I3Position &from, const I3Position &to)

std::set<int> FindMissingStrings(const std::vector<OMKey> &badDOMs, const I3Geometry &geo, double missingDOMFractionForBadString = 0.9, bool ignoreDeepCoreStrings = true)

std::vector<I3Position> IntersectionsWithInstrumentedVolume(const I3Geometry &geo, const I3Particle &particle)

Find the intersection points of a particle’s path with the boundaries of the detector volume.

Parameters:

• geo – The relevant detector geometry

• particle – The particle whose intersection points are to be found

Returns:

A vector of all points where the (forward and backward) projected path of particle passes through the detector boundary. Note that these points may not be within the particle’s length.

std::vector<I3Position> IntersectionsWithInstrumentedVolume(const reducedgeo_t &geo, const I3Particle &particle)

Find the intersection points of a particle’s path with the boundaries of the detector volume.

Parameters:

• geo – The relevant detector geometry.

• particle – The particle whose intersection points are to be found

Returns:

A vector of all points where the (forward and backward) projected path of particle passes through the detector boundary. Note that these points may not be within the particle’s length.

Pre:

geo must have all boundary widths set to zero, which can be accomplished using RemoveBoundariesFromReducedGeometry.

file BadStringRemover.cxx

#include <icetray/I3PacketModule.h>

#include <icetray/I3Bool.h>

#include <icetray/I3Int.h>

#include <icetray/I3Units.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <dataclasses/I3MapOMKeyMask.h>

#include <dataclasses/I3Double.h>

#include <boost/foreach.hpp>

#include <algorithm>

#include <VHESelfVeto/VHESelfVetoUtils.h>

Functions

I3_MODULE(BadStringRemover)

file clipper.cxx

#include “clipper/clipper.h”

#include <cmath>

#include <vector>

#include <algorithm>

#include <stdexcept>

#include <cstring>

#include <cstdlib>

#include <ostream>

Defines

HORIZONTAL

TOLERANCE

NEAR_ZERO(val)

NEAR_EQUAL(a, b)

file clipper.h

#include <vector>

#include <stdexcept>

#include <cstring>

#include <cstdlib>

#include <ostream>

#include <stdint.h>

file DetectorShrinker.cxx

#include <icetray/I3PacketModule.h>

#include <icetray/I3Bool.h>

#include <icetray/I3Units.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <dataclasses/I3MapOMKeyMask.h>

#include <dataclasses/I3Double.h>

#include <boost/foreach.hpp>

#include <algorithm>

#include <VHESelfVeto/VHESelfVetoUtils.h>

Functions

I3_MODULE(DetectorShrinker)

file FiducialVolumeEntryPointFinder.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Bool.h>

#include <dataclasses/I3Double.h>

#include <icetray/I3Units.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3MCTree.h>

#include <dataclasses/physics/I3MCTreeUtils.h>

#include <boost/foreach.hpp>

#include <algorithm>

#include “recclasses/I3ParticleIntersections.h”

#include “VHESelfVeto/VHESelfVetoUtils.h”

Functions

I3_MODULE(FiducialVolumeEntryPointFinder)

file HomogenizedQTot.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Units.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <dataclasses/I3Double.h>

#include <boost/foreach.hpp>

Functions

I3_MODULE(HomogenizedQTot)

static double CalculateHomogenizedQtot(I3RecoPulseSeriesMapConstPtr pulses, I3CalibrationConstPtr cal, I3DoubleConstPtr vertexTime, double maxChargePerDom)

file LayerVeto.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Units.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <dataclasses/I3MapOMKeyMask.h>

#include <dataclasses/I3Constants.h>

#include <dataclasses/I3Vector.h>

#include <dataclasses/I3Double.h>

#include <boost/python/object.hpp>

#include <boost/foreach.hpp>

#include <boost/make_shared.hpp>

#include <boost/next_prior.hpp>

Functions

I3_MODULE(LayerVeto)

double TotalCharge(const I3RecoPulseSeriesMap &pmap)

I3RecoPulseSeriesMapConstPtr RemovePulses(I3FramePtr frame, const std::string &key, const I3RecoPulseSeriesMap &selection)

void AddPulses(I3FramePtr frame, const std::string &key, I3RecoPulseSeriesMap &lhs, const I3RecoPulseSeriesMap &rhs)

file TauGeneratesMuon.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Bool.h>

#include <icetray/I3Units.h>

#include <dataclasses/physics/I3MCTree.h>

#include <dataclasses/physics/I3MCTreeUtils.h>

#include <vector>

#include <boost/foreach.hpp>

#include <algorithm>

Functions

I3_MODULE(TauGeneratesMuon)

file VertexInFiducialVolume.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Bool.h>

#include <dataclasses/I3Double.h>

#include <icetray/I3Int.h>

#include <icetray/I3Units.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3MCTree.h>

#include <dataclasses/physics/I3MCTreeUtils.h>

#include <vector>

#include <boost/foreach.hpp>

#include <algorithm>

#include <VHESelfVeto/VHESelfVetoUtils.h>

Functions

I3_MODULE(VertexInFiducialVolume)

file VHESelfVeto.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Bool.h>

#include <icetray/I3Units.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <dataclasses/I3Double.h>

#include <boost/foreach.hpp>

#include <algorithm>

#include <VHESelfVeto/VHESelfVetoUtils.h>

Typedefs

typedef boost::tuple<OMKey, I3Position, I3RecoPulse> OMKeyPulsePair

typedef std::vector<OMKeyPulsePair> OMKeyPulseVector

Functions

I3_MODULE(VHESelfVeto)

static bool operator<(const OMKeyPulsePair &a, const OMKeyPulsePair &b)

file VHESelfVetoUtils.cxx

#include <boost/foreach.hpp>

#include <algorithm>

#include <cmath>

#include <VHESelfVeto/VHESelfVetoUtils.h>

#include “clipper/clipper.h”

file VHESelfVetoUtils.h

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3Particle.h>

#include <vector>

#include <map>

#include <set>

dir clipper

dir icetray

dir private

dir public

dir VHESelfVeto

dir VHESelfVeto

dir VHESelfVeto