finiteReco C++ API Reference

struct CylinderGeo
#include <I3FiniteCalc.h>

Public Members

double timeStart
double timeStopp
OMKey omStart
OMKey omStopp
double distStart
double distStopp
class I3FiniteCalc
#include <I3FiniteCalc.h>

Public Functions

I3FiniteCalc(const I3Geometry &geo, const I3Particle &track, I3RecoPulseSeriesMapConstPtr pulsemap, const double radius, const bool chMode = false)
inline ~I3FiniteCalc()
double GetSdet() const
double GetFiniteCut() const
double GetLend() const
double GetLstart() const
I3FiniteCuts GetCuts() const
double GetEventLength() const
double GetEventLengthMax() const
double GetDetectorLength() const
I3Position GetEventStart() const
I3Position GetEventStop() const
I3Position GetEventStartMax() const
I3Position GetEventStopMax() const
I3Position GetDetectorStart() const
I3Position GetDetectorStop() const
CylinderGeo FindDetectorEnds() const
CylinderGeo FindEventEnds() const
CylinderGeo FindEventEndsMax() const

Private Functions

void CheckHit(const OMKey &key, const I3Position &omPos, const double &time, const I3Particle &cylinder, CylinderGeo &geo) const

Private Members

const I3Geometry &geometry_
const I3Particle &cylinder_
I3RecoPulseSeriesMapConstPtr pulsemap_
const double cylinderR_
bool chMode_
CylinderGeo detector_
bool haveEvent_
CylinderGeo event_
CylinderGeo eventMax_

Private Static Functions

static inline double GetDistPerp(const I3Particle &cylinder, const I3Position &omPos)
static inline double GetDistChPos(const I3Particle &cylinder, const I3Position &omPos)
static inline double GetDistPara(const I3Particle &cylinder, const I3Position &omPos)
class I3FiniteCutsModule : public I3Module

Public Functions

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

Private Functions

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

Private Members

std::string fitName_
std::string inputRecoPulses_
double cylinderRadius_
class I3GulliverFinitePhPnh : public I3EventLogLikelihoodBase

Public Functions

I3GulliverFinitePhPnh(const std::string &name, const std::string &inputreadout, const double &noiserate, const double &defaultEventDuration, const double &rCylinder, const bool &FlagStringLLH, const std::vector<int> selectedStrings, const PhPnhProbBasePtr prob, const bool &useOnlyFirstHit, const double &probMultiDet = 0.5)
~I3GulliverFinitePhPnh()
inline void SetGeometry(const I3Geometry &geo)
void SetEvent(const I3Frame &f)
unsigned int GetMultiplicity()
double GetLogLikelihood(const I3EventHypothesis &p)
inline const std::string GetName() const

Private Functions

bool IsStringSelected(const int &stringNr)
I3GulliverFinitePhPnh()
double GetProbCylinder(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit)
double GetLogLikelihoodString(const I3Particle &track)
double GetLogLikelihoodOM(const I3Particle &track)
I3GulliverFinitePhPnh(const I3GulliverFinitePhPnh&)
I3GulliverFinitePhPnh operator=(const I3GulliverFinitePhPnh &rhs)

Private Members

std::map<OMKey, I3MHit> hits_
std::string name_
std::string inputReadout_
std::string llhName_
double noiseRate_
double defaultEventDuration_
double rCylinder_
bool flagStringLLH_
std::vector<int> selectedStrings_
PhPnhProbBasePtr prob_
int multi_
bool useOnlyFirstHit_
double probMultiDet_
double minProb_
class I3GulliverFinitePhPnhFactory : public I3ServiceFactory

Public Functions

I3GulliverFinitePhPnhFactory(const I3Context &context)
~I3GulliverFinitePhPnhFactory()
virtual bool InstallService(I3Context &services)

Install this service into the specified object.

Parameters:

services – the I3Services into which the service should be installed.

Returns:

true if the service is successfully installed.

virtual void Configure()

Configure service prior to installing it.

Private Functions

I3GulliverFinitePhPnhFactory(const I3GulliverFinitePhPnhFactory &rhs)
I3GulliverFinitePhPnhFactory operator=(const I3GulliverFinitePhPnhFactory &rhs)
SET_LOGGER ("I3GulliverFinitePhPnhFactory")

Private Members

