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).
Protected Attributes
-
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")
-
double qtotFraction_¶
-
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
-
void Configure()¶
Configure function.
Private Functions
- SET_LOGGER ("AfterpulseTester")
-
Result Test(I3FrameConstPtr hypoframe, I3FrameConstPtr frameA, I3FrameConstPtr frameB) const¶
Implement the evaluation for mutual-testing.
Private Members
-
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
-
void Configure()¶
-
class AlignmentTester : public TesterModule¶
A I3Module if a track does align to a hypothetical track in angle and distance
Public Functions
-
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
-
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
-
void Configure()¶
-
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
-
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
-
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
-
void Configure()¶
-
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
-
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
-
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::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
-
void Configure()¶
-
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
-
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
-
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
-
void Configure()¶
-
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.
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::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?
-
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
Private Functions
- SET_LOGGER ("EmptyFrameDiscard")
-
class FakeHypoFrameReverter : public I3ConditionalModule¶
A Module that wipes away CoincSuite-keys of FAKE HypoFrames and reverts them to clean (plain) P-frames.
Public Functions
-
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")
-
void Configure()¶
-
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
-
void Configure()¶
std Configure function
-
void Finish()¶
std Finish function
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
Protected Attributes
-
CoincSuite::FrameRegister FrameRegister_¶
create my most private instance of FrameRegister
Private Functions
- SET_LOGGER ("FrameCombiner")
-
void Configure()¶
-
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> 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
Public Members
-
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
-
FrameRegister()¶
-
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 void Configure()¶
Private Functions
- SET_LOGGER ("FrameSentinel")
-
inline void Configure()¶
-
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¶
-
inline GeoLine(const I3Position p, const I3Direction d)¶
-
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¶
-
inline GeoSurface(const I3Position p, const I3Direction d)¶
-
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
Public Members
-
OMKeyHash::SimpleIndex domIndex¶
The index of the DOM on which this hit occurred, within the set of hit DOMs of the current event.
-
unsigned int pulseIndex¶
The index of this hit on the DOM where it occurred, index 0 is first hit.
-
double time¶
The actual time of the hit.
-
double charge¶
The charge of this hit.
-
Hit(const unsigned int di, const unsigned int pi, const double t, const double c = 1.)¶
-
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
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 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.
-
inline HitSortingFacility(I3FramePtr frame, const std::string &key)¶
-
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
-
void Configure()¶
Configure.
Private Functions
- SET_LOGGER ("HypoFrameCreator")
Private Members
-
double maxTimeSeparation_¶
PARAM: maximum time separation between any two events that can be recombined.
-
void Configure()¶
-
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
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
-
void Configure()¶
Configure function.
Private Types
-
typedef std::pair<I3Position, double> Emission¶
short-hand for the emission point(s) along a track
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::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
-
void Configure()¶
-
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.
-
MaskPredicate(const HitsContainer &hitSet)¶
-
class NoiseClusterDiscard : public FrameCombiner¶
A Module that does ID noise events in a very crude way.
Public Functions
-
void Configure()¶
ConfigureMethode: to bind new Parameters.
Private Functions
- SET_LOGGER ("NoiseClusterDiscard")
Private Members
-
bool discardOpt_¶
Param: Discard the frame right away (True) or just mark it with a key ‘NoiseCluster’ (False)
-
void Configure()¶
-
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
-
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
-
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
-
void Configure()¶
-
struct retrievalOrdered¶
- #include <HitSorting.h>
Determine whether Hits are in an order more suitable for retrieval from an I3RecoPulseSeriesMap.
-
struct SortAlongTrack¶
helper for sorting operation on EmissionSeries
Public Functions
-
inline SortAlongTrack(const I3Particle &fit)¶
Public Members
-
I3Particle fit_¶
-
inline SortAlongTrack(const I3Particle &fit)¶
-
class SpeedTester : public TesterModule¶
A Tester-Module testing if the ParticleFit speed of a hypoFit is comparable to light speed in vacuum.
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
-
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.
-
struct SubEventSummary¶
A struct to save an event/frame and the information utilized to identify Afterpulses.
Public Functions
-
inline SubEventSummary(const I3FramePtr frame)¶
-
inline SubEventSummary(const I3FramePtr frame)¶
-
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.
-
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
-
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
Protected Types
Protected Functions
-
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")
-
struct timeOrdered¶
- #include <HitSorting.h>
Determine whether hits are in time order.
-
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
-
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
-
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
-
void Configure()¶
-
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
-
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
-
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
-
void Configure()¶
-
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
-
std::string FrameIDstring(const I3FrameConstPtr frame)¶
-
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.
Enums
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)
-
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
-
typedef std::set<Hit, Hit::timeOrdered> TimeOrderedHitSet¶
-
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
-
inline I3Position PointAlongTrack(const I3Particle &track, const double &distance)¶
-
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
-
typedef unsigned int SimpleIndex¶
-
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)
-
typedef std::pair<I3Position, double> PosTime¶
-
namespace std
STL namespace.
- file AfterpulseDiscard.cxx
- #include <boost/make_shared.hpp>#include “CoincSuite/Modules/FrameCombiner.h”#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::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>
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
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”
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”#include “CoincSuite/Testers/TesterModule.h”#include “CoincSuite/lib/HitSorting.h”#include “CoincSuite/lib/PartialCOG.h”#include “CoincSuite/lib/I3FakeCalculator.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 “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”
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 “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>
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 “CoincSuite/Testers/TesterModule.h”#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”#include “CoincSuite/Modules/FrameCombiner.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 “CoincSuite/Modules/FrameCombiner.h”#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 “CoincSuite/Modules/FrameCombiner.h”#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”#include “CoincSuite/Modules/FrameRegister.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”#include “CoincSuite/lib/CoincSuiteHelpers.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
- file FrameSentinel.cxx
- #include “CoincSuite/Modules/FrameCombiner.h”#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
- #include <CoincSuite/lib/HitSorting.h>
(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 “CoincSuite/Modules/FrameCombiner.h”#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
- file I3FakeCalculator.cxx
- #include “CoincSuite/lib/I3FakeCalculator.h”#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 “CoincSuite/Testers/TesterModule.h”#include “CoincSuite/lib/HitSorting.h”#include “phys-services/I3Calculator.h”#include “CoincSuite/lib/OMKeyHash.h”#include “CoincSuite/lib/I3FakeCalculator.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 “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”
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 <CoincSuite/lib/PartialCOG.h>#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 “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”
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 “CoincSuite/Testers/TesterModule.h”#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 “CoincSuite/Testers/TesterModule.h”#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 “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.
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 “CoincSuite/Testers/TesterModule.h”#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 “CoincSuite/Testers/TesterModule.h”#include “CoincSuite/lib/HitSorting.h”#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