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

#include “HiveSplitter/HitSorting.h”

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”

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”

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”

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”

$Id$

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”

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”

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”

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

HiveSplitter C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page