topsimulator C++ API Reference

union CORSIKA_WORD
#include <CorsikaSubBlock.h>

Data structure to convert (32bit)FLOAT to 4*CHAR.

Public Members

float FLOAT
int32_t INT32
char CHAR[4]
class CorsikaSubBlock
#include <CorsikaSubBlock.h>

This class defines one sublock from a CORSIKA data file By simple streaming operators (>>) this class can read subblocks of a CORSIKA file. The SubBlock data and type can easily accessed.

Public Types

enum Block_Type

Values:

enumerator RUNH
enumerator RUNE
enumerator EVTH
enumerator EVTE
enumerator PART
enumerator LONG
enumerator UNKNOWN

Public Functions

CorsikaSubBlock(int32_t BlockSize = 0, int32_t AdditionalCharacters = 0)
~CorsikaSubBlock()
void Reset(int32_t BlockSize = 0, int32_t AdditionalCharacters = 0)
void Clear()

Clears the buffer

inline float operator[](int32_t i) const

operator[] to access the data of the stored SubBlock

inline CORSIKA_WORD GetWord(int32_t i) const
Block_Type BlockType()

return SubBlock type of actual SubBlock

inline void SubBlockCounter(int32_t n)
inline int32_t SubBlockCounter()
void Dump()
int32_t findRUNH()

Public Members

int32_t m_BlockSize

Actual size of one CORSIKA SubBlock.

int32_t m_AdditionalCharacters

Number of Additional CHARs after each Block (21 SubBlocks)

int32_t m_SubBlockCounter

Counter of SubBlocks read from file.

CORSIKA_WORD *m_Buffer

The Buffer to store one SubBlock.

Public Static Attributes

static const int32_t BLOCKSIZE_THINNED = 312
static const int32_t BLOCKSIZE_UNTHINNED = 273
class ExtendedI3Particle : public I3Particle

ExtendedI3Particle extends the functionality of I3Particle by adding a component enumeration type that corresponds to the air shower component.

NOTE: I3Particle provides no virtual method (except the destructor, fortunately). That means one should NOT reimplement ANY of I3Particle methods as this could cause trouble and/or confusion when sliced. As it is, zero intersection with I3Particle, it works fine.

Public Functions

ExtendedI3Particle()
explicit ExtendedI3Particle(const I3Particle &p, AirShowerComponent c = Undefined)

Explicit copy constructor to avoid implicit conversion.

inline ~ExtendedI3Particle()
inline ExtendedI3Particle Clone() const
inline AirShowerComponent GetAirShowerComponent() const
inline void SetAirShowerComponent(AirShowerComponent c)

Private Functions

SET_LOGGER ("ExtendedI3Particle")

Private Members

AirShowerComponent component_
struct GridKey

Public Functions

inline GridKey(double x, double y, double width)
inline double GetX() const
inline double GetY() const
inline bool operator==(const GridKey &rhs) const
inline bool operator!=(const GridKey &rhs) const
inline bool operator<(const GridKey &rhs) const

Private Members

double width_
int32_t x_
int32_t y_
struct GridNode

Public Members

Statistics stats_[4]
std::vector<unsigned> stations_
class HitHisto
#include <HitHisto.h>

HitHisto groups photo-electrons that arrive in a short time-window.

It provides a simple histogram class that bins PEs according to their time. Depending on the constructor arguments, it can also keep track of the origin of the PEs. The origin of the PEs can be traced at two levels of granularity:

  • high granularity: the ID of each I3MCPE is set to the ID of the I3Particle that produced it. This can potentially produce hundreds of thousands of PEs.

  • low granularity: the ID of each * I3MCPE is not a true particle ID. The major ID is set to zero and * the minor ID is set to the air shower component in the * ExtendedI3Particle that produced it.

It also provides a set of functions to fill standard frame object containers (usually I3MCPESeries, but there are convenience methods for I3MCHitSeries, I3RecoPulseSeries).

For more detailed comments, look into the source code.

Public Functions

HitHisto(double binWidth, I3MCPESeries *series, std::vector<int32_t> components)

Constructor specifying the width of the time bin, a pointer to I3MCPESeries and air shower components. Note that series should not be non-NULL if components is not-empty and viceversa.

Parameters:
  • binWidth – specifies the width of the time bins (in nanosecond)

  • series – is a pointer to an I3MCPESeries. If it is not NULL (high granularity tracking of PE origin), every time a Fill method is called, an I3MCPE will be added to this (with ID set to the particle that produced it). HitHisto does not own this pointer.

  • components – contains the enum values of the different possible air shower components. If it is not empty (low granularity tracking of PE origin), I3MCPEs will be grouped by the air shower component of the particle that produced them.

inline double GetBinWidth() const
inline void Fill(double time, double npe) __attribute__((deprecated))

don’t use this anymore, use one of the overloads below

void Fill(double time, double npe, const ExtendedI3Particle &p)

use this for the cherenkov histogram only

void Fill(std::vector<double> &times, const ExtendedI3Particle &p)

use this for the pe histogram, it allows HitHisto to merge I3MCPEs generated from the same particle at the same time effectively; note: we are passing a vector non-const, because it is sorted internally

inline bool HasHits() const
inline double GetNumHits() const
void Scale(double factor)
inline double GetBin(double time) const

these are internal details and should be private…

inline double GetBinCenter(double bin) const
inline double GetBinLowEdge(double bin) const

Private Types

typedef std::map<double, NPE> Histo

Private Functions

void FillBin(int32_t bin, double npe, const ExtendedI3Particle &p)

The main filling method. All others call this.

void FillObject(I3MCPESeries&) const

Fill an I3MCPESeries (all PEs if peSeries_ is not NULL or weighted PEs according to their time otherwise)

void FillObject(I3MCHitSeries&) const

Fill an I3MCPESeries (all PEs if peSeries_ is not NULL or weighted PEs according to their time otherwise)

Convenience method to fill a container of the old I3MCHit. Will be deprecated.

void FillObject(I3RecoPulseSeries&) const
void FillWithClassifiedPE(I3MCPESeries&) const

Fill an I3MCPESeries with PEs weighted according to their time and shower component. Will fail if peSeries_ is not NULL and will be empty if components_ is empty.

Private Members

const double binWidth_
I3MCPESeries *peSeries_
I3MCPESeries *scintpeSeries_
std::vector<int32_t> components_
std::map<int32_t, int32_t> index_
Histo histo_
double npesum_

Friends

friend class HitHistoCollection
class HitHistoCollection
#include <HitHisto.h>

Collection of the HitHisto instances per tank (OMKey)

It provides a simple histogram class that bins PEs according to their time. Depending on the constructor arguments, it can also keep track of the origin of the PEs. The origin of the PEs can be traced at two levels of granularity:

  • high granularity: the ID of each I3MCPE is set to the ID of the I3Particle that produced it. This can potentially produce hundreds of thousands of PEs.

  • low granularity: the ID of each * I3MCPE is not a true particle ID. The major ID is set to zero and * the minor ID is set to the air shower component in the * ExtendedI3Particle that produced it.

It also provides a set of functions to fill standard frame object containers (usually I3MCPESeries, but there are convenience methods for I3MCHitSeries, I3RecoPulseSeries).

Public Functions

HitHistoCollection(double binWidth, bool compressPEs, std::vector<int32_t> components)

Construct by specifying , the type of book-keeping to use when handling air shower components, and the enumeration values of the air shower components.

The compressPEs parameter controls whether the origin of the I3MCPEs is tracked:

  • 0: I3MCPEs are binned according to time and to the particle that produced them (largest number of I3MCPE objects),

  • 1: I3MCPEs are binned according to time and air shower components specified in components (medium number of I3MCPE objects),

  • 2: I3MCPE origin is discarded and all I3MCPEs are binned according to time only} (least number of I3MCPEs)

Parameters:
  • binWidth – specifies the width of the time bins (in nanosecond)

  • compressPEs – can take the values {0,1,2}.

  • components – the air shower component enum values.

HitHisto &GetHitHisto(const OMKey &omKey)

Get the HitHisto for a given OMKey.

