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 ¶

#include <I3FiniteCutsModule.h>

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 ¶

#include <I3GulliverFinitePhPnh.h>

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 ¶

#include <I3GulliverFinitePhPnhFactory.h>

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¶

#include <I3GulliverFinitePhPnh.h>

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 ¶

#include <PhPnhPhotorecCone.h>

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 “finiteReco/I3FiniteCalc.h”

#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 “finiteReco/I3FiniteCutsModule.h”

#include “finiteReco/I3FiniteCalc.h”

#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/I3GulliverFinitePhPnh.h”

#include “finiteReco/StringLLH.h”

#include “finiteReco/probability/PhPnhProbBase.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 “finiteReco/probability/PhPnhProbBase.h”

#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 “finiteReco/I3GulliverFinitePhPnh.h”

#include “finiteReco/I3GulliverFinitePhPnhFactory.h”

#include “gulliver/I3PDFBase.h”

#include “finiteReco/probability/PhPnhProbBase.h”

#include “finiteReco/probability/PhPnhParam.h”

#include “finiteReco/probability/PhPnhMCDist.h”

#include “finiteReco/probability/PhPnhPhotorec.h”

#include “finiteReco/probability/PhPnhPhotorecCone.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 “finiteReco/I3GulliverFinitePhPnh.h”

#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/I3GulliverFinitePhPnh.h”

#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 “finiteReco/I3GulliverFinitePhPnh.h”

#include “finiteReco/I3StartStopLProb.h”

#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 “finiteReco/I3StartStopPoint.h”

#include “finiteReco/I3FiniteCalc.h”

#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 “finiteReco/probability/PhPnhMCDist.h”

#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 “finiteReco/probability/PhPnhProbBase.h”

#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 “finiteReco/probability/PhPnhParam.h”

#include “finiteReco/probability/PhPnhPhotorec.h”

#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 “finiteReco/probability/PhPnhProbBase.h”

#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 “finiteReco/probability/PhPnhPhotorec.h”

#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 “finiteReco/probability/PhPnhProbBase.h”

#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

#include “finiteReco/probability/PhPnhPhotorecCone.h”

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 “finiteReco/probability/PhPnhProbBase.h”

#include “finiteReco/probability/PhPnhPhotorec.h”

#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

#include “finiteReco/probability/PhPnhProbBase.h”

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

finiteReco C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page