std::string useSignalsFrom_
std::string flagStringLLH_
std::string namePhotorec_
std::string probName_
std::string inputProbFile_
double noiseRate_
double defaultEventDuration_
double absorptionLength_
double rCylinder_
double probMultiDet_
double finiteDefaultLength_
std::vector<int> selectedStrings_
bool onlyInfiniteTables_
bool useOnlyFirstHit_
I3GulliverFinitePhPnhPtr finitePhPnh_
std::string name_
class I3LengthLLH : public I3Module
#include <I3LengthLLH.h>

Public Functions

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

Private Functions

I3LengthLLH()
I3LengthLLH(const I3LengthLLH &source)
I3LengthLLH &operator=(const I3LengthLLH &source)
double GetProbability(const I3ParticlePtr &track) const
std::map<double, double> DoLengthIter(const I3ParticlePtr &partPtr) const
SET_LOGGER ("I3LengthLLH")

Private Members

I3EventLogLikelihoodBasePtr finite_
std::string fitName_
std::string serviceName_
double stepSize_
double maxLength_
struct I3MHit

Internal struct holding simple hits.

Public Members

int n

number of hits

double t

hit time

double a

hit amplitude

I3OMGeo omgeo

geometrical hit position

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

Public Functions

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

Private Functions

I3StartStopLProb()
I3StartStopLProb(const I3StartStopLProb &source)
I3StartStopLProb &operator=(const I3StartStopLProb &source)
double GetProbability(const I3ParticlePtr &track) const
SET_LOGGER ("I3StartStopLProb")

Private Members

std::string fitName_
std::string serviceName_
I3EventLogLikelihoodBasePtr finite_
class I3StartStopPoint : public I3ConditionalModule
#include <I3StartStopPoint.h>

Public Functions

I3StartStopPoint(const I3Context &ctx)
~I3StartStopPoint()
void Configure()
void Physics(I3FramePtr frame)
void Finish()

Private Functions

I3StartStopPoint()
I3StartStopPoint(const I3StartStopPoint &source)
I3StartStopPoint &operator=(const I3StartStopPoint &source)
void CalculateStartStopPoint(I3FramePtr frame, I3RecoPulseSeriesMapConstPtr pulsemap, const I3Particle &particle)
SET_LOGGER ("I3StopPoint")

Private Members

std::string fitName_
std::string inputRecoPulses_
double cylinderRadius_
I3Particle::ParticleShape shape_
int shapeInt_
unsigned int recoOKCounter_

counter variable for events where the module succeeds in finding vertices

unsigned int recoFailedCounter_

counter variable for events where the input fit has status OK, but does not even come close to a launched DOM

unsigned int inputRecoFailedCounter_

counter variable for events where the input fit does not have status OK

class PhPnhMCDist : public PhPnhProbBase
#include <PhPnhMCDist.h>

Public Functions

PhPnhMCDist(const std::string &inputProbFile_)
virtual ~PhPnhMCDist()
virtual double GetHitProb(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit) const

Private Functions

double GetHitProb(const double &chdist, const double &ori, const double &energy, const int &Nhit = 1) const
PhPnhMCDist()

Private Members

float stepSize_
float maxDist_
std::vector<float> prob_
class PhPnhParam : public PhPnhProbBase
#include <PhPnhParam.h>

Public Functions

PhPnhParam()
PhPnhParam(double tau, const double &absorptionLength)
virtual ~PhPnhParam()
virtual double GetHitProb(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit) const

Private Functions

double GetHitProb(const double &chdist, const double &ori, const double &energy, const int &Nhit = 1) const

Private Members

double tau_
double l_a_
class PhPnhPhotorec : public PhPnhProbBase
#include <PhPnhPhotorec.h>

Public Functions

inline PhPnhPhotorec(I3PhotonicsServicePtr photorecPtr, const double &finiteDefaultLength = 2 * I3Units::km, const bool &onlyInfiniteTables = false)
inline virtual ~PhPnhPhotorec()
virtual double GetHitProb(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit = 1) const

Private Functions

inline PhPnhPhotorec()

Private Members

I3PhotonicsServicePtr PhotorecPtr_
double finiteDefaultLength_
bool onlyInfiniteTables_
class PhPnhPhotorecCone : public PhPnhProbBase

Public Functions

PhPnhPhotorecCone(I3PhotonicsServicePtr photorecPtr, const double &finiteDefaultLength = 2 * I3Units::km, const bool &onlyInfiniteTables = false)
virtual ~PhPnhPhotorecCone()
virtual double GetHitProb(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit = 1) const

Private Functions

int GetCone(const I3Particle &track, const I3Position &pos) const
PhPnhPhotorecCone()

Private Members

