NoiseEngine C++ API Reference

class HitPair
#include <HitPair.h>

class: HitPair Class to hold the azimuth and zenith information. Use this instead of having multiple parallel arrays. HitPair A class designed to hold pairs of hits. Holds the time, distance, direction and weight of each pair of hits along with methods to calculate each.

Version

Rcs
Date

:

Rcs
Author

Michael Larson mjlarson@crimson.ua.edu (c) 2011,2012 IceCube Collaboration

Public Functions

inline bool InTimeWindow(double startTime, double windowLength)

InTimeWindow Calculates whether this pair of hits lies within the time window specified by [startTime, startTime + windowLength]

Parameters:

  • startTime – The time of the beginning of the window

  • windowLength – The length of the time window to calculate the end time

inline bool InVelocityWindow(double start, double end)

InVelocityWindow Check whether the apparent velocity is within the velocity window defined by [start,end] m/ns

Parameters:

  • start – The lower bound on the velocity window in m/ns

  • end – The upper bound on the velocity window in m/ns

inline double GetVelocity()

GetVelocity Returns the apparent velocity

inline void SetAngles(const I3Position &dom1, const I3Position &dom2)

SetAngles Find the distance, azimuth, and zenith angles between two I3Positions. The pointing is from dom1 to dom2, so the assumption is that the earlier hit is the first argument.

Parameters:

  • dom1 – The position of the earlier hit.

  • dom2 – The position of the later hit.

inline void SetWeight(double weight1, double weight2)

SetWeight Calculate the weight for the hit pair. The NoiseEngine user may choose to either use unity or use charge weighting.

Parameters:

  • weight1 – The weight associated with the first hit.

  • weight2 – The weight associated with the second hit.

inline void SetTimes(double hit1, double hit2)

SetTimes Set the times of the first and second hit. This doesn’t provide constraints on the order of the hits, although NoiseEngine always uses the first argument as the earlier hit and the second as the later.

Parameters:

  • hit1 – The first time for this pair

  • hit2 – The second time for this pair

inline double GetFirstTime()

GetFirstTime Returns the first time given to the SetTimes function.

Returns:

The first time passed to SetTimes

inline double GetLastTime()

GetLastTime Returns the second time given to the SetTimes function.

Returns:

The second time passed to SetTimes

inline double GetAzimuth()

GetAzimuth Returns the azimuth as calculated by the SetAngles function. It points from the first passed DOM to the second in that function.

Returns:

The azimuthal angle between DOMs

inline double GetZenith()

GetZenith Returns the zenith as calculated by the SetAngles function. It points from the first passed DOM to the second in that function.

Returns:

The zenith angle between DOMs

inline double GetWeight()

GetWeight Returns the weight calculated by the SetWeight function.

Returns:

The weight

Private Members

double azimuth
double zenith
double firstTime
double lastTime
double distance
double weight
class NoiseEngine : public I3ConditionalModule
#include <NoiseEngine.h>

IceTray.

Public Functions

NoiseEngine(const I3Context &ctx)

Constructor: builds an instance of the module, with the context provided by IceTray.

class: NoiseEngine The NoiseEngine filter module is designed to identify triggers caused by random detector noise. It does this by using the TrackEngine algorithm, which maps all possible pairs of hits with apparent velocities inside of a given window and maximum time separation onto a binned Healpix unit sphere. If more than some threshold number of pairs land in a single bin, then the event passes. Thus, the filter looks for any hint of directionality. All parameters are designed to be intentionally easy for any physics events to pass, which results in a dramatic increase in data/MC agreement at very low NCh. For more information and results from IC79, see the Berkeley talk here: https://events.icecube.wisc.edu/contributionDisplay.py?sessionId=32&contribId=114&confId=43NoiseEngine Constructor

Version

Rcs
Date

:

Rcs
Author

Michael Larson mjlarson@crimson.ua.edu (c) 2011,2012 IceCube Collaboration

~NoiseEngine()

Destructor: deletes the module.

NoiseEngine Destructor

void Configure()

Configure: Grabs options from the python processing script.

NoiseEngine Configure