HitHisto &GetHitHisto(const ScintKey &scintKey)
template<typename T>
inline boost::shared_ptr<I3Map<OMKey, T>> GenerateMap() const

Generate frame objects of different types (I3RecoPulseSeries, I3MCHitSeries, I3MCPESeries). This is usually called at the end of I3TopSimulator::DAQ.

template<typename T>
inline boost::shared_ptr<I3Map<ScintKey, T>> GenerateScintMap() const
I3MCPESeriesMapPtr GeneratePEClassMap() const

Generate I3MCPESeries frame object. This is the same as GenerateMap, but it is only used for I3MCPEs and only if compressPEs==1.

I3MCScintPESeriesMapPtr GeneratePEClassScintMap() const
template<>
I3MCPESeriesMapPtr GenerateMap() const
template<>
I3MCScintPESeriesMapPtr GenerateScintMap() const
template<>
I3MCPESeriesMapPtr GenerateMap() const
template<>
I3MCScintPESeriesMapPtr GenerateScintMap() const

Private Types

typedef std::map<OMKey, HitHisto> HistoMap
typedef std::map<ScintKey, HitHisto> ScintHistoMap

Private Members

const double binWidth_
I3MCPESeriesMapPtr peSeriesMap_
I3MCScintPESeriesMapPtr scintpeSeriesMap_
HistoMap histoMap_
ScintHistoMap scinthistoMap_
std::vector<int32_t> components_
class I3CorsikaGridInjector : public I3InjectorService

Scans through a CORSIKA file, samples all particles on a grid centered around the specified tanks or stations, and passes those to I3TopSimulator.

It is based on an idea of Arne Van Overloop and provides a very efficient way for generating a lot of statistics for single tank/station studies (e.g. to make a muon spectrum). It is not suited for doing full air-shower simulations!

Public Functions

I3CorsikaGridInjector(const I3Context &context)
~I3CorsikaGridInjector()
virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

bool NextEvent(int &runID, int &evtID, I3Particle &primary, I3FrameConstPtr frame)
virtual bool NextParticle(ExtendedI3Particle &primary)

Get the next particle in line. If there are no more particles, return false. Otherwise return true.

Note that the parameter is of type ExtendedI3Particle. ExtendedI3Particle extends the functionality of I3Particle by adding an enumeration type that corresponds to the air shower component. It is the responsibility of the derived classes to specify the shower component of each particle. It is “Undefined” by default.

One can assign particles to a categories. How this category is chosen is implementation specific as it depends on the code used to simulate the air shower. For example, one could split particles into EM component or muon component (where the electrons from muon decay are categorized in the muon component), or we could categorize muons as “prompt” and “non prompt”.

virtual std::map<std::string, int> GetAirShowerComponentNameMap() const

Get a map of shower component name to enum.

This method provides a mapping between the ExtendedI3Particle::AirShowerComponent enumeration value and the meaning of the category in human readable form. This helps to make i3 files self-documenting.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

virtual I3FrameObjectConstPtr GetEventInfo()

Return additional event info. This is implementation dependent, as each service can define its own frame object type to hold the event info.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

virtual I3TopInjectorInfoPtr GetTopInjectorInfo()

Set pointer to the tank response service.

This is a bit of a hack. It is done because CORSIKA files can be very large and iterating over all particles and all tanks can be very costly. A solution is to index tanks according to positions once and then iterate over a subset of tanks for each particle. This indexing happens inside I3IceTopResponseService. This method essentially breaks the encapsulation of responses and injectors.

This method is called in I3TopSimulator::DetectorStatus.

Private Functions

void FillTankList(const std::vector<std::string> &tankList)
void FillCenterList()
void RelocateParticle(I3Particle &particle, double shiftX, double shiftY)
SET_LOGGER ("I3CorsikaGridInjector")

Private Members

std::map<GridKey, std::vector<I3Particle>> eventBuffer_
std::map<GridKey, std::vector<I3Particle>>::const_iterator eventIter_
std::vector<I3Particle>::const_iterator particleIter_
std::vector<I3Position> centerList_
std::vector<I3Position>::const_iterator centerIter_
std::vector<std::string> corsikaFiles_
I3CorsikaReader reader_
I3Particle currentPrimary_
int currentRunID_
int currentEvtID_
double gridSize_
std::vector<TankKey> tankList_
std::vector<int> stationList_
std::string randomServiceName_
I3RandomServicePtr randomService_
class I3CorsikaInjector : public I3InjectorService

InjectorService that scans through a CORSIKA file and iterates over the particles.

It randomly choses the the core position within a circular sampling area and resamples the same shower several times. It also performs the un-thinning of thinned CORSIKA files and can optionally insert high pT muons.

Public Functions

I3CorsikaInjector(const I3Context &context)
~I3CorsikaInjector()
virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

virtual bool NextEvent(int32_t &runID, int32_t &evtID, I3Particle &primary, I3FrameConstPtr frame)

Reset the injector before proceeding to the next event. Derived classes are responsible for setting the first three arguments (run ID, event ID and primary particle). It is called at the beginning of I3TopSimulator::DAQ.

virtual bool NextParticle(ExtendedI3Particle &primary)

Get the next particle in line. If there are no more particles, return false. Otherwise return true.

Note that the parameter is of type ExtendedI3Particle. ExtendedI3Particle extends the functionality of I3Particle by adding an enumeration type that corresponds to the air shower component. It is the responsibility of the derived classes to specify the shower component of each particle. It is “Undefined” by default.

One can assign particles to a categories. How this category is chosen is implementation specific as it depends on the code used to simulate the air shower. For example, one could split particles into EM component or muon component (where the electrons from muon decay are categorized in the muon component), or we could categorize muons as “prompt” and “non prompt”.

virtual std::map<std::string, int32_t> GetAirShowerComponentNameMap() const

Get a map of shower component name to enum.

This method provides a mapping between the ExtendedI3Particle::AirShowerComponent enumeration value and the meaning of the category in human readable form. This helps to make i3 files self-documenting.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

virtual I3FrameObjectConstPtr GetEventInfo()

Return additional event info. This is implementation dependent, as each service can define its own frame object type to hold the event info.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

virtual I3TopInjectorInfoPtr GetTopInjectorInfo()

Set pointer to the tank response service.

This is a bit of a hack. It is done because CORSIKA files can be very large and iterating over all particles and all tanks can be very costly. A solution is to index tanks according to positions once and then iterate over a subset of tanks for each particle. This indexing happens inside I3IceTopResponseService. This method essentially breaks the encapsulation of responses and injectors.

This method is called in I3TopSimulator::DetectorStatus.

void Finish()

Private Functions

void ClearBuffers()
void CalculateOnRegions(const I3Particle &primary)
void CalculateArrayFootprint(const I3Particle &primary)
void ComputeOptDistances()
void GenerateClones(const I3Particle &particle, const double &weight)
void SetClonePosition(double &x, double &y, double &z, const I3Particle &particle, const double height, const double radius)
bool InsertHighPtMuon(I3Particle &particle)
AirShowerComponent GetAirShowerComponent(const I3Particle &p, double hadgen) const
SET_LOGGER ("I3CorsikaInjector")

Private Members

std::vector<std::string> corsikaFiles_
I3CorsikaReader reader_
int32_t relocationStation_
std::vector<TankKey> tankKeys_
double relocationX_
double relocationY_
double relocationR_
double shiftX_
double shiftY_
int32_t currentRunID_
int32_t currentEvtID_
int32_t numSamples_
int32_t sampleIndex_
I3Particle primary_
int32_t numHpTMuons_
int32_t hpTMuonCounter_
double hpTMuTotalMomentum_
double hpTMuTransMomentum_
std::map<boost::variant<TankKey, ScintKey>, double> optDistMap_
std::vector<I3Particle> cloneBuffer_
double dcheck_
bool alreadyWarned_
bool manyDetWarn_
boost::shared_ptr<topsim::SparseHistogram> phDistr_
boost::shared_ptr<topsim::SparseHistogram> particleDistr_
boost::shared_ptr<topsim::SparseHistogram> arrayFootprint_
double samplingWeight_
bool weightedRandomSampling_
double samplingRegionSide_
double onRegionSide_
double arraySide_
double tankSampleDistance_
double raiseObsLevel_
bool autoObsLevelHack_
double man_arrang_
std::vector<double> relocsX_
std::vector<double> relocsY_
int32_t nominalNumSamples_
I3RandomServicePtr randomService_
std::vector<int32_t> ignoreTypes_
class I3CorsikaReader
#include <I3CorsikaReader.h>