I3PhotonicsServicePtr PhotorecPtr_
double finiteDefaultLength_
bool onlyInfiniteTables_
class PhPnhProbBase
#include <PhPnhProbBase.h>

Subclassed by PhPnhMCDist, PhPnhParam, PhPnhPhotorec, PhPnhPhotorecCone

Public Functions

PhPnhProbBase()
virtual ~PhPnhProbBase()
virtual double GetHitProb(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit = -1) const = 0
double GetNoHitProb(const I3Particle &track, const I3OMGeo &omgeo, const int &Nhit = -1) const
bool CherenkovCalc(const I3Particle &track, const I3Position &pos, I3Position &chpos, double &chtime, double &chdist, double &ori) const
class StringLLH
#include <StringLLH.h>

Public Functions

StringLLH(const int &stringNr)

Constructor: takes a string number.

StringLLH()
~StringLLH()
void AddOM(double probHit, bool hit, const bool &broken)

Adds a DOM to the LLH. probHit: complete probability for the DOM to have a hit. hit: true if there was a hit. broken: true if the DOM is broken.

double GetProb()

Returns the LogProb for the string.

void NewString(const int &stringNr)

Deletes the information of the actual string and sets all values to default.

double GetStringNr()

Returns the number of the string.

Private Functions

StringLLH(const StringLLH&)
StringLLH operator=(const StringLLH &rhs)

Private Members

int numOM_

Number of DOMs added to the string.

int typeOM_

Type of the last DOM: 1=Hit, 0=NoHit, -1=NoHit but not the first one.

bool brokenOM_

True if the last DOM was broken.

double logProb_

Logarithmic probability for the string.

double probLast_

Probability for a hit in the last DOM.

double probChainNO_

Probability for a chain ending at the 2nd-to-last DOM with no removed hit in the last DOM.

double probChainYES_

Probability for a chain ending at the 2nd-to-last DOM with a removed hit in the last DOM.

int stringNr_

String number.

namespace std

STL namespace.

file I3FiniteCalc.cxx
#include <boost/make_shared.hpp>

implementation of the I3FiniteCalc class

This class calculates some parameters useful for the identification of finite tracks. These parameters can be stored within the I3FiniteCuts class (where you can find a short explanation of them).

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

The calculation of these parameters is placed in this separate class due to the structure of the calculation. For a given track a cylinder is created. The axis of the cylinder is oriented along the track axis. The radius defines which DOMs are included in the calculations. For each DOM the Cherenkov light emission point on the track is estimated. Those points are used for the calculation of the parameters.

Functions

static I3Position MoveAlongCylinder(const I3Particle &cylinder, const double &length)
file I3FiniteCalc.h
#include “recclasses/I3FiniteCuts.h”
#include “icetray/I3FrameObject.h”
#include “icetray/I3Logging.h”
#include “icetray/serialization.h”
#include “dataclasses/Utility.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “phys-services/I3Calculator.h”
#include <cmath>

declaration of the I3FiniteCalc class

This class calculates some values useful to determine whether a event is starting or not. These values are stored within an I3FiniteCuts object. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.I3FiniteCuts)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(I3FiniteCalc)
file I3FiniteCutsModule.cxx
#include “recclasses/I3FiniteCuts.h”
#include “icetray/I3Frame.h”
#include “icetray/I3Units.h”
#include “icetray/OMKey.h”
#include “icetray/I3PhysicsTimer.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/I3Position.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “phys-services/I3Calculator.h”
#include “gulliver/I3EventHypothesis.h”

implementation of the I3FiniteCutsModule class

This module collects the required objects from the frame and passes them to I3FiniteCalc. The returned I3FiniteCuts are placed in the frame.

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_MODULE(I3FiniteCutsModule)
file I3FiniteCutsModule.h
#include “icetray/I3Module.h”
#include “dataclasses/physics/I3Particle.h”

declaration of the I3FiniteCutsModule class

This module derives cuts which might be used to determine whether an event is starting or not. I3FiniteCalc is called and the returned I3FiniteCuts object is placed in the frame. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.I3FiniteCuts)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file I3GulliverFinitePhPnh.cxx
#include “finiteReco/StringLLH.h
#include “icetray/I3Units.h”
#include “icetray/I3Frame.h”
#include “dataclasses/physics/I3RecoPulse.h”
#include “dataclasses/physics/I3EventHeader.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/physics/I3Particle.h”
#include “gulliver/I3EventHypothesis.h”
#include “gulliver/I3PDFBase.h”
#include “phys-services/I3Calculator.h”
#include <float.h>