Parameters:

  • ChargeWeight – Apply charge-weighting for reco pulse pairs of hits? At the moment, uses the average charge of the two hits.

  • HealpixOrder – The order of the Healpix map used. 0 = 12 bins, 1 = 48 bins, 2 = 192 bins, 3 = 768 bins.

  • HitSeriesName – Name of the DOMLaunch/RecoPulse series to use.

  • NChLimit – To save on processing time, the user can set the maximum nchannel to be processed. Defaults to 20.

  • OutputName – The name of the I3Bool decision to be pushed to the frame.

  • StartVelocity – The minimum apparent velocity between hits to use. This is intentionally low (0.1 m/ns) to keep as many physics events as possible.

  • EndVelocity – The maximum apparent velocity between hits to use. This is intentionally high (1.0 m/ns) to keep as many physics events as possible.

  • TimeWindowLength – The size of the sliding time window to use The time window maximizes the number of hits

  • Threshold – The minimum number of pairs mapped to one healpix bin to pass this filter.

  • TimerName – If given, the name of an I3Double put into the frame holding the amount of processing time taken for each even. Included for testing purposes.

void Physics(I3FramePtr frame)

Physics: Process the event if the input series are in the physics frame.

Find the time window that maximizes the number of hits, then produce a map of all possible hit pairs that satisfy the time window and velocity window requirements. Map those pairs to a healpix map and check whether any of the healpix bins have more pairs than threshold. If so, then the event passes. Otherwise, the event fails.

Parameters:

frame – The frame that will be processed.

std::vector<HitPair> GetHitPairs(const I3Geometry &geometry, I3RecoPulseSeriesMapConstPtr hitmap, double startTime, std::vector<double> &velocities)

GetHitPairs: Create all of the possible hit pairs using the time, velocity constraints.

The meat of the NoiseEngine algorithm. Forms all possible hit pairs given the time window and apparent velocity constraints.

Parameters:

  • geometry – The geometry associated with the hitmap

  • hitmap – The DOMLaunch/RecoPulse map to process

  • startTime – The start of the time window

  • velocities – The apparent velocity constraints

double PickStartTime(I3RecoPulseSeriesMapConstPtr hitmap)

PickStartTime: Choose a start time that maximizes the number of hits within a time window.

Find the maximum number of hits for a given time window and return the starting time

Parameters:

hitmap – The DOMLaunch/RecoPulse map to process

std::vector<double> CheckTrigger(std::vector<HitPair> TWPairs, Healpix_Base hp_base, double threshold, bool &decision)

CheckTrigger: Check all of the healpix bins to identify any bins over threshold.

Private Functions

SET_LOGGER ("NoiseEngine")

Private Members

double optStartVelocity_
double optEndVelocity_
double optTimeWindowLength_
int optHealpixOrder_
int optNChLimit_
double optThreshold_
bool optChargeWeight_
std::string optHitSeriesName_
std::string optOutputName_
std::string optTimerName_
std::string optBinsName_
std::string optVelocityName_
namespace std

STL namespace.

file HitPair.cxx
#include <NoiseEngine/HitPair.h>
file HitPair.h
#include <cmath>
#include “dataclasses/I3Position.h”
#include “dataclasses/I3Vector.h”
#include “dataclasses/physics/I3RecoPulse.h”

Typedefs

typedef I3Vector<HitPair> HitPairVect

Functions

I3_POINTER_TYPEDEFS(HitPairVect)
file NoiseEngine.cxx
#include “NoiseEngine/NoiseEngine.h”

Functions

I3_MODULE(NoiseEngine)
file NoiseEngine.h
#include <algorithm>
#include <vector>
#include <string>
#include <sys/time.h>
#include “icetray/I3ConditionalModule.h”
#include “icetray/I3Frame.h”
#include “icetray/I3Bool.h”
#include “icetray/I3Units.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/I3Constants.h”
#include “dataclasses/I3Vector.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “healpix_cxx/healpix_base.h”
#include “NoiseEngine/HitPair.h”
dir icetray
dir NoiseEngine
dir NoiseEngine
dir NoiseEngine
dir private
dir public