radcube C++ API Reference

class AddElectronicNoise : public I3Module

#include <AddElectronicNoise.h>

Public Functions

AddElectronicNoise(const I3Context &context)

inline ~AddElectronicNoise()

void Configure()

void DAQ(I3FramePtr frame)

void Physics(I3FramePtr frame)

Private Functions

void InitFiles()

void InitFlatNoise()

void InitReadInNoise()

void ApplyNoise(I3FramePtr frame)

SET_LOGGER ("AddElectronicNoise")

Private Members

std::vector<double> frequencies_

std::vector<double> amplitudes_

std::string inputName_

std::string outputName_

bool applyInDAQ_

bool keepNoiseOnly_

double flatNoiseDbmHz_

std::string randomServiceName_

I3RandomServicePtr randomService_

class AddPhaseDelay : public I3Module

#include <AddPhaseDelay.h>

Public Functions

AddPhaseDelay(const I3Context &context)

inline ~AddPhaseDelay()

void ApplyDelay(I3FramePtr frame)

void Configure()

void DAQ(I3FramePtr frame)

void Physics(I3FramePtr frame)

Private Functions

SET_LOGGER ("AddPhaseDelay")

Private Members

std::string inputName_

std::string outputName_

bool applyInDAQ_

double delayTime_

class BandpassFilter : public I3Module

#include <BandpassFilter.h>

Public Functions

BandpassFilter(const I3Context &context)

inline ~BandpassFilter()

void Configure()

void DAQ(I3FramePtr frame)

void Physics(I3FramePtr frame)

void ApplyFilter(I3FramePtr frame)

I3AntennaDataMapPtr ApplyFilter1D(I3AntennaDataMapConstPtr map)

EFieldTimeSeriesMapPtr ApplyFilter3D(EFieldTimeSeriesMapConstPtr map)

Private Functions

SET_LOGGER ("BandpassFilter")

Private Members

std::string inputName_

std::string outputName_

radcube::FilterType filterType_

std::vector<double> filterLimits_

int butterworthOrder_

double boxTimeDelay_

bool applyInDAQ_

radcube::FilterOptions filterOptions_

class BringTheNoise : public I3Module

#include <BringTheNoise.h>

Public Functions

BringTheNoise(const I3Context &context)

inline ~BringTheNoise()

void Configure()

void DAQ(I3FramePtr frame)

void Finish()

Private Functions

void ResetCachedResponse()

const AntennaSpectrum &GetCachedResponse(AntennaSpectrum &spectrum)

void ApplyCachedResponse(AntennaSpectrum &spectrum, AntennaSpectrum &noiseOnly)

SET_LOGGER ("BringTheNoise")

Private Members

std::string inputName_

std::string outputName_

bool useThermalNoise_

bool useCaneNoise_

double thermalNoiseTemp_

double noiseMultiplier_

bool insertNoiseOnly_

std::string antennaResponseName_

I3AntennaResponsePtr antennaResponse_

std::string randomServiceName_

I3RandomServicePtr randomService_

const unsigned int maxCachedResponses_ = 20

std::vector<AntennaSpectrum> cachedResponses_

std::vector<int> cachedResponseUses_

class ChannelInjector : public I3Module

#include <ChannelInjector.h>

Public Functions

ChannelInjector(const I3Context &context)

inline ~ChannelInjector()

void Configure()

void Geometry(I3FramePtr frame)

void DAQ(I3FramePtr frame)

Private Functions

SET_LOGGER ("ChannelInjector")

Private Members

std::string inputName_

std::string outputName_

std::string antennaResponseName_

I3AntennaGeoMap antennageo_

I3AntennaResponsePtr antennaResponse_

class CoREASDataBlock

#include <CoREASDataBlock.h>

Public Functions

inline CoREASDataBlock()

inline ~CoREASDataBlock()

bool CheckForFiles(const std::string &directoryName)

bool CheckFile(boost::filesystem::path filepath, std::string extn, std::string &store)

bool LoadAntennaNames()

void ClearFiles()

Public Members

std::string currentReasFile

std::string currentListFile

std::string currentLogFile

std::string currentDataDir

std::vector<std::string> antennaNames

class CoreasReader : public I3Module

#include <CoreasReader.h>

Public Functions

CoreasReader(const I3Context &context)

inline ~CoreasReader()

void Configure()

bool ShouldDoProcess(I3FramePtr frame)

void Process()

void ProcessAddToGCD(I3FramePtr frame)

void Geometry(I3FramePtr frame)

void Calibration(I3FramePtr frame)

void DetectorStatus(I3FramePtr frame)

void DAQ(I3FramePtr frame)

void Finish()

Private Functions

void NextFile()

bool LoadGCDFrames()

bool MakeDAQFrame()

bool AddToDAQFrame(I3FramePtr frame)

bool MakeGCDFrames()

bool MakeGFrame()

SET_LOGGER ("CoreasReader")

Private Members

std::vector<std::string> directoryList_

bool addToExistingGCD_ = false

bool makeGCDFile_ = false

bool makeDAQ_ = false

int gcdFramesSeen_ = 0

bool piggybackMode_ = false

bool makeGFrameForEach_ = false

I3GeometryPtr geometry_ = NULL

I3CalibrationPtr calibration_ = NULL

I3DetectorStatusPtr detStatus_ = NULL

CoREASDataBlock coreasData_

std::string currentFilename_

unsigned int nFilesRead_

class CoREASToAntennaMap : public I3Module

#include <CoREASToAntennaMap.h>

Public Functions

CoREASToAntennaMap(const I3Context &context)

inline ~CoREASToAntennaMap()

void Configure()

