DomTools C++ API Reference

struct HitDomPair

Public Functions

inline HitDomPair()

Public Members

OMKey key
SignalType hit
bool kept
class HitTime_greater

Public Functions

inline explicit HitTime_greater(double time)
inline bool operator()(const HitDomPair &hdPair)

Private Types

typedef HitDomPair argument_type
typedef bool result_type

Private Members

double minTime_
template<class responseClass>
class I3Coincify : public I3ConditionalModule
#include <I3Coincify.h>

IceTray module to apply a Local Coincidence window to I3RecoPulse, I3RecoHit, I3MCHit, I3DOMLaunch.

Public Functions

inline I3Coincify(const I3Context &ctx)
inline void Configure()
inline void Physics(I3FramePtr frame)

Private Functions

I3Coincify()
I3Coincify(const I3Coincify &source)
I3Coincify &operator=(const I3Coincify &source)
SET_LOGGER ("I3Coincify")

Private Members

std::string inputName_
std::string outputName_
std::string isoName_
double coincWindow_
int coincSpacing_
int Multiplicity_
int frame_counter_
int frame_with_missing_inputName_counter_
class I3DistanceMap
#include <I3DistanceMap.h>

Creates a very large vector that contains a map of the distance squared between each OM.

This class trades memory for speed by creating ~300M vector. As distances are requested they are added to the vector. This generated an approximate 5 fold increase in speed.

Author

Kevin J Meagher

Date

March 2007

Public Functions

inline I3DistanceMap(const I3OMGeoMap &geo)

constructor

Gets the geometry to map and allocates the vector

Parameters:

geo – the geomerty to map

inline const I3OMGeoMap &getGeo() const
Returns:

the geometry being used by the distance map

inline double getDistance(const OMKey &key1, const OMKey &key2)

Looks up distance squared in map if it has been calculated return it else calculate it

Parameters:

  • key1 –

  • key2 –

Returns:

the distance squared between key1 and key2

Private Functions

inline int32_t getHash(const OMKey &key) const
Parameters:

key –

Returns:

A unique hash for key

inline int32_t getIndex(const OMKey &key1, const OMKey &key2) const
Parameters:

  • key1 –

  • key2 –

Returns:

the a index for a pair of keys

inline double setDistance(const OMKey &key1, const OMKey &key2)
Parameters:

  • key1 –

  • key2 –

Returns:

the distance squared between key1 and key2

SET_LOGGER ("I3DistanceMap")

Private Members

const I3OMGeoMap &geo_

geometry to map

std::vector<double> map_

vector to hold distances squared

int32_t size_

“size” of hash, must be larger that the greatest value of getHash

int min_string_

lowest string number

unsigned int min_om_

losest om number

unsigned int om_range_

range of om number

class I3DOMLaunchCleaning : public I3ConditionalModule
#include <I3DOMLaunchCleaning.h>

Public Functions

I3DOMLaunchCleaning(const I3Context &context)
void Configure()
void DAQ(I3FramePtr frame)

Private Members

std::vector<OMKey> cleanedKeys_
std::string cleanedKeysList_
std::string inIceInput_
std::string iceTopInput_
std::string inIceOutput_
std::string iceTopOutput_
bool firstLaunchCleaning_
class I3FirstPulsifier : public I3ConditionalModule
#include <I3FirstPulsifier.h>

Returns a pulse series map containing only the first pulses, however each first pulse carrying the total charge of all pulses by default.

This module takes a regular pulse series map as input and returns a pulse series map that has only the first pulses in it. I.e. it converts all the pulse series to a vector of length one containing only the first pulse. This new first pulse has the time and width of the original first pulse, but by default carries the total charge of all pulses that are in the full pulse series. This behaviour can be modified though.

The module is motivated by the calculation of cut variables such as Ndir and Ldir that use the information of when the modules are hit. If not only the first pulse, but all pulses are used for calculation of hit-time-critical cut variables, then late hits on the same module can seriously disturb the result. It has been found that the cut variables effectively lose their cut efficiency if all pulses are used. Calculating Ndir, Ldir etc. using all pulses is more or less meaningless. So please make sure to first-pulsify your pulse series map first.

