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 ¶

#include <ExtendedI3Particle.h>

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¶

#include <I3CorsikaGridInjector.h>

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¶

#include <ParticleUnthinner.h>

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 ¶

#include <I3CorsikaGridInjector.h>

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 ¶

#include <I3CorsikaInjector.h>

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 ¶

#include <I3CorsikaThinnedInjector.h>

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>¶

#include <I3IceTopResponseFactory.h>

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 ¶

#include <I3IceTopResponseService.h>

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 ¶

#include <I3IceTopResponseTemplate.h>

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>¶

#include <I3InjectorFactory.h>

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 ¶

#include <I3InjectorService.h>

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 ¶

#include <I3ParamTankResponse.h>

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 ¶

#include <I3ParticleInjector.h>

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¶

#include <ParticleUnthinner.h>

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¶

#include <ParticleUnthinner.h>

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¶

#include <ParticleUnthinner.h>

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¶

#include <ParticleUnthinner.h>

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 “topsimulator/injectors/CorsikaSubBlock.h”

#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

#include <topsimulator/ExtendedI3Particle.h>

Rcs

Version
Rcs
Date
Rcs
Author: Javier Gonzalez

file ExtendedI3Particle.h

#include <dataclasses/physics/I3Particle.h>

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

#include <topsimulator/GeoFunctions.h>

Rcs

Version
Rcs
Date
Rcs
Author: Tilo Waldenmaier

file GeoFunctions.h

#include <dataclasses/I3Position.h>

#include <dataclasses/physics/I3Particle.h>

Rcs

Version
Rcs
Date
Rcs
Author: Tilo Waldenmaier

file HitHisto.cxx

#include <topsimulator/HitHisto.h>

#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 <topsimulator/ExtendedI3Particle.h>

#include <boost/variant.hpp>

file I3CorsikaGridInjector.cxx

#include <topsimulator/interface/I3InjectorFactory.h>

#include <topsimulator/injectors/I3CorsikaGridInjector.h>

#include <phys-services/I3GSLRandomService.h>

Functions

I3_SERVICE_FACTORY(I3InjectorFactory<I3CorsikaGridInjector>)¶

file I3CorsikaGridInjector.h: #include <topsimulator/interface/I3InjectorService.h>

#include <topsimulator/injectors/I3CorsikaReader.h>

#include <topsimulator/ExtendedI3Particle.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 <topsimulator/interface/I3InjectorFactory.h>

#include <topsimulator/injectors/I3CorsikaInjector.h>

#include <dataclasses/I3Constants.h>

#include <limits.h>

#include <cstdlib>

Functions

I3_SERVICE_FACTORY(I3InjectorFactory<I3CorsikaInjector>)¶

file I3CorsikaInjector.h: #include <topsimulator/interface/I3InjectorService.h>

#include <topsimulator/injectors/I3CorsikaReader.h>

#include <topsimulator/ExtendedI3Particle.h>

#include <topsimulator/injectors/SparseHistogram.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 <topsimulator/injectors/I3CorsikaReader.h>

#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 <topsimulator/injectors/CorsikaSubBlock.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 <topsimulator/injectors/I3CorsikaThinnedInjector.h>

#include <topsimulator/interface/I3InjectorFactory.h>

#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 <topsimulator/interface/I3InjectorService.h>

#include <topsimulator/injectors/I3CorsikaReader.h>

#include <topsimulator/injectors/ParticleUnthinner.h>

#include <phys-services/I3RandomService.h>

#include <vector>

#include <string>

file I3IceTopResponseFactory.h

#include <icetray/I3SingleServiceFactory.h>

#include <topsimulator/interface/I3IceTopResponseTemplate.h>

Rcs

Version
Rcs
Date
Rcs
Author: Tilo Waldenmaier

file I3IceTopResponseService.cxx: #include <topsimulator/interface/I3IceTopResponseService.h>

#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 <topsimulator/interface/I3TankResponse.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 <topsimulator/interface/I3IceTopResponseService.h>

#include <topsimulator/interface/I3TankResponse.h>

#include <boost/foreach.hpp>

#include <I3/name_of.h>

file I3InjectorFactory.h: #include <icetray/I3SingleServiceFactory.h>

#include <topsimulator/interface/I3InjectorService.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 <topsimulator/interface/I3IceTopResponseService.h>

#include <topsimulator/ExtendedI3Particle.h>

#include <map>

#include <string>

Functions

I3_DEFAULT_NAME(I3InjectorService)¶

I3_POINTER_TYPEDEFS(I3InjectorService)¶

file I3ParamTankResponse.cxx

#include <topsimulator/interface/I3IceTopResponseFactory.h>

#include <topsimulator/responses/I3ParamTankResponse.h>

#include <topsimulator/responses/vem_yield.h>

#include <topsimulator/GeoFunctions.h>

#include <dataclasses/I3Constants.h>

#include <phys-services/I3GSLRandomService.h>

Functions

I3_SERVICE_FACTORY(I3IceTopResponseFactory<I3ParamTankResponse>)¶

file I3ParamTankResponse.h: #include <topsimulator/interface/I3TankResponse.h>

#include <dataclasses/physics/I3Particle.h>

#include <phys-services/I3RandomService.h>

file I3ParticleInjector.cxx

#include <topsimulator/interface/I3InjectorFactory.h>

#include <topsimulator/injectors/I3ParticleInjector.h>

#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 <topsimulator/interface/I3InjectorService.h>

#include <topsimulator/ExtendedI3Particle.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 <topsimulator/HitHisto.h>

#include <topsimulator/ExtendedI3Particle.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 <topsimulator/I3TopSimulator.h>

#include <topsimulator/ExtendedI3Particle.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 <topsimulator/interface/I3InjectorService.h>

#include <topsimulator/interface/I3IceTopResponseService.h>

#include <topsimulator/ExtendedI3Particle.h>

#include <dataclasses/TankKey.h>

#include <dataclasses/ScintKey.h>

file MCTreeShimInjector.cxx

#include “topsimulator/interface/I3InjectorService.h”

#include “icetray/I3SingleServiceFactory.h”

#include “icetray/I3Frame.h”

#include “dataclasses/physics/I3MCTree.h”

#include “dataclasses/physics/I3EventHeader.h”

#include “topsimulator/ExtendedI3Particle.h”

Functions

I3_SERVICE_FACTORY(topsim::MCTreeShimInjectorFactory)¶

file ParticleUnthinner.cxx: #include “topsimulator/injectors/ParticleUnthinner.h”

#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 <topsimulator/ExtendedI3Particle.h>

#include <boost/noncopyable.hpp>

#include <vector>

#include <map>

file SparseHistogram.cxx: #include <topsimulator/injectors/SparseHistogram.h>

#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>

#include <topsimulator/responses/vem_yield.h>

Rcs

Version
Rcs
Date
Rcs
Author: Stefan Klepser, Patrick Berghaus

file vem_yield.h

#include <cmath>

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

topsimulator C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page