void DAQ(I3FramePtr frame)

Private Functions

SET_LOGGER ("CoREASToAntennaMap")

Private Members

std::string inputName_

std::string outputName_

class EFieldCalculator : public I3Module

#include <EFieldCalculator.h>

Public Functions

EFieldCalculator(const I3Context &context)

inline ~EFieldCalculator()

void Configure()

void Physics(I3FramePtr frame)

Private Functions

SET_LOGGER ("EFieldCalculator")

Private Members

std::string inputName_

std::string outputName_

std::string responseName_

I3AntennaResponsePtr response_

class ElectronicResponseAdder : public I3Module

#include <ElectronicResponseAdder.h>

Public Functions

ElectronicResponseAdder(const I3Context &context)

inline ~ElectronicResponseAdder()

void Configure()

void Geometry(I3FramePtr frame)

void DAQ(I3FramePtr frame)

Private Functions

SET_LOGGER ("ElectronicResponseAdder")

Private Members

std::string inputName_

std::string outputName_

std::string geometryName_

I3GeometryConstPtr geometry_

std::string responseName_

I3ElectronicsResponsePtr response_

class ElectronicResponseRemover : public I3Module

#include <ElectronicResponseRemover.h>

Public Functions

ElectronicResponseRemover(const I3Context &context)

inline ~ElectronicResponseRemover()

void Configure()

void Geometry(I3FramePtr frame)

void Physics(I3FramePtr frame)

Private Functions

SET_LOGGER ("ElectronicResponseRemover")

Private Members

std::string inputName_

std::string outputName_

std::string geometryName_

I3GeometryConstPtr geometry_

std::string responseName_

I3ElectronicsResponsePtr response_

class EstimateRadioShower : public I3Module

#include <EstimateRadioShower.h>

Public Functions

EstimateRadioShower(const I3Context &context)

inline ~EstimateRadioShower()

void Configure()

void Geometry(I3FramePtr frame)

void Physics(I3FramePtr frame)

Private Functions

void AnalyzeSignals(I3FramePtr frame, bool topThree)

bool EstimateCoreLocation(I3FramePtr frame)

bool EstimateDirectionPlane(I3FramePtr frame, bool useMultiple)

void AddParticleToFrame(I3FramePtr frame, bool goodReco)

SET_LOGGER ("EstimateRadioShower")

Private Members

std::string inputName_

std::string outputName_

std::string antennaBadListName_

bool onlyUseTopThree_

double heightAboveBackground_

I3AntennaGeoMap antennageo_

I3Position core_

double coreTime_

I3Direction showerDirection_

I3VectorAntennaKey badAntennas_

std::vector<AntennaKey> usedKeys_

std::vector<double> usedTimes_

std::vector<double> usedSignals_

class FilterOptions

#include <FrequencyFilters.h>

Public Functions

inline FilterOptions()

inline ~FilterOptions()

inline void SetBand(double low, double high)

Public Members

double fLowpass_

double fHighpass_

double butterworthOrder_

double boxTimeDelay_

FilterType type_

class I3AntennaResponse

#include <I3AntennaResponse.h>

Public Functions

I3AntennaResponse()

I3AntennaResponse(I3AntennaGeo::AntennaType type, std::string dir)

inline ~I3AntennaResponse()

const I3AntennaGeo::AntennaType GetAntennaType() const

const int GetNZenithBins() const

const int GetNAzimuthBins() const

const int GetNFrequencyBins() const

I3ComplexVector GetVectorEffectiveLength(const double freq, const double azimuth, const double zenith) const

I3ComplexVector GetEffectiveArea(const double freq, const double azimuth, const double zenith) const

const double GetIntegratedVectorEffectiveLength(const double freq) const

const double GetIntegratedGain(const double freq) const

bool GetChannelFromEField(const EFieldTimeSeriesMap &in, I3AntennaDataMap &out, const I3AntennaGeoMap &geo, const I3Particle &prim) const

bool GetEFieldFromChannel(const I3AntennaDataMap &in, EFieldTimeSeriesMap &out, const I3AntennaGeoMap &geo, const I3Particle &prim) const

Private Types

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

Private Functions

void LoadAntennaResponse_()

int BinaryBinSearch_(double value, int low, int high, const std::vector<double> &list) const

const double TrilinearInterpolation_(const double freq, const double azi, const double zen, const int idata) const

SET_LOGGER ("I3AntennaResponse")

Private Members

I3AntennaGeo::AntennaType antennaType_

std::string overrideHeadDir_

std::string fileLocation_

std::vector<double> responseZenithAngles_

std::vector<double> responseAzimuthAngles_

std::vector<double> responseFrequencies_

DataBlock gain_

std::vector<std::vector<double>> effectiveHeights_

std::vector<std::vector<double>> effectiveAreas_

class I3AntennaResponseFactory : public I3ServiceFactory

#include <I3AntennaResponseFactory.h>

Public Functions

I3AntennaResponseFactory(const I3Context &context)

inline ~I3AntennaResponseFactory()

bool InstallService(I3Context &services)

virtual void Configure()

Private Functions

I3AntennaResponseFactory(const I3AntennaResponseFactory &rhs)

I3AntennaResponseFactory operator=(const I3AntennaResponseFactory &rhs)

SET_LOGGER ("I3AntennaResponseFactory")

Private Members

std::string installServiceAs_

I3AntennaGeo::AntennaType antennaType_

std::string overrideHeadDir_

I3AntennaResponsePtr response_

class I3ComponentResponse

#include <I3ComponentResponse.h>

Public Functions

inline I3ComponentResponse()

I3ComponentResponse(std::string filename, unsigned int nDimension)