Keeping only the time and width of the first hit, but the total charge of all hits is meant to circumvent the problem mentioned above, however keeping as much information as possible. If you want to weight the DOMs with their charge, then this might be interesting. However, it may also turn out that keeping the charge of the later hits is not desirable. If you want to keep only the charge of the first pulse, then you can do so by setting the parameter ‘KeepOnlyFirstCharge’ to True.

Public Functions

I3FirstPulsifier(const I3Context &ctx)
inline ~I3FirstPulsifier()
void Configure()
void Physics(I3FramePtr frame)

Private Members

std::string pulseSeriesMapName_
std::string outputPulseSeriesMapName_
bool keepOnlyFirstCharge_
bool useMask_
template<class responseClass>
class I3IsolatedHitsCutModule : public I3ConditionalModule
#include <I3IsolatedHitsCutModule.h>

Public Functions

I3IsolatedHitsCutModule(const I3Context &context)
void Configure()

Private Functions

I3IsolatedHitsCutModule()
I3IsolatedHitsCutModule(const I3IsolatedHitsCutModule &source)
I3IsolatedHitsCutModule &operator=(const I3IsolatedHitsCutModule &source)
void HitCleaning(I3FramePtr frame)
void WriteToFrame(I3FramePtr ptr, boost::shared_ptr<I3Map<OMKey, std::vector<responseClass>>> output)
SET_LOGGER ("I3IsolatedHitsCutModule")
template<>
void WriteToFrame(I3FramePtr frame, I3RecoPulseSeriesMapPtr output)

Private Members

std::string inputResponse_
std::string outputResponse_
double RTRadius_

cut hits outside this radius

double RTTime_

cut hits outside this time

int RTMultiplicity_

cut hits with a multiplicity lower than this

int UseWidth_
boost::shared_ptr<I3DistanceMap> distPtr

pointer to a class that remembers distances bewteen OMs

class I3LCCleaning : public I3ConditionalModule
#include <I3LCCleaning.h>

This module splits an I3DOMLaunchSeriesMap into two maps. One of which contains only HLC launches, the other of which contains only SLC launches.

Public Functions

I3LCCleaning(const I3Context &context)
void Configure()
void DAQ(I3FramePtr frame)

Public Members

std::string inIceInput_
std::string inIceOutput_
std::string inIceOutputSLC_
bool writeSLCOutput_

this is set if inIceOutputSLC_ is not empty; default is false

class I3LCPulseCleaning : public I3ConditionalModule

Public Functions

I3LCPulseCleaning(const I3Context&)
void Configure()
void Physics(I3FramePtr fr)

Private Members

std::string input
std::string output_hlc
std::string output_slc

Private Static Functions

static inline bool IsHLC(const OMKey &key, unsigned idx, const I3RecoPulse &pulse)
static inline bool IsSLC(const OMKey &key, unsigned idx, const I3RecoPulse &pulse)
template<class Selected>
class I3OMSelection : public I3ConditionalModule
#include <I3OMSelection.h>

Public Functions

inline void DefaultStream(I3Frame::Stream &v)
inline I3OMSelection(const I3Context &context)
inline void Configure()
inline void Geometry(I3FramePtr frame)
inline void HitCleaning(I3FramePtr frame)
template<>
inline void DefaultStream(I3Frame::Stream &v)

Private Functions

SET_LOGGER ("DomTools")

Private Members

std::string inputName_
std::string outputName_
std::string fileName_
std::vector<OMKey> omittedKeysVect_
std::vector<int> omittedStringsVect_
std::set<OMKey> omittedKeysByFile_
std::set<OMKey> omittedKeysByUser_
std::set<OMKey> omittedKeysPrevious_
std::set<OMKey> omittedAll_
std::string inputResponse_
std::string outputResponse_
bool selectInverse_
int frame_counter_
int frame_with_missing_inputResponse_counter_
template<class responseClass>
class I3ResponseIter
#include <I3ResponseIter.h>

Public Functions

