CoincSuite C++ API Reference

class AfterpulseDiscard : public FrameCombiner

A I3Module which Identifies subevents which are comprised of Afterpulses from a previous (sub)events (‘Host-event’). Decision is taken by the following arguments: -Afterpulses should have much less total charge than the original pulses. -Afterpulses must occur after the original pulses. -Afterpulses should occur on the same DOMs as the original pulses (although there are likely to be some noise pulses present as well).

Public Functions

AfterpulseDiscard(const I3Context &context)

constructor

void Configure()

std Configure function

void Finish()

Finish to tell me stuff.

void FramePacket(std::vector<I3FramePtr> &packet)

where stuff should happen

Protected Attributes

std::string recoMapName_

PARAM: Name of the RecoPulseSeriesMap.

double qtotFraction_

PARAM: Maximum fraction of qTot compared to the host-event.

double timeOffset_

PARAM: Required TimeOffset.

double maxTimeOffset_

PARAM: Maximum time difference to the host-event.

double overlapFraction_

PARAM: Required OverlapFraction in hit DOMs to the proposed host-event.

bool discard_

PARAM: Immediately discard identified AfterpulseEvents as such.

Private Functions

SET_LOGGER ("AfterpulseDiscard")

Private Members

uint n_afterpulses_

Count the number of Afterpulses tagged.

class AfterpulseTester : public TesterModule

A I3Module which Identifies subevents which are comprised of Afterpulses from a previous (sub)events (‘Host-event’). Decision is taken by the following arguments: -Afterpulses should have much less total charge than the original pulses. -Afterpulses must occur after the original pulses. -Afterpulses should occur on the same DOMs as the original pulses (although there are likely to be some noise pulses present as well).

Public Functions

AfterpulseTester(const I3Context &context)

constructor

void Configure()

Configure function.

Private Functions

SET_LOGGER ("AfterpulseTester")
Result Test(I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB) const

Implement the evaluation for mutual-testing.

SubEvent CreateSummary(I3RecoPulseSeriesMapConstPtr pulses) const

create an event summary from such pulses

Parameters:

pulses – convert these pulses

Returns:

the created subevent-summary

Private Members

std::string recoMapName_

PARAM: Name of the RecoPulseSeriesMap(Mask)

double qtotFraction_

PARAM: Maximum fraction of qTot compared to the host-event.

double timeOffset_

PARAM: Required time offset.

double overlapFraction_

PARAM: Required overlap fraction in hit DOMs to the proposed host-event.

Private Static Functions

static inline Result runTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

class AlignmentTester : public TesterModule

A I3Module if a track does align to a hypothetical track in angle and distance

Public Functions

AlignmentTester(const I3Context &context)

Constructor.

void Configure()

std Configure function

Private Functions

SET_LOGGER ("AlignmentTester")
Result HypoTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for hypo-testing.

Result MutualTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for mutual-testing.

bool AlignmentCriterium(const I3Particle &fit_A, const I3Particle &fit_B) const

Test if fitA and fitB do align in angle and distance

Parameters:
  • fit_A – the first (I3Particle)Fit to compare

  • fit_B – the second (I3Particle)Fit to compare

Returns:

true, if so

Private Members

std::string recoFitName_

PARAM: Name of the reconstructed (I3Particle) Fit.

std::string hypoFitName_

PARAM: Name of the hypthetical (I3Particle) Fit.

double criticalAngle_

PARAM: maximal angle deviations.

double criticalDistance_

PARAM: maximal distance.

bool mutualOpt_

PARAM: Test Mutually instead of Hypothetically.

Private Static Functions

static inline Result runHypoTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

static inline Result runMutualTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

class CausalConnectTester : public TesterModule

A I3Module testing if two series of Pulses are connected topologically and in timing of two fractions of Pulses, test if they: are happening after each other from the COG of the respective last three and respective first three Pulses evaluate horizontal distance, vertical distance, maximum time difference and the CT-time-residual.

Public Functions

CausalConnectTester(const I3Context &context)

constructor

void Configure()

std Configure function

void Geometry(I3FramePtr frame)

Geometry: cash it.

Private Functions