inline ~I3ComponentResponse()

std::complex<double> GetResponse(double freq) const

std::complex<double> GetResponse(double freq, double temp) const

void LoadData(std::string filename, unsigned int nDimension)

void Clear()

inline void SetName(std::string name)

inline std::string GetName() const

int GetNFreqs() const

int GetNTemps() const

Private Functions

void ReadIn1D(const std::string filename)

void ReadIn2D(const std::string filename)

std::complex<double> GetResponseFromBlock(double freq, const ResponseBlock &block) const

std::complex<double> GetResponseFromBlock2D(double freq, double temp, const ResponseBlock2D &block) const

Private Members

ResponseBlock responseBlock_

ResponseBlock2D responseBlock2D_

std::string componentName_

class I3ElectronicsResponse

#include <I3ElectronicsResponse.h>

Public Functions

I3ElectronicsResponse()

I3ElectronicsResponse(I3AntennaGeo::AntennaType type, const std::string headDir)

inline ~I3ElectronicsResponse()

void SetAntennaType(I3AntennaGeo::AntennaType type)

void SetTemperature(double temp)

void IncludeLNA(bool inc)

void IncludeCables(bool inc)

void IncludeRadioBoard(bool inc)

void IncludeTaxi(bool inc)

std::complex<double> GetTotalResponse(double freq, double length) const

std::complex<double> GetLNAResponse(double freq) const

std::complex<double> GetCableResponse(double freq, double length) const

std::complex<double> GetRadioBoardResponse(double freq) const

std::complex<double> GetTaxiResponse(double freq) const

double GetCableTimeDelay(double length) const

void SetCableTemperature(double temp)

void SetAdditionalGain(double gain)

inline void SetNADCBits(int n)

inline void SetADCVoltageRange(double range)

inline void SetADCPedestalVoltage(double volt)

inline void SetIncludeSaturation(bool x)

double GetVoltagePerADC() const

int GetADCBinFromVoltage(const double voltage) const

void AddElectronicsResponse(const I3AntennaDataMap &inputAntennaDataMap, I3AntennaDataMap &outputAntennaDataMap, const I3AntennaGeoMap &antgeo)

void RemoveElectronicsResponse(const I3AntennaDataMap &inputAntennaDataMap, I3AntennaDataMap &outputAntennaDataMap, const I3AntennaGeoMap &antgeo)

void AddCustomResponse(const I3ComponentResponse &resp)

void ClearCustomResponses()

void ApplyCachedResponse(AntennaSpectrum &spectrum, double length)

void RemoveCachedResponse(AntennaSpectrum &spectrum, double length)

void ResetCachedResponse()

Private Functions

void SetDefaults()

void InitLNAResponse()

void InitCableResponse()

void InitRadioBoardResponse(bool withTaxi = false)

void InitTaxiResponse()

void SetTaxiToDummy()

SET_LOGGER ("I3ElectronicsResponse")

Private Members

I3AntennaGeo::AntennaType antennaType_

std::string overrideHeadDir_

double temperature_

bool includeLNA_

I3ComponentResponse lnaResponse_

bool includeCables_

double cableTemperature_

bool includeRadioBoard_

double additionalGain_

I3ComponentResponse radioBoardResponse_

bool includeTaxi_

I3ComponentResponse taxiResponse_

int nADCBits_

double adcVoltageRange_

double adcPedestalVoltage_

bool includeSaturation_

std::map<double, std::vector<AntennaSpectrum>> cachedResponses_

std::vector<I3ComponentResponse> customResponses_

class I3ElectronicsResponseFactory : public I3ServiceFactory

#include <I3ElectronicsResponseFactory.h>

Public Functions

I3ElectronicsResponseFactory(const I3Context &context)

inline ~I3ElectronicsResponseFactory()

bool InstallService(I3Context &services)

virtual void Configure()

Private Functions

I3ElectronicsResponseFactory(const I3ElectronicsResponseFactory &rhs)

I3ElectronicsResponseFactory operator=(const I3ElectronicsResponseFactory &rhs)

SET_LOGGER ("I3ElectronicsResponseFactory")

Private Members

std::string installServiceAs_

I3ElectronicsResponsePtr response_

I3AntennaGeo::AntennaType antennaType_

std::string overrideHeadDir_

bool includeLNA_

bool includeCables_

double cableTemperature_

bool includeRadioBoard_

double temperature_

double additionalGain_

bool includeTaxi_

int nADCBits_

double adcVoltageRange_

double adcPedestalVoltage_

bool includeSaturation_

std::vector<std::string> customResponseFiles_

class MedianFrequencyFilter : public I3Module

#include <MedianFrequencyFilter.h>

Public Functions

MedianFrequencyFilter(const I3Context &context)

inline ~MedianFrequencyFilter()

virtual void Configure()

virtual void Physics(I3FramePtr frame)

double GetMedian(const AntennaSpectrum &freqSpec, int binLow, int binHigh)

Private Functions

SET_LOGGER ("MedianFrequencyFilter")

Private Members

std::string inputName_

std::string outputName_

int filterWindowWidth_

class PedestalRemover : public I3Module

#include <PedestalRemover.h>

Public Functions

PedestalRemover(const I3Context &context)

inline ~PedestalRemover()

void Configure()

void Physics(I3FramePtr frame)

Private Functions

SET_LOGGER ("PedestalRemover")

Private Members

std::string inputName_

std::string outputName_

std::string electronicsResponseName_

I3ElectronicsResponsePtr response_

bool convertToVoltage_

class RadcubeDataUtility

#include <RadcubeDataUtility.h>

Public Functions