inline I3ResponseIter(const I3Map<OMKey, std::vector<responseClass>> &rsm)
inline void operator++(int)
inline void operator++()
inline bool End()
inline responseClass Get()
inline int GetSequencenumber()
inline const OMKey &GetOMKey()
inline double GetTime()
inline double GetAmplitude()
inline double GetWidth()
SET_LOGGER ("I3ResponseIter")

Private Functions

I3ResponseIter()
inline void Check()

Private Members

I3Map<OMKey, std::vector<responseClass>>::const_iterator response_series_map_iter_
I3Map<OMKey, std::vector<responseClass>>::const_iterator response_series_map_end_
std::vector<responseClass>::const_iterator response_series_iter_
bool valid_response_
int sequence_number_
class I3ResponseMapSplitter : public I3ConditionalModule, private I3Splitter
#include <I3ResponseMapSplitter.h>

hit set splitteer

Todo:

docs

Public Types

enum splitweight_t

Values:

enumerator SW_OLD
enumerator SW_Charge
enumerator SW_DOM

Public Functions

I3ResponseMapSplitter(const I3Context &ctx)

constructor (define configurables)

inline ~I3ResponseMapSplitter()

destructor

void Configure()

configure (get & check configurables)

void Physics(I3FramePtr frame)

do a reconstruction

void DAQ(I3FramePtr frame)

monkey with entire readouts

void Finish()

say bye

Public Static Functions

template<typename Response>
static double SplitByTime(typename boost::shared_ptr<const I3Map<OMKey, std::vector<Response>>> responsemap, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap1, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap2, unsigned int &nhits1, unsigned int &nhits2, bool median, I3ResponseMapSplitter::splitweight_t sw, const std::string &name)

New implementation of pulsemap splitting using mean/median time static method for convenience (unit test & external use) instantiated for ResponseMap=I3RecoPulseMap

Note that you really need to call this method with unsigned ints for nhits1 and nhits2, some or all compilers will not accept a call with signed ints here.

Returns:

split time (useful for testing)

template<typename Response>
static void SplitByTrackAndCOG(I3ParticleConstPtr track, I3GeometryConstPtr geoptr, typename boost::shared_ptr<const I3Map<OMKey, std::vector<Response>>> responsemap, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap1, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap2, unsigned int &nhits1, unsigned int &nhits2, const std::string &name)

Implementation of geometric pulsemap splitting (using track & COG) static method for convenience (unit test & external use) instantiated for ResponseMap=I3RecoPulseMap

template<typename Response>
static void SplitByTimeResidual(double minTRes, double maxTRes, I3ParticleConstPtr track, I3GeometryConstPtr geoptr, typename boost::shared_ptr<const I3Map<OMKey, std::vector<Response>>> responsemap, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap1, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap2, unsigned int &nhits1, unsigned int &nhits2, const std::string &name)

Implementation of geometric pulsemap splitting (using track & time residuals) static method for convenience (unit test & external use) instantiated for ResponseMap=I3RecoPulseMap

template<typename Response>
static void SplitByBrightness(double maxDBrightSt, I3GeometryConstPtr geoptr, typename boost::shared_ptr<const I3Map<OMKey, std::vector<Response>>> responsemap, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap1, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap2, unsigned int &nhits1, unsigned int &nhits2, const std::string &name)

Implementation of pulsemap splitting (using pulse charges) static method for convenience (unit test & external use) instantiated for ResponseMap=I3RecoPulseMap

template<typename Response>
static void SplitByKmeans(bool wantRotated_, I3ParticleConstPtr track, I3GeometryConstPtr geoptr, typename boost::shared_ptr<const I3Map<OMKey, std::vector<Response>>> responsemap, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap1, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap2, unsigned int &npulses1, unsigned int &npulses2, unsigned int &nhits1, unsigned int &nhits2, const std::string &name, I3RandomServicePtr rnd)

Implementation of k-means clustering algorithm in x and y can rotate into plane defined by a given track before splitting largest number of hit DOMs is in “1” pulse static method for convenience (unit test & external use) instantiated for ResponseMap=I3RecoPulseMap