SET_LOGGER ("CausalConnectTester")
Result Test(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the Evaluation for Testing.

bool CausalConnected(const I3RecoPulseSeriesMap &pulsesA, const I3RecoPulseSeriesMap &pulsesB) const

Tests if we can causally connect the last 3 hits except one of PulsesA to the first 3 hits except one of PulsesB (if X is before Y)

Parameters:
  • pulsesA – Map of RecoPulseSeriesMap A

  • pulsesB – Map of RecoPulseSeriesMap B

Returns:

true if so

Private Members

std::string recoMapName_

PARAM: Name of the I3RecoPulseSeriesMap that should be checked.

double timeConeMinus_

PARAM: negative time deviation from the speed of light [ns] before subseries of pulses cannot be seen as connected any more.

double timeConePlus_

PARAM: positive time deviation from the speed of light [ns] before subseries of pulses cannot be seen as connected any more.

double wallTime_

PARAM: maximal time before subseries of pulses can not be seen as connected any more.

double maxVertDist_

PARAM: maximal vertical distance before subseries of pulses can not be seen as connected any more.

double maxHorDist_

PARAM: maximal horizontal distance before subseries of pulses can not be seen as connected any more.

std::vector<I3Position> domPos_cache_

holds the geometry

Private Static Functions

static inline Result runTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

class ClustersRegister

A most ingenious structure, whose index of recluster_ directly corresponds to the SplitFrame.SubEventID and whose value is the cluster the frames belong to. Entries equal zero(==0) are not assorted to any clusters. e.g.: recluster_(0,0,1,2,0,1,2) does mean that subevents 3 and 6 are forming one cluster, so do subevents 4 and 7

Public Functions

ClustersRegister(const uint a)

constructor

void AddFrameCluster(const uint subEID_A, const uint subEID_B)

add a new cluster of these 2 frames: add them to a previous cluster if A or B already belong to one, otherwise open a new cluster, raise the n_max_cluster_ index

uint ComputeReducedCount()

considering the formed clusters, how many frames would be removed

Public Members

std::vector<uint> recluster_

index is SplitFrame.SubEventID; value is cluster_index (starting at ‘1’, ‘0’ is no cluster)

uint n_max_cluster_

current max cluster index

class cogCausalConnectTester : public TesterModule

A I3Module testing if two series of Pulses are connected topologically and in timing of two fractions of Pulses, test if they: are happening after each other from the COG of the respective last three and respective first three Pulses evaluate horizontal distance, vertical distance, maximum time difference and the ct time-residual.

Public Functions

cogCausalConnectTester(const I3Context &context)

constructor

void Configure()

std Configure function

void Geometry(I3FramePtr frame)

Geometry call method to interact with Geometry frame.

Private Functions

SET_LOGGER ("cogCausalConnectTester")
Result Test(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the Evaluatuon for MutualTesting.

bool CausalConnected(const I3RecoPulseSeriesMap &pulsesA, const I3RecoPulseSeriesMap &pulsesB, const I3Particle &hypoFit) const

Tests if we can causally connect the last 3 hits except one of PulsesA to the first 3 hits except one of PulsesB (if X is before Y)

Parameters:
  • pulsesA – Map of RecoPulseSeriesMap A

  • pulsesB – Map of RecoPulseSeriesMap B

  • hypoFit – Fit from the HypoFrame

Returns:

true, if so

Private Members

std::string recoMapName_

Param: Name of the I3RecoPulseSeriesMap that should be check.

std::string hypoFitName_

Param: Name of the fit that should be tested.

std::pair<double, double> timeResTravel_

PARAM: Allowed time residual window for travel between the Emission-Points.

double wallTime_

Param: maximal time before subseries of pulses can not be seen as connected any more.

double maxVertDist_

Param: maximal vertical distance before subseries of pulses can not be seen as connected any more.

double maxHorDist_

Param: maximal horizontal distance before subseries of pulses can not be seen as connected any more.

double maxTrackDist_

Param: maximal distance between track and cog.

double maxFurthestDist_

Param: maximal distance between outmost(furthest) hit and track (perpendicular)

PartialCOG::DomPos_cache domPos_cache_

the DOMposition cache; buffering up the position of each DOM in a direct access

Private Static Functions

static inline Result runTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

class CylinderPulsesTester : public TesterModule

A I3Module testing a hypothesis that a fraction of the pulses are contained around any hypothetical track Input are: A track <I3Particle> and a PulseSeries <I3RecoPulseSeriesMap(Mask)> Requirements: The Fit Status needs to be Okay, This Module has a ‘Hypo’ and a ‘Mutual’ mode of operation

Public Functions

CylinderPulsesTester(const I3Context &context)

Constructor.

void Configure()

Configure function.

Private Functions

SET_LOGGER ("CylinderPulsesTester")
Result HypoTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for hypo-testing.

Result MutualTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for mutual-testing.

bool CylinderPulsesCritera(const I3Particle &recoFitA, const I3RecoPulseSeriesMap &pulsesB) const

Tests if the Pulses are found in a cylinder around the recoFit

Parameters:
  • recoFitA – test around this track

  • pulsesB – test this pulses

Returns:

true, if so

Private Members

std::string recoMapName_

Param: Name of the RecoPulseSeriesMap.

std::string hypoFitName_

Param: Name of the Fit I should test for.

std::string recoFitName_

Param: Name of the (I3Particle) Fit.

double cylinderRadius_

Param: Radius around the HypoFit within the Pulses should be found.

double criticalRatio_

Param: Ratio above which we accept hypophesis.

bool mutualOpt_

PARAM: Test Mutually instead of Hyothetically.

Private Static Functions

static inline Result runHypoTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

static inline Result runMutualTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

class DecisionMaker : public FrameCombiner

A class to unify all decisions of the tester modules and make a final decision, if these events should be recombined or not.

Public Functions

DecisionMaker(const I3Context &context)

Constructor.

void Configure()

Configure function.

void Finish()

Finish and report.

void FramePacket(std::vector<I3FramePtr> &packet)

ACTION: work through the HypoFrames and their RecombinationSuccess tables to derive a final decision, if we should recombine.

Private Functions

SET_LOGGER ("DecisionMaker")
void RecombinationMarking(I3FramePtr hypoframe, I3FramePtr frameA, I3FramePtr frameB)

put all necessary keys in the split- and hypoframe

void RecombineFrames()

recombine frames and put them into the FrameRegister

Private Members

std::vector<std::string> likeNameList_

PARAM: List of all decision that liked to be recombined if any of them is true.

std::vector<std::string> vetoNameList_

PARAM: List of all decision that veto to be recombined if any of them is false.

std::vector<std::string> trueNameList_

PARAM: List of all decision that are not affected by veto list.

std::string trigHierName_

PARAM: Name of the trigger hierarchy to recombine.

std::string recoMapName_

PARAM: Name of the RecoPulseSeriesMap to recombine.

std::vector<std::string> recoMapList_

PARAM: A List of RecoPulseSeriesMap which also should be recombined alongside.

bool discard_

PARAM: discard recombined frames directly.

bool unite_th

PARAM: hidden parameter: unite triggerHierarchies; //FIXME needs to be implemented properly.

bool warnOnEmpty_

PARAM: Issue warning on empty recclusters?

uint64_t n_YES_

count how many hypoframes have been recombined

uint64_t n_NO_
uint64_t n_RECOMBINED_
ClustersRegister clusterRegister_

maybe stuff is clustering, this object handles this

class EmptyFrameDiscard : public FrameCombiner

A I3Module which Identifies empty frames where the pulse-series only contains only few hit DOMs

Public Functions

EmptyFrameDiscard(const I3Context &context)

constructor

void Configure()

std Configure function

void Finish()

Finish to tell me stuff.

void FramePacket(std::vector<I3FramePtr> &packet)

where stuff should happen

Private Functions

SET_LOGGER ("EmptyFrameDiscard")

Private Members

std::string recoMapName_

Param: Name of the RecoPulseSeriesMap.

int minDOMshit_

Param: min hit doms.

uint n_fewpulses

Count the number of afterpulses tagged.

class FakeHypoFrameReverter : public I3ConditionalModule

A Module that wipes away CoincSuite-keys of FAKE HypoFrames and reverts them to clean (plain) P-frames.

Public Functions

FakeHypoFrameReverter(const I3Context &context)

constructor

void Configure()

configure

void Physics(I3FramePtr frame)

Action: if 2 splits are found and there is only 1 such hypothesis frame, place the keys.

Private Functions

SET_LOGGER ("FakeHypoFrameReverter")

Private Members

std::string hypoName_
class FrameCombiner : public I3PacketModule
#include <FrameCombiner.h>

A class that provides basic low-level functions for event recombinations Derive from this class all modules of CoincSuite as the this class will guide interactions to the underlying frames of a whole Frame Packet. This class will explicitly help to figure out which frames are to be treated as SplitFrames, HypoFrames, Q-frames.

Subclassed by AfterpulseDiscard, DecisionMaker, EmptyFrameDiscard, FrameSentinel, HypoFrameCreator, HypoFrameFaker, NoiseClusterDiscard, TesterModule

Public Functions

FrameCombiner(const I3Context &context)

std constructor

void Configure()

std Configure function

void Finish()

std Finish function

void FramePacket(std::vector<I3FramePtr> &packet)

ACTION do nothing: build and push frame register, INPUT == OUTPUT.

Parameters:

packet – the FramePacket

void BuildFrameRegister(std::vector<I3FramePtr> &packet)

Build the FrameRegister with the packet Fills the object FrameRegister_. takes silent parameters splitname_ and hypoName_.

Parameters:

packet – the FramePacket to build from

Protected Functions

void PushPacket(std::vector<I3FramePtr> &packet)

Push all frames in the packet back into the Outbox.

Parameters:

packet – the FramePacket to push

void PushFrameRegister()

Push all frames in the FrameRegister_ back into the Outbox push every frame that is in the FrameRegister.AllFrames_ vector into the Outbox in the same order they appear.

std::pair<int, I3FramePtr> FindCorrIndices(const std::string &subEventStream, const uint subEventID) const

helper: find on which place this splitframe is in the FrameRegister_.allFrames_ vector Implements a first guess and a granular searching; unique identification is done by SubEventStream and SubEventID

Parameters:
  • subEventStream – Name of the subEventStream that should be searched for

  • subEventID – SubEventID of the event that should be searched for

Returns:

a pair of position of that frame in the FramePackage and the Pointer to the frame itself

void ReduceEffSplitCount(const uint reduce = 1)

helper function to reduce the Effective SplitCount

Parameters:

reduce – the effective SplitCount by that much, by incrementing the ReducedCount; defaults to 1

inline uint GetNumberAllFrames()

return length of vector AllFrames

inline uint GetNumberQFrames()

return length of vector SplitFrames

inline uint GetNumberSplitFrames()

return length of vector SplitFrames

inline uint GetNumberHypoFrames()

return length of vector HypoFrames

inline uint GetNumberOtherFrames()

return length of vector OtherFrames

inline uint GetSplitCount()

return the value of ‘SplitCount’ in Qframe

inline uint GetReducedCount()

return the value of ‘ReducedCount’ in Qframe

inline uint GetEffSplits()

how many effective split remain?

Protected Attributes

std::string splitName_

PARAM: Name of the subevent-stream to try to recombine.

std::string hypoName_

PARAM: Name of the hypothesis-splits.

CoincSuite::FrameRegister FrameRegister_

create my most private instance of FrameRegister

Private Functions

SET_LOGGER ("FrameCombiner")
class FrameRegister
#include <FrameRegister.h>

a class which can buffer up and hold all frames in that package consists of multiple vectors of PosFrames, which holds frames which fulfil certain criteria e.g. belong to a certain SubEventStream

Public Functions

FrameRegister()

constructor (setting everything void)

FrameRegister(std::vector<I3FramePtr> &packet, const std::string &SplitName, const std::string &HypoName)

constructor (building the FrameRegister directly)

Parameters:
  • packet – the FramePacket to fill the FrameRegister from

  • SplitName – name of the split subevent stream

  • HypoName – name of the HypoFrame subevent stream

bool BuildFrameRegister(std::vector<I3FramePtr> &packet, const std::string &SplitName, const std::string &HypoName)

Build the frame register.

Parameters:
  • packet – the FramePacket to fill the FrameRegister from

  • SplitName – name of the split subevent stream

  • HypoName – name of the HypoFrame subevent stream

bool InsertFrame(I3FramePtr frame)

insert a singular frame

Parameters:

frame – the frame to insert

Returns:

true if success

void Clear()

reset everything : purge all objects and all variables

std::vector<I3FramePtr> RetrieveAllContent() const

retrieve the content of the frame register

std::vector<I3FramePtr> RetrieveFrameSequence(const bool qframes = true, const bool splitframes = true, const bool hypoframes = true, const bool otherframes = true) const

retrieve the content from the specified special fields

Parameters:
  • qframes – retrieve the (one!) Q-Frames

  • splitframes – retrieve the AplitFrames

  • hypoframes – retrieve the HypoFrmaes

  • otherframes – retrieve the OtherFrames

bool RemoveFrameAtPosition(const uint frameindex)

Remove the frame at this position find the position in the array of all frames, eraze it, and rebuild the FrameRegister from the remaining content

Parameters:

frameindex – the position of the frame to remove

PosFrame FindCorrIndices(const std::string &subEventStream, const uint subEventID) const

find the frame with the following subevent stream and ID

Parameters:
  • subEventStream – the stream to search for; special for “Q” which will give the Q-frame

  • subEventID – the ID to search for

Returns:

the position and a pointer to that frame; default to (-1, *0) if not found

PosFrame GetFrameAtPosition(const uint position) const

Get me the entry at this position.

inline uint GetNumberAllFrames() const

return length of vector AllFrames

inline uint GetNumberQFrames() const

return length of vector AllFrames

inline uint GetNumberSplitFrames() const

return length of vector SplitFrames

inline uint GetNumberHypoFrames() const

return length of vector HypoFrames

inline uint GetNumberOtherFrames() const

return length of vector OtherFrames

inline uint GetSplitCount() const

return the value of ‘SplitCount’ in Q-frame

inline uint GetReducedCount() const

return the value of ‘ReducedCount’ in Q-frame

inline uint GetEffSplits() const

how many effective split remain

Public Members

std::vector<PosFrame> AllFrames_

holds all Frames there are

std::vector<PosFrame> QFrames_

holds only the (one?!) Q Frame

std::vector<PosFrame> SplitFrames_

holds all frames of SubEventStream ‘SplitName’

std::vector<PosFrame> HypoFrames_

holds all frames of SubEventStream ‘HypoName’

std::vector<PosFrame> OtherFrames_

holds all frames of which are neither Q-frame, ‘SplitName’ nor ‘HypoName’

int SplitCount_

stores the value of ‘SplitCount’ as read from the Q-frame: Number of splitframes as created by the splitter

int ReducedCount_

stores the value of ‘ReducedCount’ as read from the Q-frame: Number of splitframes which were removed by recombinations

std::string SplitName_

remembers the name of SubEventStream for SplitFrames

std::string HypoName_

remembers the name of SubEventStream for HypoFrames

class FrameSentinel : public FrameCombiner

A Module that kills frames that contain a certain frame-key signaling that this frame should be discared.

Public Functions

inline FrameSentinel(const I3Context &context)

constructor

inline void Configure()
inline void FramePacket(std::vector<I3FramePtr> &packet)

Clean-out and push.

inline std::vector<uint> FlaggedFrames()

ACTION: clean away any frame that has the discardKey register and push remainder of the packet.

Private Functions

SET_LOGGER ("FrameSentinel")

Private Members

std::string discardFlag_

PARAM: the flag which should be discarded.

class GeoLine
#include <I3FakeCalculator.h>

a reprensentation of a Line in 3d space

Public Functions

inline GeoLine(const I3Position p, const I3Direction d)
inline GeoLine(I3Particle part)
inline I3Position GetPos() const
inline I3Direction GetDir() const

Private Members

I3Position pos
I3Direction dir
class GeoSurface
#include <I3FakeCalculator.h>

a representation of a Surface in 3d space

Public Functions

inline GeoSurface(const I3Position p, const I3Direction d)
inline GeoSurface(I3Particle part)
inline I3Position GetPos() const
inline I3Direction GetDir() const

Private Members

I3Position pos
I3Direction dir
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 = 1.)

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; optional

Hit(const OMKey omkey, const unsigned int pi, const double t, const double c = 1.)

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.

template<class Response>
class HitSortingFacility
#include <HitSorting.h>

A class which helps to extract hits from an ResponseMap Object in the frame; which also holds all the functionality so you do not do anything stupid

Public Types

enum Extract_Mode

Helper to steer function ExtractHits.

Values:

enumerator Extract_AllHits
enumerator Extract_FirstHitOnly
enumerator Extract_TotalChargeToFirstHit

Public Functions

inline HitSortingFacility(I3FramePtr frame, const std::string &key)

constructor

Parameters:
  • frame – frame to extract a map from

  • key – key in the frame at which we going to find a ResponseMap/Mask

template<class container>
container GetHits(HitSortingFacility::Extract_Mode mode = Extract_AllHits)

Extract Hit-objects from the ResponseMap and put/insert them into the container

Parameters:

mode – the mode how to extract the hits

Returns:

the container filled with Hits

template<class container>
ResponseSeriesMap MapFromHits(const container &hits, const bool useAllHits = false)

Revert once extracted Hits back to a subMap of the original ResonseMap

Parameters:
  • hits – a container with the hits to revert

  • useAllHits – if (true) one occurring hit a a certain DOM selects its full PulseSeries

Returns:

the subResponseMap

template<class container>
ResponseSeriesMapMask MaskFromHits(const container &hits)

Revert once extracted Hits back to a subMap and a final ResponseMask of the original ResonseMap

Parameters:

hits – a container with the hits to revert

Returns:

the subResponseMapMask

template<class HitContainer>
HitContainer GetHits(const typename HitSorting::HitSortingFacility<Response>::Extract_Mode mode)
template<class HitContainer>
HitSorting::HitSortingFacility<Response>::ResponseSeriesMap MapFromHits(const HitContainer &hits, const bool useAllHits)
template<class HitContainer>
HitSorting::HitSortingFacility<Response>::ResponseSeriesMapMask MaskFromHits(const HitContainer &hits)

Private Types

typedef std::vector<Response> ResponseSeries
typedef I3Map<OMKey, ResponseSeries> ResponseSeriesMap
typedef boost::shared_ptr<ResponseSeriesMap> ResponseSeriesMapPtr
typedef boost::shared_ptr<const ResponseSeriesMap> ResponseSeriesMapConstPtr
typedef I3RecoPulseSeriesMapMask ResponseSeriesMapMask
typedef I3RecoPulseSeriesMapMaskPtr ResponseSeriesMapMaskPtr
typedef I3RecoPulseSeriesMapMaskConstPtr ResponseSeriesMapMaskConstPtr

Private Functions

SET_LOGGER ("HitSortingFacility")

Private Members

ResponseSeriesMapConstPtr map_

hold a pointer to the object that the Hits have been extracted from

I3FramePtr frame_

PARAM: the frame this might have been extracted from.

std::string key_

PARAM: name of this map in the frame.

class HypoFrameCreator : public FrameCombiner

A I3Module that creates HypoFrames by forcefully combining all 2-permutations of SplitFrames, or if a the Parameter ‘Flagname’ is defined, only frames of which one is holding the flag will be combined.

Public Functions

HypoFrameCreator(const I3Context &context)

Constructor.

void Configure()

Configure.

void FramePacket(std::vector<I3FramePtr> &packet)

Action: create the HypoFrames loop over every combination of two SplitFrames and combine their RecoPulseSeries; name this new frame HypoFrame.

Private Functions

SET_LOGGER ("HypoFrameCreator")

Private Members

std::string recoMapName_

PARAM: Name of the RecoPulseSeriesMap(Mask) to recombine.

double maxTimeSeparation_

PARAM: maximum time separation between any two events that can be recombined.

std::string flagName_

PARAM: name of the flag that should be recombined (a useful thing to have)

class HypoFrameFaker : public FrameCombiner

A Module that forces recombination keys onto frames which could act like hypothesis of a DOUBLE split (e.g. ‘in_ice’)

Public Functions

HypoFrameFaker(const I3Context &context)

Constructor.

void FramePacket(std::vector<I3FramePtr> &packet)

Action: if there are exactly two splits found and exactly one such hypothesis frame, place the keys.

Private Functions

SET_LOGGER ("HypoFrameFaker")
class impCausalConnectTester : public TesterModule

A I3Module testing if two series of Pulses are connected topologically and have correct timing Of two fractions of pulses, test if they: -are happening after each other -the last/first emission point of !direct! Cherenkov-light hitting a DOM -horizontal distance, -vertical distance, -maximum time difference -and the CT-time-residual.

Public Functions

impCausalConnectTester(const I3Context &context)

constructor

void Configure()

Configure function.

Private Types

typedef std::pair<I3Position, double> Emission

short-hand for the emission point(s) along a track

typedef std::vector<Emission> EmissionSeries

Private Functions

SET_LOGGER ("impCausalConnectTester")
Result Test(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for mutual-testing.

Emission CherenkovPointTime(const HitSorting::TimeOrderedHitSet &hits, const I3Particle &fit, const bool first_last) const

‘CRAZY’ function return the last or first position along a track where Cherenkov-light hit the first or last OM in a series of first hits

Parameters:
  • hits – a time ordered set of hit to find the emisson-points for

  • fit – the track which is the sum of all possible emission points

  • first_last – if (true) take the first (earliest) emission point (start of the track), if (false) take the last (latest) emission point (end of the track)

bool CausalConnected(const I3RecoPulseSeriesMap &pulsesA, const I3RecoPulseSeriesMap &pulsesB, const I3Particle &fit) const

Tests if we can causally connect the Pulses.

Parameters:
  • pulsesA – Map of RecoPulseSeriesMap A

  • pulsesB – Map of RecoPulseSeriesMap B

  • fit – which is the particle hypothesis

Returns:

true, if SplitPulses are causally connected through the fit

Private Members

std::string recoMapName_

PARAM: Name of the I3RecoPulseSeriesMap that should be checked.

std::string hypoFitName_

PARAM: Name of the fit that should be tested.

std::pair<double, double> timeResTravel_

PARAM: Allowed time residual window for travel between the Emission-Points.

std::pair<double, double> timeResHit_

PARAM: Allowed time residual window for direct hits in the consideration for EmissionPoints.

double wallTime_

PARAM: maximal time before subseries of pulses can not be seen as connected any more.

double maxVertDist_

PARAM: maximal vertical distance before subseries of pulses can not be seen as connected any more.

double maxHorDist_

PARAM: maximal horizontal distance before subseries of pulses can not be seen as connected any more.

Private Static Functions

static inline Result runTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

template<class HitsContainer, class Response>
struct MaskPredicate
#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

MaskPredicate(const HitsContainer &hitSet)

constructor

bool operator()(const OMKey &k, const size_t pulseIdx, const Response &p)

Determine whether a particular pulse (hit) is part of the subevent

Parameters:
  • k – The OMKey on which the pulse occurred

  • pulseIdx – The index of the pulse on this specific DOM (position in the vector)

  • p – the RecoPulse object to check against

Returns:

true if the requested pulse is found in the set of hits

Public Members

const HitsContainer &hits

The collection of hits making up the subevent.

class NoiseClusterDiscard : public FrameCombiner

A Module that does ID noise events in a very crude way.

Public Functions

NoiseClusterDiscard(const I3Context &context)

constructor

void Configure()

ConfigureMethode: to bind new Parameters.

void FramePacket(std::vector<I3FramePtr> &packet)

Action: Find arguments why this is noise and mark to discard, increase the ‘ReducedCount’.

Private Functions

SET_LOGGER ("NoiseClusterDiscard")

Private Members

std::string recoMapName_

Param: Name of the I3RecoPulseSeriesMap i should check.

uint nChanLimit_

Param: Maximal number of DOMs that can participate in an NoiseCluster events.

uint tExtLimit_

Param: Minimal duration of a NoiseClusterEvent.

bool discardOpt_

Param: Discard the frame right away (True) or just mark it with a key ‘NoiseCluster’ (False)

class ReducingLikelihoodTester : public TesterModule

A Tester Module that probes if the Likelihood of a Fit is reduced when it is calculated on the provisionary recombined Pulses.

Public Functions

ReducingLikelihoodTester(const I3Context &context)

constructor

void Configure()

std Configure function

void Geometry(I3FramePtr frame)

need to reimplement to set the geometry for llhService

Private Functions

SET_LOGGER ("ReducingLikelihoodTester")
Result HypoTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for hypo-testing.

Result MutualTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for mutual-testing.

double FitCalcLogLikelihood(I3FrameConstPtr frame, const I3Particle &particle) const

fit and calculate the LogLikelihood value of a track fitting to the event outlined by objects in a frame

Parameters:
  • frame – pointer to the frame that holds the pulses (besides other objects, which are checked in silence)

  • particle – pointer to the Fit that should be checked

Returns:

the LLh-value

double CalculateLogLikelihood(I3FrameConstPtr frame, const I3Particle &particle) const

Just calculate the LogLikelihood value of a track fitting to the event outlined by objects in a frame.

Parameters:
  • frame – pointer to the frame that holds the pulses (besides other objects, which are checked in silence)

  • particle – pointer to the Fit that should be checked

Returns:

the LLh-value

Private Members

std::string llhServiceName_

PARAM: name of the llhService.

std::string miniServiceName_

PARAM: name of the miniService.

std::string paraServiceName_

PARAM: name of the paraService.

std::string recoFitName_

PARAM: Name of the reconstructed (I3Particle) Fit.

std::string hypoFitName_

PARAM: Name of the hypthetical (I3Particle) Fit.

double redFactor_

PARAM: the factor by which the likelihood has to be reduced by the recombination.

bool refit_

PARAM: Refit the hypothesis first and take the LLH from the new fit.

bool mutualOpt_

PARAM: Test Mutually instead of Hypothetically NOTE there is a difference of the meaning of this option in this module when compared to other Testers.

I3EventLogLikelihoodBasePtr llhService_

The llh service from context.

I3MinimizerBasePtr miniService_

The minimizer service from context.

I3ParametrizationBasePtr paraService_

The parametrization service from context.

I3GulliverPtr fitterCore_

The gulliver service: the work-horse.

Private Static Functions

static inline Result runHypoTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

static inline Result runMutualTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

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 SortAlongTrack

helper for sorting operation on EmissionSeries

Public Functions

inline SortAlongTrack(const I3Particle &fit)
inline bool operator()(const Emission &lhs, const Emission &rhs)

Public Members

I3Particle fit_
class SpeedTester : public TesterModule

A Tester-Module testing if the ParticleFit speed of a hypoFit is comparable to light speed in vacuum.

Public Functions

SpeedTester(const I3Context &context)

Constructor.

void Configure()

Configure.

Private Functions

SET_LOGGER ("SpeedTester")
Result Test(I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB) const

Implement the evaluation for mutual-testing.

bool SpeedCriterium(const I3Particle &hypoFit) const

Tests if the hypoFit-speed is within the given limits

Returns:

true, if speed is within …[speedLowerCut_, speedUpperCut_]…

Private Members

std::string hypoFitName_

PARAM: Name of the hypoFit i should check.

double speedUpperCut_

PARAM: Upper Cut value on the particle’s speed in [m/ns].

double speedLowerCut_

PARAM: Lower Cut value on the particle’s speed in [m/ns].

Private Static Functions

static inline Result runTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

struct SubEvent

A structure to save an event/frame and the information utilized to identify Afterpulses.

Public Members

Summary eventSummary
HitSummaryMap hitSummaries
struct SubEventSummary

A struct to save an event/frame and the information utilized to identify Afterpulses.

Public Functions

inline SubEventSummary(const I3FramePtr frame)

Public Members

I3FramePtr frame
Summary eventSummary
HitSummaryMap hitSummaries
struct Summary

A struct to store total charge and mean hit-time per DOM and/or event.

A structure to store total charge and mean hit-time per DOM or event.

Public Functions

inline Summary()
inline Summary()

constructor

Public Members

double qtot
double tmean
class TesterModule : public FrameCombiner
#include <TesterModule.h>

A module class that provides higher order functions for Tester Modules Derived classes must provide an evaluation on the split/unsplit-hypothesis, which will than be stored in the HypoFrame for later evaluation

Normal mode of operation is this:

-> Configuration: Provide a base-set of configurable Parameters “SplitName”, “RecoMapName”, which are needed operate the FrameRegister

Expand this parameters for the needs of the specific module

-> FramePacket:

The FramePacket is buffered up in the FrameRegister and access to Q/Split/HypoFrames provided.

Each HypoFrame is looped over and its originators are identified and picked from the subevent-stream

The derived Tester-class must implement a function: Result Evaluate((void*) this, HypoFrame, frameA, frameB), which evaluates the unsplit-hypothesis is to be preferred to the split-hypothesis (as present) with one of the following possibilities:

  • evaluation of the SplitFrame A against Splitframe B (MutualTest)

  • evaluation of the HypoFrame only (HypoTest)

  • evaluation of the SplitFrames A and SplitFrame B against the HypoFrame

    the result of the evaluation must be returned as either YES, NO, or UNDECIDED, in case no definite decision could be made, e.g. because keys were missing or the situation is unclear

    Put this decision into a map in the HypoFrame which can than be later evaluated and frames can get recombined

    Put a map into the Q frame, that stores that the specific Tester module has run

    Push the augmented FramePackage back into the processing pipeline

Subclassed by AfterpulseTester, AlignmentTester, CausalConnectTester, cogCausalConnectTester, CylinderPulsesTester, impCausalConnectTester, ReducingLikelihoodTester, SpeedTester, TrackLikelihoodTester, TrackSystemTester

Public Functions

TesterModule(const I3Context &context)

Constructor.

void Configure()

Configure function: Add more Parameters.

void Finish()

just use Finish of I3PacketModule: a must do

void Geometry(I3FramePtr frame)

buffer the I3Geometry up in geometry

void FramePacket(std::vector<I3FramePtr> &packet)

ACTION: Check if a recombination attempt makes sense Check for all objects needed to run. Check the criteria Check discrimination/veto Mark frames according to decision

Protected Types

enum Result

Formalizes the decision of a module.

Values:

enumerator UNDECIDED
enumerator YES
enumerator NO

Protected Functions

inline Result Bool2Result(const bool b) const

Convenience converter function.

void ModuleMarking(const std::string &moduleName)

Bookkeeping: tell the q frame we attempted this recombinations Put ‘RecombinationAttempts’ into the Qframe so that it knows this module has run.

Parameters:

moduleName – name of this Module (should be fetched by I3Module-method GetName())

void TesterMarking(I3FramePtr hypoframe, I3FramePtr frameA, I3FramePtr frameB, const std::string &moduleName, const bool success)

Bookkeeping: Put all necessary keys in the split- and HypoFrame to decide about recombinations Put ‘RecombinationSuccess’ key into the HypoFrame so that it knows about the success or failure of the run Tester.

Parameters:
  • hypoframe – the HypoFrame that was tested

  • frameA – the first frame the HypoFrame has been tested against

  • frameB – the second frame the HypoFrame has been tested against

  • moduleName – name of this Module (should be fetched by I3Module-method GetName())

  • success – was the recombination test successful?

Protected Attributes

I3GeometryConstPtr geometry_

buffers the geometry for arbitrary purpose

Result (*Evaluate)(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

Overwritable function which evaluates the criterion

Param tester:

pointer to the instance of the tester

Param hypoframe:

The HypoFrame pointer

Param frameA:

the frame A that should be evaluated against frame B and/or against the HypoFrame

Param frameB:

the frame B that should be evaluated against frame A and/or against the HypoFrame

Private Functions

SET_LOGGER ("TesterModule")

Private Members

unsigned int n_YES_
unsigned int n_NO_
unsigned int n_UNDECIDED_
struct timeOrdered
#include <HitSorting.h>

Determine whether hits are in time order.

Public Functions

bool operator()(const Hit &h1, const Hit &h2) const
class TrackLikelihoodTester : public TesterModule

A testing module that tests the logLikelihood of the track hypothesis of either SplitFrame with the combined pulses in the HypoFrame. If the reduced logLikelihood value is below a set threshold the two fractures are recombined.

Public Functions

TrackLikelihoodTester(const I3Context &context)

constructor

void Configure()

std Configure function

void Geometry(I3FramePtr frame)

need to reimplement to set the geometry for llhService

Private Functions

SET_LOGGER ("TrackLikelihoodTester")
Result HypoTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the Evaluation for hypo-testing.

Result MutualTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for mutual-testing.

double CalculateLogLikelihood(I3FrameConstPtr frame, const I3Particle &particle) const

calculate the LogLikelihood value of a track fitting to the event outlined by objects in a frame

Parameters:
  • frame – pointer to the frame that holds the pulses (besides other objects, which are checked in silence)

  • particle – pointer to the Fit that should be checked

Returns:

the LLh-value

Private Members

std::string llhServiceName_

PARAM: Name of event loglikelihood calculation service.

std::string fitName_

PARAM: fit name.

double llhThreshold_

PARAM: Threshold value on the logLikelihood for which frames should be recombined.

double averageLlhThreshold_

PARAM: Threshold value on the average logLikelihood for which frames should be recombined.

bool mutualOpt_

PARAM: Test Mutually instead of Hypothetically.

I3EventLogLikelihoodBasePtr llhService_

log-likelihood service

Private Static Functions

static inline Result runHypoTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

static inline Result runMutualTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

class TrackSystemTester : public TesterModule

A test if pulses are, by a certain fraction, in the in the track system of a proposed ParticleFit.

Public Functions

TrackSystemTester(const I3Context &context)

Constructor.

void Configure()

Configure function.

Private Functions

SET_LOGGER ("TrackSystemTester")
Result HypoTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the Evaluation for hypo-testing.

Result MutualTest(I3FrameConstPtr, I3FrameConstPtr, I3FrameConstPtr) const

Implement the evaluation for mutual-testing.

bool TrackSystemCriterum(const I3Particle &track, const I3RecoPulseSeriesMap &pulses) const

Are the found pulses on the Track System within the required time residual

Parameters:
  • track – the (I3Particle)track defining the moving particle (no cascade please)

  • pulses – the pulses being probed

Private Members

std::string recoMapName_

Param: Name of the RecoPulseSeriesMap.

std::string recoFitName_

Param: Name of the reconstructed (I3Particle) Fit.

std::string hypoFitName_

Param: Name of the hypothetical (I3Particle) Fit.

std::pair<double, double> resTimeWindow_

Param: residual window to find pulses with.

double cylinderRadius_

Param: Radius around the HypoFit within the Pulses should be found.

double criticalRatio_

Param: Ratio above which we accept hypothesis.

double particleSpeed_

Param: Adjust the Speed of the Particle to this value.

bool mutualOpt_

PARAM: Test Mutually instead of Hypothetically.

Private Static Functions

static inline Result runHypoTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

static inline Result runMutualTest(void *tester, I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB)

call-back function

namespace CoincSuite

Helper functions and convenience.

global namespace for all helpers

Functions

std::string FrameIDstring(const I3FrameConstPtr frame)

Get an unique identification string for frames with not so much information

Parameters:

frame

Returns:

a nicely formated string

I3RecoPulseSeriesMap UniteRecoMaps(const I3RecoPulseSeriesMap &mapA, const I3RecoPulseSeriesMap &mapB)

A convenience function to unite two RecoMaps into a single one.

Parameters:
  • mapA – the one map

  • mapB – the other map

Returns:

the united map

I3RecoPulseSeriesMapMask UniteRecoMaps_To_Mask(const std::string &key, const I3FramePtr qframe, const std::vector<I3FramePtr> &frames)

A convenience function to unite multiple RecoMaps found in frames to one Mask pointing to a q-frame.

Note

it is assumed that all Masks/Maps ahve similar derivition structure

Parameters:
  • key – the key to the map or mask object in the frames

  • qframe – the Q frame the frames derived from

  • frames – a number of frames where maps/masks should be reunited

Returns:

the united mask

std::vector<std::string> GetMaskAncestry(I3FrameConstPtr frame, const std::string &key)

Get a list of all deriations of this mask; children up front, grandparents in the back

Parameters:
  • frame – The frame which is searched for the the mask and its ancestors

  • key – The name of a I3RecoPulseSeriesMap or I3RecoPulseSeriesMapMask

Returns:

the ancestry of this map/mask, parents in the back

std::vector<std::string> GetCommonMaskAncestry(I3FrameConstPtr frame, const std::string &keyA, const std::string &keyB)

Get me the oldest common ancestors for masks

Parameters:
  • frame – The frame which is searched for the the mask and its ancestors

  • key1 – the one I3RecoPulseSeriesMapMask

  • key2 – the other I3RecoPulseSeriesMapMask

Returns:

key of the first common ancestor

I3TriggerHierarchy UniteTriggerHierarchies(const I3TriggerHierarchy &trigA, const I3TriggerHierarchy &trigB)

Unite two TriggererHierarchies into a single one

Parameters:
  • trigA – the one TriggerHierarchy

  • trigB – the other TriggerHierarchy

Returns:

the united Hierarchy

inline uint GetSubEventID(const I3FramePtr frame)

helper to return the SubEventID of a frame

Note

if this is called on a frame not containing a I3EventHeader if will crash and burn, just don’t do that

Parameters:

frame – a Regular frame which has to contain a I3EventHeader

template<class time_var>
double TimeSeparation(const time_var startA, const time_var endA, const time_var startB, const time_var endB)

Give the time-separation of two time windows; preferred either I3Time or double-expressions of whatever.

Note

the ‘<’ operator has to be defined for this; aka the times have to obey an ordering principle

Parameters:
  • startA – start of eventA

  • endA – stop of eventA

  • startB – start of eventB

  • endB – stop of eventB

Returns:

NAN: full inclusion, negative value: partial inclusion by so many ns, positive value: separated by that many ns

inline bool RecoPulse_timeorder(const I3RecoPulse &lhs, const I3RecoPulse &rhs)

an convenience time order operator

namespace HitSorting

provides functionality to extract and sort Hit-objects

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.

typedef std::vector<Hit> HitSeries
typedef std::list<Hit> HitList
typedef std::vector<HitSeries> HitSeriesSeries

Enums

enum Extract_Mode

Helper to steer function ExtractHits.

Values:

enumerator Extract_AllHits
enumerator Extract_FirstHitOnly
enumerator Extract_TotalChargeToFirstHit

Functions

std::ostream &operator<<(std::ostream &oss, const Hit &h)

Dump the object into a string-stream (this is bound to python as string-cast)

bool RetrievalOrdered(const Hit &h1, const Hit &h2)

need to implement a ordering principle

inline RetrievalOrderedHitSet TimeOrderedToRetrievalOrdered(const TimeOrderedHitSet &hitSet)

A function that does convert a TimeOrderedHitSet to a RetrievalOrderedHitSet.

Parameters:

hitSet – a time ordered hit set

inline TimeOrderedHitSet RetrievalOrderedToTimeOrdered(const RetrievalOrderedHitSet &hitSet)

A function that does convert a RetrievalOrderedHitSet to a TimeOrderedHitSet.

Parameters:

hitSet – a retrieval ordered hit set

bool operator==(const Hit &h1, const Hit &h2)

Comparison Operator for Hits just compare the (unique) index in the time ordered Hit-series.

bool operator!=(const Hit &h1, const Hit &h2)

Anti-Comparison 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 ordered_set>
bool SetsIntersect(const ordered_set &lhs, const ordered_set &rhs)

Test whether any item in a sorted container is also found in another container NOTE: requirements: iterator and operator< (order!) defined

Parameters:
  • lhs – the one container

  • rhs – the other container having the same sorting as lhs_iter

Returns:

(true) if lhs and rhs intersect by at least one element

template<class ordered_set>
bool SetsIdentical(const ordered_set &lhs, const ordered_set &rhs)

a helper function that compares two sets and evaluates the identity by evaluating the identity of every element NOTE: requirements: iterator and operator< (order!) defined

Parameters:
  • lhs – the one container

  • rhs – the other container having the same sorting as lhs_iter

Returns:

(true) if sets are identical in every element

template<class ordered_set>
ordered_set UniteSets(const ordered_set &lhs, const ordered_set &rhs)

Return the union of lhs and rhs.

Parameters:
  • lhs – the one container

  • rhs – the other container having the same sorting as lhs_iter

Returns:

the union of the sets

template<class HitsContainer, class Response>
HitsContainer ExtractHits(const I3Map<OMKey, std::vector<Response>> &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 – mode how the extraction should commence Extract_AllHits = All Hits are extracted, [DEFAULT] 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 retrieval ordered HitSeries

template<class Response, class HitsContainer>
I3Map<OMKey, std::vector<Response>> RevertHits(const HitsContainer &hits, const I3Map<OMKey, std::vector<Response>> &pulses, const bool useAllHits = false)

Convert a series of Hits back to an native ResponseSeriesMap.

Parameters:
  • hits – the retrieval ordered Hits to revert

  • pulses – the Pulses the Hits were created from;

  • useAllHits – use all Hits on each original OM; useful if only first hits were extracted

Returns:

the ResponseMap of reverted Hits

template<class Response>
I3Map<OMKey, std::vector<Response>> ConvertHits_To_ResponseSeriesMap(const HitSorting::RetrievalOrderedHitSet &hits)

Convert a series of Hits back to an regular ResponseSeriesMap by recreating the Pulses; NOTE this function does only convert the format, and does not augment information.

Parameters:

hits – the retrieval ordered Hits to revert

Returns:

the retrieval ordered HitSeries

template<class HitsContainer>
I3RecoPulseSeriesMapMask I3RecoPulseSeriesMapMaskFromHits(const I3Frame &frame, const std::string &key, const HitsContainer &hits)

Note

Specialization to I3RecoPulse

Parameters:
  • frame – frame to extract pulses from

  • key – at the frame where the original map is found

  • hits – the hits to use for the mask

namespace I3Calculator
namespace I3FakeCalculator

This is a namespace, which provides a collection of stand-alone functions which can seamlessly be integrated into “phys-services/I3Calculator.h/cxx”

Functions

inline I3Position PointAlongTrack(const I3Particle &track, const double &distance)

Get Point in along track in this distance from vertex [distance in i3units::meter].

inline I3Position TimeAlongTrack(const I3Particle &track, const double &time)

Get Point along track which is time later than the vertex [time in i3units::ns].

inline I3Position PointAlongLine(const GeoLine &line, const double &distance)

walk along a line from its base-factor along the positive direction

double TrackDistance(const GeoLine &p1, const GeoLine &p2)

returns the closest distance between two input tracks (distance of closest approach)

I3Position TrackClosestPoint(const GeoLine &track1, const GeoLine &track2)

return point on track1 which is closest to track2

I3Position TrackSurfaceIntersection(const GeoSurface &surf, const GeoLine &track)

Get the intersection point of track with surface.

inline double PointSurfaceDistance(const I3Position &point, const GeoSurface &surf)

distance of a point towards a surface

double DistanceTowardsPoint(const I3Position &point, const I3Position &origin = I3Position(0, 0, 0))

return the distance of this point to the origin (length of vector), or to another point

namespace OMKeyHash

Defines hashing of OMKeys and ModuleKeys.

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 integers in the range [1, MAX_STRINGS].

typedef unsigned int OmNbr

OM numbers are unsigned integers in the range [1, MAX_OMS].

Functions

static const unsigned int MAX_STRINGS (86)

number of strings in the detector

static const unsigned int MAX_OMS (64)

number of OMs on each string

inline StringNbr SimpleIndex2StringNbr(const SimpleIndex simpleIndex)

convert a SimpleIndex to an string-number

Parameters:

simpleIndex – the plain index

Returns:

the string number

inline OmNbr SimpleIndex2OmNbr(const SimpleIndex simpleIndex)

convert a SimpleIndex to an OM-number

Parameters:

simpleIndex – the plain index

Returns:

the OM-number

inline SimpleIndex StringOmNbr2SimpleIndex(const StringNbr string, const OmNbr om)

convert a combination string and OM-number to a SimpleIndex

Parameters:
  • string – the string-number

  • om – the OM-number

Returns:

the plain index

inline SimpleIndex OMKey2SimpleIndex(const OMKey &omkey)

convert an OMKey to a SimpleIndex

Parameters:

omkey – the OMKey

Returns:

the plain index

inline SimpleIndex ModuleKey2SimpleIndex(const ModuleKey &mkey)

convert an ModuleKey to a SimpleIndex

Parameters:

mkey – the ModuleKey

Returns:

the plain index

inline OMKey SimpleIndex2OMKey(const SimpleIndex simpleIndex)

convert a SimpleIndex to an OMKey

Parameters:

simpleIndex – the plain index

Returns:

the OMKey

inline ModuleKey SimpleIndex2ModuleKey(const SimpleIndex simpleIndex)

convert a SimpleIndex to an ModuleKey

Parameters:

simpleIndex – the plain index

Returns:

the ModuleKey

Variables

static const unsigned int MAX_SIMPLEINDEX = MAX_STRINGS * MAX_OMS - 1

effective number of hashing range

namespace PartialCOG

Typedefs

typedef std::pair<I3Position, double> PosTime

give me a 4-vector

typedef std::vector<I3Position> DomPos_cache

a cache for DOM-positions indexed by Hashed OMKeys

Functions

std::vector<I3Position> BuildDomPos_cache(const I3Geometry &geo)

Build the DOMposition cache

Parameters:

geo – the geometry

Returns:

a ordered vector holding all I3Positions of the hashed OMKeys

std::pair<I3Position, double> PartialCOGhit(const HitSorting::TimeOrderedHitSet &hits, const std::vector<I3Position> &domPos_cache, const uint nFrac, const uint useFrac, const bool heads_tails, const uint min_inc, const uint max_inc, const bool useCharge = true)

compute COG in pos and time of the fraction of DOMs using absolut position/numbers

Parameters:
  • hits – map of OMKeys and time of their first hits

  • domPos_cache – a ordered vector holding all I3Positions of the hashed OMKeys

  • nFrac – number of fractions that should be used

  • useFrac – use that fraction (always absolute counting from the front)

  • heads_tails – counting from front (true) or back (false) within the fraction

  • min_inc – include at least that many doms in the COG

  • max_inc – include no more than that many doms in the COG

  • useCharge – weight the COG by the charge of each hit

Returns:

a pair of COG position and time (as average of the configured pulses)

std::pair<I3Position, double> PartialCOGcharged(const HitSorting::TimeOrderedHitSet &hits, const std::vector<I3Position> &domPos_cache, const uint nFrac, const uint useFrac, const bool heads_tails, const uint min_inc, const uint max_inc)

compute COG in pos and time of the fraction of DOMs using accumulated charge

Note

the cog is always charge-weighted

Parameters:
  • hits – map of OMKeys and time of their first hits

  • domPos_cache – a ordered vector holding all I3Positions of the hashed OMKeys

  • nFrac – number of fractions that should be used

  • useFrac – use that fraction (always absolute counting from the front)

  • heads_tails – counting from front (true) or back (false) within the fraction

  • min_inc – include at least that many hits in the COG

  • max_inc – include no more than that many hits in the COG

Returns:

a pair of COG position and time (as average of the configured pulses)

std::pair<I3Position, double> PartialCOGexclude(const HitSorting::TimeOrderedHitSet &hits, const std::vector<I3Position> &domPos_cache, const bool heads_tails, const uint n_many, const uint n_exclude = 0, const bool useCharge = true)

compute COG in pos and time of the fraction of DOMs using exclusions

Parameters:
  • hits – map of OMKeys and time of their first hits

  • domPos_cache – a ordered vector holding all I3Positions of the hashed OMKeys

  • heads_tails – counting from front (true) or back (false) within the fraction

  • n_many – number of hits to include

  • n_exclude – number of hits to exclude up front, before DOMs are being included

  • useCharge – weight the COG by the charge of each hit

Returns:

a pair of COG position and time (as average of the configured pulses)

namespace std

STL namespace.

file AfterpulseDiscard.cxx
#include <boost/make_shared.hpp>
#include “icetray/I3Units.h”

copyright (C) 2011 the IceCube collaboration $Id$

The code core is copied from Chris Weaver’s AfterpulseSpotter and adapted for Coincident Suite http://code.icecube.wisc.edu/svn/sandbox/cweaver/RandomStuff/private/RandomStuff/AfterPulseSpotter.cxx

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se (Chrisopher Weaver c.weaver@icecube.wisc.edu)

Date

$Date: 20 Mar 2013

Defines

AFTERPULSEDISCARD_H

Typedefs

typedef std::map<OMKey, Summary> HitSummaryMap
typedef std::vector<SubEventSummary> SubEventSummarySeries

Functions

inline bool earlierTime(const SubEventSummary &s1, const SubEventSummary &s2)

helper function to sort subevents in ascending time order

I3_MODULE(AfterpulseDiscard)
file AfterpulseTester.cxx
#include “dataclasses/I3Constants.h”
#include “icetray/I3Units.h”
#include <boost/make_shared.hpp>

copyright (C) 2011 the IceCube collaboration $Id$

This is mainly derived from the module AfterpulsesDiscard

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

AFTERPULSETESTER_H

Typedefs

typedef std::map<OMKey, Summary> HitSummaryMap
typedef std::vector<SubEvent> SubEventSeries

Functions

inline bool earlierTime(const SubEvent &s1, const SubEvent &s2)

helper function to sort subevents in ascending time order

I3_MODULE(AfterpulseTester)
file AlignmentTester.cxx
#include “phys-services/I3Calculator.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

ALIGNMENTTEST_H

Functions

I3_MODULE(AlignmentTester)
file CausalConnectTester.cxx
#include “gulliver/I3LogLikelihoodFitParams.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

CAUSALCONNECTTEST_H

Functions

I3_MODULE(CausalConnectTester)
file cogCausalConnectTester.cxx
#include “phys-services/I3Calculator.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

COGCAUSALCONNECTTEST_H

Functions

I3_MODULE(cogCausalConnectTester)
file CoincSuiteHelpers.cxx
#include <algorithm>
file CoincSuiteHelpers.h
#include <vector>
#include <string>
#include <utility>
#include “icetray/I3Frame.h”
#include “icetray/I3Int.h”
#include “icetray/OMKey.h”
#include “dataclasses/physics/I3EventHeader.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”
#include “dataclasses/physics/I3TriggerHierarchy.h”
#include <sstream>

copyright (C) 2011 the IceCube collaboration $Id$

Provide some convenience functions

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Typedefs

typedef unsigned int uint

make uint accessible

file CylinderPulsesTester.cxx
#include “phys-services/I3Calculator.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

CYLINDERPULSESTEST_H

Functions

I3_MODULE(CylinderPulsesTester)
file DecisionMaker.cxx
#include <limits>
#include <vector>
#include <string>
#include <boost/make_shared.hpp>
#include “dataclasses/I3MapOMKeyMask.h”
#include “dataclasses/I3Map.h”
#include “dataclasses/I3String.h”
#include “icetray/I3Bool.h”
#include “dataclasses/I3TimeWindow.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

DECISIONMAKER_H

Functions

I3_MODULE(DecisionMaker)
file EmptyFrameDiscard.cxx
#include <boost/make_shared.hpp>
#include “icetray/I3Units.h”
#include “icetray/I3Bool.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: 20 Mar 2013

Defines

EMPTYFRAMEDISCARD

Functions

I3_MODULE(EmptyFrameDiscard)
file FrameCombiner.cxx
#include <algorithm>
#include <boost/make_shared.hpp>

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

file FrameCombiner.h
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <utility>
#include “icetray/I3PacketModule.h”
#include “icetray/I3Frame.h”
#include “dataclasses/I3Double.h”
#include “icetray/I3Int.h”
#include “icetray/OMKey.h”
#include “dataclasses/physics/I3EventHeader.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”

copyright (C) 2011 the IceCube collaboration $Id$

The main purpose of this class and collection of functions is to provide a unified interface and random access to all frames that come along in a single FramePackage. Each FramePackage is therefore buffered up in an ordered register ‘FrameRegister’, that indicates the frame-type (Q-frame, SplitFrame, HypoFrame) and its later purpose.

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

file FrameRegister.h
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <utility>
#include “icetray/I3PacketModule.h”
#include “icetray/I3Frame.h”
#include “dataclasses/I3Double.h”
#include “icetray/I3Int.h”
#include “icetray/OMKey.h”
#include “dataclasses/physics/I3EventHeader.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”

copyright (C) 2011 the IceCube collaboration

Rcs

FrameCombiner.h 122365 2014-08-11 13:21:53Z mzoll

The main purpose of this class and collection of functions is to provide a unified interface and random access to all frames that come along in a single FramePackage. Each FramePackage is therefore buffered up in an ordered register ‘FrameRegister’, that indicates the frame-type (Q-frame, SplitFrame, HypoFrame) and its later purpose.

Version

Rcs

122365

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Typedefs

typedef std::vector<I3FramePtr> FramePack

an object that buffers up all frames in a ordered structure, not different to FramePacket

typedef std::pair<uint, I3FramePtr> PosFrame

an object that remembers the (original) position[0,…] of a given frame in the FramePack(et), and the pointer to it

typedef std::vector<PosFrame> PosFrameSeries

a series of PosFrames of common traits

file FrameSentinel.cxx
#include <vector>
#include <string>
#include <limits>

copyright (C) 2011 the IceCube collaboration $Id$

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Sept 24 2013

Functions

I3_MODULE(FrameSentinel)
file HitSorting.cxx

(c) 2012 the IceCube Collaboration

$Id$

Version

$Revision$

Date

$Date$

Author

Marcel Zoll marcel.zoll@fysik.su.se

file HitSorting.h
#include <numeric>
#include “OMKeyHash.h
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”

(c) 2012 the IceCube Collaboration

$Id$

Provides functionality to extract and sort Hit-objects from various kinds of representations of hits in icetray

Version

$Revision$

Date

$Date$

Author

mzoll marcel.zoll@fysik.su.se

file HypoFrame.cxx
#include <vector>
#include <string>
#include “dataclasses/I3MapOMKeyMask.h”
#include “dataclasses/I3Map.h”
#include “dataclasses/I3String.h”
#include “boost/make_shared.hpp”
#include “icetray/I3ConditionalModule.h”

copyright (C) 2011 the IceCube collaboration $Id$

Provides functions to create and destroy HypoFrames as unsplit hypothesis of SplitFrames

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Functions

I3_MODULE(HypoFrameCreator)
I3_MODULE(HypoFrameFaker)
I3_MODULE(FakeHypoFrameReverter)
file I3FakeCalculator.cxx
#include “phys-services/I3Calculator.h”

copyright (C) 2004 the icecube collaboration $Id$

Version

$Revision$

Date

$Date$

Author

mzoll marcel.zoll@fysik.su.se

file I3FakeCalculator.h
#include <cmath>
#include <utility>
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/I3Constants.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “dataclasses/I3Direction.h”

copyright (C) 2004 the IceCube collaboration $Id$

Version

$Revision$

Date

$Date$

Author

mzoll marcel.zoll@fysik.su.se

file impCausalConnectTester.cxx
#include “phys-services/I3Calculator.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

IMPCAUSALCONNECTTEST_H

Functions

I3_MODULE(impCausalConnectTester)
file index.dox
file NoiseClusterDiscard.cxx
#include <boost/make_shared.hpp>
#include <vector>
#include <string>
#include <limits>
#include “dataclasses/I3MapOMKeyMask.h”
#include “dataclasses/I3Map.h”
#include “dataclasses/I3String.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “icetray/I3Bool.h”
#include “icetray/I3PacketModule.h”
#include “icetray/I3Units.h”

copyright (C) 2011 the IceCube collaboration $Id:$

Version

$Revision:$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

NOISECLUSTERDISCARD_H

Functions

I3_MODULE(NoiseClusterDiscard)
file OMKeyHash.h
#include “icetray/OMKey.h”
#include “dataclasses/ModuleKey.h”

(c) 2012 the IceCube Collaboration

Provide hashing of OMKeys and ModuleKeys that is well ordered, complete, hierarchical and minimal injective into the natural numbers (N) aka. unsigned integers This makes it implicitly usable as an unique Hash (bidirectional) and as a Index-range in regular array-applications

Rcs

OMKeyHash.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

mzoll marcel.zoll@fysik.su.se

file PartialCOG.cxx
#include “dataclasses/I3Double.h”
#include “icetray/I3Bool.h”

(c) 2012 the IceCube Collaboration

$Id$

Version

$Revision$

Date

$Date$

Author

mzoll marcel.zoll@fysik.su.se

file PartialCOG.h
#include <algorithm>
#include <cassert>
#include <limits>
#include <list>
#include <map>
#include <sstream>
#include “icetray/I3ConditionalModule.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”
#include <boost/make_shared.hpp>
#include “OMKeyHash.h
#include “HitSorting.h

(c) 2012 the IceCube Collaboration

$Id$

Version

$Revision$

Date

$Date$

Author

mzoll marcel.zoll@fysik.su.se

file ReducingLikelihoodTester.cxx
#include “gulliver/I3EventLogLikelihoodBase.h”
#include “gulliver/I3ParametrizationBase.h”
#include “gulliver/I3MinimizerBase.h”
#include “gulliver/I3Gulliver.h”
#include “gulliver/I3EventHypothesis.h”
#include “gulliver/utilities/ordinal.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

sflis samuel.flis@fysik.su.se, mzoll marcel.zoll@fysik.su.se

Date

$Date: Sept 2013

Defines

REDUCINGLIHOODTEST_H

Functions

I3_MODULE(ReducingLikelihoodTester)
file SpeedTester.cxx
#include “dataclasses/I3Constants.h”
#include <boost/lexical_cast.hpp>

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.0

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

Defines

SPEEDTEST_H

Functions

I3_MODULE(SpeedTester)
file TesterModule.cxx
#include “boost/make_shared.hpp”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

file TesterModule.h
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/geometry/I3OMGeo.h”
#include “dataclasses/I3MapOMKeyMask.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3Map.h”
#include “dataclasses/I3Vector.h”
#include “dataclasses/I3String.h”
#include “icetray/OMKey.h”
#include “icetray/I3Units.h”
#include “dataclasses/I3Constants.h”

Baseclass definitions for any TesterModule.

copyright (C) 2011 the IceCube collaboration $Id$

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date: Nov 30 2011

file TrackLikelihoodTester.cxx
#include “gulliver/I3EventLogLikelihoodBase.h”
#include “gulliver/I3Gulliver.h”
#include “gulliver/I3EventHypothesis.h”
#include “gulliver/utilities/ordinal.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

Rcs

1.00

Author

sflis samuel.flis@fysik.su.se, mzoll marcel.zoll@fysik.su.se

Date

$Date: Sept 2013

Defines

TRACKLIKELIHOODTEST_H

Functions

I3_MODULE(TrackLikelihoodTester)
file TrackSystemTester.cxx
#include “phys-services/I3Calculator.h”

copyright (C) 2011 the IceCube collaboration $Id$

Version

$Revision$

Author

mzoll marcel.zoll@fysik.su.se

Date

$Date$

Defines

TRACKSYSTEMTEST_H

Functions

I3_MODULE(TrackSystemTester)
dir CoincSuite
dir CoincSuite
dir CoincSuite
dir icetray
dir lib
dir lib
dir Modules
dir Modules
dir private
dir public
dir Testers
dir Testers
page index

Author

mzoll marcel.zoll@fysik.su.se

Introduction

Coincident Suite is a project that is conceived to deal with coincident events in IceCube and their ramifications, which is a multiple P-frame (subevent) structure.

The code and its outline are highly motivated by a splitting module (e.g. TopologicalSplitter) that tries to separate a coincident event in the detector into subevents, which are contained in their own P-frames and subseries of pulses.

Some Definitions and Abbreviations

There must be some definitions and abbreviations introduced:

  • SimMultiplicity (SimMult) = Number of simulated primaries with NHit >= 1 in an event

  • TrueMultiplicity (TrueMult) = Number of primaries with NCh >=4 in an event

  • MC (MonteCarlo) = simulated truth, can be used in association with pulses to indicate the 100% physics that can be uncovered for every primary

  • Matched/Physics = Pulses/DOMs matched to the MCtruth of an incident primary

  • Noise = Pulses/DOMs caused by noise in that sub-series (==_MC - _Matched)

  • SplitCount = Number of subevents/splits found by EventSplitter, this includes splits of PhysicsClusters (correct splits), NoiseClusters, and fractured tracks; i.e. identical to the number of subevent frames generated

  • ReducedCount = Number of successful recombinations, removed NoiseClusters and Afterpulses, or other measures which reduced the number of original subevents/splits

  • EffectiveCount (EffCount) = Number of effective splits after recombinations (== SplitCount – ReducedCount)

  • Subevent = part of a bigger Hit/Pulse-Series, which was split off by e.g. a splitter representing a individual event seperated to others e.g in time or space. Multiple subevents can i.g. be associated to Q frame

  • Fracture = Deficit of splitters can cause that e.g. single track events are fractured into two or more subevents, which is than a wrong split

  • Recombination = The unification of two or more subevents into one single subevent.

  • Split = synonym to a subevent found and written out by a SplitterModule

  • NoiseCluster = a subevent that contains only noise hits and no Physics. Their creation is a consequence from the fact that noise can also cluster mimicking low multiplicity events.

  • RecoFit = A fit performed on individual subevents

  • HypoFit = A fit performed on he recombination of two subevents

  • SplitFrame = A frame of a split-off subevent

  • HypoFrame = A frame containing the recombination of two subevents and associated objects; is used for hypothesis testing

  • COG (Center of gravity) = the averaged position and time considering a series of Hits/Pulses

  • FramePackage = A series of frames which all belong to one mother-(Q)frame. Mostly associated with a leading Q-frames and a series of P-(subevent)frames.

Hierarchical Structure and Contained Modules

CoincidentSuite or short CoincSuite is a collection of libraries and classes. Some of these (e.g. Testers) inherit from a common base class as they have to perform operations in a similar way.

The base-structure is outlined by the library “FrameCombiner”, which contains the class “FrameCombiner” as an I3Module and the supporting class “FrameRegister”.

FrameRegister

The class “FrameRegister” is the center point of the project: It is designed to buffer up a whole series of frames as an ordered package and provide random access to these by different unique identifiers, like subevent-stream and subevent-ID. The FrameRegister deals with three special classes of frames to provide the fastest access: “Qframes”, “SplitFrames” and “HypoFrames”.

”Qframes” are the header frames of any single event that can be composed from a number of subevents. “Splitframes” are those frames that are output of a splitter module and are representing the discovered subevents. “Hypoframes” are an unsplit hypophesis, thus combinations, of some of the “Splitframes”, they should contain a “CS_CreatedBy”-object telling about their originators.

FrameCombiner

The class FrameCombiner

does provide the interaction routines for a general I3Module to interact with the FrameRegister: It provides templates to build such a FrameRegister from a FramePackage, to push frames back into the Outbox from a filled FrameRegister and to randomly access frames. It also implements all necessary variables for all its derived classes to interact with the FrameRegister.

Many Modules inherit from this class to operate on frames buffered up in the FrameRegister. The usual modes of operation are:

Locate single frames: This must be done by either knowing the position in the frame in the FramePackage or its unique identifiers. Find and read variables of a frame: While most variables can directly accessed in any frame directly, some variables are special and it is saver to use the Modules interaction routines to those. Manipulate the contents of a frame: For this some template functionality is provided in this base-class Create a new frame: Fast create a series of new frames, e.g. HypoFrames. Kill a single frame: Remove a frame completely as it should be discarded.

TesterModule

The class “TesterModule” is a direct descendant from FrameCombiner and is the base-class for any TesterModule

. It implements a bit more functionality and user interaction, but also channels the way how TesterModules perform their criteria testing and how they communicate to Icetray and other internals.

The most important propagated functionality is however the routines for standardized marking of recombination attempts.

There are two classes or modes how these Tester modules can be run: In ‘Hypo’ or ‘Mutual’ mode. The Hypo-mode signals that for decisions reconstructions aor other information from the Hypo frame is taken as arguments, while for the Mutual-mode information from the respective other frame is taken as arguments. Is to say, that the Mutual-mode is more selective and gives lesser false positives, while Hypo-mode gives lesser false negatives for the recombination decisions.

Frame-Objects

There is a number of I3Objects by which the communication of this software suite is realized. These are either written by the Modules themselves, or must be provided by the user for successful operation:

  • SplitFrames (I3Frame) in FramePackage after QFrame: P-frames written out by the Splitter Module, which hold the subevent split pulse-series; must have an “I3EventHeader” with subevent-stream by the name of the SplitterModule (if you are using phys-services.GetNextSubEvent() this is automatic)

  • HypoFrames (I3Frame) in FramePackage after QFrame and (usally after P-Frames) : P-frames created by the HypoFrameCreator Module, which hold the preliminary recombined pulse-series from two SplitFrames and act as the unsplit hypothesis of these frames; must have an “I3EventHeader” with subevent-stream by the name of the ‘HypoFrame’ (automatic) and have an ‘CreatedFrom’ object telling about the parents of this HypoFrame.

  • SplitCount (I3Int) in QFrame : Holds the number of SplitFrames written out by the Splitter. Must go by the name “[SplitterModuleName]SplitCount”. (Most Splitters allow the option ‘WriteSplitCount’ to be set or use the module CoincSuite.SplitCountMaker)

  • ReducedCount (I3Int) in QFrame: Holds the number of removed SplitFrames from the FramePackage. This variable must be created before CoincSuite starts computation. Must go by the name “[SplitterModuleName]ReducedCount”. (Use the module CoincSuite.ReducedCountPlacer to create it)

  • CS_RecombSuccess (I3MapStringBool) in HypoFrame : A map that will be created and/or augmented by and Tester module that is run. Entries are made if that specific Tester voted in favor or against a recombination of the SplitFrames the HypoFrame was created from.

  • CS_RecombAttempts (I3VectorString) in QFrame : A list that will be created and/or augmented by and Tester module that is run. Entries are made for each Tester that has been run.

  • CS_CreatedFrom (I3MapStringVectorDouble) in HypoFrame : Holds the parent’s subevent-ID of this HypoFrame; is created by HypoFrameCreator or HypoFrameFaker

  • CS_ComboFrom (I3MapStringVectorDouble) in recombined ComboFrame : In SplitsFrames which are the result of a successful recombination, tracking the parent’s subevent-ID.

  • CS_Reducing (I3MapStringVectorDouble) in HypoFrame : upon successful recombination put into the HypoFrame to signal the frames which are the fractures leading to this recombined event

  • CS_ReducedWith (I3MapStringVectorDouble) in recombined SplitFrame : upon successful recombination put into the Splitframe pointing to the partner SplitFrame which are fractures of the recobined events

  • CS_ReducedBy (I3MapStringVectorDouble) in SplitFrame : upon successful recombination put into the SplitFrame pointing to the Hypoframe which is the host event of this fraction

  • Discard (I3Bool) in SplitFrame: A marker that this frame can be discarded, because it has either been identified as nuisance or as a fracture of a recombined event, which has already been dealt with