rock_bottom C++ API Reference

class EstimateRadioRbParameters : public I3Module

#include <EstimateRadioRbParameters.h>

Public Functions

EstimateRadioRbParameters(const I3Context &context)

inline ~EstimateRadioRbParameters()

void Configure()

void Physics(I3FramePtr frame)

double ScanDx(const double dXEst, const double lgSEst, const double range, const double step, const I3Particle &particle)

double ScanLgS(const double dXEst, const double lgSEst, const double range, const double step, const I3Particle &particle)

Private Functions

SET_LOGGER ("EstimateRadioRbParameters")

Private Members

std::string llhServiceName_

std::string particleName_

std::string outputName_

std::string signalModelName_

I3EventLogLikelihoodBasePtr llhService_

double dXStep_

double lgSStep_

class I3FrontRadioModel : public I3RbSignalModel

#include <I3FrontRadioModel.h>

Public Functions

I3FrontRadioModel(const std::string &name)

I3FrontRadioModel(const I3Context &c)

inline virtual ~I3FrontRadioModel()

virtual void Configure()

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters, steps and bounds.

virtual double TimingLLH(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

inline virtual std::string GetModelName() const

Protected Functions

inline const I3Configuration &GetConfiguration() const

Private Functions

SET_LOGGER ("I3FrontRadioModel")

Private Members

I3RbTimingServicePtr fTimeFcn

class I3FrontScintModel : public I3RbSignalModel

#include <I3FrontScintModel.h>

Public Functions

I3FrontScintModel(const std::string &name)

I3FrontScintModel(const I3Context &c)

inline virtual ~I3FrontScintModel()

virtual void Configure()

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetLogSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetHitProbability(const I3RockBall &ball, const I3EventHypothesis &hypo) const

inline virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters, steps and bounds.

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

virtual double TimingLLH(const I3RockBall &ball, const I3EventHypothesis &hypo) const

inline virtual std::string GetModelName() const

Protected Functions

inline const I3Configuration &GetConfiguration() const

Private Functions

SET_LOGGER ("I3FrontScintModel")

Private Members

I3RbTimingServicePtr fTimeFcn

class I3GaussCurveModel : public I3RbSignalModel

#include <I3GaussCurveModel.h>

Public Functions

I3GaussCurveModel(const std::string &name)

I3GaussCurveModel(const I3Context &c)

inline virtual ~I3GaussCurveModel()

virtual void Configure()

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetLogSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetHitProbability(const I3RockBall &ball, const I3EventHypothesis &hypo) const

inline virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters, steps and bounds.

virtual double TimingLLH(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

inline virtual std::string GetModelName() const

Protected Functions

inline const I3Configuration &GetConfiguration() const

Private Functions

SET_LOGGER ("I3GaussCurveModel")

Private Members

I3RbTimingServicePtr fTimeFcn

class I3LaputopSignalModel : public I3RbSignalModel

#include <I3LaputopSignalModel.h>

Public Functions

I3LaputopSignalModel(const std::string &name)

I3LaputopSignalModel(const I3Context &c)

inline virtual ~I3LaputopSignalModel()

virtual void Configure()

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetLogSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetHitProbability(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters, steps and bounds.

double GetTopSigmaSignal(double signal, double rho) const

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

inline virtual std::string GetModelName() const

Protected Attributes

I3SnowAttenuationServiceBasePtr snow_service_

Private Functions

SET_LOGGER ("I3LaputopSignalModel")

Private Members

I3RbLDFServicePtr fLDF

class I3MultiSurfaceParametrization : public I3ServiceBase, public I3ParametrizationBase

#include <I3MultiSurfaceParametrization.h>

Public Functions

I3MultiSurfaceParametrization(const I3Context &context)

factory constructor (for I3ServiceBase)

I3MultiSurfaceParametrization(const std::string name, const I3MultiSurfaceSeedServicePtr SeedService)

inline ~I3MultiSurfaceParametrization()

inline const std::string GetName() const

void Configure()

configuration (for I3ServiceBase)

void SetSeedServiceVariables()

virtual void InitializeFitParSpecs()

virtual void UpdatePhysicsVariables()

this should calculate datamembers of the I3Particle from the values in par_

this should calculate datamembers of EmissionHypothesis from the values in par_

virtual void UpdateParameters()

This should calculate the values in par_ from datamembers of the I3Particle If relevant it should also update stepsizes.

This should calculate the values in par_ from datamembers of EmissionHypothesis If relevant it should also update stepsizes.

SET_LOGGER ("I3MultiSurfaceParametrization")

Public Members

std::string SeedServiceName_

std::vector<std::string> ParameterNames_

std::vector<double> steps_

std::vector<std::vector<double>> absbounds_

std::vector<std::vector<double>> relbounds_

unsigned int PAR_N

std::vector<bool> free_

I3Position SeedXYZ_

double SeedT_

Private Functions

I3MultiSurfaceParametrization()

I3MultiSurfaceParametrization operator=(const I3MultiSurfaceParametrization &rhs)

Private Members

const std::string name_

I3MultiSurfaceSeedServicePtr seedService_

Seed preparation service.

class I3MultiSurfaceSeedService : public I3SeedServiceBase

#include <I3MultiSurfaceSeedService.h>

Public Functions

I3MultiSurfaceSeedService(const std::string &SeedServiceName, std::vector<std::string> FirstGuessParticleNames, std::vector<std::string> signalModelNames, std::vector<I3RbSignalModelPtr> signalModels, std::string seedsMapName, double ParticleXStep, double ParticleYStep, double ParticleZStep, double ParticleZenStep, double ParticleAziStep, double ParticleTStep, std::vector<double> ParticleXBounds, std::vector<double> ParticleYBounds, std::vector<double> ParticleZBounds, std::vector<double> ParticleZenBounds, std::vector<double> ParticleAziBounds, std::vector<double> ParticleTBounds, std::vector<double> ParticleXRelBounds, std::vector<double> ParticleYRelBounds, std::vector<double> ParticleZRelBounds, std::vector<double> ParticleZenRelBounds, std::vector<double> ParticleAziRelBounds, std::vector<double> ParticleTRelBounds)

constructor

First guesses can refer to either a single I3Particle or I3Vector<I3Particle>. Signal models refer to descriptions of LLH routines for a given detector type. SeedMap is of a RbParameterMap type and contains the first guesses for the step. Users can define absolute bounds and bounds relative to a given seed, as well as step sizes. Zero step size means that the parameter is fixed.

virtual ~I3MultiSurfaceSeedService()

base class destructor (idle)

virtual unsigned int SetEvent(const I3Frame &f)

virtual I3EventHypothesis GetSeed(unsigned int iseed) const

get the seed of the given index

virtual I3EventHypothesis GetDummy() const

get a dummy seed (useful in case of fg failure)

virtual I3EventHypothesis GetCopy(const I3EventHypothesis &eh) const

void GetGuessesFromModels(const I3Frame &f)

void GetParametrization()

void CreateSeedHypothesis(const I3Frame &f)

std::vector<std::string> GetParameterNames()

std::vector<double> GetStepValues()

vecvecd GetBoundsValues()

vecvecd GetRelBoundsValues()

Private Functions

SET_LOGGER ("I3MultiSurfaceSeedService")

Private Members

std::string SeedServiceName_

std::vector<I3EventHypothesis> seeds_

I3Direction dir_

I3RbParameterMapPtr parameterMap_

std::vector<std::string> ParameterNames_

vecvecd absbounds_

vecvecd relbounds_

std::vector<double> steps_

std::vector<std::string> FirstGuessParticleNames_

std::vector<std::string> signalModelNames_

std::vector<I3RbSignalModelPtr> signalModels_

std::string seedsMapName_

double ParticleXStep_

double ParticleYStep_

double ParticleZStep_

double ParticleZenStep_

double ParticleAziStep_

double ParticleTStep_

std::vector<double> ParticleXBounds_

std::vector<double> ParticleYBounds_

std::vector<double> ParticleZBounds_

std::vector<double> ParticleZenBounds_

std::vector<double> ParticleAziBounds_

std::vector<double> ParticleTBounds_

std::vector<double> ParticleXRelBounds_

std::vector<double> ParticleYRelBounds_

std::vector<double> ParticleZRelBounds_

std::vector<double> ParticleZenRelBounds_

std::vector<double> ParticleAziRelBounds_

std::vector<double> ParticleTRelBounds_

class I3MultiSurfaceSeedServiceFactory : public I3ServiceFactory

#include <I3MultiSurfaceSeedServiceFactory.h>

Public Functions

I3MultiSurfaceSeedServiceFactory(const I3Context &context)

constructors

virtual ~I3MultiSurfaceSeedServiceFactory()

destructor

virtual bool InstallService(I3Context &ctx)

Installed this objects service into the specified services object.

Parameters:

ctx – the I3Context 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

I3MultiSurfaceSeedServiceFactory(const I3MultiSurfaceSeedServiceFactory &rhs)

I3MultiSurfaceSeedServiceFactory operator=(const I3MultiSurfaceSeedServiceFactory &rhs)

no copy constructor

SET_LOGGER ("I3MultiSurfaceSeedServiceFactory")

Private Members

std::vector<std::string> FirstGuessParticleNames_

no assignment operator

std::vector<std::string> signalModelNames_

std::vector<I3RbSignalModelPtr> signalModels_

std::string seedsMapName_

double ParticleXStep_

double ParticleYStep_

double ParticleZStep_

double ParticleZenStep_

double ParticleAziStep_

double ParticleTStep_

std::vector<double> ParticleXBounds_

std::vector<double> ParticleYBounds_

std::vector<double> ParticleZBounds_

std::vector<double> ParticleZenBounds_

std::vector<double> ParticleAziBounds_

std::vector<double> ParticleTBounds_

std::vector<double> ParticleXRelBounds_

std::vector<double> ParticleYRelBounds_

std::vector<double> ParticleZRelBounds_

std::vector<double> ParticleZenRelBounds_

std::vector<double> ParticleAziRelBounds_

std::vector<double> ParticleTRelBounds_

std::string SeedServiceName_

I3SeedServiceBasePtr SeedService_

name of this service

unsigned int nContext_

class I3RadioSignalModel : public I3RbSignalModel

#include <I3RadioSignalModel.h>

Public Functions

I3RadioSignalModel(const std::string &name)

I3RadioSignalModel(const I3Context &c)

inline virtual ~I3RadioSignalModel()

virtual void Configure()

virtual double GetSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetLogSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters, steps and bounds.

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

inline virtual std::string GetModelName() const

void LoadParametersFromFile(std::string filename, vecvecd &pars)

double Polynomial(const double x, const std::vector<double> &pars) const

Private Functions

SET_LOGGER ("I3RadioSignalModel")

Private Members

I3RbLDFServicePtr fLDF

std::string fMeanParFilename

std::string fSigmaParFilename

vecvecd fMeanPars

vecvecd fSigmaPars

double fMinFluence

double fMaxFluence

class I3RbGeoCe : public I3RbLDFService

#include <I3RbGeoCe.h>

Public Functions

I3RbGeoCe()

inline virtual ~I3RbGeoCe()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

Private Functions

void LoadNormalizationFromFile(const std::string &filename, std::vector<double> &dx, std::vector<double> &norm)

void LoadParametersFromFile(const std::string &filename, vecvecd &pars)

void LoadChargeExcessFractionFromFile(std::string filename)

double Polynomial(const double x, const std::vector<double> &pars) const

double ModifiedGaussian(const double r, const double mu, const double sig, const double power) const

double ModifiedErf(const double x) const

double GeomagneticShape(const double r, const double dX) const

double ChargeExcessShape(const double r, const double dX) const

double GetCEFrac(const double dX, const double alpha, const double sec) const

std::vector<double> GetPars(double dX, vecvecd) const

double Interpolate(const double x, const std::vector<double> xx, const std::vector<double> yy) const

Private Members

std::vector<double> geoDx_

std::vector<double> geoNorm_

vecvecd geoPolyPars_

std::vector<double> ceDx_

std::vector<double> ceNorm_

vecvecd cePolyPars_

std::vector<double> ceDxPolyPars_

std::vector<double> ceSecPolyPars_

class I3RbLagutin : public I3RbLDFService

#include <I3RbLagutin.h>

Public Functions

I3RbLagutin()

inline virtual ~I3RbLagutin()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

Private Functions

double GetBeta(double zenith) const

double GetGamma(double zenith) const

class I3RbLDFLikelihood : public I3RbLikelihoodBase

#include <I3RbLDFLikelihood.h>

Public Functions

I3RbLDFLikelihood(const I3Context &c)

inline ~I3RbLDFLikelihood()

DECLARE_WRAPPED(IceTop)

DECLARE_WRAPPED(Scint)

DECLARE_WRAPPED(Radio)

SET_LOGGER ("RockBottom")

class I3RbLDFService

#include <I3RbLDFService.h>

Subclassed by I3RbGeoCe, I3RbLagutin, I3RbLogLog, I3RbMuonLDF, I3RbNKG, I3RbTwoGauss

Public Functions

inline I3RbLDFService()

inline virtual ~I3RbLDFService()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const = 0

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const = 0

Protected Functions

SET_LOGGER ("RockBottom")

class I3RbLikelihoodBase : public I3ServiceBase, public I3EventLogLikelihoodBase

#include <I3RbLikelihoodBase.h>

Subclassed by I3RbLDFLikelihood, I3RbTimingLikelihood

Public Functions

I3RbLikelihoodBase(const I3Context &c)

virtual void Configure()

inline virtual const std::string GetName() const

virtual void SetGeometry(const I3Geometry &geometry)

virtual void SetEvent(const I3Frame &frame)

virtual double GetLogLikelihood(const I3EventHypothesis &ehypo)

virtual unsigned int GetMultiplicity()

unsigned int GetNumberOfActiveDetectors()

DECLARE_WRAPPED(IceTop, I3RecoPulseSeriesMap)

DECLARE_WRAPPED(Scint, I3ScintRecoPulseSeriesMap)

DECLARE_WRAPPED(Radio, I3AntennaDataMap)

I3RecoPulseSeriesMap MergeIceTopPulses(const I3Frame &frame, I3RecoPulseSeriesMap pulses1, I3RecoPulseSeriesMap pulses2) const

Variables for IceTop.

I3VectorI3Position GetOMPosition(const I3Frame &frame, I3RecoPulseSeriesMap &pulseMap) const

SET_LOGGER ("RockBottom")

Public Members

rock_bottom::DetectorTypes fCurrentType

I3RbSignalModelPtr fSignalModel

bool fUseSilent

Variables for all/many detector types.

bool ToprecRepeat

double fMinSignal

double fMinSignal2

double fMaxTime

double fLateralMin

double fLateralMax

bool fUseSaturated

bool fUseLLHPenalty

I3ParticlePtr fParticle

I3RbParameterMapPtr fParameterMap

std::string fPulsesName1

std::string fPulsesName2

std::string fBadDetectorsName

std::string fSaturatedDetectorsName

std::string fDetectorResponseName

double fLowGainSaturationThreshold

double lgS_opt

std::map<TankKey, I3TankGeo> fStations

I3VectorTankKey fBadTanks

I3VectorTankKey fSilentTanks1

I3VectorTankKey fSilentTanks2

I3RecoPulseSeriesMap fPulseSeries1

I3RecoPulseSeriesMap fPulseSeries2

I3RecoPulseSeriesMap fSaturatedSeries

I3RecoPulseSeriesMap fSaturatedSeries1

I3RecoPulseSeriesMap fSaturatedSeries2

I3VectorI3Position fPulseSeriesDOMs1

I3VectorI3Position fPulseSeriesDOMs2

I3VectorI3Position fSaturatedDOMs1

I3VectorI3Position fSaturatedDOMs2

I3VectorI3Position fSaturatedDOMs

I3VectorI3Position fSilentDOMs1

I3VectorI3Position fSilentDOMs2

std::vector<double> fSilentSnow1

std::vector<double> fSilentSnow2

std::vector<int> fSilentStations2

std::vector<int> fStations1

std::vector<int> fStations2

I3CalibrationConstPtr fCalibration

I3DetectorStatusConstPtr fStatus

I3VectorScintKey fSilentScint

Variables for Scint.

std::map<ScintKey, I3ScintGeo> fScintOMGeo

I3ScintRecoPulseSeriesMap fScintPulseSeries

I3ScintRecoPulseSeriesMap fSaturatedScints

I3ScintRecoPulseSeriesMap fScintSaturatedSeries

I3ScintRecoPulseSeriesMap fBadScints

I3VectorAntennaKey fSilentAntennaKeys

Variables for Radio.

I3AntennaResponsePtr fAntennaResponse

I3AntennaDataMap fAntennaDataMap

I3AntennaGeoMap fAntennaGeo

class I3RbLogLog : public I3RbLDFService

#include <I3RbLogLog.h>

Public Functions

I3RbLogLog()

inline virtual ~I3RbLogLog()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

class I3RbMuonLDF : public I3RbLDFService

#include <I3RbMuonLDF.h>

Public Functions

I3RbMuonLDF()

inline virtual ~I3RbMuonLDF()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

Private Functions

double GetBeta(double zenith) const

double GetGamma(double zenith) const

class I3RbNKG : public I3RbLDFService

#include <I3RbNKG.h>

Public Functions

I3RbNKG()

inline virtual ~I3RbNKG()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

class I3RbParameterMap : public I3FrameObject

#include <I3RbParameterMap.h>

Public Functions

inline I3RbParameterMap()

inline I3RbParameterMap(rock_bottom::OuterMap parameters)

inline I3RbParameterMap(const I3RbParameterMap &map)

inline ~I3RbParameterMap()

inline rock_bottom::OuterMap GetMap() const

unsigned int GetSize() const

double GetParameterByName(std::string n, std::string d, int i) const

void SetParameterByName(std::string parName, std::string modelName, int i, double val)

double HasParameter(std::string n, std::string d, int i) const

inline void GetCopy(rock_bottom::OuterMap &omap) const

std::vector<std::string> ConvertToArrayNames()

std::vector<double> ConvertToArrayValues()

double HasParameterByString(std::string n) const

double GetParameterByString(std::string n) const

void SetParameterByString(std::string n, double v)

template<class Archive>
void serialize(Archive &ar, unsigned version)

inline I3RbParameterMap &operator=(const I3RbParameterMap &map)

Private Members

rock_bottom::OuterMap fParameters

class I3RbSeeds : public I3Module

#include <I3RbSeeds.h>

Public Functions

I3RbSeeds(const I3Context &context)

inline ~I3RbSeeds()

void Configure()

void Geometry(I3FramePtr frame)

void Physics(I3FramePtr frame)

Private Functions

bool COG()

bool PlaneFront()

bool GetlgSref(const I3Particle &particle)

Iterate over pulses, calculate radial distance based on seed values and take as Sref seed the average (above certain distance)

SET_LOGGER ("I3RbSeeds")

Private Members

std::string inputName_

std::string geoName_

std::string modelName_

std::string mapName_

std::string outputName_

long unsigned int detCondition_

double powerCOG_

bool fixSigmaPlane_

double powerPlane_

double sigmaPlane_

bool multi_

std::vector<double> rhoRange_

I3Position core_

double timeCOG_

double coreTime_

I3Direction showerDirection_

double lgSref_

I3Geometry geo_

I3GeometryConstPtr geo_ptr

bool statusCore_

bool statusDirection_

I3VectorI3Position positions

std::vector<double> charges

std::vector<double> times

unsigned int pulse_size

bool scint_

class I3RbSignalModel : public I3ServiceBase

#include <I3RbSignalModel.h>

Interface class to provide a likelihood model of the shower parameters.

This class knows nothing of the IceTray/IceTop/IceCube data structures, HLCs, SLCs, whatever. It only deals with the model of the air shower and the response of a single tank. It encapsulates things like the LDF, the hit/no-hit probability, the snow correction, and saturation effects.

To set the parameters, this class uses I3EventHypothesis. It abuses the nonStd data member for all the extra information that is required (LDF parameters, muon fraction…) so it is trivial to use it with a Gulliver likelihood. We can consider subclassing I3EventHypothesis.

This interface takes I3TankGeo references mostly for snowhight, and I3VEMCalibration references mostly for pePerVEM and corrFactor. Maybe this requires some thinking.

To implement your own, just inherit from this class and add something like the following to your implementation file: typedef I3SingleServiceFactory<I3LaputopSignalModel, I3RbSignalModel> LaputopSignalModel; I3_SERVICE_FACTORY(LaputopSignalModel);

Subclassed by I3FrontRadioModel, I3FrontScintModel, I3GaussCurveModel, I3LaputopSignalModel, I3RadioSignalModel, I3ScintSignalModel, I3SkeletonSignalModel, I3TwoLDFSignalModel

Public Functions

inline I3RbSignalModel(const std::string &name)

inline I3RbSignalModel(const I3Context &c)

inline virtual ~I3RbSignalModel()

void SetParameters(const I3EventHypothesis &ehypo)

void AddPulses(I3RecoPulseSeriesMap *pulses)

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall&, const I3EventHypothesis &hypo) const

virtual double GetLogSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetHitProbability(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double TimingLLH(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

virtual void SetBound(std::vector<std::string> parameterList, vecvecd &emptyList, std::string name, int index, double boundLower, double boudnUpper) const

virtual void SetStep(std::vector<std::string> parameterList, std::vector<double> &emptyList, std::string name, int index, double step) const

virtual void GetBoundsFromUser(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual void GetRelBoundsFromUser(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual void GetStepsFromUser(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

void InitializeModelParameters(I3RbParameterMapPtr &MasterParameterMap, I3RbParameterMapPtr defaultMap) const

virtual std::string GetModelName() const = 0

Protected Functions

inline const I3Configuration &GetConfiguration()

inline const I3Configuration &GetConfiguration() const

void DefaultConstruction()

void DefaultConfigure()

SET_LOGGER ("RockBottom")

Protected Attributes

I3ParticlePtr fParticle

I3RbParameterMapPtr fParameterMap

std::vector<std::pair<std::string, int>> fParameterNames

std::vector<double> fParameterValues

std::vector<std::pair<std::string, int>> fBoundNames

vecvecd fBoundValues

std::vector<std::pair<std::string, int>> fRelBoundNames

vecvecd fRelBoundValues

std::vector<std::pair<std::string, int>> fStepNames

std::vector<double> fStepValues

class I3RbTimeGauss : public I3RbTimingService

#include <I3RbTimeGauss.h>

Public Functions

I3RbTimeGauss()

inline virtual ~I3RbTimeGauss()

virtual double GetExpectedTime(const I3Position &pos, const I3Particle &shower, const I3RbParameterMap &paramMap, std::string model) const

class I3RbTimeHyperbola : public I3RbTimingService

#include <I3RbTimeHyperbola.h>

Public Functions

I3RbTimeHyperbola()

inline virtual ~I3RbTimeHyperbola()

virtual double GetExpectedTime(const I3Position &pos, const I3Particle &shower, const I3RbParameterMap &paramMap, std::string model) const

class I3RbTimeParabola : public I3RbTimingService

#include <I3RbTimeParabola.h>

Public Functions

I3RbTimeParabola()

inline virtual ~I3RbTimeParabola()

virtual double GetExpectedTime(const I3Position &pos, const I3Particle &shower, const I3RbParameterMap &paramMap, std::string model) const

class I3RbTimePlane : public I3RbTimingService

#include <I3RbTimePlane.h>

Public Functions

I3RbTimePlane()

inline virtual ~I3RbTimePlane()

virtual double GetExpectedTime(const I3Position &pos, const I3Particle &shower, const I3RbParameterMap &paramMap, std::string model) const

class I3RbTimingLikelihood : public I3RbLikelihoodBase

#include <I3RbTimingLikelihood.h>

Public Functions

I3RbTimingLikelihood(const I3Context &c)

inline ~I3RbTimingLikelihood()

DECLARE_WRAPPED(IceTop)

DECLARE_WRAPPED(Scint)

DECLARE_WRAPPED(Radio)

SET_LOGGER ("RockBottom")

class I3RbTimingService

#include <I3RbTimingService.h>

Subclassed by I3RbTimeGauss, I3RbTimeHyperbola, I3RbTimeParabola, I3RbTimePlane

Public Functions

inline I3RbTimingService()

inline virtual ~I3RbTimingService()

virtual double GetExpectedTime(const I3Position &pos, const I3Particle &shower, const I3RbParameterMap &paramMap, std::string model) const = 0

inline void SetParameters(const I3RbParameterMap &paramMap)

Protected Functions

SET_LOGGER ("RockBottom")

Protected Attributes

rock_bottom::OuterMap fParameterMap

class I3RbTwoGauss : public I3RbLDFService

#include <I3RbTwoGauss.h>

Public Functions

I3RbTwoGauss()

inline virtual ~I3RbTwoGauss()

virtual double GetSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

virtual double GetLogSignal(const I3Position &detPos, const I3Particle &shower, bool zenith_dependence, const I3RbParameterMap &paramMap, std::string model) const

class I3RockBall

#include <I3RockBall.h>

Public Functions

I3RockBall()

I3RockBall(const I3RockBall &ball)

inline ~I3RockBall()

void SetTankGeo(const I3TankGeo tankGeo)

const I3TankGeo GetTankGeo() const

void SetVEMCalibration(const I3VEMCalibration vemCalib)

const I3VEMCalibration GetVEMCalibration() const

void SetPosition(const I3Position pos)

const I3Position GetPosition() const

void SetSaturatedStatus(bool x)

const bool GetSaturatedStatus() const

void SetCharge(double x)

const double GetCharge() const

void SetTime(double x)

const double GetTime() const

void SetLdfFlag(int x)

const double GetLdfFlag() const

Private Members

I3TankGeo fTankGeo

I3VEMCalibration fVemCal

I3Position fPos

bool fIsSaturated

double fCharge

double fTime

int fLdfFlag

class I3ScintSignalModel : public I3RbSignalModel

#include <I3ScintSignalModel.h>

Public Functions

I3ScintSignalModel(const std::string &name)

I3ScintSignalModel(const I3Context &c)

inline virtual ~I3ScintSignalModel()

virtual void Configure()

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetLogSignalMean(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetHitProbability(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters + from user set in python code.

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

Setting default absolute bounds + from user set in python code.

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

Setting default relative bounds + from user set in python code.

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

Setting default steps + from user set in python code.

inline virtual std::string GetModelName() const

Private Functions

SET_LOGGER ("I3ScintSignalModel")

Private Members

I3RbLDFServicePtr fLDF

class I3SkeletonSignalModel : public I3RbSignalModel

#include <SkeletonSignalModel.h>

Public Functions

I3SkeletonSignalModel(const std::string &name)

I3SkeletonSignalModel(const I3Context &c)

inline virtual ~I3SkeletonSignalModel()

virtual void Configure()

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall &ball) const

virtual double GetLogSignalMean(const I3RockBall &ball) const

virtual double GetHitProbability(const I3RockBall &ball) const

virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball) const

virtual double TimingLLH(const I3RockBall &ball, const I3EventHypothesis &hypo, const double rho) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters + from user set in python code.

virtual std::vector<std::vector<double>> GetBounds(std::vector<std::string> parameterList, std::vector<std::vector<double>> &emptyList) const

Setting default absolute bounds + from user set in python code.

virtual std::vector<std::vector<double>> GetRelBounds(std::vector<std::string> parameterList, std::vector<std::vector<double>> &emptyList) const

Setting default relative bounds + from user set in python code.

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

Setting default steps + from user set in python code.

inline virtual std::string GetModelName() const

Private Functions

SET_LOGGER ("I3SkeletonSignalModel")

Private Members

I3RbLDFServicePtr fLDF

class I3TwoLDFSignalModel : public I3RbSignalModel

#include <I3TwoLDFSignalModel.h>

Public Functions

I3TwoLDFSignalModel(const std::string &name)

I3TwoLDFSignalModel(const I3Context &c)

inline virtual ~I3TwoLDFSignalModel()

virtual void Configure()

virtual double GetSignalCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogCumulativeProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalMean(const I3RockBall &bal, const I3EventHypothesis &hypol) const

virtual double GetLogSignalMean(const I3RockBall&, const I3EventHypothesis &hypo) const

virtual double GetHitProbability(const I3RockBall &bal, const I3EventHypothesis &hypo) const

virtual double GetSignalProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalLogProbability2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double CalcChi2(const I3RockBall &ball, const I3EventHypothesis &hypo, double signal) const

virtual double GetSignalVariance(const I3RockBall &ball, const I3EventHypothesis &hypo) const

virtual void FillInParameters(I3RbParameterMapPtr &masterParameterMap) const

Setting default parameters, steps and bounds.

double GetEMSignalLogProbability(double s, double mean_s, double zenith, double rho, const I3EventHypothesis &hypo) const

double GetMuonSignalLogProbability(double s, double mean_n, double zenith, std::string tank_type) const

double GetEMSignalProbability(double s, double mean_s, double zenith, double rho, const I3EventHypothesis &hypo) const

double GetMuonSignalProbability(double s, double mean_n, double zenith, std::string tank_type) const

double GetMuonSignalProbability2(double s, int n, double zenith, std::string tank_type) const

double GetMuonSignalLogProbability2(double s, int n, double zenith, std::string tank_type) const

void InitTankResponse(const std::string &dir)

double GetTopSigmaSignal(double signal, double rho) const

virtual vecvecd GetBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual vecvecd GetRelBounds(std::vector<std::string> parameterList, vecvecd &emptyList) const

virtual std::vector<double> GetSteps(std::vector<std::string> parameterList, std::vector<double> &emptyList) const

inline virtual std::string GetModelName() const

Protected Functions

double TankResponseGetMuonMean(double zenith, int n) const

double TankResponseGetMuonWidth(double zenith, int n) const

Protected Attributes

double uptime_

std::vector<double> ltp_params_

std::vector<boost::shared_ptr<photospline::splinetable<>>> muon_responses_

boost::shared_ptr<photospline::splinetable<>> muon_response_mean_

boost::shared_ptr<photospline::splinetable<>> muon_response_width_

bool zenith_dependence_

I3SnowAttenuationServiceBasePtr snow_service_

Private Functions

SET_LOGGER ("I3TwoLDFSignalModel")

Private Members

I3RbLDFServicePtr femLDF

I3RbLDFServicePtr fmuLDF

namespace rock_bottom

Typedefs

typedef std::pair<std::string, int> ParIndex

typedef I3Map<ParIndex, double> InnerMap

typedef I3Map<std::string, InnerMap> OuterMap

Enums

enum DetectorTypes

Values:

enumerator IceTop

enumerator Scint

enumerator Radio

enumerator NDetectorTypes

Functions

void RbDelimiterCheck(std::string parName, std::string modelName)

double GetDistToAxis(const I3Particle &particle, const I3Position &pos)

double GetDistToPlane(const I3Particle &particle, const I3Position &pos, const double time)

double GetTimeToShowerPlane(const I3Particle &particle, const I3Position &pos, const double time)

bool CheckIfExsitsInFrame(const I3Frame &frame, std::string name, bool doFatal, std::string objType)

I3LaputopParams ConvertRbtoLaputopParams(I3Particle &particle, I3RbParameterMap &rbMap)

Variables

const char RbDelimiter = '@'

namespace std

STL namespace.

file EstimateRadioRbParameters.cxx

#include “rock_bottom/modules/EstimateRadioRbParameters.h”

#include <icetray/I3Logging.h>

Functions

I3_MODULE(EstimateRadioRbParameters)

file EstimateRadioRbParameters.h

#include <icetray/I3Module.h>

#include “rock_bottom/I3RbParameterMap.h”

#include “rock_bottom/interface/I3RbLDFLikelihood.h”

file I3FrontRadioModel.cxx

#include <rock_bottom/models/radio/I3FrontRadioModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

#include <radcube/util/RadUtility.h>

Typedefs

typedef I3SingleServiceFactory<I3FrontRadioModel, I3RbSignalModel> FrontRadioModel

using vecvecd = std::vector<std::vector<double>>

Functions

I3_SERVICE_FACTORY(FrontRadioModel)

file I3FrontRadioModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3RbTimingService.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3FrontRadioModel)

file I3FrontScintModel.cxx

#include <rock_bottom/models/scint/I3FrontScintModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

Typedefs

typedef I3SingleServiceFactory<I3FrontScintModel, I3RbSignalModel> FrontScintModel

using vecvecd = std::vector<std::vector<double>>

Functions

I3_SERVICE_FACTORY(FrontScintModel)

file I3FrontScintModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3RbTimingService.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3FrontScintModel)

file I3GaussCurveModel.cxx

#include <rock_bottom/models/icetop/I3GaussCurveModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

Typedefs

typedef I3SingleServiceFactory<I3GaussCurveModel, I3RbSignalModel> GaussCurveModel

using vecvecd = std::vector<std::vector<double>>

Functions

I3_SERVICE_FACTORY(GaussCurveModel)

file I3GaussCurveModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3RbTimingService.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3GaussCurveModel)

file I3IceTopBaseLikelihood.cxx

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

Variables

const double SAT_LG = 90000.

file I3IceTopLDFLikelihood.cxx

#include <rock_bottom/interface/I3RbLDFLikelihood.h>

#include <rock_bottom/interface/I3RockBall.h>

#include <gulliver/I3EventHypothesis.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <icetray/I3SingleServiceFactory.h>

#include <dataclasses/TankKey.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/status/I3DOMStatus.h>

#include <math.h>

#include <boost/limits.hpp>

file I3IceTopTimingLikelihood.cxx

#include <rock_bottom/interface/I3RbTimingLikelihood.h>

file I3LaputopSignalModel.cxx

#include <rock_bottom/models/icetop/I3LaputopSignalModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

#include <rock_bottom/LaputopConverter.h>

#include <toprec/tankPulse.h>

Typedefs

typedef I3SingleServiceFactory<I3LaputopSignalModel, I3RbSignalModel> LaputopSignalModel

using vecvecd = std::vector<std::vector<double>>

Functions

I3_SERVICE_FACTORY(LaputopSignalModel)

file I3LaputopSignalModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3RbLDFService.h>

#include <toprec/I3SnowAttenuationService.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3LaputopSignalModel)

file I3MultiSurfaceParametrization.cxx

#include “dataclasses/physics/I3Particle.h”

#include “dataclasses/I3Position.h”

#include “dataclasses/I3Direction.h”

#include “icetray/I3SingleServiceFactory.h”

#include “icetray/I3Logging.h”

#include “icetray/I3Module.h”

#include <string>

#include <map>

#include <vector>

#include <cmath>

#include “rock_bottom/lilliput/I3MultiSurfaceParametrization.h”

#include “gulliver/I3EventHypothesis.h”

#include “gulliver/I3Gulliver.h”

#include “rock_bottom/I3RbParameterMap.h”

#include <rock_bottom/interface/I3RbSignalModel.h>

Typedefs

typedef I3SingleServiceFactory<I3MultiSurfaceParametrization, I3ParametrizationBase> I3MultiSurfaceParametrizationFactory

Functions

I3_SERVICE_FACTORY(I3MultiSurfaceParametrizationFactory)

file I3MultiSurfaceParametrization.h

#include <bitset>

#include <string>

#include <vector>

#include “gulliver/I3ParametrizationBase.h”

#include “gulliver/I3SeedServiceBase.h”

#include “dataclasses/physics/I3Particle.h”

#include “dataclasses/I3Position.h”

#include “dataclasses/I3Direction.h”

#include “icetray/I3ServiceBase.h”

#include “icetray/I3Logging.h”

#include “rock_bottom/lilliput/I3MultiSurfaceSeedService.h”

Functions

I3_POINTER_TYPEDEFS(I3MultiSurfaceParametrization)

file I3MultiSurfaceSeedService.cxx

#include <cmath>

#include <vector>

#include <string>

#include <list>

#include “rock_bottom/lilliput/I3MultiSurfaceParametrization.h”

#include “rock_bottom/lilliput/I3MultiSurfaceSeedService.h”

#include “icetray/I3Frame.h”

#include “icetray/I3FrameObject.h”

#include “icetray/I3Units.h”

#include “phys-services/I3Cuts.h”

#include “phys-services/I3Calculator.h”

#include “rock_bottom/I3RbParameterMap.h”

#include <dataclasses/physics/I3Particle.h>

#include <icetray/I3SingleServiceFactory.h>

#include <rock_bottom/interface/I3RbSignalModel.h>

#include “dataclasses/physics/I3RecoHit.h”

#include “dataclasses/physics/I3RecoPulse.h”

Typedefs

using vecvecd = std::vector<std::vector<double>>

file I3MultiSurfaceSeedService.h

#include <vector>

#include <string>

#include “boost/shared_ptr.hpp”

#include <rock_bottom/interface/I3RbSignalModel.h>

#include “icetray/IcetrayFwd.h”

#include “icetray/I3DefaultName.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “dataclasses/physics/I3RecoHit.h”

#include “dataclasses/physics/I3RecoPulse.h”

#include “gulliver/I3SeedServiceBase.h”

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3MultiSurfaceSeedService)

I3_DEFAULT_NAME(I3MultiSurfaceSeedService)

file I3MultiSurfaceSeedServiceFactory.cxx

#include “rock_bottom/lilliput/I3MultiSurfaceSeedServiceFactory.h”

#include “rock_bottom/lilliput/I3MultiSurfaceSeedService.h”

#include “toprec/I3LaputopSeedService.h”

#include <rock_bottom/interface/I3RbSignalModel.h>

#include “icetray/IcetrayFwd.h”

Defines

INITALL(name)

INITALL(name)

file I3MultiSurfaceSeedServiceFactory.h

#include <string>

#include “icetray/IcetrayFwd.h”

#include “icetray/I3ServiceFactory.h”

#include “gulliver/I3SeedServiceBase.h”

#include “rock_bottom/lilliput/I3MultiSurfaceSeedService.h”

#include <rock_bottom/interface/I3RbSignalModel.h>

file I3MyDetBaseLikelihood.cxx

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

file I3MyDetLDFLikelihood.cxx

#include <rock_bottom/interface/I3RbLDFLikelihood.h>

file I3MyDetTimingLikelihood.cxx

#include <rock_bottom/interface/I3RbTimingLikelihood.h>

file I3RadioBaseLikelihood.cxx

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

#include <radcube/util/RadUtility.h>

file I3RadioLDFLikelihood.cxx

#include <rock_bottom/interface/I3RbLDFLikelihood.h>

#include <radcube/util/CoordinateSystem.h>

#include <radcube/util/FFTTools.h>

file I3RadioSignalModel.cxx

#include <rock_bottom/models/radio/I3RadioSignalModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

Typedefs

typedef I3SingleServiceFactory<I3RadioSignalModel, I3RbSignalModel> RadioSignalModel

using vecvecd = std::vector<std::vector<double>>

Functions

I3_SERVICE_FACTORY(RadioSignalModel)

file I3RadioSignalModel.h

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/I3Vector.h>

#include <string>

#include <vector>

#include <fstream>

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3RbLDFService.h>

#include <cmath>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3RadioSignalModel)

file I3RadioTimingLikelihood.cxx

#include <rock_bottom/interface/I3RbTimingLikelihood.h>

#include <dataclasses/fft/FFTHilbertEnvelope.h>

file I3RbGeoCe.cxx

#include <rock_bottom/functions/I3RbGeoCe.h>

#include <boost/filesystem.hpp>

#include <cmath>

#include <fstream>

#include <icetray/I3Logging.h>

#include <radcube/util/CoordinateSystem.h>

#include <rock_bottom/I3RbUtilities.h>

file I3RbGeoCe.h

#include <rock_bottom/interface/I3RbLDFService.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3RbGeoCe)

file I3RbLagutin.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbLagutin.h>

#include <gsl/gsl_sf_gamma.h>

#include <gsl/gsl_sf_hyperg.h>

#include <cmath>

file I3RbLagutin.h

#include <rock_bottom/interface/I3RbLDFService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbLagutin)

file I3RbLDFLikelihood.cxx

#include <rock_bottom/interface/I3RbLDFLikelihood.h>

#include <icetray/I3SingleServiceFactory.h>

Typedefs

typedef I3SingleServiceFactory<I3RbLDFLikelihood, I3EventLogLikelihoodBase> I3RbLDFLikelihoodFactory

Functions

I3_SERVICE_FACTORY(I3RbLDFLikelihoodFactory)

file I3RbLDFLikelihood.h

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

Defines

DECLARE_WRAPPED(detType)

Functions

I3_POINTER_TYPEDEFS(I3RbLDFLikelihood)

file I3RbLDFService.h

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/I3Vector.h>

#include <gulliver/I3EventHypothesis.h>

#include <string>

#include <rock_bottom/I3RbParameterMap.h>

#include <rock_bottom/I3RbUtilities.h>

#include <dataclasses/I3MapOMKeyMask.h>

Functions

I3_POINTER_TYPEDEFS(I3RbLDFService)

file I3RbLikelihoodBase.cxx

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

file I3RbLikelihoodBase.h

#include <gulliver/I3EventLogLikelihoodBase.h>

#include <icetray/I3ServiceBase.h>

#include <icetray/I3SingleServiceFactory.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/geometry/I3TankGeo.h>

#include <gulliver/I3EventHypothesis.h>

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <radcube/services/I3AntennaResponse.h>

Defines

DECLARE_WRAPPED(detType, waveformType)

Functions

I3_POINTER_TYPEDEFS(I3RbLikelihoodBase)

file I3RbLogLog.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbLogLog.h>

#include <cmath>

file I3RbLogLog.h

#include <rock_bottom/interface/I3RbLDFService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbLogLog)

file I3RbMuonLDF.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbMuonLDF.h>

#include <cmath>

file I3RbMuonLDF.h

#include <rock_bottom/interface/I3RbLDFService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbMuonLDF)

file I3RbNKG.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbNKG.h>

#include <cmath>

file I3RbNKG.h

#include <rock_bottom/interface/I3RbLDFService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbNKG)

file I3RbParameterMap.cxx

#include <rock_bottom/I3RbParameterMap.h>

Functions

I3_SERIALIZABLE(I3RbParameterMap)

std::ostream &operator<<(std::ostream &os, const I3RbParameterMap &map)

file I3RbParameterMap.h

#include <icetray/I3FrameObject.h>

#include <icetray/I3PointerTypedefs.h>

#include <dataclasses/I3Vector.h>

#include <dataclasses/I3Map.h>

#include <string>

#include <sstream>

#include <algorithm>

#include <map>

#include <iostream>

#include <rock_bottom/I3RbUtilities.h>

Functions

std::ostream &operator<<(std::ostream &os, const I3RbParameterMap &map)

I3_POINTER_TYPEDEFS(I3RbParameterMap)

I3_CLASS_VERSION(I3RbParameterMap, i3rbparametermap_version_)

Variables

static const unsigned i3rbparametermap_version_ = 1

file I3RbSeeds.cxx

#include “rock_bottom/modules/I3RbSeeds.h”

#include “rock_bottom/I3RbUtilities.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “dataclasses/physics/I3RecoHit.h”

#include “dataclasses/physics/I3RecoPulse.h”

#include “dataclasses/physics/I3Particle.h”

#include “dataclasses/I3Double.h”

#include <phys-services/I3ScaleCalculator.h>

#include <cmath>

#include <typeinfo>

#include <variant>

Functions

I3_MODULE(I3RbSeeds)

README:

file I3RbSeeds.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include “rock_bottom/I3RbParameterMap.h”

#include “dataclasses/physics/I3Particle.h”

#include “dataclasses/physics/I3RecoHit.h”

#include “dataclasses/physics/I3RecoPulse.h”

#include “dataclasses/geometry/I3Geometry.h”

#include <dataclasses/physics/I3ScintRecoPulseSeriesMap.h>

#include <phys-services/I3ScaleCalculator.h>

#include “boost/variant.hpp”

copyright (C) 2019

The Icecube Collaboration

Rcs

I3RbSeeds.h 173728 2019-06-04 17:46:14Z dsoldin

Last changed by

on

Author

Agnieszka Leszchynska

Date

1 Nov 2019

Version

Rcs

173728

Rcs

dsoldin

Rcs

2019-06-04 19:46:14 +0200 (Di, 04 Jun 2019)

file I3RbSignalModel.cxx

#include <rock_bottom/interface/I3RbSignalModel.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

file I3RbSignalModel.h

#include <rock_bottom/I3RbParameterMap.h>

#include “rock_bottom/modules/I3RbSeeds.h”

#include <dataclasses/I3MapOMKeyMask.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <rock_bottom/interface/I3RockBall.h>

#include <gulliver/I3EventHypothesis.h>

#include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

#include <icetray/I3ServiceBase.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3RbSignalModel)

file I3RbTimeGauss.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbTimeGauss.h>

#include <cmath>

file I3RbTimeGauss.h

#include <rock_bottom/interface/I3RbTimingService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbTimeGauss)

file I3RbTimeHyperbola.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbTimeHyperbola.h>

#include <cmath>

file I3RbTimeHyperbola.h

#include <rock_bottom/interface/I3RbTimingService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbTimeHyperbola)

file I3RbTimeParabola.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbTimeParabola.h>

#include <cmath>

file I3RbTimeParabola.h

#include <rock_bottom/interface/I3RbTimingService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbTimeParabola)

file I3RbTimePlane.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbTimePlane.h>

#include <cmath>

file I3RbTimePlane.h

#include <rock_bottom/interface/I3RbTimingService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbTimePlane)

file I3RbTimingLikelihood.cxx

#include <rock_bottom/interface/I3RbTimingLikelihood.h>

#include <icetray/I3SingleServiceFactory.h>

Typedefs

typedef I3SingleServiceFactory<I3RbTimingLikelihood, I3EventLogLikelihoodBase> I3RbTimingLikelihoodFactory

Functions

I3_SERVICE_FACTORY(I3RbTimingLikelihoodFactory)

file I3RbTimingLikelihood.h

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

Defines

DECLARE_WRAPPED(detType)

Functions

I3_POINTER_TYPEDEFS(I3RbTimingLikelihood)

file I3RbTimingService.h

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/I3Vector.h>

#include <gulliver/I3EventHypothesis.h>

#include <string>

#include <rock_bottom/I3RbParameterMap.h>

#include <rock_bottom/I3RbUtilities.h>

#include <dataclasses/I3MapOMKeyMask.h>

Functions

I3_POINTER_TYPEDEFS(I3RbTimingService)

file I3RbTwoGauss.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/functions/I3RbTwoGauss.h>

#include <radcube/util/CoordinateSystem.h>

#include <cmath>

file I3RbTwoGauss.h

#include <rock_bottom/interface/I3RbLDFService.h>

Functions

I3_POINTER_TYPEDEFS(I3RbTwoGauss)

file I3RbUtilities.cxx

#include <rock_bottom/I3RbUtilities.h>

#include <iostream>

file I3RbUtilities.h

#include <icetray/I3Frame.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/physics/I3Particle.h>

#include <boost/numeric/ublas/matrix.hpp>

file I3RockBall.cxx

#include <rock_bottom/interface/I3RockBall.h>

#include <icetray/I3Logging.h>

file I3RockBall.h

#include <dataclasses/geometry/I3TankGeo.h>

#include <dataclasses/geometry/I3OMGeo.h>

#include <dataclasses/calibration/I3VEMCalibration.h>

file I3ScintBaseLikelihood.cxx

#include <rock_bottom/interface/I3RbLikelihoodBase.h>

#include <dataclasses/I3MapOMKeyMask.h>

file I3ScintLDFLikelihood.cxx

#include <rock_bottom/interface/I3RbLDFLikelihood.h>

#include <rock_bottom/I3RbUtilities.h>

#include <rock_bottom/interface/I3RockBall.h>

#include <icetray/I3SingleServiceFactory.h>

#include <gulliver/I3EventHypothesis.h>

#include <math.h>

#include <boost/limits.hpp>

file I3ScintSignalModel.cxx

#include <rock_bottom/models/scint/I3ScintSignalModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

typedef I3SingleServiceFactory<I3ScintSignalModel, I3RbSignalModel> ScintSignalModel

Functions

I3_SERVICE_FACTORY(ScintSignalModel)

file I3ScintSignalModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3RbLDFService.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3ScintSignalModel)

file I3ScintTimingLikelihood.cxx

#include <rock_bottom/interface/I3RbTimingLikelihood.h>

file I3TwoLDFSignalModel.cxx

#include <rock_bottom/models/icetop/I3TwoLDFSignalModel.h>

#include <rock_bottom/I3RbUtilities.h>

#include <icetray/I3SingleServiceFactory.h>

#include <boost/filesystem.hpp>

#include <boost/math/special_functions/factorials.hpp>

#include <rock_bottom/LaputopConverter.h>

#include <toprec/tankPulse.h>

#include <photospline/splinetable.h>

#include <photospline/bspline.h>

Typedefs

typedef I3SingleServiceFactory<I3TwoLDFSignalModel, I3RbSignalModel> TwoLDFSignalModel

using vecvecd = std::vector<std::vector<double>>

Functions

I3_SERVICE_FACTORY(TwoLDFSignalModel)

Variables

static const double min_exponent = -250

static const double max_exponent = 250

static const double min_value = exp(min_exponent)

static const double max_value = exp(max_exponent)

file I3TwoLDFSignalModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <photospline/splinetable.h>

#include <rock_bottom/interface/I3RbLDFService.h>

#include <toprec/I3SnowAttenuationService.h>

#include <photospline/bspline.h>

Typedefs

using vecvecd = std::vector<std::vector<double>>

Functions

I3_POINTER_TYPEDEFS(I3TwoLDFSignalModel)

file LaputopConverter.cxx

#include <rock_bottom/LaputopConverter.h>

#include <rock_bottom/models/icetop/I3LaputopSignalModel.h>

#include <rock_bottom/models/icetop/I3GaussCurveModel.h>

file LaputopConverter.h

#include <recclasses/I3LaputopParams.h>

#include <rock_bottom/I3RbParameterMap.h>

file SkeletonSignalModel.cxx

#include <rock_bottom/models/I3SkeltonSignalModel.h>

#include <rock_bottom/I3TopRockBottomUtilities.h>

Typedefs

typedef I3SingleServiceFactory<I3SkeletonSignalModel, I3RbSignalModel> SkeletonSignalModel

Functions

I3_SERVICE_FACTORY(SkeletonSignalModel)

file SkeletonSignalModel.h

#include <rock_bottom/interface/I3RbSignalModel.h>

#include <rock_bottom/interface/I3TopLDFService.h>

Functions

I3_POINTER_TYPEDEFS(I3SkeletonSignalModel)

file SkeletonSignalModelPy.cxx

#include <tableio/converter/pybindings.h>

#include <rock_bottom/models/SkeletonSignalModel.h>

#include <icetray/python/context_suite.hpp>

Functions

void registerSkeletonSignalModel()

dir functions

dir functions

dir icetop

dir icetop

dir icetop

dir icetray

dir interface

dir interface

dir lilliput

dir lilliput

dir models

dir models

dir modules

dir modules

dir private

dir public

dir radio

dir radio

dir radio

dir resources

dir rock_bottom

dir rock_bottom

dir rock_bottom

dir scint

dir scint

dir scint

dir skeleton