RadcubeDataUtility()

RadcubeDataUtility(std::string infoCardLocation)

inline ~RadcubeDataUtility()

inline void SetInfoCardLocation(std::string loc)

void SetHeadDir(std::string headDir)

std::string GetHeadDir()

void Initialize()

DECLARE_DIRECTORY_FUNCTIONS(AntennaResponse)

DECLARE_DIRECTORY_FUNCTIONS(ElectronicsResponse)

Public Members

std::string infoCardLocation_ = ""

std::string dirHead_ = ""

struct ResponseBlock

Public Members

std::vector<double> freq

std::vector<double> gain

std::vector<double> phase

struct ResponseBlock2D

Public Members

std::vector<double> freq

std::vector<double> temp

std::vector<std::vector<double>> gain

std::vector<std::vector<double>> phase

class TraceResampler : public I3Module

#include <TraceResampler.h>

Public Functions

TraceResampler(const I3Context &context)

inline ~TraceResampler()

void Configure()

void DAQ(I3FramePtr frame)

void Resample1D(I3FramePtr frame, I3AntennaDataMapConstPtr map)

void Resample3D(I3FramePtr frame, EFieldTimeSeriesMapConstPtr map)

Private Functions

SET_LOGGER ("TraceResampler")

Private Members

std::string inputName_

std::string outputName_

double resampledBinning_

class WaveformChopper : public I3Module

#include <WaveformChopper.h>

Public Functions

WaveformChopper(const I3Context &context)

inline ~WaveformChopper()

void Configure()

void DAQ(I3FramePtr frame)

void Physics(I3FramePtr frame)

void ChopEmUp(I3FramePtr frame)

Private Functions

SET_LOGGER ("WaveformChopper")

Private Members

std::string inputName_

std::string outputName_

unsigned int minBin_

unsigned int maxBin_

bool applyInDAQ_

class WaveformDigitizer : public I3Module

#include <WaveformDigitizer.h>

Public Functions

WaveformDigitizer(const I3Context &context)

inline ~WaveformDigitizer()

void Configure()

void DAQ(I3FramePtr frame)

Private Functions

SET_LOGGER ("WaveformDigitizer")

Private Members

std::string inputName_

std::string outputName_

std::string electronicsResponseName_

I3ElectronicsResponsePtr response_

class ZeroPadder : public I3Module

#include <ZeroPadder.h>

Public Functions

ZeroPadder(const I3Context &context)

inline ~ZeroPadder()

void Configure()

void DAQ(I3FramePtr frame)

void Physics(I3FramePtr frame)

void ApplyTheZeros(I3FramePtr frame)

void ApplyTheZerosTimeSeries(I3FramePtr frame)

void ApplyTheZerosFrequencySpectrum(I3FramePtr frame)

void ApplyTheZerosTimeSeries3D(I3FramePtr frame)

void ApplyTheZerosFrequencySpectrum3D(I3FramePtr frame)

Private Functions

SET_LOGGER ("ZeroPadder")

Private Members

std::string inputName_

std::string outputName_

bool addToFront_

bool addToTimeSeries_

int appendN_

int fixedLength_

bool applyInDAQ_

bool isFFTData3D_

namespace I3Constants

Variables

static const double bfield_x = -8556.6 * I3Units::nT

static const double bfield_y = 14398.6 * I3Units::nT

static const double bfield_z = 51961.2 * I3Units::nT

static const double bfield = 54593.9 * I3Units::nT

namespace radcube

Enums

enum FilterType

Values:

enumerator eNone

enumerator eBox

enumerator eButterworth

enumerator eCausalBox

enumerator eFilterTypeCount

Functions

AntennaKey GetAntennaKeyFromAntennaName(std::string name, int i)

I3ParticlePtr ReadReasFile(const std::string &filename)

void ReadListFile(const std::string &filename, I3GeometryPtr geom, I3CalibrationPtr calib, I3DetectorStatusPtr detStatus)

void UpdateGeometryFromListLine(std::istringstream &line, I3GeometryPtr geom)

void UpdateCalibrationFromListLine(std::istringstream &line, I3CalibrationPtr calib)

void UpdateDetectorStatusFromListLine(std::istringstream &line, I3DetectorStatusPtr detStatus)

I3CorsikaShowerInfoPtr ReadLogFile(const std::string &filename)

void AddLongitudinalProfile(const std::string &filename, I3CorsikaShowerInfo &corsikaInfo)

EFieldTimeSeriesMapPtr ReadAntennaFiles(CoREASDataBlock &block)

EFieldTimeSeries ReadAntennaFile(const std::string &filename)

const double GetMagneticRotation()

I3Position TransformPositionCORSIKAToI3(const double magNorth, const double magWest, const double vertical)

I3Direction TransformDirectionCORSIKAToI3(const double magNorth, const double magWest, const double vertical)

I3Direction TransformDirectionCORSIKAToI3(const double magZenith, const double maAzimuth)

I3Orientation TransformOrientationCORSIKAToI3(const double magDirX, const double magDirY, const double magDirZ)

I3Orientation TransformOrientationCORSIKAToI3(const double magDirX, const double magDirY, const double magDirZ, const double magUpX, const double magUpY, const double magUpZ)

I3Position GetBFieldVector()

I3Position GetBFieldUnitVector()

double GetGeomagneticAngle(const I3Direction &vec)

double GetGeomagneticAngle(const I3Particle &part)

I3Position GetVxB(const I3Position &v)

I3Position GetVxBUnit(const I3Position &v)

I3Position GetVxVxB(const I3Position &v)

I3Position GetVxVxBUnit(const I3Position &v)