CORSIKA reader based on the original CORSIKA reader in the corsikaXX project written by Ralf Ulrich and Peter Niessen.

Public Functions

I3CorsikaReader()
~I3CorsikaReader()
void SetFileList(const std::vector<std::string> &fileNameList)
bool NextRun(int32_t &runID)
bool NextEvent(I3Particle &primary, int32_t &evtID)
bool NextParticle(I3Particle &particle, double &weight, const std::vector<int32_t> &ignoretypes = std::vector<int32_t>())
bool NextParticle(I3Particle &particle, double &weight, double &hadgen, const std::vector<int32_t> &ignoretypes = std::vector<int32_t>())
inline I3CorsikaShowerInfoPtr GetShowerInfo()
inline I3TopInjectorInfoPtr GetTopInjectorInfo()
void Rewind()
inline bool IsThinned()
inline void HackObsLevelUpwards(double extraz = 0)

As the method name states: This is a hack to shift al particle’s z-coordinate upwards a fixed amount. This is usually called immediately after I3CorsikaReader::NextRun() (before reading in any particles!)

inline double GetObsLevel() const

Get the observation level altitude above sea level. This value is nan until set in NextRun.

inline void HackArrang(double ext_arrang = 0)
int32_t CorsikaToPDG(int32_t corsika_id)
inline void HackIceActReader(bool is_iceact = false)

Private Functions

bool OpenFile(const std::string &filename)
void CloseFile()
bool NextSubBlock()
void FillLongProfile(const CorsikaSubBlock &longBlock)

Private Members

bool isIceActReader_
bool isThinned_
bool isCurved_
bool nonCartesian_
int32_t particleDataSize_
int32_t currentRunNumber_
int32_t currentEvtNumber_
int32_t currentPartIndex_
std::ios::pos_type lastEvtBlockPtr_
int32_t lastEvtSubBlockCounter_
int32_t eventCounter_
int64_t particleCounter_
time_t startTime_
time_t endTime_
int32_t obsLevel_
double zObsLevel_
double atmosphereHeight_
double m_arrang_
double_t minGenEnergy_
double_t maxGenEnergy_
double_t powerLawIndex_
std::vector<std::string> fileNameList_
int32_t fileIndex_
std::ifstream corsFile_
CorsikaSubBlock subBlock_
I3CorsikaShowerInfoPtr showerInfo_
I3TopInjectorInfoPtr topInjectorInfo_
class I3CorsikaThinnedInjector : public I3InjectorService

InjectorService that scans through a CORSIKA file and passes the particles to I3TopSimulator.

It randomly chooses the the core position within a circular sampling area and resamples the same shower several times. It also performs the un-thinning of thinned CORSIKA files and can optionally insert high pT muons.

Public Functions

I3CorsikaThinnedInjector(const I3Context &context)
~I3CorsikaThinnedInjector()
virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

virtual bool NextEvent(int32_t &runID, int32_t &evtID, I3Particle &primary, I3FrameConstPtr frame)

Reset the injector before proceeding to the next event. Derived classes are responsible for setting the first three arguments (run ID, event ID and primary particle). It is called at the beginning of I3TopSimulator::DAQ.

virtual bool NextParticle(ExtendedI3Particle &primary)

Get the next particle in line. If there are no more particles, return false. Otherwise return true.

Note that the parameter is of type ExtendedI3Particle. ExtendedI3Particle extends the functionality of I3Particle by adding an enumeration type that corresponds to the air shower component. It is the responsibility of the derived classes to specify the shower component of each particle. It is “Undefined” by default.

One can assign particles to a categories. How this category is chosen is implementation specific as it depends on the code used to simulate the air shower. For example, one could split particles into EM component or muon component (where the electrons from muon decay are categorized in the muon component), or we could categorize muons as “prompt” and “non prompt”.

virtual std::map<std::string, int> GetAirShowerComponentNameMap() const

Get a map of shower component name to enum.

This method provides a mapping between the ExtendedI3Particle::AirShowerComponent enumeration value and the meaning of the category in human readable form. This helps to make i3 files self-documenting.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

virtual I3FrameObjectConstPtr GetEventInfo()

Return additional event info. This is implementation dependent, as each service can define its own frame object type to hold the event info.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

virtual I3TopInjectorInfoPtr GetTopInjectorInfo()

Set pointer to the tank response service.

This is a bit of a hack. It is done because CORSIKA files can be very large and iterating over all particles and all tanks can be very costly. A solution is to index tanks according to positions once and then iterate over a subset of tanks for each particle. This indexing happens inside I3IceTopResponseService. This method essentially breaks the encapsulation of responses and injectors.

This method is called in I3TopSimulator::DetectorStatus.

Private Functions

AirShowerComponent GetAirShowerComponent(const I3Particle &p, double hadgen) const
SET_LOGGER ("I3CorsikaThinnedInjector")

Private Members

std::vector<std::string> corsikaFiles_
std::vector<int32_t> ignoreTypes_
I3CorsikaReader reader_
double raiseObsLevel_
bool autoObsLevelHack_
double man_arrang_
ParticleUnthinner unthinner_
double relocationX_
double relocationY_
double relocationR_
double shiftX_
double shiftY_
int32_t currentRunID_
int32_t currentEvtID_
unsigned numSamples_
unsigned sampleIndex_
std::vector<ExtendedI3Particle> clones_
std::string randomServiceName_
I3RandomServicePtr randomService_
bool smartUnthinning_
template<class T>
class I3IceTopResponseFactory : public I3SingleServiceFactory<I3IceTopResponseTemplate<T>, I3IceTopResponseService>

This is the IceTop response service factory which adds the IceTop response service to the contexts of all modules/services. This class is here only for backward compatibility with older scripts since everything is handled by I3SingleServiceFactory.

Public Functions

inline I3IceTopResponseFactory(const I3Context &context)
class I3IceTopResponseService : public I3ServiceBase

Each IceTop tank has a corresponding I3TankResponse object. This service provides access to them.

CORSIKA files can be very large and iterating over all particles for each tanks can be very costly. A solution adopted in topsimulator is to index tank according to positions. This class provides the methods for indexing and fast access to tank responses.

Subclassed by I3IceTopResponseTemplate< T >

Public Functions

I3IceTopResponseService(const I3Context &context)
inline virtual ~I3IceTopResponseService()
void Configure()

This method configures this class

virtual void Initialize(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status) = 0

The implementation of this method is done in I3IceTopResponseTemplate.h. It initializes all tank and scintillator responses and adds them to the search grid

virtual void Initialize_Scintillator(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status) = 0
virtual void Initialize_SurfaceDetector() = 0
I3TankResponsePtr GetTankResponse(const boost::variant<TankKey, ScintKey> &tankKey)

This method returns the tank response for a single tank

I3TankResponsePtr GetScintResponse(const boost::variant<TankKey, ScintKey> &scintKey)

This method returns the tank response for a single scintillator

inline I3TankResponseMapPtr GetTankResponseMap()

This method returns the map of all registered tank responses

inline I3TankResponseMapPtr GetScintResponseMap()
inline I3TankResponseMapPtr GetTankResponseMap(int32_t bin)

This method returns the map of all tank responses which are assigned to a certain bin of the search grid

I3TankResponseMapPtr GetTankResponseMap(double x, double y)

This method returns the map of all tank responses which are assigned to a certain position on the search grid

I3TankResponseMapPtr GetTankResponseMap(const I3Particle &track)

This method returns the map of all tank responses at the position where the track intersects the tank plane

inline double GetMeanTankZ() const

This method returns the average z position off all registered tanks which is used as the z-position of the search grid plane

