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
-
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
Private Functions
- SET_LOGGER ("NoiseEngine")
-
NoiseEngine(const I3Context &ctx)¶
-
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”
Functions
-
I3_POINTER_TYPEDEFS(HitPairVect)¶
-
I3_POINTER_TYPEDEFS(HitPairVect)¶
- file NoiseEngine.cxx
- #include “NoiseEngine/NoiseEngine.h”
Functions
-
I3_MODULE(NoiseEngine)¶
-
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