TopologicalSplitter C++ API Reference

struct CausalCluster

An object which keeps track of a group of hits which are (mostly) causally connected to each other, and the number of distinct DOMs on which those hits occurred.

Public Functions

inline CausalCluster()
inline void insert(Hit h, unsigned int multiplicity)

Add a new hit to the cluster.

Parameters:

  • h – The hit to add

  • multiplicity – The threshold for a group of hits within the time window to form a subevent

inline float earliestTime() const

Finds the time of the earliest hit in this cluster.

Returns:

The earliest hit time or infinity if the cluster is empty

inline bool advanceTime(float t, I3TopologicalSplitter &tt)

Move this cluster forawrd in time to t, dropping hits which are no longer within the time window.

Parameters:

  • t – The current time to which the cluster should be moved

  • tt – The owning splitter

inline void takeComplete(CausalCluster &other)

Take all hits in other’s complete list and merge them into this cluster’s complete list.

Public Members

std::list<Hit> hits

The ordered queue of hits within this cluster which are still within the time window of the current time.

std::map<unsigned int, unsigned int> doms

Keeps track of the number of hits on each of the doms present in this cluster, keys are dom indices.

TimeOrderedHitSet complete

The hits which have formed a group surpassing the multiplicity and are now outside the time window.

unsigned int endDom

The indices of the most recent hit contributing to meeting the multiplicity condition.

unsigned int endPulse
bool multiplicityMet

Whether the multiplicity condition is met.

class I3TopologicalSplitter : public I3ConditionalModule, private I3Splitter

The main splitter module.

Public Functions

inline I3TopologicalSplitter(const I3Context &context)
inline void Configure()
inline void DAQ(I3FramePtr frame)

Protected Functions

inline virtual void OutputSubEvent(I3FramePtr frame, I3RecoPulseSeriesMapMaskPtr mask)

Overidable function for storing each subevent This exists pretty much solely for the benefit of the non-splitting backwards-compatibility subclass.

Parameters:

  • frame – The frame from which the pulses are being split

  • mask – The subset of pulses forming this subevent

Protected Attributes

std::string inputName_

Name of the pulses to split.

std::string outputName_

Name of the pulses to put in the split frames.

unsigned int multiplicity_

Required multiplicity of a subevent.

float timeWindow_

Time span within which the multiplicity requirement must be met.

float xyDist_

Maximum horizontal distance within which hits will be considered connected.

unsigned int zDomDist_

Maximum vertical distance within which hits will be considered connected, expressed as a number of DOM spacings.

float timeCone_

Maximum deviation from speed of light travel time which will allow a pair of hits to be considered connected.

bool saveSplitCount_

Whether to save an integer in the frame indicating the number of subevents generated.

Private Functions

inline bool causallyConnected(const Hit &h1, const Hit &h2)

Determine whether two hits are related.

inline void AddHit(Hit h)

The main driver for the entire algorithm. Adds a new hit to all clusters with which it is connected (including subsets of existing clusters) By ‘advancing’ the clusters this function also causes subevents to be built when possible.

inline bool AddHitToCluster(CausalCluster &s, Hit h)

Attempt to add Hit h to existing cluster s, or to the subset of s with which it is connected, if it is not connected to enough of s to meet the multiplicity condition returns true if h was added to s, or to a new subset of s, and false if h was not placed in a cluster.

inline void AddSubEvent(TimeOrderedHitSet &newSet)

Inserts a cluster of hits into the set of subevents, after merging it with any existing subevents with which it shares at least one hit This functon also moves any subevents which can no longer grow into the finished subevent collection.

inline void FinalizeSubEvents()

Pushes all hits through the clusters and completes all subevents, on the assumption that no more future hits will be added.

Private Members

std::vector<DomGeo> geometryCache_

a fast lookup table of simplified geometry information

std::map<OMKey, unsigned int> domIndices_

a mapping fomr OMKeys to the indices of DOMs in the current event’s pulse series map

std::list<CausalCluster> clusters_

all in-progress causal clusters

std::list<CausalCluster> newClusters_

temporary storage for causal clusters generated while adding a single hit

std::list<TimeOrderedHitSet> partialSubEvents_

all in-progress subevents

std::map<float, RetrievalOrderedHitSet> subEvents_

map of start times to complete subevents

Private Static Functions

static inline bool isSubset(const CausalCluster &c1, const CausalCluster &c2)

Test whether c1 is a subset of c2.

struct SubEventPredicate

A function object which facilitates creating pulse masks for given subevents.

Public Functions

inline SubEventPredicate(const std::map<OMKey, unsigned int> &di, const RetrievalOrderedHitSet &h)
inline bool operator()(const OMKey &k, size_t pulseIdx, const I3RecoPulse&)

Determine whether a particular pulse (hit) is part of the subevent.

Parameters:

  • k – The DOM on which the pulse occurred

  • pulseIdx – The index of the pulse on the DOM

Public Members

const std::map<OMKey, unsigned int> &domIndices

The lookup table for converting OMKeys to indices of DOMs in the current event.

const RetrievalOrderedHitSet &hits

The collection of hits making up the subevent.

template<class Record>
class ttrigger : public CompatibilityShim

A module with the same interface as the ttrigger module provided by the ttrigger project.

This module runs on P frames rather than Q frames, and outputs each subevent as a numbered pulse series in the original P frame.

Public Functions

inline ttrigger(const I3Context &context)
inline void Configure()
inline void DAQ(I3FramePtr frame)
inline void Physics(I3FramePtr frame)
inline virtual void OutputSubEvent(I3FramePtr frame, I3RecoPulseSeriesMapMaskPtr mask)

Private Members

unsigned int subEventNumber
std::vector<std::string> InputNames
class TTriggerSplitter : public CompatibilityShim

A module with the same interface as the TTriggerSplitter module provided by the ttrigger project.

Public Functions

inline TTriggerSplitter(const I3Context &context)
namespace [anonymous]
namespace std

STL namespace.

file TopologicalSplitter.cxx
#include <algorithm>
#include <cassert>
#include <limits>
#include <list>
#include <map>
#include <sstream>
#include “icetray/I3ConditionalModule.h”
#include “icetray/I3Units.h”
#include “icetray/I3Int.h”
#include “dataclasses/I3Constants.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”
#include “phys-services/I3Splitter.h”
#include <boost/make_shared.hpp>

(c) 2012 the IceCube Collaboration

$Id$

Version

$Revision$

Date

$Date$

Author

Chris Weaver chris.weaver@icecube.wisc.edu

Functions

I3_MODULE(I3TopologicalSplitter)
I3_MODULE(TTriggerSplitter)
I3_MODULE(ttrigger<I3RecoPulse>)
dir icetray
dir private
dir TopologicalSplitter
dir TopologicalSplitter