inline double GetTankSamplingRadius() const

This method returns the tank sampling radius. A tank response is assigned to all bins (pixels) within the sampling radius

void BeginEvent(const I3Particle &primary)

This method is called by the I3TopSimulator at the beginning of each event. It calls the corresponding method of all registered tank responses

void EndEvent(HitHistoCollection &hitHC, HitHistoCollection &cherHitCollection, HitHistoCollection &scintHitCollection)

This method is called by the I3TopSimulator at the end of each event. It calls the corresponding method of all registered tank responses

void Print()

This method prints the coordinates of all registered tanks on the screen (for debugging purpose)

Protected Functions

void InitializeGrid()
template<class ParamType>
inline void AddParameter(const std::string &name, const std::string &description, const ParamType &defaultValue)
template<class ParamType>
inline void GetParameter(const std::string &name, ParamType &value) const
inline const I3Context &GetContext()

Protected Attributes

I3TankResponseMapPtr tankMap_
I3TankResponseMapPtr scintMap_

Private Functions

void ResetGrid(double xmin, double xwidth, int xbins, double ymin, double ywidth, int ybins)
void AddTank(double x, double y, const boost::variant<TankKey, ScintKey> &tankKey, I3TankResponsePtr response)
int32_t GetBin(double x, double y)
int32_t GetBinX(double x)
int32_t GetBinY(double y)
double GetBinCenterX(int xbin)
double GetBinCenterY(int ybin)
SET_LOGGER ("I3IceTopResponseService")

Private Members

int32_t xbins_
double xwidth_
double xmin_
double xmax_
int32_t ybins_
double ywidth_
double ymin_
double ymax_
double meanz_
double gridSize_
double samplRadius_
std::vector<I3TankResponseMapPtr> fastGrid_
template<class T>
class I3IceTopResponseTemplate : public I3IceTopResponseService

This class provides the interface to different I3TankResponse implementations (types)

Public Functions

inline I3IceTopResponseTemplate(const I3Context &context)
inline virtual void Initialize(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)

The implementation of this method is done in I3IceTopResponseTemplate.h. It initializes all tank and scintillator responses and adds them to the search grid

inline virtual void Initialize_Scintillator(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)
inline virtual void Initialize_SurfaceDetector()
SET_LOGGER ("I3IceTopResponseTemplate")
template<class T>
class I3InjectorFactory : public I3SingleServiceFactory<T, I3InjectorService>

This is the injector service factory which adds the injector service to the contexts of all modules/services. This class is here only for backward compatibility with older scripts since now everything is handled by I3SingleServiceFactory.

Public Functions

inline I3InjectorFactory(const I3Context &context)
class I3InjectorService : public I3ServiceBase

This virtual base class specifies the interface for all IceTop particle injectors.

The main method that any particle injector needs to implement is NextParticle, which takes a non-const reference to a particle. This method gets called until there are no more particles.

Other methods that need to be implemented:

  • NextEvent

  • GetAirShowerComponentNameMap

Subclassed by I3CorsikaGridInjector, I3CorsikaInjector, I3CorsikaThinnedInjector, I3ParticleInjector, topsim::MCTreeShimInjector

Public Functions

inline I3InjectorService(const I3Context &context)
inline virtual ~I3InjectorService()
inline virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

virtual bool NextEvent(int32_t &runID, int32_t &evtID, I3Particle &primary, I3FrameConstPtr frame) = 0

Reset the injector before proceeding to the next event. Derived classes are responsible for setting the first three arguments (run ID, event ID and primary particle). It is called at the beginning of I3TopSimulator::DAQ.

virtual bool NextParticle(ExtendedI3Particle &particle) = 0

Get the next particle in line. If there are no more particles, return false. Otherwise return true.

Note that the parameter is of type ExtendedI3Particle. ExtendedI3Particle extends the functionality of I3Particle by adding an enumeration type that corresponds to the air shower component. It is the responsibility of the derived classes to specify the shower component of each particle. It is “Undefined” by default.

One can assign particles to a categories. How this category is chosen is implementation specific as it depends on the code used to simulate the air shower. For example, one could split particles into EM component or muon component (where the electrons from muon decay are categorized in the muon component), or we could categorize muons as “prompt” and “non prompt”.

inline virtual I3FrameObjectConstPtr GetEventInfo()

Return additional event info. This is implementation dependent, as each service can define its own frame object type to hold the event info.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

inline virtual I3TopInjectorInfoPtr GetTopInjectorInfo()

Set pointer to the tank response service.

This is a bit of a hack. It is done because CORSIKA files can be very large and iterating over all particles and all tanks can be very costly. A solution is to index tanks according to positions once and then iterate over a subset of tanks for each particle. This indexing happens inside I3IceTopResponseService. This method essentially breaks the encapsulation of responses and injectors.

This method is called in I3TopSimulator::DetectorStatus.

inline void SetResponseService(I3IceTopResponseServicePtr response)
virtual std::map<std::string, int32_t> GetAirShowerComponentNameMap() const = 0

Get a map of shower component name to enum.

This method provides a mapping between the ExtendedI3Particle::AirShowerComponent enumeration value and the meaning of the category in human readable form. This helps to make i3 files self-documenting.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

Protected Functions

template<class ParamType>
inline void AddParameter(const std::string &name, const std::string &description, const ParamType &defaultValue)
template<class ParamType>
inline void GetParameter(const std::string &name, ParamType &value) const
inline const I3Context &GetContext()
SET_LOGGER ("I3InjectorService")

Protected Attributes

I3IceTopResponseServicePtr responseService_
class I3ParamTankResponse : public I3TankResponse

Generates a signal which is proportional to the extrapolated track length of a particle trajectory in the tank.

The conversion to VEM is done by parametrisations for each particle type, see vem_yield.

Public Functions

I3ParamTankResponse(I3Configuration &config, const I3Context &context, const TankKey &tankKey, const ScintKey &scintKey)
virtual void Initialize(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)

This method initializes the tank geometry and other things

virtual void Initialize_Scintillator(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)
virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

inline virtual double GetX() const

X coordinate of tank center.

inline virtual double GetY() const

Y coordinate of tank center.

inline virtual double GetZ() const

Z coordinate of tank center.

inline virtual double GetTankHeight() const

Tank height.

inline virtual double GetVirtualTankHeight() const

Tank height plus an (optional) margin (e.g. needed for geant4 simulations) This is method is called by the injector service (the minimum should be the actual tank height).

inline virtual double GetTankRadius() const

Outer tank radius.

inline virtual double GetVirtualTankRadius() const

Tank radius plus an (optional) margin (e.g. needed for geant4 simulations) This is method is called by the injector service (the minimum should be the actual tank radius)

inline virtual double GetSnowHeight() const

Snow height.

virtual bool TrackParticle(const ExtendedI3Particle &particle, HitHistoCollection &hitHC, HitHistoCollection &cherHitCollection, HitHistoCollection &scintHitCollection)

This method is called by the I3Topsimulator to do the tracking of a particle It should return True if the particle has hit a tank (it generated a signal).

Private Functions

void AddParameters(I3Configuration &configuration)
bool TankResponse(const ExtendedI3Particle &iceTrack, HitHistoCollection &hitHC, HitHistoCollection &cherHitCollection, HitHistoCollection &scintHitCollection)
void GenerateHits(int32_t npe, const ExtendedI3Particle &p, HitHisto &hitHisto)
SET_LOGGER ("I3ParamTankResponse")

Private Members

double posX_
double posY_
double posZ_
double tankRadius_
double tankHeight_
double fillHeight_
double snowHeight_
double perlHeight_
double tauZirco_
double tauTyvek_
double decayTime_
bool useSnowPar_
std::map<OMKey, double> pePerVEM_
std::string randomServiceName_
I3RandomServicePtr randomService_

Private Static Attributes

static const double MEAN_NORMALIZED_PE = 0.850529

Mean charge per PE.

The Constant used to be in <pmt-simulator/I3PMTConstants.h>, which is now deprecated. Does it exist anywhere else now?

This parameter needs to be updated whenever the charge distribution constants change. This should be caught in the tests.