I3Position GetMagneticFromIC(const I3Position &vec, const I3Direction &showerDir)

I3Position GetICFromMagnetic(const I3Position &vec, const I3Direction &showerDir)

I3Position GetShowerPlaneXUnit(const I3Direction &showerDir, const I3Position up = I3Position(0, 0, 1))

I3Position GetShowerPlaneYUnit(const I3Direction &showerDir, const I3Position up = I3Position(0, 0, 1))

I3Position GetShowerPlaneZUnit(const I3Direction &showerDir, const I3Position up = I3Position(0, 0, 1))

I3Position GetShowerFromIC(const I3Position &vec, const I3Direction &showerDir)

I3ComplexVector GetShowerFromIC(const I3ComplexVector &vec, const I3Direction &showerDir)

I3Position GetICFromShower(const I3Position &vec, const I3Direction &showerDir)

I3ComplexVector GetICFromShower(const I3ComplexVector &vec, const I3Direction &showerDir)

I3Position GetInChannelCS(const I3Position &vec, const I3Position &channelDir, const I3Position &antennaUp)

I3ComplexVector GetInChannelCS(const I3ComplexVector &vec, const I3Position &channelDir, const I3Position &antennaUp)

double GetChannelZenith(const I3Direction &showerDir, const I3Orientation &orientation, int ichannel)

double GetChannelAzimuth(const I3Direction &showerDir, const I3Orientation &orientation, int ichannel)

I3Position GetChannelSphericalFromIC(const I3Position &vec, const I3Direction &showerDir, const I3Position &antennaUp)

I3ComplexVector GetChannelSphericalFromIC(const I3ComplexVector &vec, const I3Direction &showerDir, const I3Position &antennaUp)

I3Position GetICFromChannelSpherical(const I3Position &vec, const I3Direction &showerDir, const I3Position &antennaUp)

I3ComplexVector GetICFromChannelSpherical(const I3ComplexVector &vec, const I3Direction &showerDir, const I3Position &antennaUp)

void GetInverse(I3Position &x, I3Position &y, I3Position &z)

void GetInverse(I3ComplexVector &x, I3ComplexVector &y, I3ComplexVector &z)