Private Functions

I3ResponseMapSplitter()
I3ResponseMapSplitter(const I3ResponseMapSplitter &source)

inhibited

I3ResponseMapSplitter &operator=(const I3ResponseMapSplitter &source)

inhibited

template<class ResponseMap>
void SplitMap(I3FramePtr frame)

record maximum number of hits in set 2

type dependent implementation details

template<typename Response>
void WriteOutput(I3FramePtr frame, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap1, typename boost::shared_ptr<I3Map<OMKey, std::vector<Response>>> newmap2)
SET_LOGGER ("I3ResponseMapSplitter")
template<>
void WriteOutput(I3FramePtr frame, I3RecoPulseSeriesMapPtr newmap1, I3RecoPulseSeriesMapPtr newmap2)

Private Members

std::string inResponseMapName_

inhibited

std::string inPulseMapName_

obsolete (setting this will result in a fatal)

std::string inTrackName_

name of pulseseriesmap

std::string geoName_

alternative splitting using a track (still to be implemented)

int minNch_

name of I3Geometry object in the frame

bool doTRes_

minimum number of channels in the response map to be splitted

double minTRes_

sort hits according to time residual rel to inTrackName_

double maxTRes_

minimum time residual rel to inTrackName_

bool doBrightSt_

maximum time residual rel to inTrackName_

double maxDBrightSt_

sort hits according to proximity to brightest string

bool doKmeans_

maximum radial distance to brigthest string

bool wantRotated_

sort hits using k-means clustering

bool splitEvents_

rotated hits into plane of track before clustering search

bool doTMedian_

run as an event splitter

std::string tSplitWeightName_

do time splitting on median instead of mean time

splitweight_t tSplitWeight_

option name for time based splitting strategy

std::string outResponseMap1Name_

option enum for time based splitting strategy

std::string outResponseMap2Name_

name of the first half of the response map

unsigned int nEvents_

name of the other half of the response map

unsigned int nBadEvents_

count events with enough hits to split

unsigned int nHits1_

count events with too few hits

unsigned int nHits2_

count total number of hits in set 1

unsigned int nMinHits1_

count total number of hits in set 2

unsigned int nMinHits2_

record minimum number of hits in set 1

unsigned int nMaxHits1_

record minimum number of hits in set 2

unsigned int nMaxHits2_

record maximum number of hits in set 1

template<class SignalType>
class I3TimeWindowCleaning : public I3ConditionalModule
#include <I3TimeWindowCleaning.h>

Public Functions

I3TimeWindowCleaning(const I3Context &context)
void Physics(I3FramePtr frame)
void Configure()
template<>
void Configure()
template<>
void Physics(I3FramePtr frame)

Private Functions

SET_LOGGER ("I3TimeWindowCleaning")

Private Members

double timeWindow_
bool useCharge_
std::string inputResponseName_
std::string outputResponseName_

Private Static Functions

static inline bool sortHits(const HitDomPair &lhs, const HitDomPair &rhs)
static std::string logTraceKeptHits(std::vector<HitDomPair>&)
namespace domtools

Functions

inline double GetTime(const I3RecoHit &hit)
inline double GetTime(const I3RecoPulse &pulse)
inline double GetTime(const I3DOMLaunch &launch)
inline double GetTime(const I3MCHit &hit)
inline double GetWidth(const I3RecoHit &hit)
inline double GetWidth(const I3MCHit &hit)
inline double GetWidth(const I3RecoPulse &pulse)
inline double GetWidth(const I3DOMLaunch &launch)
inline double GetAmplitude(const I3RecoHit &hit)
inline double GetAmplitude(const I3MCHit &hit)
inline double GetAmplitude(const I3RecoPulse &pulse)
inline double GetAmplitude(const I3DOMLaunch &launch)
namespace std

STL namespace.

file I3Coincify.cxx
#include “DomTools/I3Coincify.h”
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3RecoHit.h>
#include <dataclasses/physics/I3MCHit.h>

Functions

I3_MODULE(I3Coincify<I3RecoPulse>)