static const double PERL_SNOW_EQUIV = 0.3

Perlite/Snow density ratio.

class I3ParticleInjector : public I3InjectorService

Generates particles according to various distributions at the positions of specified tanks and passes them to I3TopSimulator.

It may be used to tabulate the tank response for analytical purposes and other cases, where user-defined particles need to be injected into tanks.

Public Functions

I3ParticleInjector(const I3Context &context)
~I3ParticleInjector()
virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

virtual bool NextEvent(int32_t &runID, int32_t &evtID, I3Particle &primary, I3FrameConstPtr frame)

Reset the injector before proceeding to the next event. Derived classes are responsible for setting the first three arguments (run ID, event ID and primary particle). It is called at the beginning of I3TopSimulator::DAQ.

virtual bool NextParticle(ExtendedI3Particle &primary)

Get the next particle in line. If there are no more particles, return false. Otherwise return true.

Note that the parameter is of type ExtendedI3Particle. ExtendedI3Particle extends the functionality of I3Particle by adding an enumeration type that corresponds to the air shower component. It is the responsibility of the derived classes to specify the shower component of each particle. It is “Undefined” by default.

One can assign particles to a categories. How this category is chosen is implementation specific as it depends on the code used to simulate the air shower. For example, one could split particles into EM component or muon component (where the electrons from muon decay are categorized in the muon component), or we could categorize muons as “prompt” and “non prompt”.

virtual std::map<std::string, int> GetAirShowerComponentNameMap() const

Get a map of shower component name to enum.

This method provides a mapping between the ExtendedI3Particle::AirShowerComponent enumeration value and the meaning of the category in human readable form. This helps to make i3 files self-documenting.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

Private Functions

void FillTankList(const std::vector<std::string> &tankList)
I3Particle::ParticleType GetParticleType(const std::string &typeName)
double GetEnergy()
double GetZenith()
double GetAzimuth()
void GetXY(double &x, double &y)
void GetRangeParameter(const std::string &name, std::vector<double> &range, double unit = 1.0)
void ShiftAlongTrack(I3Particle &particle, double z)
SET_LOGGER ("I3ParticleInjector")

Private Members

int numParticles_
int numEvents_
std::vector<boost::variant<TankKey, ScintKey>> tankKeys_
std::vector<boost::variant<TankKey, ScintKey>>::const_iterator tankKey_iter_
bool useAllTanks_
I3Particle::ParticleType particleType_
std::string randomServiceName_
I3RandomServicePtr randomService_
int32_t eventCounter_
int32_t particleCounter_
std::vector<double> energyRange_
double specIndex_
std::vector<double> radiusRange_
std::vector<double> phiRange_
double startHeight_
std::vector<double> zenithRange_
double zenithPower_
std::vector<double> azimuthRange_
class I3TankResponse
#include <I3TankResponse.h>

This is the base class for the IceTop tank responses.

Subclassed by I3ParamTankResponse

Public Functions

inline I3TankResponse(I3Configuration &config, const I3Context &context, const TankKey &tankKey, const ScintKey &scintKey)
inline virtual ~I3TankResponse()
inline virtual void Configure()

This method should be used to read in optional tank parameters which can be defined in the constructor (as in I3Module)

inline virtual void Initialize(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)

This method initializes the tank geometry and other things

inline virtual void Initialize_Scintillator(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)
inline const TankKey &GetTankKey() const
inline const ScintKey &GetScintKey() const
virtual double GetX() const = 0

X coordinate of tank center

virtual double GetY() const = 0

Y coordinate of tank center

virtual double GetZ() const = 0

Z coordinate of tank center

virtual double GetTankHeight() const = 0

Tank height

virtual double GetVirtualTankHeight() const = 0

Tank height plus an (optional) margin (e.g. needed for geant4 simulations) This is method is called by the injector service (the minimum should be the actual tank height).

virtual double GetTankRadius() const = 0

Outer tank radius

virtual double GetVirtualTankRadius() const = 0

Tank radius plus an (optional) margin (e.g. needed for geant4 simulations) This is method is called by the injector service (the minimum should be the actual tank radius)

virtual double GetSnowHeight() const = 0

Snow height

inline virtual bool TrackParticle(const ExtendedI3Particle &particle, HitHistoCollection &hitHC, HitHistoCollection &cherHitCollectionHit, HitHistoCollection &scintHitCollection)

This method is called by the I3Topsimulator to do the tracking of a particle It should return True if the particle has hit a tank (it generated a signal).

inline virtual void BeginEvent(const I3Particle &primary)

This method is called by the I3Topsimulator at the beginning of an event

inline virtual void EndEvent(HitHistoCollection &hitHC, HitHistoCollection &cherHitCollection, HitHistoCollection &scintHitCollection)

This method is called by the I3Topsimulator at the end of an event

inline const I3Configuration &GetConfiguration()

Protected Functions

template<class ParamType>
inline void AddParameter(const std::string &name, const std::string &description, const ParamType &defaultValue)
template<class ParamType>
inline void GetParameter(const std::string &name, ParamType &value)
inline const I3Context &GetContext()

Protected Attributes

const TankKey tankKey_
const ScintKey scintKey_

Private Functions

SET_LOGGER ("I3TankResponse")

Private Members

const I3Context &context_
I3Configuration &configuration_
class I3TopAddComponentWaveforms : public I3ConditionalModule

Public Functions

inline I3TopAddComponentWaveforms(const I3Context &context)
inline ~I3TopAddComponentWaveforms()
inline void Configure()
inline void DAQ(I3FramePtr frame)

Private Functions

std::vector<Binning> GetBinnings(I3WaveformSeriesMapConstPtr waveforms_in) const
std::vector<Binning> GetBinnings(I3DOMLaunchSeriesMapConstPtr launches) const

This function replicates things done in WaveCalibrator

double GetStartTime(const I3DOMLaunch &launch, const I3DOMCalibration &calib, const I3DOMStatus &status, bool fadc) const
SET_LOGGER ("I3TopAddComponentWaveforms")

Private Members

std::string launches_
std::string waveforms_in_
std::string pe_series_map_
std::string components_
std::string waveforms_
std::string pulses_
I3GeometryConstPtr geometry_
I3CalibrationConstPtr calibration_
I3DetectorStatusConstPtr detector_status_
class I3TopSimulator : public I3Module
#include <I3TopSimulator.h>

The I3Topsimulator module handles the whole simulation and stores the results in the frame.

Public Functions

I3TopSimulator(const I3Context &context)
~I3TopSimulator()
void Configure()
void DetectorStatus(I3FramePtr frame)
void DAQ(I3FramePtr frame)

Private Functions

void WriteEventHeader(I3FramePtr frame, int32_t runID, int32_t evtID)

This function generates an event header and put it to the frame.

TankKey GetTankKey(std::string key) const
ScintKey GetScintKey(std::string key) const
AirShowerComponent GetAirShowerComponent(const I3Particle &p) const
std::map<std::string, int32_t> GetAirShowerComponentNameMap() const
SET_LOGGER ("I3TopSimulator")

Private Members

std::string injectorServiceName_
std::string responseServiceName_
std::string mcPrimaryName_
std::string hitSeriesName_
std::string peSeriesName_
std::string scintpeSeriesName_
std::string cherSeriesName_
std::string scintSeriesName_
std::string testPulsesName_
std::string icMCTreeName_
std::string itMCTreeName_
double hitBinWidth_
double muEnergyCut_
bool writeEvtHeader_
bool createSframe_
int32_t compressPEs_
bool useInjectorComponents_
bool useScintillator_
std::set<TankKey> tankKeys_
std::set<ScintKey> scintKeys_
int32_t sampleCount_
I3InjectorServicePtr injector_
I3IceTopResponseServicePtr response_

Private Static Attributes

static const std::string INC_ID_NAME = "MCTimeIncEventID"
struct Index

Public Types

typedef unsigned short elem_t

Public Functions

inline Index(elem_t a, elem_t b)
inline bool operator<(Index other) const

Public Members

elem_t i
elem_t j
class MCTreeShimInjector : public I3InjectorService

