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.

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

uint GetCenter() const

get the central string

void AddCenter(const uint center)

add the central string

void SetCenter(const uint center)

set the central string

uint GetNRings() const

get the number of implemented Rings

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

DOMHoneyComb(const uint center, std::vector<std::set<uint>> &rings)

constructor with arbitrary number of rings

Parameters:
  • center – the center of the HoneyComb

  • rings – vector of rings and their contained strings

void AddStringToRing(const uint center, const uint ringnbr, const uint string)

Add the single string [string] to the honeycomb at central string [center] on ring [ringnbr].

Parameters:
  • center – the central string

  • ringnbr – the ring on which to add the string to

  • string – that should be added

Private Members

std::vector<std::set<unsigned int>> honey_

member: storing the index of the ring [0…n] and the contained strings;

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.

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

Public Members

uint scaleFactor_

realtive scaling factor in comparison to regular IceCube string spacings

DOMHoneyCombRegister combs_

the Register holding all information

uint max_rings_

the maximum amount of registered rings

class HiveSplitter
#include <HiveSplitter.h>

The main splitter module.

Public Functions

HiveSplitter(const HiveSplitter_ParameterSet &params = HiveSplitter_ParameterSet())

Constructor from a ParameterSet.

void Configure(const HiveSplitter_ParameterSet &params)

(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

enum Mode

PARAM: The Norm to use in causallyConnect.

Values:

enumerator Lorentz
enumerator Euclidean
enumerator Static
enumerator Advanced
typedef std::vector<double> RingLimits

parameter-format for UI parsing

typedef std::vector<std::pair<double, double>> RingLimitPairs

better accessable limit parameter format

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_
uint modeOpt_

PARAM: The Norm that is to be configured.

Private Types

enum DOMTopo

Topology helper function.

Values:

enumerator IceTop
enumerator IceCube
enumerator DeepCore
enumerator Pingu
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.

struct HiveSplitter_ParameterSet
#include <HiveSplitter.h>

A set of parameters that steer HiveSplitter.

Public Functions

HiveSplitter_ParameterSet()

Public Members

unsigned int multiplicity_
double timeWindow_
double timeConeMinus_
double timeConePlus_
bool domSpacingsOpt_
std::vector<double> SingleDenseRingLimits_
std::vector<double> DoubleDenseRingLimits_
std::vector<double> TrippleDenseRingLimits_
uint modeOpt_
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

std::string inputName_

PARAM: Name of the pulses to split.

std::string outputName_

PARAM: Name of the pulses to put in the split frames.

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_
struct retrievalOrdered
#include <HitSorting.h>

Determine whether Hits are in an order more suitable for retrieval from an I3RecoPulseSeriesMap.

Public Functions

bool operator()(const Hit &h1, const Hit &h2) const
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.

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)

Public Members

I3RecoPulseSeriesMap subevent_
double start_time_
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
struct timeOrdered
#include <HitSorting.h>

Determine whether hits are in time order.

Public Functions

bool operator()(const Hit &h1, const Hit &h2) const
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

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

namespace honey

Typedefs

typedef std::set<uint> Ring

a set of strings can define a ring (around a central string)

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

std::string DumpHive(const Hive &hive)

Dump an entire hive.

Parameters:

hive – the Hive to dump

Returns:

the dumped hive

Hive ReadHiveFromFile(const std::string &fileName)

Reads an entire Hive from a configuration file.

Parameters:

fileName – the path of the file to read from

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

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

bool IsDCDOM(const OMKey &omkey)

Is this a DOM in DeepCore?

bool IsVetoCapDOM(const OMKey &omkey)

Is this DOM in the DeepCore Veto layer?

bool IsDCFidDOM(const OMKey &omkey)

Is this Dom in the denser populated DeepCore region?

bool IsVetoCapFidDOM(const OMKey &omkey)

Is this DOM in the denser populated DeepCore Veto Region?

bool IsDC_VetoCapFidDOM(const OMKey &omkey)

Is this DOM in the undense populated regions?

bool IsIceTopDOM(const OMKey &omkey)

Is this DOM in IceTop?

bool IsDCString(const OMKey &omkey)

Is this string in the DeepCore array?

bool IsPinguString(const OMKey &omkey)

Is this string in the Pingu (DeepCore infill) array.

bool IsICString(const OMKey &omkey)

is this string a in the regular IceCube array?

file HitSorting.cxx

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

(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 “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>

(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

Defines

MAX_STRINGS
MAX_OMS
dir HiveSplitter
dir HiveSplitter
dir HiveSplitter
dir icetray
dir private
dir public