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>

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

#include “VHESelfVeto/I3TrackVeto.h”

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

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
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>

#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

VHESelfVeto C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page