copyright (C) 2005 the IceCube collaboration Version $Id$

I3_MODULE(I3Coincify<I3RecoHit>)
I3_MODULE(I3Coincify<I3MCHit>)
I3_MODULE(I3Coincify<I3DOMLaunch>)
file I3Coincify.h
#include “icetray/I3ConditionalModule.h”
#include “icetray/I3Frame.h”
#include “icetray/I3Units.h”
#include “dataclasses/I3Map.h”
#include “DomTools/I3ResponseIter.h”
#include “DomTools/Utility.h”
#include <string>
#include <cmath>

copyright (C) 2005 the IceCube collaboration Version $Id$

Version

$Revision:$

Date

$Date$

file I3DistanceMap.h
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/I3Position.h>
#include <boost/foreach.hpp>
#include <limits>
#include <cmath>
file I3DOMLaunchCleaning.cxx
#include <algorithm>
#include <boost/foreach.hpp>
#include <dataclasses/physics/I3DOMLaunch.h>
#include <dataclasses/I3Vector.h>
#include <icetray/I3Frame.h>
#include <DomTools/I3DOMLaunchCleaning.h>

Functions

I3_MODULE(I3DOMLaunchCleaning)

copyright (C) 2005 the IceCube collaboration Version $Id$

file I3DOMLaunchCleaning.h
#include <icetray/I3ConditionalModule.h>
#include <icetray/OMKey.h>

copyright (C) 2005 the IceCube collaboration Version $Id$

Version

$Revision:$

Date

$Date$

file I3FirstPulsifier.cxx
#include “DomTools/I3FirstPulsifier.h”
#include <string>

Functions

I3_MODULE(I3FirstPulsifier)
I3RecoPulseSeriesMap GetFirstPulseSeriesMap(const I3RecoPulseSeriesMap&, bool)
I3RecoPulseSeriesMapMask GetFirstPulseSeriesMapMask(const I3Frame&, const std::string&)
bool compare(const I3RecoPulse &a, const I3RecoPulse &b)
file I3FirstPulsifier.h
#include “icetray/I3ConditionalModule.h”
#include “icetray/I3Context.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”

This class takes a pulse series map, extracts only the first pulse of each pulse series and puts a new pulse series map with only the first pulses into the frame. The charge of the new pulse is by default the total charge of all pulses.

Definition of I3FirstPulsifier class

copyright (C) 2012 The IceCube collaboration $Id$

Version

$Revision$

Date

$Date$

Author

Markus Voge voge@physik.uni-bonn.de

file I3IsolatedHitsCutModule.cxx
#include <cmath>
#include <dataclasses/I3MapOMKeyMask.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <DomTools/I3IsolatedHitsCutModule.h>

copyright (C) 2005 the icecube collaboration Some functionalities of this module have been taken from the Sieglinde SLHitSel(ector) module $Id$

Version

Rcs

1.45

Date

$Date$

Author

Ralf Ehrlich

Functions

I3_MODULE(I3IsolatedHitsCutModule<I3RecoPulse>)
file I3IsolatedHitsCutModule.h
#include <string>
#include <icetray/I3ConditionalModule.h>
#include <icetray/I3Frame.h>
#include <dataclasses/I3Map.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <icetray/I3Units.h>
#include <DomTools/I3ResponseIter.h>
#include <DomTools/I3DistanceMap.h>

copyright (C) 2005 the icecube collaboration Some functionalities of this module have been taken from the Sieglinde SLHitSel(ector) module $Id$

Version

Rcs

1.45

Date

$Date$

Author

Ralf Ehrlich

file I3LCCleaning.cxx
#include “DomTools/I3LCCleaning.h”
#include <icetray/I3Frame.h>
#include <dataclasses/physics/I3DOMLaunch.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/I3MapOMKeyMask.h>

Functions

I3_MODULE(I3LCCleaning)

copyright (C) 2007 the IceCube collaboration Version

Author: wikstrom

Rcs

file I3LCCleaning.h
#include <icetray/I3ConditionalModule.h>
#include <icetray/OMKey.h>

