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 DOMCache

Public Functions

inline DOMCache(const I3OMGeo &g, const I3RecoPulseSeries &ps)

Public Members

const I3Position &pos
const I3OMGeo::OMType omtype
I3RecoPulseSeries::const_iterator cbegin
I3RecoPulseSeries::const_iterator cend
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 I3TrackVeto : public I3ConditionalModule
#include <I3TrackVeto.h>

Down-going muon track veto of the MESE selection.

This module loops over a series of track hypotheses. For each hypothesis, the number and total charge of direct hits is calculate. The hypothesis that gives the largest total charge is stored in the frame.

Public Functions

I3TrackVeto(const I3Context&)
void Configure()
void Physics(I3FramePtr)
void Geometry(I3FramePtr)

Private Types

using DOMCacheMap = std::map<OMKey, DOMCache>

Private Functions

void GetVetoCharge(Result&)
void FillDOMCache()

Private Members

std::string pulseName_
std::string outputName_
double distanceWindow_
std::pair<double, double> timeWindow_
I3SeedServiceBasePtr seedService_
I3RecoPulseSeriesMapConstPtr pulses_
I3GeometryConstPtr geometry_
DOMCacheMap domCache_
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 Result

Public Functions

inline Result(I3EventHypothesisConstPtr h)
inline bool operator<(const Result &other) const

Public Members

double charge
unsigned int nchannel
I3EventHypothesisConstPtr hypo
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 [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>

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>

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”

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 I3TrackVeto.cxx
#include <cmath>
#include <limits>
#include <list>
#include <utility>
#include <boost/make_shared.hpp>
#include <icetray/I3ConditionalModule.h>
#include <icetray/I3Context.h>
#include <icetray/I3Factory.h>
#include <icetray/I3Frame.h>
#include <icetray/I3Int.h>
#include <icetray/I3Logging.h>
#include <icetray/I3Units.h>
#include <dataclasses/I3Constants.h>
#include <dataclasses/I3Double.h>
#include <dataclasses/I3Position.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/geometry/I3OMGeo.h>
#include <dataclasses/physics/I3Particle.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <gulliver/I3EventHypothesis.h>
#include <gulliver/I3SeedServiceBase.h>

Copyright (C) 2018 Kai Krings <kkrings>

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Implementation of down-going muon track veto

Version

$Revision$

Date

$Date$

Author

Kai Krings

Functions

I3_MODULE(I3TrackVeto)
file I3TrackVeto.h
#include <map>
#include <string>
#include <utility>
#include <icetray/I3ConditionalModule.h>
#include <icetray/I3Context.h>
#include <icetray/I3Frame.h>
#include <dataclasses/I3Position.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/geometry/I3OMGeo.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <gulliver/I3EventHypothesis.h>
#include <gulliver/I3SeedServiceBase.h>

SPDX-FileCopyrightText: 2024 The IceTray Contributors SPDX-License-Identifier: BSD-2-Clause

Author

Kai Krings <kkrings>

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>

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>

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