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.

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 HitSet, class Response> HitSet 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 “CoincSuite/Modules/FrameCombiner.h”

#include “icetray/I3Units.h”

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 “CoincSuite/Testers/TesterModule.h”

#include “dataclasses/I3Constants.h”

#include “icetray/I3Units.h”

#include <boost/make_shared.hpp>

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 “CoincSuite/Testers/TesterModule.h”

#include “phys-services/I3Calculator.h”

#include “CoincSuite/lib/I3FakeCalculator.h”

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”

#include “CoincSuite/Testers/TesterModule.h”

#include “CoincSuite/lib/HitSorting.h”

#include “CoincSuite/lib/PartialCOG.h”

#include “CoincSuite/lib/I3FakeCalculator.h”

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 “CoincSuite/Testers/TesterModule.h”

#include “CoincSuite/lib/PartialCOG.h”

#include “phys-services/I3Calculator.h”

#include “CoincSuite/lib/OMKeyHash.h”

#include “CoincSuite/lib/HitSorting.h”

#include “CoincSuite/lib/I3FakeCalculator.h”

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 “CoincSuite/lib/CoincSuiteHelpers.h”

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

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 “CoincSuite/Testers/TesterModule.h”

#include “phys-services/I3Calculator.h”

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”

#include “CoincSuite/Modules/FrameCombiner.h”

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 “CoincSuite/Modules/FrameCombiner.h”

#include “icetray/I3Units.h”

#include “icetray/I3Bool.h”

Version: $Revision$
Author: mzoll marcel.zoll@fysik.su.se
Date: $Date: 20 Mar 2013

Defines

EMPTYFRAMEDISCARD¶

Functions

I3_MODULE(EmptyFrameDiscard)¶

file FrameCombiner.cxx

#include “CoincSuite/Modules/FrameCombiner.h”

#include <algorithm>

#include <boost/make_shared.hpp>

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”

#include “CoincSuite/Modules/FrameRegister.h”

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”

#include “CoincSuite/lib/CoincSuiteHelpers.h”

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 “CoincSuite/Modules/FrameCombiner.h”

#include <vector>

#include <string>

#include <limits>

Version: $Revision$
Author: mzoll marcel.zoll@fysik.su.se
Date: $Date: Sept 24 2013

Functions

I3_MODULE(FrameSentinel)¶

file HitSorting.cxx

#include <CoincSuite/lib/HitSorting.h>

$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”

$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 “CoincSuite/Modules/FrameCombiner.h”

#include “icetray/I3ConditionalModule.h”

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 “CoincSuite/lib/I3FakeCalculator.h”

#include “phys-services/I3Calculator.h”

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”

Version: $Revision$
Date: $Date$
Author: mzoll marcel.zoll@fysik.su.se

file impCausalConnectTester.cxx

#include “CoincSuite/Testers/TesterModule.h”

#include “CoincSuite/lib/HitSorting.h”

#include “phys-services/I3Calculator.h”

#include “CoincSuite/lib/OMKeyHash.h”

#include “CoincSuite/lib/I3FakeCalculator.h”

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 “CoincSuite/Modules/FrameCombiner.h”

#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”

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”

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 <CoincSuite/lib/PartialCOG.h>

#include “dataclasses/I3Double.h”

#include “icetray/I3Bool.h”

$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”

$Id$

Version: $Revision$
Date: $Date$
Author: mzoll marcel.zoll@fysik.su.se

file ReducingLikelihoodTester.cxx

#include “CoincSuite/Testers/TesterModule.h”

#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”

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 “CoincSuite/Testers/TesterModule.h”

#include “dataclasses/I3Constants.h”

#include <boost/lexical_cast.hpp>

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 “CoincSuite/Testers/TesterModule.h”

#include “boost/make_shared.hpp”

Version
Rcs: 1.00
Author: mzoll marcel.zoll@fysik.su.se
Date: $Date: Nov 30 2011

file TesterModule.h

#include “CoincSuite/Modules/FrameCombiner.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.

Version: $Revision$
Author: mzoll marcel.zoll@fysik.su.se
Date: $Date: Nov 30 2011

file TrackLikelihoodTester.cxx

#include “CoincSuite/Testers/TesterModule.h”

#include “gulliver/I3EventLogLikelihoodBase.h”

#include “gulliver/I3Gulliver.h”

#include “gulliver/I3EventHypothesis.h”

#include “gulliver/utilities/ordinal.h”

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 “CoincSuite/Testers/TesterModule.h”

#include “CoincSuite/lib/HitSorting.h”

#include “phys-services/I3Calculator.h”

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

CoincSuite C++ API Reference¶

Introduction¶

Some Definitions and Abbreviations¶

Hierarchical Structure and Contained Modules¶

FrameRegister¶

FrameCombiner¶

TesterModule¶

Frame-Objects¶

Table of Contents

Previous topic

Next topic

This Page