copyright (C) 2007 the IceCube collaboration Version

Rcs

Version

$Revision:$

Date

Rcs
Author

: wikstrom

file I3OMSelection.cxx
#include <DomTools/I3OMSelection.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3DOMLaunch.h>

Functions

I3_MODULE(I3OMSelection<I3RecoPulseSeries>)

copyright (C) 2005 the IceCube collaboration Version $Id$

I3_MODULE(I3OMSelection<I3DOMLaunchSeries>)
file I3OMSelection.h
#include <icetray/I3ConditionalModule.h>
#include <icetray/I3Frame.h>
#include <icetray/OMKey.h>
#include <dataclasses/I3Map.h>
#include <dataclasses/I3Vector.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/physics/I3DOMLaunch.h>
#include <vector>
#include <set>
#include <fstream>
#include <iostream>

copyright (C) 2005 the IceCube collaboration Version $Id$

Version

$Revision:$

Date

$Date$

file I3ResponseIter.h
#include “DomTools/Utility.h”
#include “icetray/OMKey.h”
#include “dataclasses/I3Map.h”
#include “icetray/I3Logging.h”
#include <string>
#include <map>
#include <vector>

copyright (C) 2005 the IceCube collaboration Version $Id$

Version

$Revision:$

Date

$Date$

file I3ResponseMapSplitter.cxx
#include “icetray/IcetrayFwd.h”
#include <vector>
#include <string>
#include <utility>
#include <list>
#include <functional>
#include <cmath>
#include “DomTools/I3ResponseMapSplitter.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/I3MapOMKeyMask.h”
#include “icetray/I3Context.h”
#include “icetray/I3Frame.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “phys-services/I3Cuts.h”
#include “phys-services/I3Calculator.h”
#include “phys-services/I3RandomService.h”
#include “dataclasses/physics/I3EventHeader.h”

copyright (C) 2005 the icecube collaboration $Id$

Version

$Revision$

Date

$Date$

Author

boersma

Functions

I3_MODULE(I3ResponseMapSplitter)

Variables

static const std::string inpulse_optionname = "InputPulseMap"
static const std::string intrack_optionname = "InputTrackName"
static const std::string minnch_optionname = "MinimumNch"
static const std::string dotres_optionname = "DoTRes"
static const std::string mintres_optionname = "MinTRes"
static const std::string maxtres_optionname = "MaxTRes"
static const std::string dobrightst_optionname = "DoBrightSt"
static const std::string maxdbrightst_optionname = "maxDBrightSt"
static const std::string dokmeans_optionname = "DoKmeans"
static const std::string tmedian_optionname = "DoTMedian"
static const std::string tweight_optionname = "TSplitWeight"
static const std::string wantrotated_optionname = "WantRotated"
static const std::string splitevents_optionname = "SplitEvents"
static const std::string geo_optionname = "I3GeometryName"
file I3ResponseMapSplitter.h
#include <vector>
#include “icetray/I3ConditionalModule.h”
#include “icetray/IcetrayFwd.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/I3Map.h”
#include “icetray/OMKey.h”
#include “phys-services/I3Splitter.h”
#include “phys-services/I3RandomService.h”

copyright (C) 2005 the icecube collaboration $Id$

Version

$Revision$

Date

$Date$

Author

boersma

file I3TimeWindowCleaning.cxx
#include <dataclasses/physics/I3RecoHit.h>
#include <dataclasses/physics/I3MCHit.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3DOMLaunch.h>
#include “DomTools/I3TimeWindowCleaning.h”

Functions

I3_MODULE(I3TimeWindowCleaning<I3RecoHit>)

copyright (C) 2005 the IceCube collaboration Version $Id$

I3_MODULE(I3TimeWindowCleaning<I3MCHit>)
I3_MODULE(I3TimeWindowCleaning<I3RecoPulse>)
I3_MODULE(I3TimeWindowCleaning<I3DOMLaunch>)
file I3TimeWindowCleaning.h
#include <icetray/I3ConditionalModule.h>
#include <icetray/OMKey.h>
#include <icetray/I3Frame.h>
#include <vector>
#include <dataclasses/I3Map.h>
#include <dataclasses/I3MapOMKeyMask.h>
#include <sstream>
#include <DomTools/Utility.h>