double GetEnergy(const AntennaTimeSeries &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetPower(const AntennaTimeSeries &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetEnergy(const AntennaSpectrum &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetPower(const AntennaSpectrum &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetEnergy(const FFTData &fft, double impedance, bool calcInTimeDomain = true, int lowbin = 0, int highbin = -1)

double GetPower(const FFTData &fft, double impedance, bool calcInTimeDomain = true, int lowbin = 0, int highbin = -1)

double GetEnergy(const EFieldTimeSeries &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetPower(const EFieldTimeSeries &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetEnergy(const EFieldSpectrum &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetPower(const EFieldSpectrum &timeSeries, double impedance, int lowbin = 0, int highbin = -1)

double GetEnergy(const FFTData3D &fft, double impedance, bool calcInTimeDomain = true, int lowbin = 0, int highbin = -1)

double GetPower(const FFTData3D &fft, double impedance, bool calcInTimeDomain = true, int lowbin = 0, int highbin = -1)

std::complex<double> BoxFilterTransferFunction(const double f, const FilterOptions &opts)

std::complex<double> CausalBoxFilterTransferFunction(const double f, const FilterOptions &opts)

std::complex<double> ButterworthTransferFunction(const double f, const FilterOptions &opts)

std::complex<double> ButterworthPolynomial(const std::complex<double> s, const int n)

AntennaSpectrum GetFilteredSpectrum(const AntennaSpectrum &spectrum, const FilterOptions &opts)

FFTData GetFilteredSpectrum(const FFTData &fftData, const FilterOptions &opts)

EFieldSpectrum GetFilteredSpectrum(const EFieldSpectrum &spectrum, const FilterOptions &opts)

FFTData3D GetFilteredSpectrum(const FFTData3D &fftData, const FilterOptions &opts)

bool IsBetween(const double x, const double lim1, const double lim2)

double Interpolation(const double x, const double x0, const double x1, double f0, double f1, bool isAngle = false)

std::complex<double> InterpolationC(const double x, const double x0, const double x1, std::complex<double> f0, std::complex<double> f1)

double Interpolation(const double x, std::vector<double> xVals, std::vector<double> data, bool isAngle = false)

double Interpolation2D(const double x, const double x0, const double x1, const double y, const double y0, const double y1, const double f00, const double f01, const double f10, const double f11, bool isAngle = false)

std::complex<double> Interpolation2DC(const double x, const double x0, const double x1, const double y, const double y1, const double y2, const std::complex<double> f00, const std::complex<double> f01, const std::complex<double> f10, const std::complex<double> f11)

double BilinearInterpolation(const double x, std::vector<double> xVals, const double y, std::vector<double> yVals, std::vector<std::vector<double>> data, bool isAngle = false)

double Interpolation3D(const double x, const double x0, const double x1, const double y, const double y0, const double y1, const double z, const double z0, const double z1, const double f000, const double f001, const double f010, const double f011, const double f100, const double f101, const double f110, const double f111, bool isAngle = false)

std::complex<double> Interpolation3DC(const double x, const double x0, const double x1, const double y, const double y0, const double y1, const double z, const double z0, const double z1, const std::complex<double> f000, const std::complex<double> f001, const std::complex<double> f010, const std::complex<double> f011, const std::complex<double> f100, const std::complex<double> f101, const std::complex<double> f110, const std::complex<double> f111)

double TrilinearInterpolation(const double x, std::vector<double> xArray, const double y, std::vector<double> yArray, const double z, std::vector<double> zArray, std::vector<std::vector<std::vector<double>>> data, bool isAngle = false)

double CaneNoiseBrightnessTemp(const double freq)

double GetPowerFromTemperature(const double df, const double temp, const double effArea)

const char *GetAntennaTypeName(I3AntennaGeo::AntennaType type)

AntennaKey GetGenericAntennaKey(int x)

const char *GetDefaultResponseName(I3AntennaGeo::AntennaType ant)

const char *GetDefaultSimEFieldName()

const char *GetDefaultGeometryName()

const char *GetDefaultCalibrationName()

const char *GetDefaultDetectorStatusName()

const char *GetDefaultAntennaBadNameList()

int GetNAntennaChannels(I3AntennaGeo::AntennaType ant)

double GetAntennaImpedance(I3AntennaGeo::AntennaType ant)

boost::rational<long> GetRationalNumberFromDecimal(double decimal, const bool secondCall = false)

double NormalizeAngle(double x)

double GetFourierAmplitudeFromDbmHz(double dbmHz, double df, double impendance = 100 * I3Units::ohm)

double GetDbmHzFromFourierAmplitude(double amp, double df, double impendance = 100 * I3Units::ohm)

std::complex<double> GetPhaseGradient(double f, double dt)

double GetMean(const AntennaTimeSeries &trace, const double finalInclude = 1.)

double GetRMS(const AntennaTimeSeries &trace, const double finalInclude = 1.)

double GetStd(const AntennaTimeSeries &trace, const double finalInclude = 1.)

double GetSNR(const AntennaTimeSeries &trace, const double finalInclude = 1.)

double GetIntegral(const AntennaTimeSeries &trace, const double finalInclude = 1.)

double GetIntegralBackgroundSubtracted(const AntennaTimeSeries &trace, const double finalInclude = 0.3)

double GetMean(const FFTData &fft, const double finalInclude = 1.)

double GetRMS(const FFTData &fft, const double finalInclude = 1.)

double GetStd(const FFTData &fft, const double finalInclude = 1.)

double GetSNR(const FFTData &fft, const double finalInclude = 1.)

double GetIntegral(const FFTData &fft, const double finalInclude = 1.)

double GetIntegralBackgroundSubtracted(const FFTData &fft, const double finalInclude = 0.3)

I3Position GetMean(const EFieldTimeSeries &trace, const double finalInclude = 1.)

I3Position GetRMS(const EFieldTimeSeries &trace, const double finalInclude = 1.)

I3Position GetStd(const EFieldTimeSeries &trace, const double finalInclude = 1.)

I3Position GetIntegral(const EFieldTimeSeries &fft, const double finalInclude = 1.)

AntennaTimeSeries TimeSeriesConvolution(const AntennaTimeSeries &lhs, const AntennaTimeSeries &rhs)

FFTData TimeSeriesConvolution(const FFTData &lhs, const FFTData &rhs)

Variables

const double knownCOREASVersions[2] = {1.3, 1.4}

namespace RadcubeConstants

Variables

static const I3AntennaGeo::AntennaType antennaType = I3AntennaGeo::AntennaType::SKALA2

static const double thermalNoiseTemp = 30. * I3Units::kelvin

static const double resampledBinning = 1. * I3Units::ns

static const double cableTemp = 273.15 * I3Units::kelvin

static const double electronicsTemp = 285. * I3Units::kelvin

static const std::vector<double> bandPassLimits = {70. * I3Units::megahertz, 350. * I3Units::megahertz}

static const int butterworthOrder = 6

namespace std

STL namespace.

file AddElectronicNoise.cxx

#include <radcube/modules/AddElectronicNoise.h>

#include <fstream>

#include <dataclasses/I3AntennaDataMap.h>

#include <radcube/readers/RadcubeDataUtility.h>

#include <radcube/util/InterpolationTools.h>

#include <radcube/util/RadUtility.h>

Functions

I3_MODULE(AddElectronicNoise)

file AddElectronicNoise.h

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <phys-services/I3RandomService.h>

#include <string>

#include <vector>

file AddPhaseDelay.cxx

#include <radcube/modules/AddPhaseDelay.h>

#include <radcube/util/RadUtility.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <complex>

Functions

I3_MODULE(AddPhaseDelay)

file AddPhaseDelay.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

file BandpassFilter.cxx

#include <radcube/modules/BandpassFilter.h>

#include <dataclasses/fft/FFTDataContainer.h>

#include <radcube/util/FrequencyFilters.h>

#include <radcube/util/RadcubeConstants.h>

Functions

I3_MODULE(BandpassFilter)

file BandpassFilter.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/util/RadUtility.h>

#include <radcube/util/FrequencyFilters.h>

#include <dataclasses/I3AntennaDataMap.h>

file BringTheNoise.cxx

#include <radcube/modules/BringTheNoise.h>

#include <icetray/I3Units.h>

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <radcube/util/RadcubeConstants.h>

Functions

I3_MODULE(BringTheNoise)

file BringTheNoise.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <phys-services/I3RandomService.h>

#include <radcube/util/NoiseModels.h>

#include <radcube/util/RadUtility.h>

#include <radcube/services/I3AntennaResponse.h>

file ChannelInjector.cxx

#include <radcube/modules/ChannelInjector.h>

#include <math.h>

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_MODULE(ChannelInjector)

file ChannelInjector.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <radcube/services/I3AntennaResponse.h>

#include <radcube/util/RadUtility.h>

file CoordinateSystem.cxx

#include <radcube/util/CoordinateSystem.h>

#include <radcube/util/RadUtility.h>

#include <cmath>

file CoordinateSystem.h

#include <dataclasses/I3ComplexVector.h>

#include <dataclasses/I3Direction.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/I3Orientation.h>

#include <dataclasses/physics/I3Particle.h>

#include <icetray/I3Units.h>

file CoREASDataBlock.cxx

#include <radcube/readers/CoREASDataBlock.h>

#include <iostream>

#include <fstream>

file CoREASDataBlock.h

#include <string>

#include <boost/filesystem.hpp>

#include <icetray/I3Logging.h>

file CoreasReader.cxx

#include <boost/filesystem.hpp>

#include <icetray/I3Module.h>

#include <dataclasses/physics/I3EventHeader.h>

#include <radcube/modules/CoreasReader.h>

#include <radcube/util/RadUtility.h>

Functions

I3_MODULE(CoreasReader)

file CoreasReader.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/readers/CoREASDataBlock.h>

#include <radcube/readers/FileReaders.h>

file CoREASToAntennaMap.cxx

#include <radcube/modules/CoREASToAntennaMap.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_MODULE(CoREASToAntennaMap)

file CoREASToAntennaMap.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

file EFieldCalculator.cxx

#include <radcube/modules/EFieldCalculator.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <icetray/I3Units.h>

Functions

I3_MODULE(EFieldCalculator)

file EFieldCalculator.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/services/I3AntennaResponse.h>

file ElectronicResponseAdder.cxx

#include <radcube/modules/ElectronicResponseAdder.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <icetray/I3Units.h>

Functions

I3_MODULE(ElectronicResponseAdder)

file ElectronicResponseAdder.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/services/I3ElectronicsResponse.h>

#include <dataclasses/geometry/I3Geometry.h>

file ElectronicResponseRemover.cxx

#include <radcube/modules/ElectronicResponseRemover.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <icetray/I3Units.h>

Functions

I3_MODULE(ElectronicResponseRemover)

file ElectronicResponseRemover.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/services/I3ElectronicsResponse.h>

#include <dataclasses/geometry/I3Geometry.h>

file EstimateRadioShower.cxx

#include <radcube/modules/EstimateRadioShower.h>

#include <cmath>

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <dataclasses/fft/FFTHilbertEnvelope.h>

#include <radcube/util/RadUtility.h>

Functions

I3_MODULE(EstimateRadioShower)

file EstimateRadioShower.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <dataclasses/I3Position.h>

#include <dataclasses/geometry/I3Geometry.h>

file FFTTools.cxx

#include <radcube/util/FFTTools.h>

file FFTTools.h

#include <dataclasses/fft/FFTDataContainer.h>

file FileReaders.cxx

#include <radcube/readers/FileReaders.h>

#include <radcube/util/CoordinateSystem.h>

#include <radcube/util/RadUtility.h>

#include <topsimulator/injectors/I3CorsikaReader.h>

#include <fstream>

#include <string>

#include <boost/algorithm/string/classification.hpp>

#include <boost/algorithm/string/split.hpp>

file FileReaders.h

#include <boost/filesystem.hpp>

#include <dataclasses/I3AntennaWaveform.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/physics/I3Particle.h>

#include <simclasses/I3CorsikaShowerInfo.h>

#include <radcube/readers/CoREASDataBlock.h>

file FrequencyFilters.cxx

#include <radcube/util/FrequencyFilters.h>

#include <cmath>

#include <complex>

#include <icetray/I3Units.h>

Functions

void CheckFreqBounds(const radcube::FilterOptions &opts)

file FrequencyFilters.h

#include <dataclasses/fft/FFTDataContainer.h>

file I3AntennaClassifierScore.cxx

#include <radcube/I3AntennaClassifierScore.h>

Functions

I3_SERIALIZABLE(I3AntennaClassifierScore)

file I3AntennaClassifierScore.h

#include <dataclasses/I3Map.h>

#include <dataclasses/AntennaKey.h>

#include <radcube/I3ChannelClassifierScore.h>

Typedefs

typedef I3Map<AntennaKey, I3ChannelClassifierScore> I3AntennaClassifierScore

Functions

I3_POINTER_TYPEDEFS(I3AntennaClassifierScore)

file I3AntennaResponse.cxx

#include <radcube/services/I3AntennaResponse.h>

#include <fstream>

#include <complex>

#include <icetray/I3SingleServiceFactory.h>

#include <icetray/I3Units.h>

#include <radcube/readers/RadcubeDataUtility.h>

#include <radcube/util/InterpolationTools.h>

#include <radcube/util/CoordinateSystem.h>

#include <dataclasses/geometry/I3AntennaGeo.h>

file I3AntennaResponse.h

#include <string>

#include <complex>

#include <icetray/I3DefaultName.h>

#include <radcube/util/RadUtility.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <dataclasses/geometry/I3AntennaGeo.h>

#include <dataclasses/physics/I3Particle.h>

Functions

I3_DEFAULT_NAME(I3AntennaResponse)

I3_POINTER_TYPEDEFS(I3AntennaResponse)

Variables

static const unsigned int i3antennaresponse_version_ = 0

file I3AntennaResponseFactory.cxx

#include <radcube/services/I3AntennaResponseFactory.h>

#include <radcube/util/RadcubeConstants.h>

Functions

I3_SERVICE_FACTORY(I3AntennaResponseFactory)

file I3AntennaResponseFactory.h

#include <icetray/I3ServiceFactory.h>

#include <radcube/services/I3AntennaResponse.h>

file I3ChannelClassifierScore.cxx

#include <radcube/I3ChannelClassifierScore.h>

Functions

I3_SERIALIZABLE(I3ChannelClassifierScore)

file I3ChannelClassifierScore.h

#include <dataclasses/I3Map.h>

#include <dataclasses/AntennaKey.h>

Typedefs

typedef I3Map<int, double> I3ChannelClassifierScore

Functions

I3_POINTER_TYPEDEFS(I3ChannelClassifierScore)

file I3ComponentResponse.cxx

#include <radcube/services/I3ComponentResponse.h>

#include <fstream>

#include <radcube/util/RadUtility.h>

#include <radcube/util/InterpolationTools.h>

file I3ComponentResponse.h

#include <radcube/util/RadUtility.h>

#include <complex>

#include <vector>

#include <string>

Variables

static const unsigned int i3componentresponse_version_ = 0

file I3ElectronicsResponse.cxx

#include <radcube/services/I3ElectronicsResponse.h>

#include <string>

#include <fstream>

#include <vector>

#include <icetray/I3Units.h>

#include <radcube/util/InterpolationTools.h>

#include <radcube/readers/RadcubeDataUtility.h>

#include <radcube/util/RadcubeConstants.h>

file I3ElectronicsResponse.h

#include <complex>

#include <icetray/I3DefaultName.h>

#include <radcube/services/I3ComponentResponse.h>

#include <radcube/util/RadUtility.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_DEFAULT_NAME(I3ElectronicsResponse)

I3_POINTER_TYPEDEFS(I3ElectronicsResponse)

file I3ElectronicsResponseFactory.cxx

#include <radcube/services/I3ElectronicsResponseFactory.h>

Functions

I3_SERVICE_FACTORY(I3ElectronicsResponseFactory)

file I3ElectronicsResponseFactory.h

#include <icetray/I3ServiceFactory.h>

#include <radcube/services/I3ElectronicsResponse.h>

file InterpolationTools.cxx

#include <radcube/util/InterpolationTools.h>

#include <iostream>

#include <icetray/I3Units.h>

#include <icetray/I3Logging.h>

#include <radcube/util/RadUtility.h>

Typedefs

using doubleC = std::complex<double>

Functions

const doubleC im (0, 1)

file InterpolationTools.h

#include <vector>

#include <complex>

file MedianFrequencyFilter.cxx

#include <radcube/modules/MedianFrequencyFilter.h>

#include <radcube/util/FrequencyFilters.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_MODULE(MedianFrequencyFilter)

file MedianFrequencyFilter.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <phys-services/I3RandomService.h>

#include <radcube/util/NoiseModels.h>

#include <radcube/util/RadUtility.h>

#include <radcube/services/I3AntennaResponse.h>

file NoiseModels.cxx

#include <radcube/util/NoiseModels.h>

#include <cmath>

#include <radcube/util/RadUtility.h>

file NoiseModels.h

file PedestalRemover.cxx

#include <radcube/modules/PedestalRemover.h>

#include <radcube/util/WaveformTools.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_MODULE(PedestalRemover)

file PedestalRemover.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/services/I3ElectronicsResponse.h>

file RadcubeConstants.h

#include <dataclasses/I3Constants.h>

#include <dataclasses/geometry/I3AntennaGeo.h>

file RadcubeDataUtility.cxx

#include <radcube/readers/RadcubeDataUtility.h>

#include <icetray/I3Logging.h>

#include <fstream>

#include <assert.h>

#include <boost/filesystem.hpp>

Defines

IMPLEMENT_DIRECTORY_FUNCTIONS(name)

Functions

IMPLEMENT_DIRECTORY_FUNCTIONS(AntennaResponse)

IMPLEMENT_DIRECTORY_FUNCTIONS(ElectronicsResponse)

file RadcubeDataUtility.h

#include <string>

Defines

DECLARE_DIRECTORY_FUNCTIONS(name)

file RadUtility.cxx

#include <radcube/util/RadUtility.h>

file RadUtility.h

#include <complex>

#include <boost/rational.hpp>

#include <dataclasses/AntennaKey.h>

#include <dataclasses/geometry/I3AntennaGeo.h>

#include <icetray/I3Units.h>

file TraceResampler.cxx

#include <radcube/modules/TraceResampler.h>

#include <icetray/I3Units.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <dataclasses/fft/FFTResamplingTools.h>

Functions

I3_MODULE(TraceResampler)

file TraceResampler.h

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <dataclasses/I3AntennaWaveform.h>

#include <string>

file WaveformChopper.cxx

#include <radcube/modules/WaveformChopper.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_MODULE(WaveformChopper)

file WaveformChopper.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

file WaveformDigitizer.cxx

#include <radcube/modules/WaveformDigitizer.h>

#include <icetray/I3Units.h>

#include <dataclasses/I3AntennaDataMap.h>

#include <dataclasses/fft/FFTResamplingTools.h>

Functions

I3_MODULE(WaveformDigitizer)

file WaveformDigitizer.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <radcube/services/I3ElectronicsResponse.h>

file WaveformTools.cxx

#include <radcube/util/WaveformTools.h>

#include <dataclasses/fft/FFTHilbertEnvelope.h>

Functions

void FinalCheck(const double finalInclude)

file WaveformTools.h

#include <dataclasses/fft/FFTDataContainer.h>

file ZeroPadder.cxx

#include <radcube/modules/ZeroPadder.h>

#include <dataclasses/I3AntennaDataMap.h>

Functions

I3_MODULE(ZeroPadder)

file ZeroPadder.h

#include <boost/filesystem.hpp>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <dataclasses/I3AntennaDataMap.h>

dir icetray

dir modules

dir modules

dir private

dir public

dir radcube

dir radcube

dir radcube

dir readers

dir readers

dir services

dir services

dir util

dir util