Public Functions

inline MCTreeShimInjector(const I3Context &ctx)
inline virtual bool NextEvent(int32_t &run, int32_t &event, I3Particle &primary, I3FrameConstPtr frame)

Reset the injector before proceeding to the next event. Derived classes are responsible for setting the first three arguments (run ID, event ID and primary particle). It is called at the beginning of I3TopSimulator::DAQ.

inline virtual bool NextParticle(ExtendedI3Particle &p)

Get the next particle in line. If there are no more particles, return false. Otherwise return true.

Note that the parameter is of type ExtendedI3Particle. ExtendedI3Particle extends the functionality of I3Particle by adding an enumeration type that corresponds to the air shower component. It is the responsibility of the derived classes to specify the shower component of each particle. It is “Undefined” by default.

One can assign particles to a categories. How this category is chosen is implementation specific as it depends on the code used to simulate the air shower. For example, one could split particles into EM component or muon component (where the electrons from muon decay are categorized in the muon component), or we could categorize muons as “prompt” and “non prompt”.

inline virtual std::map<std::string, int32_t> GetAirShowerComponentNameMap() const

Get a map of shower component name to enum.

This method provides a mapping between the ExtendedI3Particle::AirShowerComponent enumeration value and the meaning of the category in human readable form. This helps to make i3 files self-documenting.

This method is called at the end of I3TopSimulator::DAQ to add this map to the frame.

Private Members

I3MCTreeConstPtr mctree_
I3MCTree::const_iterator currentParticle_
struct NPE : public std::valarray<uint32_t>

Public Functions

inline NPE(double n)
class ParticleUnthinner : private noncopyable

ParticleUnthinner

Re-samples re-weighted particles into tanks, using a ring segment around the shower axis as a virtual larger collection area. Uses an internal grid to accelerate matching particles to sampling areas.

Public Functions

ParticleUnthinner(double r_max, unsigned r_bin, unsigned phi_bin)
~ParticleUnthinner()
void AddStation(const I3Position &posA, const I3Position &posB, double tank_radius, double tank_height)
void SetStations(const I3Geometry&, double dr_safety, double dh_safety)
void ClearStations()
void SetPrimary(const I3Particle&)
inline const I3Particle &GetPrimary() const
void SetPrimaryPos(const I3Position&)
Index AddParticle(const I3Particle&, double weight)
unsigned Sample(std::vector<ExtendedI3Particle>&, const ExtendedI3Particle&, double weight, I3RandomService&) const
void ToShowerFrontCS(double &rho, double &phi, double &z, const I3Position&) const
Index ToIndex(const I3Position&) const
inline Index GetGridShape() const
inline double GetGridRMax() const
const GridNode &GetGridNode(Index) const
void GetGridSegment(double &r1, double &r2, double &phi1, double &phi2, Index) const
inline const std::vector<Station> &GetStations() const

Private Functions

SET_LOGGER ("ParticleUnthinner")
Index ToIndex(double sqrt_r, double phi) const

always returns a valid index

inline GridNode &GetGridNode(Index)
void ComputeSamplingArea(Station&) const
void AssignStationToGrid(unsigned, const Station&)
double NParticles(Index, const Station&, const I3Particle&, double weight) const
unsigned GenerateClones(std::vector<ExtendedI3Particle>&, const Station&, const ExtendedI3Particle&, double npart, I3RandomService&) const
void RelocateParticle(ExtendedI3Particle&, const I3Position&, double radius, double height, I3RandomService&) const

Private Members

double sqrt_r_max_
unsigned r_bin_
unsigned phi_bin_
GridNode *grid_
std::vector<Station> stations_
I3Particle primary_
double transform_[3][3]
class SparseHistogram
#include <SparseHistogram.h>

Sparse 2d histograms with very specific characteristics.

The histograms ranges and bin sizes are equal in both axes and both ranges are symmetric. Therefore, you can specify the length of one side and the number of bins.

No default constructor provided and copy is disabled. It does not have over/underflow bin.

Public Functions

SparseHistogram(double side, int32_t bins)
~SparseHistogram()
void Reset()

Reset all entries to zero.

void Resize(double side, int32_t bins)
void Fill(double x, double y, double weight = 1.)

As the name says… add one entry to the histogram.

void Set(int32_t i, int32_t j, double v)

Directly set the value of a given bin.

inline double GetBinWidth() const
inline int32_t GetBins() const
double GetEntries() const

Calculate the sum of the weighted entries (it is not cached)

std::vector<SparseHistogramIndex> GetNonEmptyBins() const

Build a list of non-empty bins (it is not cached and might be expensive for large histograms)

int FindBin(double x) const

Give the bin number. Same for both axes.

inline double At(int32_t i, int32_t j) const
inline double GetBinCenter(int32_t i)

Private Functions

SparseHistogram(const SparseHistogram &other)
SparseHistogram &operator=(const SparseHistogram &other)

Private Members

boost::numeric::ublas::compressed_matrix<double> data_
double side_
int32_t bins_
double binSize_
struct SparseHistogramIndex
#include <SparseHistogram.h>

Simple structure to hold a pair of indices with a convenience constructor.

Public Functions

inline SparseHistogramIndex(int32_t i, int32_t j)

Public Members

int32_t x
int32_t y
struct Station

Public Functions

Station(const I3Position &posA, const I3Position &posB, double radius, double height)

Public Members

I3Position pos_[2]
double radius_
double height_
double ring_radius_[2]
double ring_phi_[2]
struct Statistics

Public Functions

inline Statistics()

Public Members

double wmax
double w_sum
double logdt_sum
double logdt2_sum
namespace [anonymous]
namespace [anonymous]
namespace [anonymous]
namespace [anonymous]

I3TopAddComponentWaveforms module adds “waveforms” and “pulses” for each air shower component.

The “waveforms” are just histograms of photoelectron times with a binning that matches the actual waveforms’ sampling. The “pulses” are just the integral of the waveforms.

namespace [anonymous]
namespace [anonymous]
namespace GeoFunctions

Functions

bool IntersectCylinder(const I3Position &center, const double &height, const double &radius, const I3Particle &particle, I3Particle &contTrack)
bool IntersectCylinder(const I3Position &center, const double &height, const double &radius, const I3Particle &particle)
bool IntersectCylinder(const double &xc, const double &yc, const double &zc, const double &height, const double &radius, const I3Particle &particle)
bool IntersectCylinder(const double &xc, const double &yc, const double &zc, const double &height, const double &radius, const I3Particle &particle, I3Particle &contTrack)

Determine whether the path of an I3Particle intersects with a cylinder.

They return a boolean to indicate an intersection, and some overloads fill a passed reference with the contained track.

namespace std

STL namespace.

namespace topsim

Typedefs

typedef I3SingleServiceFactory<MCTreeShimInjector, I3InjectorService> MCTreeShimInjectorFactory

Functions

bool operator==(const SparseHistogram &lhs, const SparseHistogram &rhs)
void Convolve(const SparseHistogram &in, const SparseHistogram &kernel, SparseHistogram &out)
inline bool operator==(const SparseHistogramIndex &lhs, const SparseHistogramIndex &rhs)
namespace vem_yield

Functions

double em_snow(double E, double snow)

Response for e-, E in [GeV], snow in [m].

double ga_snow(double E, double snow)

Response for photons, E in [GeV], snow in [m].

double mm_snow(double E, double snow)

Response for mu-, E in [GeV], snow in [m].

double em(double E)

Stefan Klepser’s original VEM-parametrisations.

Response for e-, E in [GeV]

double ep(double E)

Response for e+, E in [GeV].

double ga(double E)

Response for photons, E in [GeV].

double mm(double E)

Response for mu-, E in [GeV].

double mp(double E)

Response for mu+, E in [GeV].

double p(double E)

Response for protons, E in [GeV].

double ap(double E)

Response for anti-protons, E in [GeV].

double n(double E)

Response for neutrons, E in [GeV].

double pm(double E)

Response for pi-, E in [GeV].

double pp(double E)

Response for pi+, E in [GeV].

double km(double E)