implementation of the I3GulliverFinitePhPnh class

This class calculates a PDF based on the probability of a DOM to have a hit from a given track. By this the PDF is sensitive to finite tracks. The implementation is done as an I3PDFService for gulliver. There are various options coming along with this PDF, which are set by I3GulliverFinitePhPnhFactory.

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

static double GetCharge(const I3RecoPulse &pulse)
static double GetTime(const I3RecoPulse &pulse)
void FillHits(I3RecoPulseSeriesMapConstPtr pulsemap, const I3Geometry &geometry, const string &name, map<OMKey, I3GulliverFinitePhPnh::I3MHit> &hitvect, int &multi)
file I3GulliverFinitePhPnh.h
#include <string>
#include <vector>
#include “icetray/IcetrayFwd.h”
#include “dataclasses/I3Position.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “dataclasses/physics/I3Particle.h”
#include “gulliver/I3EventLogLikelihoodBase.h”
#include “gulliver/I3PDFBase.h”

declaration of the I3GulliverFinitePhPnh class

This class is implemented as an I3PDFService to be used with gulliver. It calculates the probability for a given track to fit to the hit pattern. The probability for each DOM to be hit or not hit is taken into account. These probabilities can be obtained in different ways, all deriving from PhPnhProbBase. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(I3GulliverFinitePhPnh)
file I3GulliverFinitePhPnhFactory.cxx
#include “icetray/IcetrayFwd.h”
#include “icetray/I3Context.h”
#include “gulliver/I3PDFBase.h”
#include “photonics-service/I3PhotonicsServiceFactory.h”

implementation of the I3GulliverFinitePhPnhFactory class

This Service places an I3GulliverFinitePhPnh object in the frame. Various parameters have to be set to use this PDF.

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

static unsigned int installcounter (0)

Variables

static const std::string input_optionname = "InputReadout"
static const std::string photorec_optionname = "PhotorecName"
static const std::string onlyInfinite_optionname = "OnlyInfiniteTables"
static const std::string finiteDefaultLength_optionname = "finiteDefaultLength"
static const std::string noiserate_optionname = "NoiseRate"
static const std::string defaultEventDuration_optionname = "DefaultEventDuration"
static const std::string absorption_optionname = "AbsorptionLength"
static const std::string flagStringLLH_optionname = "StringLLH"
static const std::string rCylinder_optionname = "RCylinder"
static const std::string SelectStrings_optionname = "SelectStrings"
static const std::string Prob_optionname = "ProbName"
static const std::string ProbFile_optionname = "InputProbFile"
static const std::string ProbMultiDet_optionname = "DOMHitProb"
static const std::string useOnlyFirstHit_optionname = "UseOnlyFirstHit"
file I3GulliverFinitePhPnhFactory.h
#include <string>
#include “icetray/IcetrayFwd.h”
#include “icetray/I3ServiceFactory.h”
#include “gulliver/I3MinimizerBase.h”

declaration of the I3GulliverFinitePhPnhFactory class

This class is an I3ServiceFactory. It places a pointer to I3GulliverFinitePhPnh in the frame, which is an I3PDFService used within the gulliver project. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@physikrwth-aachen.de

file I3LengthLLH.cxx
#include “finiteReco/I3LengthLLH.h
#include “icetray/I3Frame.h”
#include “icetray/I3PhysicsTimer.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/I3Vector.h”
#include “gulliver/I3EventHypothesis.h”

implementation of the I3LengthLLH class

A module to reconstruct the length of a given track. The direction and position of the track is kept fixed, thus this only a 1D optimization. For this optimization, first a fixed start point is chosen and the stop point is varied along the track. For each variation the likelihood value is calculated. Afterwards, the newly found stop point is fixed and the start point is optimized in the same way. Finally start and stop point are known, and thus the length.

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_MODULE(I3LengthLLH)
static I3Position GetNewPos(const I3ParticleConstPtr &partPtr, const std::map<double, double> &llhMap, const int &sgn)
static I3Position GetStartPos(const I3ParticleConstPtr &partPtr, const std::map<double, double> &llhMap)
static I3Position GetStopPos(const I3ParticleConstPtr &partPtr, const std::map<double, double> &llhMap)
file I3LengthLLH.h
#include “icetray/I3Module.h”

declaration of the I3LengthLLH class