copyright (C) 2005 the IceCube collaboration Version $Id$

Version

$Revision:$

Date

$Date$

file modules.dox
file Utility.h
#include <dataclasses/physics/I3RecoHit.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3DOMLaunch.h>
#include <dataclasses/physics/I3MCHit.h>
#include <icetray/I3Units.h>
#include <cmath>

copyright (C) 2005 the IceCube collaboration Version $Id$

Version

$Revision:$

Date

$Date$

page DomTools-modules-and-params

Summary of I3Modules and I3ServiceFactories and their parameters

DomTools

http://code.icecube.wisc.edu/svn/projects/DomTools/trunk at revision 21318

Name

Description

Default

I3Coincify<I3DOMLaunch>

coincidenceneighbors

How far to look for neighbors

1

coincidencewindow

Time window for local coincidence

800

inputname

Name of the input response series map

outputname

Name of the output response series map

Coincified

IsolatedResponseName

Name of the output response series map containing all the responses that failed the given coincidence condition

I3Coincify<I3MCHit>

coincidenceneighbors

How far to look for neighbors

1

coincidencewindow

Time window for local coincidence

800

inputname

Name of the input response series map

outputname

Name of the output response series map

Coincified

IsolatedResponseName

Name of the output response series map containing all the responses that failed the given coincidence condition

I3Coincify<I3RecoHit>

coincidenceneighbors

How far to look for neighbors

1

coincidencewindow

Time window for local coincidence

800

inputname

Name of the input response series map

outputname

Name of the output response series map

Coincified

IsolatedResponseName

Name of the output response series map containing all the responses that failed the given coincidence condition

I3Coincify<I3RecoPulse>

coincidenceneighbors

How far to look for neighbors

1

coincidencewindow

Time window for local coincidence

800

inputname

Name of the input response series map

outputname

Name of the output response series map

Coincified

IsolatedResponseName

Name of the output response series map containing all the responses that failed the given coincidence condition

I3DOMLaunchCleaning

cleanedkeys

OMKeys to clean out of the launch map

[vector 0 ]

firstlaunchcleaning

True if you want to clean out all but the first DOM launch

0

icetopinput

input icetop DOMLaunches

IceTopRawData

icetopoutput

output icetop DOMLaunches

CleanIceTopRawData

iniceinput

input inice DOMLaunches

InIceRawData

iniceoutput

output inice DOMLaunches

CleanInIceRawData

I3IsolatedHitsCutModule<I3DOMLaunch>

inputresponse

Name of the input reco pulse series

outputresponse

Name of the output reco pulse series

rtmultiplicity

reject all pulses that have a smaller count (spacial/temporal) than RTMultiplicity

1

rtradius

count pulses within this radius towards multiplicity - NAN=no cut on spacial isolation

nan

rttime

count pulses within this time range towards multiplicity - NAN=no cut on temporal isolation

nan

I3IsolatedHitsCutModule<I3MCHit>

inputresponse

Name of the input reco pulse series

outputresponse

Name of the output reco pulse series

rtmultiplicity

reject all pulses that have a smaller count (spacial/temporal) than RTMultiplicity

1

rtradius

count pulses within this radius towards multiplicity - NAN=no cut on spacial isolation

nan

rttime

count pulses within this time range towards multiplicity - NAN=no cut on temporal isolation

nan

I3IsolatedHitsCutModule<I3RecoHit>

inputresponse

Name of the input reco pulse series

outputresponse

Name of the output reco pulse series

rtmultiplicity

reject all pulses that have a smaller count (spacial/temporal) than RTMultiplicity

1

rtradius

count pulses within this radius towards multiplicity - NAN=no cut on spacial isolation

nan

rttime

count pulses within this time range towards multiplicity - NAN=no cut on temporal isolation

nan

I3IsolatedHitsCutModule<I3RecoPulse>

inputresponse

Name of the input reco pulse series