Response for K-, E in [GeV].

double kp(double E)

Response for K+, E in [GeV].

double an(double E)

Response for anti-neutrons, E in [GeV].

double k0(double E)

Response for K0, E in [GeV].

Variables

const double lowE0 = std::pow(10.0, -1)
const double lowE1 = std::pow(10.0, -1.5)
const double lowE2 = std::pow(10.0, -2)
const double highE0 = std::pow(10.0, -0.4)
const double highE1 = std::pow(10.0, -0.45)
const double highE2 = std::pow(10.0, -1.6)
const double con0 = 0.00153448
const double con1 = 0.00541449
const double con2 = 0.00664103
const double lowEp0 = std::pow(10.0, -2)
const double lowEp1 = std::pow(10.0, -1.55)
const double lowEp2 = std::pow(10.0, -0.3)
const double lowEp3 = std::pow(10.0, -2)
const double lowEp4 = std::pow(10.0, -1.55)
const double lowEp5 = std::pow(10.0, -0.3)
const double lowEp6 = std::pow(10.0, -2.7)
const double lowEp7 = std::pow(10.0, -0.35)
const double lowEp8 = std::pow(10.0, -1.3)
const double lowEp9 = std::pow(10.0, -0.98)
const double lowEp10 = std::pow(10.0, -0.5)
const double lowEp11 = std::pow(10.0, -1.3)
const double lowEp12 = std::pow(10.0, -1.12)
const double lowEp13 = std::pow(10.0, -0.45)
const double lowEp14 = std::pow(10.0, -0.4)
const double lowEp15 = std::pow(10.0, -2)
const double lowEp16 = std::pow(10.0, -0.5)
const double lowEp17 = std::pow(10.0, -0.45)
const double lowEp18 = std::pow(10.0, -2)
const double lowEp19 = std::pow(10.0, -0.3)
const double lowEp20 = std::pow(10.0, -1.6)
const double lowEp21 = std::pow(10.0, -2)
const double lowEp22 = std::pow(10.0, -2)
const double lowEp23 = std::pow(10.0, -2)
const double lowEp24 = std::pow(10.0, -2)
const double highEp0 = std::pow(10.0, -1.55)
const double highEp1 = std::pow(10.0, -0.3)
const double highEp3 = std::pow(10.0, -1.55)
const double highEp4 = std::pow(10.0, -0.3)
const double highEp6 = std::pow(10.0, -0.35)
const double highEp7 = std::pow(10.0, 3)
const double highEp8 = std::pow(10.0, -0.98)
const double highEp9 = std::pow(10.0, -0.5)
const double highEp11 = std::pow(10.0, -1.12)
const double highEp12 = std::pow(10.0, -0.45)
const double highEp14 = std::pow(10.0, 3)
const double highEp15 = std::pow(10.0, -0.5)
const double highEp16 = std::pow(10.0, 3)
const double highEp17 = std::pow(10.0, 3)
const double highEp18 = std::pow(10.0, -0.3)
const double highEp19 = std::pow(10.0, 3)
const double highEp20 = std::pow(10.0, 3)
const double highEp21 = std::pow(10.0, 3)
const double highEp22 = std::pow(10.0, 3)
const double highEp23 = std::pow(10.0, 3)
const double highEp24 = std::pow(10.0, 3)
const double shift0 = -0.657087
const double shift1 = -0.155872
const double shift2 = -2.6855
const double shift3 = -0.00170685
const double shift4 = -0.247134
const double shift5 = -1.4513
const double shift6 = -0.00244643
const double shift7 = -1.99509
const double shift8 = -11.2218
const double shift9 = -0.197563
const double shift10 = -2659.12
const double shift11 = 0.0610708
const double shift12 = 0.0416769
const double shift13 = -793.155
const double shift14 = -0.61907
const double shift15 = -0.203576
const double shift16 = 1.07027
const double shift17 = -0.24919
const double shift18 = 0.00321739
const double shift19 = 0.199565
const double shift20 = -0.141411
const double shift21 = -0.0344296
const double shift22 = -0.0726239
const double shift23 = 1.25941
const double shift24 = 0.164325
const double factor0 = 0.679547
const double factor1 = 2.34833
const double factor2 = 4.67655
const double factor3 = 0.0935907
const double factor4 = 2.25601
const double factor5 = 3.35781
const double factor6 = 2.37340
const double factor7 = 3.45558
const double factor8 = 11.3756
const double factor9 = 2.60166
const double factor10 = 2659.89
const double factor11 = 0.41587
const double factor12 = 2.40796
const double factor13 = 793.948
const double factor14 = 1.0147
const double factor15 = 2.56841
const double factor16 = 0.843406
const double factor17 = 0.524519
const double factor18 = 2.30643
const double factor19 = 0.727576
const double factor20 = 0.966665
const double factor21 = 0.858686
const double factor22 = 0.773135
const double factor23 = 0.756258
const double factor24 = 0.487564
const double index0 = 0.00707092
const double index1 = 0.750112
const double index2 = 0.281949
const double index3 = 0.826965
const double index4 = 0.616594
const double index5 = 0.347713
const double index6 = 1.17829
const double index7 = 0.212694
const double index8 = 0.00272074
const double index9 = 0.982432
const double index10 = 9.96308e-06
const double index11 = 0.573477
const double index12 = 1.18025
const double index13 = 3.31792e-05
const double index14 = 0.539015
const double index15 = 0.258919
const double index16 = 0.491593
const double index17 = 0.643671
const double index18 = 1.66533
const double index19 = 0.520686
const double index20 = 0.480246
const double index21 = 0.476828
const double index22 = 0.479467
const double index23 = 0.528013
const double index24 = 0.588115
const double VEM_SCALE_WITH_SNOW = 1.070

Various constants and parametrizations to simulate VEM-calibrated signals.

They are used by I3ParamTankResponse. For more detailed comments, please look into the header file (I couldn’t figure out how to group variables in doxygen).For Patrick’s parametrizations

const double VEM_SCALE_NO_SNOW = 1.275

For Stefan’s parametrizations.

const double VEM_NORM_SNOW = 155.0

Patrick Berghaus’s VEM-parametrisations including the snow.

Relative normalization constant, number of PEs per VEM

const double mass_ga = 0.0

Masses of the particles in GeV.

const double mass_e = 0.51099892e-3
const double mass_mu = 0.105658369
const double mass_p = 0.93827203
const double mass_n = 0.93956536
const double mass_pi = 0.13957018
const double mass_ka = 0.493677
const double mass_ka0 = 0.497648
file CorsikaSubBlock.cxx
#include <cstring>
file CorsikaSubBlock.h
#include <fstream>
#include <iostream>
#include <icetray/I3Logging.h>

Functions

inline std::ifstream &operator>>(std::ifstream &s, CorsikaSubBlock &b)

This function defines the operator>> to stream in CORSIKA data into an CorsikaSubBlock.

file ExtendedI3Particle.cxx

Copyright (C) 2015 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Javier Gonzalez

file ExtendedI3Particle.h
#include <dataclasses/physics/I3Particle.h>

Copyright (C) 2015 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Javier Gonzalez

Enums

enum AirShowerComponent

This enum lists all air shower components that could be used in simulation.

Values:

enumerator Undefined
enumerator Background
enumerator Gamma
enumerator Electron
enumerator Muon
enumerator ElectronFromChargedMesons
enumerator ElectronFromLocalChargedMesons
enumerator GammaFromChargedMesons
enumerator GammaFromLocalChargedMesons
enumerator Hadron
file GeoFunctions.cxx

Copyright (C) 2010 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Tilo Waldenmaier

file GeoFunctions.h
#include <dataclasses/I3Position.h>
#include <dataclasses/physics/I3Particle.h>

Copyright (C) 2010 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Tilo Waldenmaier

file HitHisto.cxx
#include <icetray/OMKey.h>
#include <dataclasses/physics/I3Particle.h>
#include <stdexcept>
#include <algorithm>
#include <boost/foreach.hpp>

Functions