This module reconstructs the length of a given track. An I3PDFService depending on the start and stop point is required (I3GulliverFinitePhPnh). The module calculates the likelihood value for each length at each position on the track. The best-fitting length is returned, independent of the true event shape. This module does not determine whether an an event is starting or not. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.I3LengthLLH)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file I3StartStopLProb.cxx
#include “recclasses/I3StartStopParams.h”
#include “icetray/I3Units.h”
#include “icetray/I3Frame.h”
#include “icetray/I3PhysicsTimer.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/physics/I3EventHeader.h”
#include “dataclasses/physics/I3Particle.h”
#include “gulliver/I3EventHypothesis.h”

implementation of the I3StartStopLProb class

This module returns the probability for a missed muon before the reconstructed start point and after the stop point. This can be compared to the probabilities for no muon in these regions causing no hit (i.e. a starting and/or stopping track). The ratio is a measure whether the track is infinite or not.

Version

Rcs

55694

Date

Rcs

2009-06-08 19:39:53 +0200 (Mon, 08 Jun 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_MODULE(I3StartStopLProb)
file I3StartStopLProb.h
#include “recclasses/I3StartStopParams.h”
#include “icetray/I3ConditionalModule.h”
#include “dataclasses/physics/I3Particle.h”

declaration of the I3StartStopLProb class

This module calculates the likelihood parameter for a given muon track to be infinite, starting, stopping or contained. An I3StartStopParams object is placed in the frame. The hits are arranged along the track. Some DOMs without hit might be between the first hit DOM and the detector border. For those DOMs the probability to have no hit is calculated with two different assumptions: a track passing but unseen, or no track in this area. The same procedure is done for the stop point. The ratio of the two likelihood values is a measure for the starting/stopping probability. More information can be found at https://wiki.icecube.wisc.edu/index.php/FiniteReco.I3StartStopLProb

Version

Rcs

54885

Date

:

Rcs

2009-05-11 15:24:36 +0200 (Mon, 11 May 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file I3StartStopPoint.cxx
#include “recclasses/I3FiniteCuts.h”
#include “icetray/I3Frame.h”
#include “icetray/I3Units.h”
#include “icetray/OMKey.h”
#include “icetray/I3PhysicsTimer.h”
#include “dataclasses/I3Double.h”
#include “dataclasses/I3Position.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/geometry/I3Geometry.h”
#include “phys-services/I3Calculator.h”
#include “gulliver/I3EventHypothesis.h”

implementation of the I3StartStopPoint class

This module estimates the start and stop point of a track. The algorithm is based on a projection from the DOMs to the given track along the Cherenkov cone.

Version

Rcs

48479

Date

Rcs

2008-08-22 11:18:02 +0200 (Fr, 22 Aug 2008)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_MODULE(I3StartStopPoint)
file I3StartStopPoint.h
#include “icetray/I3ConditionalModule.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/physics/I3RecoPulse.h”

declaration of the I3StartStopPoint class

This Module estimates the start and stop point of a given track. I3FiniteCalc is called. An I3Particle of the given shape and I3FiniteCuts are returned to the frame. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.I3StartStopPoint)

Version

Rcs

48479

Date

Rcs

2008-08-22 11:18:02 +0200 (Fr, 22 Aug 2008)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file PhPnhMCDist.cxx
#include <cstdio>

implementation of the PhPnhMCDist class

This class derives from PhPnhProbBase. It derives the hit probability at a certain distance from a given table. This table is averaged over energy and direction. The table has to be ASCII with the step width in meters in the first line and the maximum distance in meters in the second line. All lines afterwards contain the probabilities for each bin with float precision. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

Rcs

59053

Date

Rcs

2009-10-20 12:58:54 +0200 (Tue, 20 Oct 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file PhPnhMCDist.h
#include <string>
#include “icetray/IcetrayFwd.h”

declaration of the PhPnhMCDist class

This class derives from PhPnhProbBase. It obtains the hit probability at a certain distance from a given table. This tables is averaged over energy and direction. The table has to be ASCII with the step width in meters in the first line and the maximum distance in meters in the second line. All lines afterwards contain the probabilities for each bin with float precision. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(PhPnhMCDist)
file PhPnhParam.cxx
#include <boost/math/distributions/poisson.hpp>

implementation of the PhPnhParam class

This class derives from PhPnhProbBase. It calculates the hit probability by an analytic function. This parametrization has two free parameters. As default the AMANDA best fit values are inserted. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

Rcs

59053

Date

Rcs

2009-10-20 12:58:54 +0200 (Tue, 20 Oct 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file PhPnhParam.h
#include <cmath>
#include “icetray/IcetrayFwd.h”
#include “dataclasses/I3Constants.h”

declaration of the PhPnhParam class

This class derives from PhPnhProbBase. It calculates the hit probability by an analytic function. This parametrization has two free parameters. As default the AMANDA best fit values are inserted. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(PhPnhParam)
file PhPnhPhotorec.cxx
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/I3Constants.h”
#include <boost/math/distributions/poisson.hpp>

implementation of the PhPnhPhotorec class

This class derives from PhPnhProbBase. It calculates the hit probability at the given position by a call to the photonics tables. A corresponding pointer must be provided. Photorec requires an energy to determine the probability. If no energy is provided with the track, 1 TeV is assumed. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

Rcs

52296

Date

Rcs

2009-02-03 16:30:36 +0100 (Tue, 03 Feb 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file PhPnhPhotorec.h
#include <string>
#include “icetray/IcetrayFwd.h”
#include “gulliver/I3PDFBase.h”
#include “photonics-service/I3PhotonicsServiceFactory.h”

declaration of the PhPnhPhotorec class

This class derives from PhPnhProbBase. It calculates the hit probability at the given position by a call to the photonics tables. A corresponding pointer must be provided. Photorec requires an energy to determine the probability. If no energy is provided with the track, 1 TeV is assumed. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(PhPnhPhotorec)
file PhPnhPhotorecCone.cxx

implementation of the PhPnhPhotorecCone class

This class derives from PhPnhProbBase. It calculates the hit probability at the given position by a call to the photonics tables. A corresponding pointer must be provided. Photorec requires an energy to determine the probability. If no energy is provided with the track, 1 TeV is assumed. The probability is multiplied by a step function, to account for physical/non-physical hits. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

Rcs

52296

Date

Rcs

2009-02-03 16:30:36 +0100 (Tue, 03 Feb 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file PhPnhPhotorecCone.h
#include <string>
#include “icetray/IcetrayFwd.h”
#include “dataclasses/physics/I3Particle.h”
#include “gulliver/I3PDFBase.h”
#include “photonics-service/I3PhotonicsServiceFactory.h”

declaration of the PhPnhPhotorecCone class

This class derives from PhPnhProbBase. It calculates the hit probability at the given position by a call to the photonics tables. A corresponding pointer must be provided. Photorec requires an energy to determine the probability. If no energy is provided with the track, 1 TeV is assumed. The probability is multiplied with a step function, to account for physical/non-physical hits. (see https://wiki.icecube.wisc.edu/index.php/FiniteReco.CalculationOfProbabilities)

Version

Rcs

52296

Date

Rcs

2009-02-03 16:30:36 +0100 (Tue, 03 Feb 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(PhPnhPhotorecCone)
file PhPnhProbBase.cxx

implementation of the PhPnhProbBase class

This class provides a general interface to derive a hit probability for a DOM at a certain position. The assumed track (I3Particle) and the position of the DOM are the only required information.

Version

Rcs

59053

Date

Rcs

2009-10-20 12:58:54 +0200 (Tue, 20 Oct 2009)

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file PhPnhProbBase.h
#include “icetray/IcetrayFwd.h”
#include “icetray/I3DefaultName.h”
#include “dataclasses/physics/I3Particle.h”
#include “dataclasses/I3Position.h”
#include “phys-services/I3Calculator.h”

declaration of the PhPnhProbBase class

This class provides a general interface to derive a hit probability for a DOM at a certain position. The assumed track (I3Particle) and the position of the DOM are the only required information.

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

Functions

I3_POINTER_TYPEDEFS(PhPnhProbBase)
file StringLLH.cxx
#include <iostream>
#include <cmath>
#include “icetray/I3Frame.h”
#include “finiteReco/StringLLH.h

implementation of the StringLLH class

This class accounts for hard local coincidences in the hit probabilities. For more details about the implementation see https://wiki.icecube.wisc.edu/index.php/FiniteReco.StringLLH

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

file StringLLH.h

declaration of the StringLLH class

This class provides an algorithm to account for hard local coincidences when calculating DOM hit probabilities. The probability is calculated string-wise. For more information about the class and the algorithm see https://wiki.icecube.wisc.edu/index.php/FiniteReco.StringLLH.

Version

$Revision$

Date

$Date$

Author

Sebastian Euler sebastian.euler@icecube.wisc.edu

dir finiteReco
dir finiteReco
dir finiteReco
dir icetray
dir private
dir probability
dir public