outputresponse

Name of the output reco pulse series

rtmultiplicity

reject all pulses that have a smaller count (spacial/temporal) than RTMultiplicity

1

rtradius

count pulses within this radius towards multiplicity - NAN=no cut on spacial isolation

nan

rttime

count pulses within this time range towards multiplicity - NAN=no cut on temporal isolation

nan

I3MaxHitsCutModule<I3DOMLaunchSeries>

inputresponse

Name of the input response

input

maxhits

Maximum hits per OM

1

outputresponse

Name of the output response

output

I3MaxHitsCutModule<I3MCHitSeries>

inputresponse

Name of the input response

input

maxhits

Maximum hits per OM

1

outputresponse

Name of the output response

output

I3MaxHitsCutModule<I3RecoHitSeries>

inputresponse

Name of the input response

input

maxhits

Maximum hits per OM

1

outputresponse

Name of the output response

output

I3MaxHitsCutModule<I3RecoPulseSeries>

inputresponse

Name of the input response

input

maxhits

Maximum hits per OM

1

outputresponse

Name of the output response

output

I3OMSelection<I3AMANDAAnalogReadout>

badomfilename

Name of a file containing bad OMKeys

inputomselection

Name of a previously-existing OMSelection that you’d like to append to

inputresponse

Name of the input response

input

omittedkeys

OMKeys for OMs that we want to clean out

[vector 0 ]

omittedstrings

Strings for OMs that we want to clean out

[vector 0 ]

outputomselection

Name of the new OMSelection that will be created

BadOMSelection

outputresponse

Name of the output response

output

I3OMSelection<I3DOMLaunchSeries>

badomfilename

Name of a file containing bad OMKeys

inputomselection

Name of a previously-existing OMSelection that you’d like to append to

inputresponse

Name of the input response

input

omittedkeys

OMKeys for OMs that we want to clean out

[vector 0 ]

omittedstrings

Strings for OMs that we want to clean out

[vector 0 ]

outputomselection

Name of the new OMSelection that will be created

BadOMSelection

outputresponse

Name of the output response

output

I3OMSelection<I3RecoHitSeries>

badomfilename

Name of a file containing bad OMKeys

inputomselection

Name of a previously-existing OMSelection that you’d like to append to

inputresponse

Name of the input response

input

omittedkeys

OMKeys for OMs that we want to clean out

[vector 0 ]

omittedstrings

Strings for OMs that we want to clean out

[vector 0 ]

outputomselection

Name of the new OMSelection that will be created

BadOMSelection

outputresponse

Name of the output response

output

I3OMSelection<I3RecoPulseSeries>

badomfilename

Name of a file containing bad OMKeys

inputomselection

Name of a previously-existing OMSelection that you’d like to append to

inputresponse

Name of the input response

input

omittedkeys

OMKeys for OMs that we want to clean out

[vector 0 ]

omittedstrings

Strings for OMs that we want to clean out

[vector 0 ]

outputomselection

Name of the new OMSelection that will be created

BadOMSelection

outputresponse

Name of the output response

output

I3TimeWindowCleaning<I3DOMLaunch>

inputresponse

The detector response object to read in

hits

outputresponse

The detector response object to read in

hitsClean

timewindow

The window that is used in cleaning out DOMs.

4000

I3TimeWindowCleaning<I3MCHit>

inputresponse

The detector response object to read in

hits

outputresponse

The detector response object to read in

hitsClean

timewindow

The window that is used in cleaning out DOMs.

4000

I3TimeWindowCleaning<I3RecoHit>

inputresponse

The detector response object to read in

hits

outputresponse

The detector response object to read in

hitsClean

timewindow

The window that is used in cleaning out DOMs.

4000

I3TimeWindowCleaning<I3RecoPulse>

inputresponse

The detector response object to read in

hits

outputresponse

The detector response object to read in

hitsClean

timewindow

The window that is used in cleaning out DOMs.

4000

page todo

Class I3ResponseMapSplitter

docs

dir DomTools
dir DomTools
dir DomTools
dir icetray
dir private
dir public