HiveSplitter 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
-
CausalCluster()¶
constructor
-
void insert(HitSorting::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
-
double earliestTime() const¶
Finds the time of the earliest hit in this cluster.
- Returns:
The earliest hit time or infinity if the cluster is empty
-
bool advanceTime(const double time, HiveSplitter &splitter_inst)¶
Move this cluster forward in time to t, dropping hits which are no longer within the time window.
- Parameters:
time – The current time to which the cluster should be moved
splitter_inst – The owning splitter
-
void takeComplete(const CausalCluster &c)¶
Take all hits in other’s complete list and merge them into this cluster’s complete list.
- Parameters:
c – the cluster to be merged
Public Members
-
std::list<HitSorting::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.
-
HitSorting::TimeOrderedHitSet complete¶
The hits which have formed a group surpassing the multiplicity and are now outside the time window.
-
unsigned int endDom¶
The (DOM)index of the most recent hit contributing to meeting the multiplicity condition.
-
unsigned int endPulse¶
The (Pulse)index of the most recent hit contributing to meeting the multiplicity condition.
-
bool multiplicityMet¶
Whether the multiplicity condition is met.
-
CausalCluster()¶
-
class DOMHoneyComb¶
- #include <Hive-lib.h>
A class that stores a central string and its surrounding rings; NOTE Ring 0 is identical to center.
Public Functions
-
std::set<uint> GetRing(const uint ringnbr) const¶
get the strings of the ring [ringnbr]
- Parameters:
ringnbr – number of the ring that should be returned
- Returns:
the strings contained on [ringnbr]
-
void AddRing(const uint ringnbr, const std::set<uint> &ring)¶
Adds the strings of ring [ringnbr] to honey
- Parameters:
ringnbr – number of the ring to set
ring – strings contained on that ring
-
void SetRing(const uint ringnbr, const std::set<uint> &ring)¶
erases the previous ring [ringnbr], set the new strings of ring
- Parameters:
ringnbr – number of the ring to set
ring – strings contained on that ring
-
DOMHoneyComb()¶
Constructor with NO argument.
-
DOMHoneyComb(const uint center, const std::set<unsigned int> &ring1)¶
Constructor with 1 ring.
- Parameters:
center – the center of the HoneyComb
ring1 – strings that belong to the first ring
-
DOMHoneyComb(const uint center, const std::set<unsigned int> &ring1, const std::set<unsigned int> &ring2)¶
Constructor with 2 rings.
- Parameters:
center – the center of the HoneyComb
ring1 – strings that belong to the first ring
ring2 – strings that belong to the second ring
-
std::set<uint> GetRing(const uint ringnbr) const¶
-
struct Hit
- #include <HitSorting.h>
A compact description of a hit This type needs to be as small as possible so that copies are cheap.
Public Functions
-
Hit(const unsigned int di, const unsigned int pi, const double t, const double c = NAN)
Constructor
- Parameters:
di – The index of the DOM where the hit occurred
pi – The index of the hit on the DOM
t – The time of the hit
c – the charge of the hit
-
Hit(const OMKey omkey, const unsigned int pi, const double t, const double c = 0.)
Constructor
- Parameters:
omkey – The omkey of the DOM where the hit occurred
pi – The index of the hit on the DOM
t – The time of the hit
c – the charge of the hit
Public Members
-
OMKeyHash::SimpleIndex domIndex
The index of the DOM on which this hit occurred, within the set of hit DOMs of the current event.
-
unsigned int pulseIndex
The index of this hit on the DOM where it occurred, index 0 is first hit.
-
double time
The actual time of the hit.
-
double charge
The charge of this hit.
-
Hit(const unsigned int di, const unsigned int pi, const double t, const double c = NAN)
-
struct Hive¶
- #include <Hive-lib.h>
complex type that holds all magic information
Public Functions
-
inline Hive(const uint scaleFactor, const DOMHoneyCombRegister &combs, uint max_rings)¶
constructor
-
inline Hive(const uint scaleFactor, const DOMHoneyCombRegister &combs, uint max_rings)¶
-
class HiveSplitter¶
- #include <HiveSplitter.h>
The main splitter module.
Public Functions
-
HiveSplitter(const HiveSplitter_ParameterSet ¶ms = HiveSplitter_ParameterSet())¶
Constructor from a ParameterSet.
-
void Configure(const HiveSplitter_ParameterSet ¶ms)¶
(Re)configure the module
-
void CheckParams_n_Setup()¶
Probe the feasibility of parameter ranges and do setup work.
-
void BuildDistanceMap(I3GeometryConstPtr geo)¶
Build the DistanceMap from the parameters keep things simple and call this function from Geometry-frame.
- Parameters:
geo – pointer to the I3Geometry from Geometry frame
-
std::vector<SubEventStartStop> HiveSplitting(const I3RecoPulseSeriesMap &pulses)¶
ACTION Perform the Splitting:
Get the Pulse-Series from the Frame and read all Hits into a time ordered Hit-Series.
Than Call the Main-Alorithm and iterate over all thee Hits and try to form clusters of Hits and add Hits to them, discard them or form a new cluster.
When Hit-Series is exhausted and Clusters/Subevents have been found write them to the datastream (either as seperate frames or into the same frame).
Save the Splitcount also if that is wanted,
Push everyting back into te pipeline.
Clean-up the memory.- Parameters:
pulses – the pulses to process on
- Returns:
a series of subEventStartStops
Protected Types
Protected Attributes
-
unsigned int multiplicity_¶
PARAM: Required multiplicity of a subevent.
-
double timeWindow_¶
PARAM: Time span within which the multiplicity requirement must be met.
-
double timeConeMinus_¶
PARAM: Maximum negative deviation from speed of light travel time which will allow a pair of hits to be considered connected.
-
double timeConePlus_¶
PARAM: Maximum positive deviation from speed of light travel time which will allow a pair of hits to be considered connected.
-
bool domSpacingsOpt_¶
PARAM: are RingLimits parsed as Meter [True] distances or DOM spacings [False].
-
RingLimits SingleDenseRingLimits_¶
PARAM: parameters for UI parsing.
-
RingLimits DoubleDenseRingLimits_¶
-
RingLimits TrippleDenseRingLimits_¶
-
RingLimitPairs SingleDenseRingLimitPairs_¶
better accessable limit format
-
RingLimitPairs DoubleDenseRingLimitPairs_¶
-
RingLimitPairs TrippleDenseRingLimitPairs_¶
Private Types
-
enum DOMTopo¶
Topology helper function.
Values:
-
enumerator IceTop¶
-
enumerator IceCube¶
-
enumerator DeepCore¶
-
enumerator Pingu¶
-
enumerator IceTop¶
-
typedef std::set<HitSorting::TimeOrderedHitSet, subEventTimeOrder> TimeOrderedSubEvents¶
container for Subevents
Private Functions
-
bool causallyConnected(const HitSorting::Hit &h1, const HitSorting::Hit &h2)¶
Determine whether two hits are related Two hits are compared, where h1 should be the earlier hit, ortherwise they are switched (self-correcting). First is checked if h1 has h2 in the inclusion volume, Than the causal connection determined by the Norm is imposed.
- Parameters:
h1 – the earlier hit, to be compared
h2 – the later hit, to be compared
- Returns:
true, if Hit1 is causally connected to Hit2; false, if not
-
void AddHit(const HitSorting::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.
- Parameters:
h – the hit to add
-
bool AddHitToCluster(CausalCluster &c, const HitSorting::Hit h)¶
Attempt to add Hit h to existing cluster c, or to the subset of c with which it is connected by enough hits in c to meet the multiplicity condition.
- Parameters:
c – the cluster to add to
h – the hit to add
- Returns:
true, if h was added to c, or to a new subset of c, false, if h was not placed in any cluster
-
void AddSubEvent(HitSorting::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.
- Parameters:
newSet – the set to add
-
void FinalizeSubEvents()¶
Pushes all hits through the clusters and completes all subevents, on the assumption that no more future hits will be added.
-
inline double GetDistance(const OMKey &omkey_a, const OMKey &omkey_b)¶
Distance between these two DOMs read from Look-Up table.
- Parameters:
omkey_a – index of the first DOM, corresponding to rows: matrix_x
omkey_b – index of the second DOM, corresponding to columns: matrix_y
- Returns:
NAN, if there is not connection between these DOMs; (positive double), the distance
-
inline double GetDistance(const OMKeyHash::SimpleIndex simpleindex_a, const OMKeyHash::SimpleIndex simpleindex_b)¶
Distance between these two DOMs read from Look-Up table.
- Parameters:
simpleindex_a – index of the first DOM, corresponding to rows: matrix_x
simpleindex_b – index of the first DOM, corresponding to columns: matrix_y
- Returns:
NAN, if there is not connection between these DOMs (positive double), the distance
Private Members
-
double DistanceMap_[(MAX_STRINGS * MAX_OMS)][(MAX_STRINGS * MAX_OMS)]¶
look-up table for dom-distances: if value==NAN, these DOMS should not be reconnected
-
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<HitSorting::TimeOrderedHitSet> partialSubEvents_¶
all in-progress subevents
-
TimeOrderedSubEvents subEvents_¶
set of completed subevents which are in time-order (in every aspect)
Private Static Functions
-
static bool isSubset(const CausalCluster &c1, const CausalCluster &c2)¶
Test whether c1 is a subset of c2.
-
HiveSplitter(const HiveSplitter_ParameterSet ¶ms = HiveSplitter_ParameterSet())¶
-
struct HiveSplitter_ParameterSet¶
- #include <HiveSplitter.h>
A set of parameters that steer HiveSplitter.
Public Functions
-
HiveSplitter_ParameterSet()¶
-
HiveSplitter_ParameterSet()¶
-
class I3HiveSplitter : public I3ConditionalModule, private I3Splitter¶
- #include <I3HiveSplitter.h>
The main splitter module.
Public Functions
-
I3HiveSplitter(const I3Context &context)¶
Constructor: configure Default values, register Parameters, register Outbox.
-
void Configure()¶
Configure Methode to interact with icetray.
-
void DAQ(I3FramePtr frame)¶
DAQ call Methode to interact with icetray.
-
void Geometry(I3FramePtr frame)¶
Geometry call methode to interact with Geometry frame.
Protected Attributes
-
bool saveSplitCount_¶
PARAM: Whether to save an integer in the frame indicating the number of subevents generated.
-
uint noSplitOpt_¶
PARAM: Mode to not split but rather unite all output clusters into one single output Map.
-
bool modifyObjectsOpt_¶
PARAM: modify the EventHeader of the new subframes with the Start and EndTime of the Subpulses.
-
HiveSplitter_ParameterSet param_set_¶
Params which are delivered to HiveSplitter.
-
bool splitter_configured_¶
flag to prohibit missuse: splitter needs to be configured before running any Q-frames
Private Members
-
HiveSplitter hiveSplitter_¶
-
I3HiveSplitter(const I3Context &context)¶
-
struct retrievalOrdered
- #include <HitSorting.h>
Determine whether Hits are in an order more suitable for retrieval from an I3RecoPulseSeriesMap.
-
struct SubEventPredicate¶
- #include <HitSorting.h>
A function object which facilitates creating pulse masks for given subevents makes you able to use I3RecoPulseSeriesMapMask(*frame, inputName_, SubEventPredicate(RetrievalOrderedHitSet));.
Public Functions
-
SubEventPredicate(const HitSorting::RetrievalOrderedHitSet &hitSet)¶
constructor
-
bool operator()(const OMKey &k, const 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 HitSorting::RetrievalOrderedHitSet &hits¶
The collection of hits making up the subevent.
-
SubEventPredicate(const HitSorting::RetrievalOrderedHitSet &hitSet)¶
-
struct SubEventStartStop¶
- #include <HiveSplitter.h>
A container to deliver subevents.
Public Functions
-
inline SubEventStartStop(const I3RecoPulseSeriesMap &subevent, const double start_time, const double stop_time)¶
-
inline SubEventStartStop(const I3RecoPulseSeriesMap &subevent, const double start_time, const double stop_time)¶
-
struct subEventTimeOrder¶
helper to establish timeorder in the set of SubEvents
Public Functions
-
inline bool operator()(const HitSorting::TimeOrderedHitSet &lhs, const HitSorting::TimeOrderedHitSet &rhs) const¶
-
inline bool operator()(const HitSorting::TimeOrderedHitSet &lhs, const HitSorting::TimeOrderedHitSet &rhs) const¶
-
struct timeOrdered
- #include <HitSorting.h>
Determine whether hits are in time order.
-
namespace HitSorting
Typedefs
-
typedef std::set<Hit, Hit::timeOrdered> TimeOrderedHitSet
A set of hits ordered by their times.
-
typedef std::set<Hit, Hit::retrievalOrdered> RetrievalOrderedHitSet
A set of hits ordered for fast lookup in the original I3RecoPulseSeriesMap.
Enums
-
enum Extract_Mode
Helper to steer function ExtractHits.
Values:
-
enumerator Extract_AllHits
-
enumerator Extract_FirstHitOnly
-
enumerator Extract_TotalChargeToFirstHit
-
enumerator Extract_AllHits
Functions
-
RetrievalOrderedHitSet TimeOrderedToRetrievalOrdered(const TimeOrderedHitSet &hitSet)
A function that does convert a TimeOrderedHitSet to a RetrievalOrderedHitSet.
- Parameters:
hitSet – a time ordered hit set
-
TimeOrderedHitSet RetrievalOrderedToTimeOrdered(const RetrievalOrderedHitSet &hitSet)
A function that does convert a RetrievalOrderedHitSet to a TimeOrderedHitSet.
- Parameters:
hitSet – aretrieval ordered hit set
-
bool operator==(const Hit &h1, const Hit &h2)
Comparision Operator for Hits just compare the (unique) index in the time ordered Hit-series.
-
bool operator!=(const Hit &h1, const Hit &h2)
Anti-Comparision Operator for Hits just compare the (unique) index in the time ordered Hit-series.
-
bool operator<(const Hit &h1, const Hit &h2)
for sorting Hits we’re mostly interested in their time, and only use their indices as tie-breakers
-
template<class InputIterator1, class InputIterator2>
bool setsIntersect(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)¶ Test whether any item in the sorted range [first1,last1) is also in the sorted range [first2,last2)
-
template<class ordered_set>
bool SetsIdentical(const ordered_set &lhs, const ordered_set &rhs) a helper class that can compares to sets and evaluates the identity by evaluating the identity of every element Use this operator if both sets are extracted from the same pulsemap
- Returns:
true, if sets are identical in every element; false if not
-
template<class ordered_set>
inline ordered_set UniteSets(const ordered_set &lhs, const ordered_set &rhs) Return the union of lhs and rhs.
- Returns:
the union of the sets
-
HitSorting::RetrievalOrderedHitSet ExtractHits(const I3RecoPulseSeriesMap &pulses, const Extract_Mode mode = Extract_AllHits)¶
Function to buffer up Pulses from an RecoPulseSeriesMap into an ordered vector of compact Hits.
- Parameters:
pulses – the Pulses to buffer up
mode – extraction_mode: Extract_AllHits = All Hits are extracted, Extract_FirstHitOnly = Only the first hit on each DOM is extracted, Extract_TotalChargeToFirstHit = Only the first hit is extracted and the total charge in this DOM assigned to it.
- Returns:
the retrievel ordered HitSeries
-
I3RecoPulseSeriesMap RevertHits(const HitSorting::RetrievalOrderedHitSet &hits, const I3RecoPulseSeriesMap &pulses, const bool useAllHits = false)¶
Convert a series of Hits back to an native I3RecoPulseSeriesMap.
- Parameters:
hits – the retrievel ordered Hits to revert
pulses – the Pulses the Hits were created from; DANGER if not so, this will fail with a segfault
useAllHits – use all Hits on each original OM; usefull if only first hits were extracted DANGER currently disabled
- Returns:
the retrievel ordered HitSeries
-
I3RecoPulseSeriesMap ConvertHits2RecoPulseSeriesMap(const HitSorting::RetrievalOrderedHitSet &hits)¶
Convert a series of Hits back to an regular I3RecoPulseSeriesMap by recreating the Pulses; DANGER this function does only convert the format not information.
- Parameters:
hits – the retrievel ordered Hits to revert
- Returns:
the retrievel ordered HitSeries
-
typedef std::set<Hit, Hit::timeOrdered> TimeOrderedHitSet
-
namespace honey¶
Typedefs
-
typedef std::map<uint, DOMHoneyComb> DOMHoneyCombRegister¶
Look-up table for the HoneyCombs, indexed by stringnumber.
Functions
-
void MutualAddStringToRing(DOMHoneyCombRegister &combs, const uint center_A, const uint center_B, const uint ringnbr)¶
Register this string [center_A] as on ring[ringnbr] on string [center_B] and vise vers.
- Parameters:
combs – the combs these strings should be registered to
center_A – the string to register
center_B – the other string to register
ringnbr – the ring that strings should be registered to; should not be further than number of already registered rings plus 1
-
bool IsRingX(const DOMHoneyCombRegister &combs, const uint center, const uint ringnbr, const uint string)¶
is this [string] on ring[ringnbr] of [center]
- Parameters:
combs – the combs to look up this ring
center – center string around to look
ringnbr – ring number around center the string should be located on
string – the string to be found
- Returns:
true, if string could be correctly located; false, if not;
-
inline bool IsRing1(DOMHoneyCombRegister &combs, const uint center, const uint string)¶
shorthand
-
inline bool IsRing2(DOMHoneyCombRegister &combs, const uint center, const uint string)¶
shorthand
-
int WhichRing(const DOMHoneyCombRegister &combs, const uint center, const uint string, const uint search_depth = 1000)¶
Which ring is this on?
- Parameters:
combs – the Combs to look this strings up on
center – the center from which the ring should be found
string – the string to locate on any ring
search_depth – the maximum ring that this string is searched for (does limit the amount of computation)
- Returns:
0, if it is the center; n, if it is on ring n; -1, if string is not registered;
-
DOMHoneyCombRegister Abstract(const DOMHoneyCombRegister combs)¶
Build the HoneyCombs for IC86 all strings treated as Pingu.
- Parameters:
combs – the filled Combs to abstract
- Returns:
the HoneyRegister for IC86Abstract a combs to next smaller RingSize definitions The assignment is done by prescribed rings : combs[ring0]->abstracted[ring0], combs[ring1]->abstracted[ring2], combs[ring2]->abstracted[ring4], …
- Returns:
the abstracted Hive
-
int ExpandToNextRing(DOMHoneyCombRegister &combs)¶
Expands a combs with the next ring The combs must have at least 1 ring assigned and equal ring size on all strings, it must also be a mutually complete (every string links against each other)
- Parameters:
combs – the filled Hive to expand
- Returns:
n number of newly added ring -1 if not possible
-
int ExpandRings(DOMHoneyCombRegister &combs, const uint scale_factor = 1)¶
Expands combs and adds new rings to it The combs must have at least 1 ring assigned and equal ring size on all strings, it must also be a mutually complete (every string links against each other)
- Parameters:
combs – the filled combs to expand
scale_factor – expand by using that many rings (this should be a scale to the next complete reverse abstraction)
- Returns:
n number of newly added ring -1 if not possible
-
DOMHoneyCombRegister UniteHive(const DOMHoneyCombRegister &combs1, const DOMHoneyCombRegister &combs2)¶
Unite two combs into one.
- Parameters:
combs1 – the first combs to unite
combs2 – the second combs to unite
- Returns:
the new united Hives
-
std::string DumpCenter(const DOMHoneyCombRegister &combs, const uint center)¶
Dump an entire entry of an combs.
- Parameters:
combs – the Hive to dump the entry from
center – the entry to dump
- Returns:
the dumped central string
-
typedef std::map<uint, DOMHoneyComb> DOMHoneyCombRegister¶
-
namespace OMKeyHash
Typedefs
-
typedef unsigned int SimpleIndex
a hash type for OMKeys: indexing range [0, MAX_STRINGS*MAX_OMS-1]
-
typedef unsigned int StringNbr
String numbers are unsigned integerts in the range [1, MAX_STRINGS].
-
typedef unsigned int OmNbr
OM numbers are unsigned integerts in the range [1, MAX_OMS].
Functions
-
inline StringNbr SimpleIndex2StringNbr(const SimpleIndex simpleIndex)
a simple transverse translator from a linear List index with offset 64 per string to StringNumber
- Parameters:
simpleIndex – the plain index
- Returns:
the string number
-
inline OmNbr SimpleIndex2OmNbr(const SimpleIndex simpleIndex)
a simple transverse translator from a linear List index with offset 64 per string to OMNumber
- Parameters:
simpleIndex – the plain index
- Returns:
the om number
-
inline SimpleIndex String_OM_Nbr2SimpleIndex(const StringNbr string, const OmNbr om)¶
a simple transverse translator from (string,OM) pair to a linear List index with offset 64 per string
- Parameters:
string – the string
om – the om
- Returns:
the plain index
-
inline SimpleIndex OMKey2SimpleIndex(const OMKey omkey)¶
a simple transverse translator from OMKeys to a linear List index with offset 64 per string
- Parameters:
omkey – the omkey
- Returns:
the plain index
-
inline OMKey SimpleIndex2OMKey(const SimpleIndex simpleIndex)
a simple transverse translator from a linear List index with offset 64 per string to OMKeys
- Parameters:
simpleIndex – the plain index
- Returns:
the omkey
-
typedef unsigned int SimpleIndex
-
namespace std
STL namespace.
-
namespace Topology¶
Namespace that provides information of Strings and DOMs to which Detector Topology they belong Definitions can be personal prference and are subject to change, once the IC86 detector should be further expanded.
Functions
- file HitSorting.cxx
- #include “HiveSplitter/HitSorting.h”
(c) 2012 the IceCube Collaboration
- Rcs
HitSorting.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
- file HitSorting.h
- #include “HiveSplitter/OMKeyHash.h”#include “dataclasses/physics/I3RecoPulse.h”#include “dataclasses/I3MapOMKeyMask.h”
(c) 2012 the IceCube Collaboration
- Rcs
HitSorting.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
- file Hive-lib.cxx
- #include <stdlib.h>#include <vector>#include <map>#include <algorithm>#include <cassert>#include <boost/assign/list_of.hpp>#include <iostream>#include <cstdio>#include <fstream>#include <boost/lexical_cast.hpp>#include “HiveSplitter/Hive-lib.h”
(c) 2012 the IceCube Collaboration
- Rcs
Hive-lib.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
- file Hive-lib.h
- #include <stdlib.h>#include <vector>#include <set>#include <map>#include “icetray/OMKey.h”
(c) 2012 the IceCube Collaboration
- Rcs
Hive-lib.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
Typedefs
-
typedef unsigned int uint
- file HiveSplitter.cxx
- #include <HiveSplitter/HiveSplitter.h>#include <HiveSplitter/Hive-lib.h>#include <math.h>#include “boost/foreach.hpp”
(c) 2012 the IceCube Collaboration
$Id$
(c) 2012 the IceCube Collaboration
- Version
$Revision$
- Date
$Date$
- Author
Marcel Zoll marcel.zoll@fysik.su.se
- Rcs
HiveSplitter.cxx 110768 2013-09-16 17:27:13Z mzoll
- Version
- Rcs
110768
- Date
- Rcs
2013-09-16 19:27:13 +0200 (Mon, 16 Sep 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
- file HiveSplitter.h
- #include <cassert>#include <limits>#include <list>#include <map>#include <sstream>#include “icetray/I3Units.h”#include “icetray/I3Int.h”#include “dataclasses/I3Constants.h”#include “dataclasses/geometry/I3Geometry.h”#include “dataclasses/physics/I3RecoPulse.h”#include <boost/make_shared.hpp>#include “HiveSplitter/OMKeyHash.h”#include “HiveSplitter/HitSorting.h”
(c) 2012 the IceCube Collaboration
The central algorithm to split I3RecoPulseSeriesMaps by arguments of clustering
- Rcs
HiveSplitter.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
Defines
-
MAX_RINGS¶
- file I3HiveSplitter.cxx
- #include <HiveSplitter/I3HiveSplitter.h>#include “icetray/I3Units.h”#include “icetray/I3Int.h”#include “dataclasses/I3Double.h”#include “dataclasses/I3Constants.h”#include “dataclasses/I3MapOMKeyMask.h”#include “dataclasses/physics/I3EventHeader.h”#include “dataclasses/I3TimeWindow.h”
- file I3HiveSplitter.h
- #include “icetray/I3ConditionalModule.h”#include “phys-services/I3Splitter.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 <boost/make_shared.hpp>#include “HiveSplitter/HiveSplitter.h”
(c) 2012 the IceCube Collaboration
The IceTray I3Module wrapper arround the central algorithm HiveSplitter
- Rcs
HiveSplitter.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
Functions
-
I3_MODULE(I3HiveSplitter)¶
- file OMKeyHash.h
- #include “icetray/OMKey.h”
(c) 2012 the IceCube Collaboration
Make a Hashing of OMkeys that is well ordered, complete, hierarchical and minimal injective into teh natural numbers (N) aka. unsigned integers This makes it implicitly usable as an unique Hash and as a Index-range in regular array-apllications
- Rcs
PartialCOG.h 99900 2013-02-26 10:10:43Z mzoll
- Version
- Rcs
99900
- Date
- Rcs
2013-02-26 11:10:43 +0100 (Tue, 26 Feb 2013)
- Author
Marcel Zoll marcel.zoll@fysik.su.se
- dir HiveSplitter
- dir HiveSplitter
- dir HiveSplitter
- dir icetray
- dir private
- dir public