bool I3MCPE_cmp(const I3MCPE &a, const I3MCPE &b)
file HitHisto.h
#include <map>
#include <string>
#include <valarray>
#include <simclasses/I3MCPE.h>
#include <dataclasses/I3Map.h>
#include <dataclasses/physics/I3MCHit.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <dataclasses/physics/I3Particle.h>
#include <boost/variant.hpp>
file I3CorsikaGridInjector.cxx
#include <phys-services/I3GSLRandomService.h>

Functions

I3_SERVICE_FACTORY(I3InjectorFactory<I3CorsikaGridInjector>)
file I3CorsikaGridInjector.h
#include <phys-services/I3RandomService.h>
#include <dataclasses/I3Position.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
#include <map>
#include <string>
file I3CorsikaInjector.cxx
#include <icetray/I3SingleServiceFactory.h>
#include <dataclasses/geometry/I3TankGeo.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/I3Constants.h>
#include <limits.h>
#include <cstdlib>

Functions

I3_SERVICE_FACTORY(I3InjectorFactory<I3CorsikaInjector>)
file I3CorsikaInjector.h
#include <phys-services/I3RandomService.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <map>
#include <string>
file I3CorsikaReader.cxx
#include <dataclasses/I3Constants.h>
#include <dataclasses/I3Direction.h>
#include <icetray/open.h>
#include <time.h>
#include <boost/assign.hpp>
#include <inttypes.h>

Typedefs

typedef std::map<int, int> CORSIKAtoPDGMap_t

Variables

static const CORSIKAtoPDGMap_t CORSIKAtoPDGMap
file I3CorsikaReader.h
#include <dataclasses/physics/I3Particle.h>
#include <simclasses/I3TopInjectorInfo.h>
#include <simclasses/I3CorsikaShowerInfo.h>
#include <simclasses/CorsikaLongStep.h>
#include <dataclasses/I3Constants.h>
#include <string>
#include <fstream>
file I3CorsikaThinnedInjector.cxx
#include <icetray/I3DefaultName.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/I3Constants.h>
#include <limits>
#include <cmath>
#include <boost/foreach.hpp>

Functions

I3_SERVICE_FACTORY(I3InjectorFactory<I3CorsikaThinnedInjector>)
file I3CorsikaThinnedInjector.h
#include <phys-services/I3RandomService.h>
#include <vector>
#include <string>
file I3IceTopResponseFactory.h
#include <icetray/I3SingleServiceFactory.h>

Copyright (C) 2010 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Tilo Waldenmaier

file I3IceTopResponseService.cxx
#include <icetray/I3Units.h>
file I3IceTopResponseService.h
#include <icetray/I3Units.h>
#include <icetray/I3ServiceBase.h>
#include <dataclasses/Utility.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <dataclasses/status/I3DetectorStatus.h>
#include <dataclasses/physics/I3Particle.h>
#include <icetray/I3DefaultName.h>

Functions

I3_DEFAULT_NAME(I3IceTopResponseService)
I3_POINTER_TYPEDEFS(I3IceTopResponseService)
file I3IceTopResponseTemplate.h
#include <icetray/I3Logging.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
#include <boost/foreach.hpp>
#include <I3/name_of.h>
file I3InjectorFactory.h
#include <icetray/I3SingleServiceFactory.h>
file I3InjectorService.h
#include <icetray/I3ServiceBase.h>
#include <icetray/I3Context.h>
#include <icetray/I3FrameObject.h>
#include <icetray/I3DefaultName.h>
#include <simclasses/I3TopInjectorInfo.h>
#include <dataclasses/physics/I3Particle.h>
#include <map>
#include <string>

Functions

I3_DEFAULT_NAME(I3InjectorService)
I3_POINTER_TYPEDEFS(I3InjectorService)
file I3ParamTankResponse.cxx
#include <dataclasses/I3Constants.h>
#include <phys-services/I3GSLRandomService.h>

Functions

I3_SERVICE_FACTORY(I3IceTopResponseFactory<I3ParamTankResponse>)
file I3ParamTankResponse.h
#include <dataclasses/physics/I3Particle.h>
#include <phys-services/I3RandomService.h>
file I3ParticleInjector.cxx
#include <phys-services/I3GSLRandomService.h>
#include <dataclasses/I3Constants.h>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <sstream>

Defines

PARTICLE_TYPE_MAP_APPEND(r, data, t)

Functions

I3_SERVICE_FACTORY(I3InjectorFactory<I3ParticleInjector>)
file I3ParticleInjector.h
#include <phys-services/I3RandomService.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
#include <dataclasses/physics/I3Particle.h>
#include <map>
#include <string>
file I3TankResponse.h
#include <icetray/I3Context.h>
#include <icetray/I3Configuration.h>
#include <icetray/I3PointerTypedefs.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <dataclasses/status/I3DetectorStatus.h>
#include <map>
#include <boost/variant.hpp>

Typedefs

typedef std::map<boost::variant<TankKey, ScintKey>, I3TankResponsePtr> I3TankResponseMap

Functions

I3_POINTER_TYPEDEFS(I3TankResponse)
I3_POINTER_TYPEDEFS(I3TankResponseMap)
file I3TopAddComponentWaveforms.cxx
#include <icetray/I3ConditionalModule.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/physics/I3Waveform.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/geometry/I3OMGeo.h>
#include <dataclasses/calibration/I3Calibration.h>
#include <dataclasses/calibration/I3DOMCalibration.h>
#include <dataclasses/status/I3DetectorStatus.h>
#include <dataclasses/status/I3DOMStatus.h>
#include <dataclasses/I3DOMFunctions.h>
#include <dataclasses/physics/I3DOMLaunch.h>
#include <dataclasses/physics/I3RecoPulse.h>
#include <simclasses/I3MCPE.h>
#include <boost/make_shared.hpp>
#include <string>
#include <map>
#include <algorithm>
#include <numeric>

Functions

I3_MODULE(I3TopAddComponentWaveforms)
file I3TopSimulator.cxx
#include <icetray/I3Context.h>
#include <icetray/I3Frame.h>
#include <icetray/I3Bool.h>
#include <dataclasses/physics/I3EventHeader.h>
#include <dataclasses/physics/I3MCTreeUtils.h>
#include <dataclasses/physics/I3ScintRecoPulseSeriesMap.h>
#include <dataclasses/I3Map.h>
#include <dataclasses/I3Double.h>
#include <stdexcept>

Functions

I3_MODULE(I3TopSimulator)
file I3TopSimulator.h
#include <icetray/I3Module.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/ScintKey.h>
file MCTreeShimInjector.cxx
#include “icetray/I3SingleServiceFactory.h”
#include “icetray/I3Frame.h”
#include “dataclasses/physics/I3MCTree.h”
#include “dataclasses/physics/I3EventHeader.h”

Functions

I3_SERVICE_FACTORY(topsim::MCTreeShimInjectorFactory)
file ParticleUnthinner.cxx
#include <phys-services/I3Calculator.h>
#include <phys-services/surfaces/Cylinder.h>
#include <dataclasses/I3Constants.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/geometry/I3TankGeo.h>
#include <boost/foreach.hpp>
#include <cmath>
#include <limits>
file ParticleUnthinner.h
#include <dataclasses/physics/I3Particle.h>
#include <dataclasses/I3Position.h>
#include <icetray/I3Logging.h>
#include <boost/noncopyable.hpp>
#include <vector>
#include <map>
file SparseHistogram.cxx
#include <icetray/I3Logging.h>
file SparseHistogram.h
#include <vector>
#include <boost/numeric/ublas/matrix_sparse.hpp>

Variables

static const char CVSId__SparseHistogram[] = "$Id$"
file vem_yield.cxx
#include <iostream>

Copyright (C) 2010 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Stefan Klepser, Patrick Berghaus

file vem_yield.h
#include <cmath>

Copyright (C) 2010 The IceCube collaboration ID:

Rcs

Version

Rcs
Date

Rcs
Author

Stefan Klepser, Patrick Berghaus

dir icetray
dir injectors
dir injectors
dir interface
dir interface
dir private
dir public
dir responses
dir responses
dir topsimulator
dir topsimulator
dir topsimulator