sim-services C++ API Reference

struct _private

#include <zmq.hpp>

struct AllParticles_t

#include <I3LightSourceParameterization.h>

struct Bunch

Public Functions

inline Bunch(const I3MCPE &hit)

inline void absorb(const I3MCPE &hit)

inline bool operator<(const I3MCPE &hit) const

Public Members

double time

uint32_t npe

std::vector<I3ParticleID> parents

class context_t

#include <zmq.hpp>

Public Functions

inline context_t()

inline explicit context_t(int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)

inline  ~context_t () ZMQ_NOTHROW

inline int setctxopt(int option_, int optval_)

inline int getctxopt(int option_)

inline void close () ZMQ_NOTHROW

inline void shutdown () ZMQ_NOTHROW

inline ZMQ_EXPLICIT operator void * () ZMQ_NOTHROW

inline ZMQ_EXPLICIT operator void const * () const ZMQ_NOTHROW

inline ZMQ_NODISCARD void * handle () ZMQ_NOTHROW

inline  operator bool () const ZMQ_NOTHROW

inline void swap (context_t &other) ZMQ_NOTHROW

Private Functions

context_t (const context_t &) ZMQ_DELETED_FUNCTION

void operator= (const context_t &) ZMQ_DELETED_FUNCTION

Private Members

void *ptr

struct ConversionResult_t

#include <I3StepToPhotonConverter.h>

Public Functions

inline ConversionResult_t()

inline ConversionResult_t(uint32_t identifier_, I3CLSimPhotonSeriesPtr photons_ = I3CLSimPhotonSeriesPtr(), I3CLSimPhotonHistorySeriesPtr photonHistories_ = I3CLSimPhotonHistorySeriesPtr())

Public Members

uint32_t identifier

I3CLSimPhotonSeriesPtr photons

I3CLSimPhotonHistorySeriesPtr photonHistories

class DiagnosticMap

#include <I3PropagatorService.h>

@ a read-write replacement for I3Frame

Public Types

typedef std::map<std::string, I3FrameObjectPtr> map_type

typedef map_type::value_type value_type

typedef map_type::iterator iterator

Public Functions

inline bool Has(const std::string &key) const

template<typename T>
inline T Get(const std::string &key, typename boost::enable_if<is_shared_ptr<T>>::type* = 0)

inline void Put(const std::string &key, I3FrameObjectPtr item)

inline iterator begin()

inline iterator end()

Private Members

map_type map_

class error_t : public std::exception

#include <zmq.hpp>

Public Functions

inline  error_t () ZMQ_NOTHROW

inline explicit  error_t (int err) ZMQ_NOTHROW

inline virtual const char * what () const ZMQ_NOTHROW ZMQ_OVERRIDE

inline int num () const ZMQ_NOTHROW

Private Members

int errnum

struct frameCacheEntry

#include <I3PhotonPropagationClientModule.h>

Public Types

typedef std::map<OMKey, MCHitMerging::MCPEStream> MCPEStreamMap

Public Functions

inline frameCacheEntry(uint32_t identifier, const I3FramePtr &f)

inline uint32_t key() const

Public Members

uint32_t frameId

uint32_t currentPhotonId

uint32_t numPendingParticles

I3FramePtr frame

bool error

std::set<ModuleKey> ignoreModules

std::vector<uint32_t> particles

boost::shared_ptr<I3CompressedPhotonSeriesMap> photons

boost::shared_ptr<I3PhotonSeriesMap> photonhistories

boost::shared_ptr<MCPEStreamMap> hits

I3MCTreePtr particleHistories

struct from_handle_t

#include <zmq.hpp>

Public Functions

inline ZMQ_CONSTEXPR_FN ZMQ_EXPLICIT from_handle_t (_private) ZMQ_NOTHROW

class I3CLSimPhotonToMCPEConverter

#include <I3CLSimPhotonToMCPEConverter.h>

Subclassed by I3CLSimPhotonToMCPEConverterForDOMs

Public Functions

virtual ~I3CLSimPhotonToMCPEConverter()

virtual boost::optional<std::tuple<OMKey, I3MCPE>> Convert(const ModuleKey&, const I3CompressedPhoton&) const = 0

class I3CLSimPhotonToMCPEConverterForDOMs : public I3CLSimPhotonToMCPEConverter

#include <I3PhotonToMCPEConverter.h>

Public Functions

I3CLSimPhotonToMCPEConverterForDOMs(I3RandomServicePtr, boost::shared_ptr<const std::map<OMKey, I3CLSimFunctionConstPtr>>, I3CLSimFunctionConstPtr)

virtual ~I3CLSimPhotonToMCPEConverterForDOMs()

virtual boost::optional<std::tuple<OMKey, I3MCPE>> Convert(const ModuleKey&, const I3CompressedPhoton&) const override

Private Members

I3RandomServicePtr randomService_

boost::shared_ptr<const std::map<OMKey, I3CLSimFunctionConstPtr>> wavelengthAcceptance_

I3CLSimFunctionConstPtr angularAcceptance_

class I3CombineMCPE : public I3ConditionalModule

#include <I3CombineMCPE.h>

Combines several I3MCPEHitSeriesMaps into one.

Public Functions

I3CombineMCPE(const I3Context &ctx)

inline ~I3CombineMCPE()

void Configure()

void DAQ(I3FramePtr frame)

inline void Finish()

Private Functions

SET_LOGGER ("I3CombineMCPE")

Private Members

std::vector<std::string> inputResponses_

std::string outputResponse_

class I3CosmicEventGenerator

#include <I3CosmicEventGenerator.h>

Public Functions

I3CosmicEventGenerator(I3IncrementalEventGeneratorServicePtr airShower, std::function<bool(const I3Particle&)> secondaryFilter = std::function<bool(const I3Particle&)>(), NeutrinoSelectorPtr neutrinoSelector = nullptr, I3IncrementalEventGeneratorServicePtr neutrinoPropagator = nullptr)

I3CosmicEventGenerator(const I3CosmicEventGenerator&) = delete

void Generate(I3MCTree&, I3Frame &frame, std::function<void(I3Particle&)> emitParticle)

Protected Attributes

I3IncrementalEventGeneratorServicePtr airShowerSimulator_

std::function<bool(const I3Particle&)> secondaryFilter_

NeutrinoSelectorPtr neutrinoSelector_

I3IncrementalEventGeneratorServicePtr neutrinoPropagator_

class I3DownsampleMCPE : public I3ConditionalModule

Randomly downsample MCPEs from one collection to another.

Copyright (c) 2014 Ben Jones bjpjones@mit.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Public Functions

I3DownsampleMCPE(const I3Context &ctx)

inline ~I3DownsampleMCPE()

void Configure()

void DAQ(I3FramePtr frame)

inline void Finish()

Private Functions

SET_LOGGER ("I3DownsampleMCPE")

Private Members

std::string inputName_

std::string outputName_

double sampleFrac_

I3RandomServicePtr rng_

class I3GeneratorService : public I3ServiceBase

#include <I3GeneratorService.h>

Base class for MC event generator service.

Public Functions

virtual I3MCTreePtr GetNextEvent() = 0

virtual I3FramePtr GetNextFrame() = 0

virtual double GetRate() = 0

I3GeneratorService()

I3GeneratorService(const I3Context &ctx)

virtual ~I3GeneratorService()

class I3IncrementalEventGeneratorService

#include <I3CosmicEventGenerator.h>

Public Functions

virtual void StartShower(I3Particle &primary, const I3Frame &frame) = 0

virtual bool NextParticle(I3Particle &particle) = 0

virtual void EndEvent(I3Frame&)

inline virtual ~I3IncrementalEventGeneratorService()

class I3InIceCORSIKATrimmer : public I3ConditionalModule

Remove muons that have no chance of reaching the detector.

Public Functions

inline I3InIceCORSIKATrimmer(const I3Context &ctx)

inline void Configure()

inline void DAQ(I3FramePtr frame)

Private Functions

inline bool Drop(const I3Particle &p)

SET_LOGGER ("I3InIceCORSIKATrimmer")

Private Members

double minRange_

bool dropNeutrinos_

bool filterMode_

Range muonRange_

struct I3LightSourceParameterization

#include <I3LightSourceParameterization.h>

Defines a particle parameterization for fast simulation, bypassing Geant4.

Public Functions

I3LightSourceParameterization()

~I3LightSourceParameterization()

I3LightSourceParameterization(I3LightSourceToStepConverterPtr converter_, I3Particle::ParticleType forParticleType_, double fromEnergy_, double toEnergy_, bool needsLength_ = false)

I3LightSourceParameterization(I3LightSourceToStepConverterPtr converter_, const I3Particle &forParticleType_, double fromEnergy_, double toEnergy_, bool needsLength_ = false)

I3LightSourceParameterization(I3LightSourceToStepConverterPtr converter_, const AllParticles_t&, double fromEnergy_, double toEnergy_, bool needsLength_ = false)

I3LightSourceParameterization(I3LightSourceToStepConverterPtr converter_, I3FlasherPulse::FlasherPulseType forFlasherPulseType_)

bool IsValidForParticle(const I3Particle &particle) const

bool IsValid(I3Particle::ParticleType type, double energy, double length = NAN) const

bool IsValidForLightSource(const I3LightSource &lightSource) const

Public Members

I3LightSourceToStepConverterPtr converter

I3Particle::ParticleType forParticleType

double fromEnergy

double toEnergy

bool needsLength

bool catchAll

bool flasherMode

I3FlasherPulse::FlasherPulseType forFlasherPulseType

Public Static Attributes

static const AllParticles_t AllParticles = I3LightSourceParameterization::AllParticles_t()

class I3LightSourcePropagator

#include <I3LightSourcePropagator.h>

Subclassed by I3LightSourcePropagatorFromI3PropagatorService

Public Types

typedef std::function<bool(I3LightSourceConstPtr&, uint32_t)> secondary_callback

Function to call when a secondary light source is produced. If the callback returns true, the light source was accepted by another propagator, and this propagator should stop processing it. Otherwise, this propagator needs to break the secondary down into steps itself.

typedef std::function<void(const I3SimStep&)> step_callback

Function to call when a step is produced.

Public Functions

virtual bool IsValidForLightSource(const I3LightSource&) = 0

virtual I3MCTreePtr Convert(I3LightSourceConstPtr&, uint32_t, secondary_callback, step_callback) = 0

inline virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias)

Sets the wavelength bias. Set this to a constant value of 1 if you do not need biased photon generation. The Cherenkov spectrum will be multiplied by this value at each wavelength. This will influence the number of photons produced. Will throw if used after the call to Initialize().

inline virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties)

Sets the medium properties. Will throw if used after the call to Initialize().

virtual void SetRandomService(I3RandomServicePtr random) = 0

virtual void Initialize() = 0

virtual bool IsInitialized() const = 0

class I3LightSourcePropagatorFromI3PropagatorService : public I3LightSourcePropagator

#include <I3LightSourcePropagatorFromI3PropagatorService.h>

Public Functions

I3LightSourcePropagatorFromI3PropagatorService(I3ParticleTypePropagatorServiceMapPtr, bool trackParticleHistory = false, double cascadeBinWidth = 50 * I3Units::m)

virtual ~I3LightSourcePropagatorFromI3PropagatorService()

virtual void SetRandomService(I3RandomServicePtr random)

inline virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias)

Sets the wavelength bias. Set this to a constant value of 1 if you do not need biased photon generation. The Cherenkov spectrum will be multiplied by this value at each wavelength. This will influence the number of photons produced. Will throw if used after the call to Initialize().

inline virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties)

Sets the medium properties. Will throw if used after the call to Initialize().

inline virtual void Initialize()

Initializes the simulation. Will throw if already initialized.

inline virtual bool IsInitialized() const

Returns true if initialized. Never throws.

virtual bool IsValidForLightSource(const I3LightSource &source)

virtual I3MCTreePtr Convert(I3LightSourceConstPtr&, uint32_t, secondary_callback, step_callback)

Private Functions

SET_LOGGER ("I3LightSourcePropagatorFromI3PropagatorService")

Private Members

I3ParticleTypePropagatorServiceMapPtr particleToPropagatorServiceMap_

bool initialized_

bool trackParticleHistory_

double cascadeBinWidth_

struct I3LightSourceToStepConverter : private noncopyable

#include <I3LightSourceToStepConverter.h>

Subclassed by I3LightSourceToStepConverterAsync, I3LightSourceToStepConverterPotemkin

Public Functions

I3LightSourceToStepConverter()

virtual ~I3LightSourceToStepConverter()

virtual void SetBunchSizeGranularity(uint64_t num) = 0

Sets the granularity of the bunch size for the return vectors. The number of entries in a vector will always be a multiple of this number. Will throw if used after the call to Initialize().

virtual void SetMaxBunchSize(uint64_t num) = 0

Sets the maximum bunch size. Will throw if used after the call to Initialize().

virtual void SetRandomService(I3RandomServicePtr random) = 0

Sets the random number generator service. This should be an instance of I3RandomService. Will throw if used after the call to Initialize().

virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias) = 0

Sets the wavelength bias. Set this to a constant value of 1 if you do not need biased photon generation. The Cherenkov spectrum will be multiplied by this value at each wavelength. This will influence the number of photons produced. Will throw if used after the call to Initialize().

virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties) = 0

Sets the medium properties. Will throw if used after the call to Initialize().

virtual void SetLightSourceParameterizationSeries(const I3LightSourceParameterizationSeries &parameterizationSeries_)

Sets the available parameterizations. Particles with parameterizations may be returned without having been converted into steps. Will throw if used after the call to Initialize().

virtual const I3LightSourceParameterizationSeries &GetLightSourceParameterizationSeries() const

Returns the available parameterizations. Particles with parameterizations may be returned without having been converted into steps.

virtual void Initialize() = 0

Initializes the simulation. Will throw if already initialized.

virtual bool IsInitialized() const = 0

Returns true if initialized. Never throws.

virtual void EnqueueLightSource(const I3LightSource &lightSource, uint32_t identifier) = 0

Adds a new I3LightSource to the queue for use as a primary in tracking. The resulting I3SimSteps can be retrieved from the I3LightSourceToStepConverter after some processing time.

Enqueuing a particle after calling EnqueueBarrier will throw if not all steps have been retrieved.

Each step produced by this particle will be tagged with the id set by “identifier”.

Will throw if not initialized.

virtual void EnqueueBarrier() = 0

Adds a “barrier” to the particle queue. This will keep the simulation running until all steps have been retrieved. New particles can only be added to the queue after all “old” steps have been retrieved.

Will throw if not initialized.

virtual bool BarrierActive() const = 0

Returns true if an enqueued barrier is still active. And active barrier means that no new particles can currently be added to the queue. Steps have to be retrieved using GetConversionResult() until this function returns false.

Will throw if not initialized.

virtual bool MoreStepsAvailable() const = 0

Returns true if more steps are available for the current particle. If the return value is false, the current simulation is finished and a new particle may be set.

Will throw if not initialized.

virtual I3SimStepSeriesConstPtr GetConversionResultWithBarrierInfo(bool &barrierWasReset, double timeout = NAN) = 0

Returns a bunch of steps stored in a vector<I3LSimStep>. The uint32_t value is the primary’s identifier as passed to EnqueueLightSource().

Might block if no steps are available. The steps may belong to various particles at the same time.

Will throw if not initialized.

virtual I3SimStepSeriesConstPtr GetConversionResult(double timeout = NAN)

Protected Attributes

I3LightSourceParameterizationSeries parameterizationSeries

class I3LightSourceToStepConverter_exception : public std::runtime_error

#include <I3LightSourceToStepConverter.h>

Base class for objects that get a I3LightSource (i.e. either a I3Particle or a I3FlasherPulse) and convert it into individual I3SimStep objects stored as bunches in an I3SimStepSeries.

Public Functions

inline I3LightSourceToStepConverter_exception(const std::string &msg)

class I3LightSourceToStepConverterAsync : public I3LightSourceToStepConverter

#include <I3LightSourceToStepConverterAsync.h>

A particle-to-step converter using a mix of MC propagators and parameterizations running in a thread.

Public Types

typedef std::tuple<I3SimStepSeriesConstPtr, std::vector<uint32_t>, std::map<uint32_t, I3MCTreePtr>, bool> FromGeant4Pair_t

Public Functions

I3LightSourceToStepConverterAsync(uint32_t maxQueueItems = default_maxQueueItems)

virtual ~I3LightSourceToStepConverterAsync()

virtual void SetBunchSizeGranularity(uint64_t num)

Sets the granularity of the bunch size for the return vectors. The number of entries in a vector will always be a multiple of this number. This will stop the worker thread; restart it with a call to Initialize() before enqueuing steps.

virtual void SetMaxBunchSize(uint64_t num)

Sets the maximum bunch size. This will stop the worker thread; restart it with a call to Initialize() before enqueuing steps.

virtual void SetRandomService(I3RandomServicePtr random)

Sets the random service to use. This will stop the worker thread; restart it with a call to Initialize() before enqueuing steps.

virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias)

Sets the wavelength bias. Set this to a constant value of 1 if you do not need biased photon generation. The Cherenkov spectrum will be multiplied by this value at each wavelength. This will influence the number of photons produced. This will stop the worker thread; restart it with a call to Initialize() before enqueuing steps.

virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties)

Sets the medium properties. This will stop the worker thread; restart it with a call to Initialize() before enqueuing steps.

virtual void SetPropagators(const std::vector<I3LightSourcePropagatorPtr>&)

Sets the propagators to use. This will stop the worker thread; restart it with a call to Initialize() before enqueuing steps.

virtual void Initialize()

Initialize the simulation and start the worker thread

virtual bool IsInitialized() const

Returns true if the worker thread has been started. Never throws.

virtual void EnqueueLightSource(const I3LightSource &lightSource, uint32_t identifier)

Adds a new I3Particle to the queue for use as a primary in tracking. The resulting I3SimSteps can be retrieved from the I3LightSourceToStepConverter after some processing time.

Enqueuing a particle after calling EnqueueBarrier will throw if not all steps have been retrieved.

Each step produced by this particles will be tagged with the id set by “identifier”.

Will throw if not initialized.

virtual void EnqueueBarrier()

Adds a “barrier” to the particle queue. This will keep the simulation running until all steps have been retrieved. New particles can only be added to the queue after all “old” steps have been retrieved.

Will throw if not initialized.

virtual bool BarrierActive() const

Returns true an enqueued barrier is still active. And active barrier means that no new particles can currently be added to the queue. Steps have to be retrieved using GetConversionResult() until this function returns false.

Will throw if not initialized.

virtual bool MoreStepsAvailable() const

Returns true if more steps are available for the current particle. If the return value is false, the current simulation is finished and a new particle may be set.

Will throw if not initialized.

virtual I3SimStepSeriesConstPtr GetConversionResultWithBarrierInfo(bool &barrierWasReset, double timeout = NAN)

Returns a bunch of steps stored in a vector<I3SimStep> or a pair of <uint32_t, I3ParticleConstPtr>. Returned particles were produced by the primary particle. The uint32_t value is the primary’s identifier as passed to EnqueueLightSource().

Might block if no steps are available. The steps may belong to various particles at the same time.

Will throw if not initialized.

virtual std::tuple<I3SimStepSeriesConstPtr, std::vector<uint32_t>, std::map<uint32_t, I3MCTreePtr>> GetConversionResultWithBarrierInfoAndMarkers(bool &barrierWasReset, double timeout = NAN)

Like GetConversionResultWithBarrierInfo(), but also returns a vector of the identifiers that have finished processing.

Public Static Attributes

static const uint32_t default_maxQueueItems = 5

Private Types

typedef std::pair<uint32_t, I3LightSourceConstPtr> ToGeant4Pair_t

Private Functions

void WorkerThread()

void WorkerThread_impl(boost::this_thread::disable_interruption &di)

void StartThread()

void StopThread()

SET_LOGGER ("I3LightSourceToStepConverterAsync")

Private Members

boost::shared_ptr<boost::thread> thread_

boost::condition_variable_any threadStarted_cond_

boost::mutex threadStarted_mutex_

bool threadStarted_

mutable boost::mutex barrier_is_enqueued_mutex_

bool barrier_is_enqueued_

boost::shared_ptr<I3CLSimQueue<ToGeant4Pair_t>> queueToGeant4_

boost::shared_ptr<I3CLSimQueue<FromGeant4Pair_t>> queueFromGeant4_

I3RandomServicePtr randomService_

bool initialized_

uint64_t bunchSizeGranularity_

uint64_t maxBunchSize_

I3CLSimFunctionConstPtr wlenBias_

I3CLSimMediumPropertiesConstPtr mediumProperties_

std::vector<I3LightSourcePropagatorPtr> propagators_

struct I3LightSourceToStepConverterPotemkin : public I3LightSourceToStepConverter

#include <I3LightSourceToStepConverterPotemkin.h>

Fake step generator for unit tests.

Public Functions

I3LightSourceToStepConverterPotemkin()

virtual ~I3LightSourceToStepConverterPotemkin()

inline virtual void SetBunchSizeGranularity(uint64_t num) override

Sets the granularity of the bunch size for the return vectors. The number of entries in a vector will always be a multiple of this number. Will throw if used after the call to Initialize().

inline virtual void SetMaxBunchSize(uint64_t num) override

Sets the maximum bunch size. Will throw if used after the call to Initialize().

inline virtual void SetRandomService(I3RandomServicePtr random) override

Sets the random number generator service. This should be an instance of I3RandomService. Will throw if used after the call to Initialize().

inline virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias) override

Sets the wavelength bias. Set this to a constant value of 1 if you do not need biased photon generation. The Cherenkov spectrum will be multiplied by this value at each wavelength. This will influence the number of photons produced. Will throw if used after the call to Initialize().

inline virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties) override

Sets the medium properties. Will throw if used after the call to Initialize().

inline virtual void Initialize() override

Initializes the simulation. Will throw if already initialized.

inline virtual bool IsInitialized() const override

Returns true if initialized. Never throws.

virtual void EnqueueLightSource(const I3LightSource &lightSource, uint32_t identifier) override

Adds a new I3LightSource to the queue for use as a primary in tracking. The resulting I3SimSteps can be retrieved from the I3LightSourceToStepConverter after some processing time.

Enqueuing a particle after calling EnqueueBarrier will throw if not all steps have been retrieved.

Each step produced by this particle will be tagged with the id set by “identifier”.

Will throw if not initialized.

inline virtual void EnqueueBarrier() override

Adds a “barrier” to the particle queue. This will keep the simulation running until all steps have been retrieved. New particles can only be added to the queue after all “old” steps have been retrieved.

Will throw if not initialized.

inline virtual bool BarrierActive() const override

Returns true if an enqueued barrier is still active. And active barrier means that no new particles can currently be added to the queue. Steps have to be retrieved using GetConversionResult() until this function returns false.

Will throw if not initialized.

virtual bool MoreStepsAvailable() const override

Returns true if more steps are available for the current particle. If the return value is false, the current simulation is finished and a new particle may be set.

Will throw if not initialized.

virtual I3SimStepSeriesConstPtr GetConversionResultWithBarrierInfo(bool &barrierWasReset, double timeout = NAN) override

Returns a bunch of steps stored in a vector<I3LSimStep>. The uint32_t value is the primary’s identifier as passed to EnqueueLightSource().

Might block if no steps are available. The steps may belong to various particles at the same time.

Will throw if not initialized.

Private Members

size_t bunchSizeGranularity_

size_t maxBunchSize_

I3RandomServicePtr randomService_

bool initialized_

bool barrierActive_

std::vector<I3SimStep> stepStore_

class I3MCEventHeaderGenerator : public I3Module

$Id$

Puts Event headers in empty frames for use in simulation

Public Functions

I3MCEventHeaderGenerator(const I3Context&)

void Configure()

void DAQ(I3FramePtr fr)

SET_LOGGER ("I3MCEventHeaderGenerator")

Private Members

int year_

Year of the run period.

int64_t daqTime_

Time since the beginning of the year in 1/10 ns.

int mjd_

MJD.

int mjd_s_

MJD seconds.

double mjd_ns_

MJD nanoseconds.

unsigned runNumber_

Run Number.

unsigned eventID_

Event ID.

bool incEventID_

If true this module will increment the eventID after adding one to the frame. This is useful for looking at untriggered events where you still want unique event IDs.

double dt_

Time difference between frames.

class I3MCPEMerger : public I3ConditionalModule

Public Functions

inline I3MCPEMerger(const I3Context &context)

inline void Configure()

inline void DAQ(boost::shared_ptr<I3Frame> frame)

Private Functions

SET_LOGGER ("I3MCPEMerger")

Private Members

std::string inputName

std::string outputName

double timeWindow

class I3MCPESort : public I3Module

#include <I3MCPESort.h>

A module that sorts the I3MCPE series.

The module simply ensures the individual PEs are sorted within each series. This should be the case already and this module is only necessary for those who want a little extra security and peace of mind. Note: there is an internal copy since we can only get const objects out of the frame. There are various ways around this if it turns out to be a problem.

Author

Alex Olivas aolivas@umd.edu

Public Functions

I3MCPESort(const I3Context &context)

~I3MCPESort()

void Configure()

void DAQ(I3FramePtr frame)

Private Functions

SET_LOGGER ("I3MCPESort")

Private Members

std::string peMapName_

The name of the I3MCPESeriesMap to process.

class I3MCPEtoI3MCHitConverter : public I3ConditionalModule

Converts an I3MCPESeriesMap to an I3MCHitSeriesMap.

Public Functions

I3MCPEtoI3MCHitConverter(const I3Context &ctx)

inline ~I3MCPEtoI3MCHitConverter()

void Configure()

void DAQ(I3FramePtr frame)

inline void Finish()

Private Functions

SET_LOGGER ("I3MCPEtoI3MCHitSeriesConverter")

Private Members

std::string inputResponse_

std::string outputResponse_

class I3MCTreeHybridSimulationSplitter : public I3Module

Splits an I3MCTree into two trees. One tree will have all tracks set to shape “Dark”, the other one will have everything else set to “Dark”.

$Id$

Copyright (C) 2012 Claudio Kopper ckopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu Can be used for hybrid simulations with two different photon propagators, one for tracks and one for cascades. (e.g. photonics/hit-maker and ppc).

WARNING: Do not use this with current versions of PPC/IceTray! At the moment PPC will read ALL I3MCTrees from the frame and will simulate particles from all of them.

Public Functions

I3MCTreeHybridSimulationSplitter(const I3Context &context)

void Configure()

void DAQ(I3FramePtr frame)

Private Functions

bool ParticleTypeIsATrack(I3Particle::ParticleType type) const

bool ParticleShouldNotBeTouched(I3Particle::ParticleType type) const

Private Members

std::string inputMCTreeName_

std::string outputMCTreeNameTracks_

std::string outputMCTreeNameCascades_

std::vector<I3Particle::ParticleType> lightProducingTracks_

std::vector<I3Particle::ParticleType> doNotTouchThese_

class I3ModifyEventID : public I3Module

class: I3ModifyEventID.cxx (c) 2004 IceCube Collaboration Version

Rcs

I3ModifyEventID.cxx,v 1.16 2005/03/17 18:33:43 olivas Exp

Date 08 June 2006

Version

Rcs

1.1

Date

Rcs

2005/03/17 18:33:43

Author

Alex Olivas olivas@icecube.umd.edu

Public Functions

I3ModifyEventID(const I3Context &ctx)

~I3ModifyEventID()

void Configure()

void DAQ(I3FramePtr frame)

Private Functions

I3ModifyEventID()

I3ModifyEventID(const I3ModifyEventID&)

I3ModifyEventID &operator=(const I3ModifyEventID&)

SET_LOGGER ("I3ModifyEventID")

Private Members

int year_

int64_t daqTime_

int mjd_

int mjd_s_

double mjd_ns_

unsigned runNumber_

unsigned subRunNumber_

unsigned startEID_

bool modTime_

bool modRunId_

bool modEventId_

class I3PhotonPropagationClient

#include <I3PhotonPropagationServer.h>

Client for communicating with I3PhotonPropagationServer.

None of the methods are thread-safe, but EnqueueSteps/EnqueueBarrier and GetConversionResultWithBarrierInfo may be called from different threads to feed and drain the client asynchronously.

Public Functions

I3PhotonPropagationClient(const std::string &server_address)

~I3PhotonPropagationClient()

I3PhotonPropagationClient(I3PhotonPropagationClient&&)

I3PhotonPropagationClient(const I3PhotonPropagationClient&) = delete

I3PhotonPropagationClient &operator=(I3PhotonPropagationClient&&)

I3PhotonPropagationClient &operator=(const I3PhotonPropagationClient&) = delete

void EnqueueSteps(I3SimStepSeriesConstPtr steps, uint32_t identifier)

Submit steps for propagation.

This function will block until the server is ready to handle more steps

void EnqueueBarrier()

Flush any steps held by the server.

This function will block until the server is ready to handle more steps

I3StepToPhotonConverter::ConversionResult_t GetConversionResultWithBarrierInfo(bool &barrierWasJustReset)

Retrieve propagated photons from the next step bunch.

Bunches will be returned in the order they were enqueued. barrierWasJustReset will be set to true when the last bunch enqueued before the barrier is returned.

This function will block until results are available

std::size_t GetWorkgroupSize() const

std::size_t GetMaxNumWorkitems() const

Private Members

std::unique_ptr<impl> impl_

class I3PhotonPropagationClientModule : public I3ConditionalModule

#include <I3PhotonPropagationClientModule.h>

Public Functions

I3PhotonPropagationClientModule(const I3Context &ctx)

Builds an instance of this class

virtual ~I3PhotonPropagationClientModule()

Destroys an instance of this class

virtual void Configure()

This module takes a configuration parameter and so it must be configured.

virtual void Process()

The module needs full control of all streams -> implement Process()!

virtual void Finish()

Warn the user if the module is aborted prematurely

virtual bool ShouldDoProcess(I3FramePtr frame)

Hack to allow buffering. This ShouldDoProcess overrides the I3ConditionalModule implementation and always returns true. The original ShouldDoProcess() is used in our Process() in order mark frames in case they should not be touched. They will be put in the buffer in any case, however.

This should retain frame ordering.

Private Types

typedef boost::bimaps::bimap<boost::bimaps::multiset_of<uint32_t>, boost::bimaps::multiset_of<uint32_t>> bimap

Private Functions

bool DigestOtherFrame(I3FramePtr frame)

The module needs to process Physics frames

void DigestGeometry(I3FramePtr frame)

The module needs to process Geometry frames

I3PhotonPropagationClientModule()

I3PhotonPropagationClientModule(const I3PhotonPropagationClientModule&)

I3PhotonPropagationClientModule &operator=(const I3PhotonPropagationClientModule&)

void StopThreads()

void StartThreads()

bool FeedSteps()

bool HarvestPhotons()

std::size_t FlushFrameCache()

void ConvertMCTreeToLightSources(const I3MCTree &mcTree, std::deque<I3LightSource> &lightSources, std::deque<double> &timeOffsets)

void ConvertFlasherPulsesToLightSources(const I3FlasherPulseSeries &flasherPulses, std::deque<I3LightSource> &lightSources, std::deque<double> &timeOffsets)

void CosmicGeneraterToLightSources(I3MCTree &mcTree, I3Frame &frame, std::deque<I3LightSource> &lightSources, std::deque<double> &timeOffsets)

bool FrameContainsWork(const I3FramePtr&, I3MCTreeConstPtr&, I3FlasherPulseSeriesConstPtr&)

SET_LOGGER ("I3PhotonPropagationClientModule")

Private Members

std::vector<I3Frame::Stream> workOnTheseStops_

Parameter: work on MCTrees found in the stream types (“stops”) specified in this list.

std::set<I3Frame::Stream> workOnTheseStops_set_

std::string MCTreeName_

Parameter: Name of the I3MCTree frame object. All particles except neutrinos will be read from this tree.

std::string flasherPulseSeriesName_

Parameter: Name of the I3FlasherPulseSeries frame object. Flasher pulses will be read from this object. Set this to the empty string to disable flashers.

std::string photonSeriesMapName_

Parameter: Name of the I3CompressedPhotonSeriesMap frame object that will be written to the frame.

std::string mcpeSeriesMapName_

Parameter: Name of the I3MCPESeriesMap frame object that will be written to the frame.

std::string omKeyMaskName_

Parameter: Name of a I3VectorOMKey with masked OMKeys. DOMs in this list will not record I3Photons.

bool ignoreMuons_

Parameter: If set to True, muons will not be propagated.

std::string statisticsName_

Parameter: Collect statistics in this frame object (e.g. number of photons generated or reaching the DOMs)

bool collectStatistics_

bool ignorePhotonPropagatorErrors_

Parameter: Continue processing even when the photon propagator encounters an error.

std::vector<std::string> ignoreSubdetectors_

Parameter: Ignore all OMKeys with these subdetector names.

uint32_t limitWorkgroupSize_

Parmeter: Limits the OpenCL workgroup size (the number of bunches to be processed in parallel). If set to zero (the default) the largest possible workgroup size will be chosen.

double closestDOMDistanceCutoff_

Parameter: do not even start light from sources that do not have any DOMs closer to to them than this distance. (default is 300m)

uint32_t photonHistoryEntries_

Parmeter: Sets the number of scattering step positions that are saved for a photon hitting a DOM. The last N photons are saved if there are more scattering points than available entries.

boost::shared_ptr<I3Surfaces::ExtrudedPolygon> detectorHull_

boost::shared_ptr<I3CosmicEventGenerator> cosmicGenerator_

I3LightSourceToStepConverterAsyncPtr stepGenerator_

I3CLSimPhotonToMCPEConverterPtr mcpeGenerator_

std::future<bool> feederTask_

std::future<bool> harvesterTask_

boost::shared_ptr<I3PhotonPropagationClient> stepsToPhotonsConverter_

boost::mutex frameCache_mutex_

std::atomic<bool> newFramesAvailable_

uint32_t currentFrameId_

uint32_t currentParticleCacheIndex_

uint32_t currentBunchId_

std::deque<frameCacheEntry> frameCache_

decltype(frameCache_)::difference_type framesInKernel_

bimap framesForBunches_

std::deque<particleCacheEntry> particleCache_

class I3PhotonPropagationServer

#include <I3PhotonPropagationServer.h>

Public Functions

I3PhotonPropagationServer(const std::string &address, const std::vector<I3StepToPhotonConverterPtr> &converters)

~I3PhotonPropagationServer()

I3PhotonPropagationServer(I3PhotonPropagationServer&&)

I3PhotonPropagationServer(const I3PhotonPropagationServer&) = delete

I3PhotonPropagationServer &operator=(I3PhotonPropagationServer&&)

I3PhotonPropagationServer &operator=(const I3PhotonPropagationServer&) = delete

std::map<std::string, double> GetStatistics() const

std::string GetAddress() const

Get the address the server is bound to. This may differ from the address passed to the ctor if that address contains wildcards instructing the system to assign a random port. See: http://api.zeromq.org/4-3:zmq-tcp.

Private Members

std::unique_ptr<impl> impl_

class I3PhotonToMCPEConverter : public I3ConditionalModule

#include <I3PhotonToMCPEConverter.h>

This module reads I3PhotonSeriesMaps generated by CLSim, applies (D)OM acceptances (wavelength&angular) to the photons and stores the results in an I3MCPESeriesMap.

Public Functions

I3PhotonToMCPEConverter(const I3Context &ctx)

Builds an instance of this class

virtual ~I3PhotonToMCPEConverter()

Destroys an instance of this class

virtual void Configure()

This module takes a configuration parameter and so it must be configured.

void DAQ(I3FramePtr frame)

The module needs to process Physics frames

virtual void Finish()

Private Functions

I3PhotonToMCPEConverter()

I3PhotonToMCPEConverter(const I3PhotonToMCPEConverter&)

I3PhotonToMCPEConverter &operator=(const I3PhotonToMCPEConverter&)

template<typename PhotonMapType>
std::pair<I3MCPESeriesMapPtr, I3ParticleIDMapPtr> Convert(I3FramePtr frame)

SET_LOGGER ("I3PhotonToMCPEConverter")

Private Members

boost::shared_ptr<I3CLSimPhotonToMCPEConverter> mcpeGenerator_

Parameter: A random number generating service (derived from I3RandomService).

std::string inputPhotonSeriesMapName_

Parameter: Name of the input I3PhotonSeriesMap frame object.

std::string outputMCPESeriesMapName_

Parameter: Name of the output I3MCPESeries frame object.

bool mergeHits_

Parameter: Compress the output I3MCPEs.

uint64_t numGeneratedHits_

class I3PrimaryInjector : public I3Module

Module to generate primaries for Dynamic Stack CORSIKA.

This module generates one primary particle per frame and puts it in the I3MCTree. Multiple types of particles are supported for the primary which are passed as a parameter. The number of each type of particles is set by a total number of particles and a vector of normalizations. The spectra for each particle type are set independently and passed as parameters. One S-Frame is emmitted for each particle type.

The direction and positions are thrown by an instance of I3UprightCylinder to generate events close to the detector. This introduces a zenith dependent weight term which must be included when calculating the weights for the event.

Public Functions

inline I3PrimaryInjector(const I3Context &ctx)

inline void Configure()

inline void DAQ(I3FramePtr frame)

void Finish()

Private Functions

SET_LOGGER ("I3PrimaryInjector")

Private Members

I3RandomServicePtr rng_

random service for Monet Carlo Sampling

uint32_t run_id_

store the RunID to match with the I3EventHeader set later in the simulation chain

std::vector<uint32_t> n_events_

Total number of events.

std::vector<I3Particle::ParticleType> types_

The types of particles to throw.

I3VectorPowerLaw spectra_

The spectra of each type of particle.

double cylinder_height_

Height of the generation cylinder.

double cylinder_radius_

Radius of the generation cylinder.

I3Position cylinder_position_

Origin of the generation cylinder.

double min_zenith_

Minimum zenith angle of the primary particles.

double max_zenith_

Minimum zenithg angle of the primary particles.

double min_cos_zenith_

store the cos of the minimum for simplicity

double max_cos_zenith_

store the cos of the minimum for simplicity

double mu_bias_target_

Leading Muon energy target bias to send to corsika.

I3Surfaces::SamplingSurfacePtr surface_

Instance to use as sampling surface.

std::string primary_name_

Name of the primary particle to put in the frame.

std::string mctree_name_

Name of the I3MCTree to put in the frame.

std::vector<uint32_t> n_produced_

keep track of the number of each type of particle to produce

size_t curr_index_

variable to keep track of which particle we are producing

class I3PrimaryPulseMapper : public I3Module

#include <I3PrimaryPulseMapper.h>

Converts mapping information describing which particles produced each MCPE to a mapping to primary particles which were the parents of the light emitting particles.

Public Types

using PrimaryIDMap = std::unordered_map<I3ParticleID, I3ParticleID, i3hash<I3ParticleID>>

Public Functions

I3PrimaryPulseMapper(const I3Context &ctx)

inline ~I3PrimaryPulseMapper()

void Configure()

void DAQ(I3FramePtr frame)

inline void Finish()

Public Static Functions

static PrimaryIDMap buildPrimaryMap(const I3MCTree &tree)

Construct a map of particle IDs to those particles’ parent primary particles.

Private Functions

SET_LOGGER ("I3PrimaryPulseMapper")

Private Members

std::string inputParticleIDMapName_

std::string outputParticleIDMapName_

std::string mcTreeName_

Friends

friend class SingleModuleTestSetup< I3PrimaryPulseMapper >

class I3PropagatorModule : public I3ConditionalModule

Propagates all particles found in an MCTree that have configured I3PropagatorServices. If one service returns another particle that can be propagated by another service, it will be passed to that one. The results, in turn, will also be propagated until there are no more particles to propagate.

The ususal use case is to pass an MCTree to PROPOSAL, the results to CMC and the resulting muons back to PROPOSAL.

Public Functions

I3PropagatorModule(const I3Context &ctx)

Builds an instance of this class

~I3PropagatorModule()

Destroys an instance of this class

void Configure()

This module takes a configuration parameter and so it must be configured.

void DAQ(I3FramePtr frame)

The module needs to process Physics frames

Private Functions

I3PropagatorModule()

I3PropagatorModule(const I3PropagatorModule&)

I3PropagatorModule &operator=(const I3PropagatorModule&)

SET_LOGGER ("I3PropagatorModule")

Private Members

std::string inputMCTreeName_

Parameter: Name of the I3MCTree frame object.

std::string outputMCTreeName_

Parameter: Name of the output I3MCTree frame object. If identical to the input or empty, the input object will be replaced.

I3ParticleTypePropagatorServiceMapPtr particleToPropagatorServiceMap_

Parameter: map of particle type to a propagator that should propagate this type.

I3RandomServicePtr random_

Parameter: a random number generator service.

std::string rngStateName_

Parameter: set this to a non-empty string to save the RNG state to the frame before each propagation (per event). If it already exist, it is loaded instead and the RNG state is being reset before propagation. This allows to re-generate MCTrees using just the output of ucr/corsika-reader or neutrino-generator and the RNG state.

bool skipAlreadyPropagated_

Parameter: if true, skips nodes that appear to have been propagated already.

class I3PropagatorService

#include <I3PropagatorService.h>

Base class for particle propagators.

Public Functions

I3_FORWARD_DECLARATION(DiagnosticMap)

virtual std::vector<I3Particle> Propagate(I3Particle &particle, DiagnosticMapPtr frameinfo, I3FramePtr frame) = 0

Propagate a particle and return secondaries.

Parameters:

• particle – [inout] a particle to be propagated. The propagator may modify its properties, e.g. set its final length.

• frameinfo – [inout] auxiliary information for the current event. The contents of this map will be added to the I3Frame for the current event after propagation.

• frame – [inout] pointer to I3Frame. This is added because NeutrinoPropagator requires to access I3Frame in order to get weights stored by preceding modules. Copying const objects from I3Frame may use computing resources heaviry, so use it carefully.

Returns:

a vector of secondary particles. These are final states as far as this propagator is concerned; they may be handled by a different propagator, but will never be passed back to this one in a further iteration.

virtual void SetRandomNumberGenerator(I3RandomServicePtr random) = 0

Set the random number generator to be used.

I3PropagatorService()

virtual ~I3PropagatorService()

class I3RemoveLargeDT : public I3Module

Removes photo-electron hits that are separated in time by a factor larger than maxDT/2 from the median time (where maxDT is the maximum size of the trigger window).

The purpose is to eliminate hits that, while physically related to a triggered event, would never be associated to that event by the DAQ. The long gaps will otherwise be filled by noise and beacon hits in DOMLauncher and will unnecessarily blow up memory consumption.

Clips any PEs later than MaxDeltaT, taken with respect to the earliest PE in the frame.

Public Functions

I3RemoveLargeDT(const I3Context &ctx)

inline ~I3RemoveLargeDT()

void Configure()

void DAQ(I3FramePtr frame)

inline void Finish()

Private Functions

SET_LOGGER ("I3RemoveLargeDT")

Private Members

std::string inputResponse_

std::string outputResponse_

double maxdt_

bool presorted_

struct I3StepToPhotonConverter : private noncopyable

#include <I3StepToPhotonConverter.h>

Subclassed by I3StepToPhotonConverterPotemkin

Public Functions

virtual void SetWlenGenerators(const std::vector<I3CLSimRandomValueConstPtr> &wlenGenerators) = 0

Sets the wavelength generators. The first generator (index 0) is assumed to return a Cherenkov spectrum that may have a bias applied to it. This bias factor needs to be set using SetWlenBias(). All other generator indices are assumed to be for flasher/laser light generation. During generation, no Cherenkov angle rotation will be applied to those photons with indices >= 1. Will throw if used after the call to Initialize().

virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias) = 0

Sets the wavelength weights. Set this to a constant value of 1 if you do not need biased photon generation. The wavelength spectrum set with SetWlenGenerator() is assumed to have a biassing factor already applied to it. This call sets this factor in order to be able to assign correct weights. Will throw if used after the call to Initialize().

virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties) = 0

Sets the medium properties. Will throw if used after the call to Initialize().

virtual void SetGeometry(I3SimpleGeometryConstPtr geometry) = 0

Sets the geometry. Will throw if used after the call to Initialize().

virtual void Initialize() = 0

Initializes the simulation. Will throw if already initialized.

virtual bool IsInitialized() const = 0

Returns true if initialized. Never throws.

virtual void EnqueueSteps(I3SimStepSeriesConstPtr steps, uint32_t identifier) = 0

Adds a new I3SimStepSeries to the queue. The resulting I3CLSimPhotonSeries can be retrieved from the I3StepToPhotonConverter after some processing time.

Enqueuing a vector after calling EnqueueBarrier will throw if not all photons have been retrieved.

Will throw if not initialized.

virtual std::size_t GetWorkgroupSize() const = 0

Gets the current workgroup size.

virtual std::size_t GetMaxNumWorkitems() const = 0

Gets the number of parallel work items.

virtual std::size_t QueueSize() const = 0

Reports the current queue size. The queue works asynchronously, so this value will probably have changed once you use it.

Will throw if not initialized.

virtual bool MorePhotonsAvailable() const = 0

Returns true if more photons are available. If the return value is false, the current simulation is finished and a new step vector may be set.

Will throw if not initialized.

virtual ConversionResult_t GetConversionResult() = 0

Returns a bunch of photons stored in a vector<I3CLSimPhoton>.

The return value is a pair<uint, vector<I3CLSimPhoton> >. The integer is the same identifier as specified in the call to EnqueueSteps().

Might block if no photons are available.

Will throw if not initialized.

inline virtual std::map<std::string, double> GetStatistics() const

inline virtual ~I3StepToPhotonConverter()

class I3StepToPhotonConverter_exception : public std::runtime_error

#include <I3StepToPhotonConverter.h>

Base class for objects that receive a vector of I3SimSteps and convert them into I3CLSimPhotons.

Depending on the implementation, these photons may either be stored directly at their emission point or after propagation to a target (e.g. a DOM)

Public Functions

inline virtual ~I3StepToPhotonConverter_exception()

inline I3StepToPhotonConverter_exception(const std::string &msg)

class I3StepToPhotonConverterPotemkin : public I3StepToPhotonConverter

#include <I3StepToPhotonConverterPotemkin.h>

Dummy photon propagator for timing tests.

Public Functions

I3StepToPhotonConverterPotemkin(size_t workgroupSize, size_t maxNumWorkItems, double nsPerPhoton, double detectionProbability, I3RandomServicePtr rng, size_t errorEveryNBunches)

inline virtual void SetWlenGenerators(const std::vector<I3CLSimRandomValueConstPtr> &wlenGenerators)

Sets the wavelength generators. The first generator (index 0) is assumed to return a Cherenkov spectrum that may have a bias applied to it. This bias factor needs to be set using SetWlenBias(). All other generator indices are assumed to be for flasher/laser light generation. During generation, no Cherenkov angle rotation will be applied to those photons with indices >= 1. Will throw if used after the call to Initialize().

inline virtual void SetWlenBias(I3CLSimFunctionConstPtr wlenBias)

Sets the wavelength weights. Set this to a constant value of 1 if you do not need biased photon generation. The wavelength spectrum set with SetWlenGenerator() is assumed to have a biassing factor already applied to it. This call sets this factor in order to be able to assign correct weights. Will throw if used after the call to Initialize().

inline virtual void SetMediumProperties(I3CLSimMediumPropertiesConstPtr mediumProperties)

Sets the medium properties. Will throw if used after the call to Initialize().

inline virtual void SetGeometry(I3SimpleGeometryConstPtr geometry)

Sets the geometry. Will throw if used after the call to Initialize().

inline void SetDOMPancakeFactor(double value)

inline virtual void Initialize()

Initializes the simulation. Will throw if already initialized.

inline virtual bool IsInitialized() const

Returns true if initialized. Never throws.

virtual void EnqueueSteps(I3SimStepSeriesConstPtr steps, uint32_t identifier)

Adds a new I3SimStepSeries to the queue. The resulting I3CLSimPhotonSeries can be retrieved from the I3StepToPhotonConverter after some processing time.

Enqueuing a vector after calling EnqueueBarrier will throw if not all photons have been retrieved.

Will throw if not initialized.

inline virtual std::size_t GetWorkgroupSize() const

Gets the current workgroup size.

inline virtual std::size_t GetMaxNumWorkitems() const

Gets the number of parallel work items.

inline virtual std::size_t QueueSize() const

Reports the current queue size. The queue works asynchronously, so this value will probably have changed once you use it.

Will throw if not initialized.

inline virtual bool MorePhotonsAvailable() const

Returns true if more photons are available. If the return value is false, the current simulation is finished and a new step vector may be set.

Will throw if not initialized.

virtual I3StepToPhotonConverter::ConversionResult_t GetConversionResult()

Returns a bunch of photons stored in a vector<I3CLSimPhoton>.

The return value is a pair<uint, vector<I3CLSimPhoton> >. The integer is the same identifier as specified in the call to EnqueueSteps().

Might block if no photons are available.

Will throw if not initialized.

virtual std::map<std::string, double> GetStatistics() const

Public Members

clock_type::time_point enqueued

clock_type::time_point returned

Private Types

typedef std::chrono::high_resolution_clock clock_type

Private Members

I3CLSimQueue<std::pair<I3SimStepSeriesConstPtr, uint32_t>> inbox_

size_t workgroupSize_

size_t maxNumWorkItems_

I3RandomServicePtr rng_

double nsPerPhoton_

double detectionProbability_

I3SimpleGeometryConstPtr geometry_

double pancakeFactor_

size_t errorEveryNBunches_

size_t bunchCounter_

statistics_bundle statistics_

struct I3StepToPhotonConverterPotemkin::[anonymous] times_

class I3SumGenerator

#include <I3SumGenerator.h>

I3SumGenerator A class for generating the sum of several random numbers which all have the same probability density, like the pulse-heights generated by several simultaneous PEs. At initialisation a set of vectors (each for a different number of terms in the sum) is created. Each vector is a lookup table holding values of the sum which correspond to equally spaced values of the cumulative probability. This is used to generate a value for the sum very quickly from a uniformly distributed random number. To improve accuracy in the tails of the distribution, finer tables with non-uniform spacing are used for high and low cumulant probabilities.

When the number of terms exceeds a specified value the gaussian random number generator is invoked instead.

Author

Klas Hultqvist (c) the IceCube Collaboration

Public Functions

inline I3SumGenerator()

Construct an uninitialised SumGenerator. Will not work before it’s initialised.

I3SumGenerator(I3RandomServicePtr r, boost::function<double(double)>, double xlo, double xhi, int bins, int switchgauss, double PLow = 0.01, int nBinsLow = 100, double PHigh = 0.99, int nBinsHigh = 100)

Construct a SumGenerator The parameters are the same as for Initialise()

Constructor with arguments, just calls Initialise method

double Generate(int terms)

Generate the value of a sum of random numbers.

Parameters:

terms – Number of terms in the sum

void Initialise(I3RandomServicePtr r, boost::function<double(double)>, double xlo, double xhi, int nbins, int switchgauss, double PLow = 0.01, int nBinsLow = 100, double PHigh = 0.99, int nBinsHigh = 100)

Initialise a SumGenerator.

Initialise I3SumGenerator

Parameters:

• r – Pointer to random number service

• fun – Pointer to probability density function

• xlo – Low edge of interval where fun is defined

• xhi – High edge

• nbins – Number of bins to calculate fun in and to use in lookup table

• switchgauss – The minimum number of terms for which gaussian generation will be enabled

• PLow – The probability defining the low tail

• nBinsLow – The number of bins (samples) used for the low tail

• PHigh – The probability defining the high tail

• nBinsHigh – The number of bins (samples) used for the high tail

Private Members

int switchGauss_

Lowest number of terms for which gaussian generation is used

int nBins_

Number of bins (same in sum value and probability)

double xLo_

Min of single term

double xHi_

Max of single term

double expectVal_

Expectation value for single term

double stdDev_

Standard deviation for single term

std::vector<std::vector<double>> X_

Vector of sum values (lookup table) for different cumulative probabilities

int nBinsLow_

Number of bins in finer lookup tables for use in low probability tail

int nBinsHigh_

Number of bins in finer lookup tables for use in high probability tail

double PLow_

Max probability for which to use the low P lookup table

double PHigh_

Min probability for which to use the high P lookup table

double binStepLow_

Stepsize for cubic root of probability in low tail

double binStepHigh_

Stepsize for cubic root of distance from unity in high P tail

std::vector<std::vector<double>> XLow_

Lookup table for low P tail

std::vector<std::vector<double>> XHigh_

Lookup table for high P tail

I3RandomServicePtr random_

Pointer to random number generator service

class impl : private no_zmq

Public Functions

inline impl(const std::string &address, const std::vector<I3StepToPhotonConverterPtr> &converters)

inline std::map<std::string, double> GetStatistics() const

inline std::string GetAddress() const

class impl : private no_zmq

Public Functions

inline impl(const std::string &server_address)

inline void EnqueueSteps(I3SimStepSeriesConstPtr steps, uint32_t identifier)

inline void EnqueueBarrier()

inline I3StepToPhotonConverter::ConversionResult_t GetConversionResultWithBarrierInfo(bool &barrierWasJustReset)

inline std::size_t GetWorkgroupSize() const

inline std::size_t GetMaxNumWorkitems() const

class MCPEStream

#include <MCPEMCPulseTools.hpp>

Public Functions

inline bool insert(const I3MCPE &hit)

inline std::pair<std::vector<I3MCPE>, ParticlePulseIndexMap> extractMCPEsWithPIDInfo() const

inline size_t size() const

Private Members

std::vector<Bunch> hits_

class message_t

#include <zmq.hpp>

Public Functions

inline  message_t () ZMQ_NOTHROW

inline explicit message_t(size_t size_)

template<class ForwardIter>
inline message_t(ForwardIter first, ForwardIter last)

inline message_t(const void *data_, size_t size_)

inline message_t(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR)

inline  ~message_t () ZMQ_NOTHROW

inline void rebuild()

inline void rebuild(size_t size_)

inline void rebuild(const void *data_, size_t size_)

inline void rebuild(void *data_, size_t size_, free_fn *ffn_, void *hint_ = ZMQ_NULLPTR)

inline void move(message_t const *msg_)

inline void move(message_t &msg_)

inline void copy(message_t const *msg_)

inline void copy(message_t &msg_)

inline bool more () const ZMQ_NOTHROW

inline void * data () ZMQ_NOTHROW

inline const void * data () const ZMQ_NOTHROW

inline size_t size () const ZMQ_NOTHROW

inline ZMQ_NODISCARD bool empty () const ZMQ_NOTHROW

template<typename T> inline T * data () ZMQ_NOTHROW

template<typename T> inline T const * data () const ZMQ_NOTHROW

inline bool equal (const message_t *other) const ZMQ_NOTHROW

inline bool operator== (const message_t &other) const ZMQ_NOTHROW

inline bool operator!= (const message_t &other) const ZMQ_NOTHROW

inline int get(int property_)

inline const char *gets(const char *property_)

inline std::string to_string() const

inline std::string str() const

Dump content to string for debugging. Ascii chars are readable, the rest is printed as hex. Probably ridiculously slow. Use to_string() or to_string_view() for interpreting the message as a string.

inline void swap (message_t &other) ZMQ_NOTHROW

inline ZMQ_NODISCARD zmq_msg_t * handle () ZMQ_NOTHROW

inline ZMQ_NODISCARD const zmq_msg_t * handle () const ZMQ_NOTHROW

Private Functions

message_t (const message_t &) ZMQ_DELETED_FUNCTION

void operator= (const message_t &) ZMQ_DELETED_FUNCTION

Private Members

zmq_msg_t msg

class metric

Public Functions

inline metric()

inline void update(double value)

inline size_t count() const

inline double mean() const

inline double variance() const

Private Members

size_t count_

double mean_

double mean2_

class monitor_t

#include <zmq.hpp>

Public Functions

inline monitor_t()

inline virtual ~monitor_t()

inline void monitor(socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL)

inline void monitor(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)

inline void init(socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL)

inline void init(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)

inline bool check_event(int timeout = 0)

inline virtual void on_monitor_started()

inline virtual void on_event_connected(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_connect_delayed(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_connect_retried(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_listening(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_bind_failed(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_accepted(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_accept_failed(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_closed(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_close_failed(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_disconnected(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_handshake_failed_no_detail(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_handshake_failed_protocol(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_handshake_failed_auth(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_handshake_succeeded(const zmq_event_t &event_, const char *addr_)

inline virtual void on_event_unknown(const zmq_event_t &event_, const char *addr_)

Private Functions

monitor_t (const monitor_t &) ZMQ_DELETED_FUNCTION

void operator= (const monitor_t &) ZMQ_DELETED_FUNCTION

inline void close () ZMQ_NOTHROW

Private Members

socket_ref _socket

socket_t _monitor_socket

class NeutrinoSelector

#include <I3CosmicEventGenerator.h>

Public Functions

virtual std::vector<I3Particle>::const_iterator Select(const std::vector<I3Particle> &neutrinos, I3Frame &frame) = 0

inline virtual ~NeutrinoSelector()

class OnboardNoiseSuppression : public I3ConditionalModule

#include <OnboardNoiseSuppression.h>

The DAQ team is planning an onboard noise-suppression algorithm for the mDOM. This algorithm will force an artificial deadtime for new-pmt hits if only single hit pmts are observed within a fixed time window, reducing the bandwidth needed for readout. This will eventually be implemented direction in DAQ firmware, which we will rely on for simulation. Until then, we need this module to simulate the impact.

Author

Michael Larson mlarson@icecube.wisc.edu

   I follow the descriptions here:
     - https://drive.google.com/file/d/1Pq_djxhYVdoP_sL1XNuwV1inB91WjxgQ/view (algorithm 3)
     - https://drive.google.com/drive/folders/1KMAUqie5ohndxfBZq72EKffbFDb-u9QW (slides 14, 15)

Public Functions

OnboardNoiseSuppression(const I3Context &context)

~OnboardNoiseSuppression()

void Configure()

void Geometry(I3FramePtr frame)

void DAQ(I3FramePtr frame)

void Finish()

Private Functions

SET_LOGGER ("OnboardNoiseSuppression")

Private Members

std::string pulsesName_

float searchWindow_

float deadtime_

std::vector<int> omtypes_

I3GeometryConstPtr geo_

struct particleCacheEntry

#include <I3PhotonPropagationClientModule.h>

Public Functions

particleCacheEntry(uint32_t id, const I3LightSource &lightSource, uint32_t frame, double dt)

inline uint32_t key() const

Public Members

uint32_t particleId

uint32_t frameId

photonStatistics generatedPhotons

photonStatistics photonsAtDOMs

double timeShift

uint64_t particleMajorID

int particleMinorID

struct photonStatistics

#include <I3PhotonPropagationClientModule.h>

Public Functions

inline photonStatistics()

Public Members

uint64_t count

double weightSum

struct PulseInfo

Public Functions

inline PulseInfo(OMKey pmt_, I3RecoPulse pulse_, bool keep_, bool in_deadtime_)

Public Members

OMKey pmt

I3RecoPulse pulse

bool keep

bool in_deadtime

struct Range

Public Functions

inline Range(double a = 0.212 / 1.2, double b = 0.251e-3 / 1.2)

inline double operator()(double energy) const

Public Members

double a_

double b_

struct ShowerParameters

#include <I3SimConstants.h>

Shower development parameters, taken from IceCube IR icecube/201210001

Public Functions

ShowerParameters(I3Particle::ParticleType type, double energy, double density = 0.9216 * (I3Units::g / I3Units::cm3))

Electromagnetic and hadronic shower shape parameters from icecube/201210001

Parameters:

• type – [in] Type of particle that initiates the shower

• energy – [in] Energy of the primary particle

• density – [in] Density of the medium

Public Members

double a

Shape parameter of a gamma distribution (dimensionless)

double b

Scale length of a gamma distribution (meters)

double emScale

Ratio of total cherenkov track yield relative to EM cascade

double emScaleSigma

Standard deviation of relative flucuations in the shower light yield

Public Static Functions

static std::vector<I3Particle::ParticleType> GetSupportedTypes()

template<typename ModuleType>
class SingleModuleTestSetup

#include <I3PrimaryPulseMapper.h>

class socket_base

#include <zmq.hpp>

Subclassed by zmq::socket_ref, zmq::socket_t

Public Functions

inline  socket_base () ZMQ_NOTHROW

inline ZMQ_EXPLICIT socket_base (void *handle) ZMQ_NOTHROW

template<typename T>
inline void setsockopt(int option_, T const &optval)

inline void setsockopt(int option_, const void *optval_, size_t optvallen_)

inline void getsockopt(int option_, void *optval_, size_t *optvallen_) const

template<typename T>
inline T getsockopt(int option_) const

inline void bind(std::string const &addr)

inline void bind(const char *addr_)

inline void unbind(std::string const &addr)

inline void unbind(const char *addr_)

inline void connect(std::string const &addr)

inline void connect(const char *addr_)

inline void disconnect(std::string const &addr)

inline void disconnect(const char *addr_)

inline bool connected () const ZMQ_NOTHROW

inline size_t send(const void *buf_, size_t len_, int flags_ = 0)

inline bool send(message_t &msg_, int flags_ = 0)

template<typename T>  ZMQ_CPP11_DEPRECATED ("from 4.4.1, use send taking message_t or buffer (for contiguous ""ranges), and send_flags") bool send(T first

Public Members

T last

T int flags_

Private Functions

inline void set_option(int option_, const void *optval_, size_t optvallen_)

inline void get_option(int option_, void *optval_, size_t *optvallen_) const

class socket_ref : public zmq::detail::socket_base

#include <zmq.hpp>

Public Functions

inline  socket_ref () ZMQ_NOTHROW

inline  socket_ref (from_handle_t, void *handle) ZMQ_NOTHROW

class socket_t : public zmq::detail::socket_base

#include <zmq.hpp>

Public Functions

inline  socket_t () ZMQ_NOTHROW

inline socket_t(context_t &context_, int type_)

inline  ~socket_t () ZMQ_NOTHROW

inline  operator void * () ZMQ_NOTHROW

inline  operator void const * () const ZMQ_NOTHROW

inline void close () ZMQ_NOTHROW

inline void swap (socket_t &other) ZMQ_NOTHROW

inline  operator socket_ref () ZMQ_NOTHROW

Private Functions

socket_t (const socket_t &) ZMQ_DELETED_FUNCTION

void operator= (const socket_t &) ZMQ_DELETED_FUNCTION

inline socket_t(void *context_, int type_)

Private Members

void *ctxptr

Friends

friend class monitor_t

struct statistics_bundle

Public Functions

inline statistics_bundle()

Public Members

metric input_wait

metric output_wait

metric host_duration

metric device_duration

uint64_t total_host_duration

uint64_t total_device_duration

uint64_t total_queue_duration

uint64_t total_kernel_calls

uint64_t total_num_photons_generated

uint64_t total_num_photons_atDOMs

struct zmq_event_t

#include <zmq.hpp>

Public Members

uint16_t event

int32_t value

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace [anonymous]

namespace I3SimConstants

A list of static variables commonly used by physics simulation specifically cross-section calculations.

Just a namespace filled with constants &#8212; add a line using namespace I3SimConstants to get access to them directly, or just use I3SimConstants::pi, for example.

Functions

bool IsEM(I3Particle::ParticleType type)

bool IsHadron(I3Particle::ParticleType type)

Particle type information for e/mu/tau/hadrons

bool IsMuon(I3Particle::ParticleType type)

bool IsTau(I3Particle::ParticleType type)

Variables

static const double m_e = 0.510998928 * I3Units::MeV / (I3Constants::c * I3Constants::c)

Particle Masses, etc. taken from http://pdg.lbl.gov/2012/reviews/rpp2012-rev-phys-constants.pdf unless otherwise stated Mass of electron

static const double m_mu = 105.6583715 * I3Units::MeV / (I3Constants::c * I3Constants::c)

Mass of muon http://pdg.lbl.gov/2012/listings/rpp2012-list-muon.pdf

static const double m_tau = 1776.82 * I3Units::MeV / (I3Constants::c * I3Constants::c)

Mass of tau http://pdg.lbl.gov/2012/listings/rpp2012-list-tau.pdf

static const double m_p = 938.272046 * I3Units::MeV / (I3Constants::c * I3Constants::c)

Mass of proton

static const double m_n = 939.565379 * I3Units::MeV / (I3Constants::c * I3Constants::c)

Mass of neutron

static const double m_W = 80.385 * I3Units::GeV / (I3Constants::c * I3Constants::c)

Mass of W boson

static const double m_Z = 91.1876 * I3Units::GeV / (I3Constants::c * I3Constants::c)

Mass of Z boson

static const double h = 6.62606957e-34 * I3Units::joule * (I3Units::second)

Planck Constant

static const double hbar = h / (2. * I3Constants::pi)

reduced Planck Constant

static const double hbarc = hbar * I3Constants::c

unit conversion constant (hbar * c)

static const double G_Fermi = 1.1663787e-5 / (I3Units::GeV * I3Units::GeV)

Fermi coupling constant / (hbar * c)^3 is assumed

static const double epsilon_0 = 8.854187817e-12 * I3Units::coulomb / (I3Units::V * I3Units::m)

Permittivity of free space

static const double mu_0 = 4 * I3Constants::pi * 10e-7 * I3Units::V * I3Units::second / (I3Units::A * I3Units::A)

Permeability of free space

static const double alpha = 1. / 137.03599976

Fine-structure constant

static const double k_B = 1.3806488 * I3Units::joule / I3Units::kelvin

Boltzmann constant

static const double sinsq_theta_W = 0.23116

Weak-mixing Angle \(sin^{2} \hat{\theta} (M_{Z}) cos \theta_{W}\)

static const double cos_theta_W = m_W / m_Z

static const double sin_theta_C = 0.4561

Cabibbo Angle

static const double cos_theta_C = 0.9746

namespace MCHitMerging

Functions

std::vector<I3ParticleID> findParents(uint32_t pulseIndex, const ParticlePulseIndexMap &idMap)

ParticlePulseIndexMap extractPIDInfoandMerge(std::vector<I3MCPE> &hits, OMKey key)

I3ParticleIDMapPtr extractPIDInfo(I3Map<OMKey, std::vector<I3MCPE>> &hits)

I3ParticleIDMapPtr extractPIDInfoandMerge(I3Map<OMKey, std::vector<I3MCPE>> &hits, const double timeWindow)

SET_LOGGER ("MCHitMerging")

template<typename HitType>
void timeMergeHits(std::vector<HitType> &hits, ParticlePulseIndexMap &aux, const double timeWindow = 0.2)

template<typename ForwardIterator>
void sortMCHits(ForwardIterator begin, ForwardIterator end, ParticlePulseIndexMap &aux)

namespace PEConversions

copyright (C) 2013 the icecube collaboration

Conversion functions between I3MCHits and I3MCPEs The main thing to keep in mind is that the conversion is asymmetric.

Version

Rcs

An I3MCPE is only a SPE or RANDOM (in the I3MCHit parlance). So all I3MCPEs can be converted to I3MCHits, but not all I3MCHits can be converted to I3MCPEs. Namely pre-, late-, and after-pulses are not converted to I3MCPEs. This is why HitToPE returns a shared pointer. If the conversion was not successful a NULL pointer is returned. Client code needs to check this before dereferencing.

For the same reason, in general, the containers won’t contain the same number of elements.

Functions

I3MCHit PEToHit(const I3MCPE&)

I3MCPEPtr HitToPE(const I3MCHit&)

void PEToHit(const I3MCPESeries&, I3MCHitSeries&)

void HitToPE(const I3MCHitSeries&, I3MCPESeries&)

void PEToHit(const I3MCPESeriesMap&, I3MCHitSeriesMap&)

void HitToPE(const I3MCHitSeriesMap&, I3MCPESeriesMap&)

namespace std

STL namespace.

namespace zmq

Typedefs

typedef zmq_free_fn free_fn

typedef zmq_pollitem_t pollitem_t

Functions

inline int poll(zmq_pollitem_t *items_, size_t nitems_, long timeout_ = -1)

inline int poll(zmq_pollitem_t const *items_, size_t nitems_, long timeout_ = -1)

inline void version(int *major_, int *minor_, int *patch_)

inline void swap (message_t &a, message_t &b) ZMQ_NOTHROW

inline void swap (context_t &a, context_t &b) ZMQ_NOTHROW

inline bool operator== (socket_ref a, socket_ref b) ZMQ_NOTHROW

inline bool operator!= (socket_ref a, socket_ref b) ZMQ_NOTHROW

inline bool operator< (socket_ref a, socket_ref b) ZMQ_NOTHROW

inline bool operator> (socket_ref a, socket_ref b) ZMQ_NOTHROW

inline bool operator<= (socket_ref a, socket_ref b) ZMQ_NOTHROW

inline bool operator>= (socket_ref a, socket_ref b) ZMQ_NOTHROW

inline void swap (socket_t &a, socket_t &b) ZMQ_NOTHROW

inline void proxy(void *frontend, void *backend, void *capture)

inline void proxy(socket_ref frontend, socket_ref backend, socket_ref capture = socket_ref())

inline void proxy_steerable(void *frontend, void *backend, void *capture, void *control)

inline void proxy_steerable(socket_ref frontend, socket_ref backend, socket_ref capture, socket_ref control)

inline std::ostream &operator<<(std::ostream &os, const message_t &msg)

Variables

ZMQ_CONSTEXPR_VAR from_handle_t from_handle   =   from_handle_t(from_handle_t::_private())

namespace detail

file I3CLSimPhotonToMCPEConverter.h

#include <icetray/OMKey.h>

#include <simclasses/I3MCPE.h>

#include <boost/optional.hpp>

file I3CombineMCPE.cxx

#include <sim-services/I3CombineMCPE.h>

#include “sim-services/MCPEMCPulseTools.hpp”

Copyright (c) 2013 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

I3_MODULE(I3CombineMCPE)

I3ParticleIDMapPtr MergeMCPEs(I3MCPESeriesMapPtr output, I3MCPESeriesMapConstPtr input, float offsetTime, I3ParticleIDMapPtr outputInfo, I3ParticleIDMapConstPtr inputInfo)

MergeHits - Takes two I3MCPESeriesMaps and merges their hits. The times of the hits in the second map are moved by offsetTime.

Parameters:

• map1 – ‘original’ map to which we will add the new hits

• map2 – second map hit times will be set within window of first map

• offsetTime – time difference between first hit in map2 relative to map1

• map1Info – any external particle parentage info for map1. Will be created if necessary.

• map2Info – any external particle parentage info for map2

Returns:

an updated version of map1Info, or nothing if that object continues to be unnecessary.

file I3CombineMCPE.h

#include <icetray/I3ConditionalModule.h>

#include <simclasses/I3MCPE.h>

#include <simclasses/I3ParticleIDMap.hpp>

Functions

I3ParticleIDMapPtr MergeMCPEs(I3MCPESeriesMapPtr map1, I3MCPESeriesMapConstPtr map2, float offsetTime, I3ParticleIDMapPtr map1Info, I3ParticleIDMapConstPtr map2Info)

MergeHits - Takes two I3MCPESeriesMaps and merges their hits. The times of the hits in the second map are moved by offsetTime.

Parameters:

• map1 – ‘original’ map to which we will add the new hits

• map2 – second map hit times will be set within window of first map

• offsetTime – time difference between first hit in map2 relative to map1

• map1Info – any external particle parentage info for map1. Will be created if necessary.

• map2Info – any external particle parentage info for map2

Returns:

an updated version of map1Info, or nothing if that object continues to be unnecessary.

file I3CosmicEventGenerator.cxx

#include “sim-services/I3CosmicEventGenerator.h”

#include <boost/make_shared.hpp>

file I3CosmicEventGenerator.h

#include <sim-services/I3PropagatorService.h>

#include <dataclasses/physics/I3MCTree.h>

Functions

I3_POINTER_TYPEDEFS(I3IncrementalEventGeneratorService)

I3_POINTER_TYPEDEFS(NeutrinoSelector)

file I3DownsampleMCPE.cxx

#include <set>

#include <string>

#include <vector>

#include <icetray/I3ConditionalModule.h>

#include <phys-services/I3RandomService.h>

#include <simclasses/I3MCPE.h>

#include <simclasses/I3ParticleIDMap.hpp>

#include <sim-services/MCPEMCPulseTools.hpp>

Functions

I3_MODULE(I3DownsampleMCPE)

file I3GeneratorService.cxx

#include <sim-services/I3GeneratorService.h>

file I3GeneratorService.h

#include <icetray/I3PointerTypedefs.h>

#include <icetray/I3Frame.h>

#include <icetray/I3ServiceBase.h>

#include <dataclasses/physics/I3MCTree.h>

Functions

I3_POINTER_TYPEDEFS(I3GeneratorService)

file I3InIceCORSIKATrimmer.cxx

#include <icetray/I3ConditionalModule.h>

#include <dataclasses/physics/I3MCTree.h>

#include <dataclasses/I3Constants.h>

Functions

I3_MODULE(I3InIceCORSIKATrimmer)

file I3LightSourceParameterization.cxx

#include <icetray/serialization.h>

#include <sim-services/I3LightSourceParameterization.h>

#include <limits>

#include <cmath>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

file I3LightSourceParameterization.h

#include “icetray/I3TrayHeaders.h”

#include “dataclasses/physics/I3Particle.h”

#include “simclasses/I3LightSource.h”

#include <vector>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Typedefs

typedef std::vector<I3LightSourceParameterization> I3LightSourceParameterizationSeries

Functions

I3_POINTER_TYPEDEFS(I3LightSourceToStepConverter)

inline bool operator==(const I3LightSourceParameterization &a, const I3LightSourceParameterization &b)

I3_POINTER_TYPEDEFS(I3LightSourceParameterization)

I3_POINTER_TYPEDEFS(I3LightSourceParameterizationSeries)

file I3LightSourcePropagator.h

#include “icetray/I3PointerTypedefs.h”

#include “dataclasses/physics/I3MCTree.h”

Functions

I3_FORWARD_DECLARATION(I3LightSource)

I3_FORWARD_DECLARATION(I3CLSimMediumProperties)

I3_FORWARD_DECLARATION(I3CLSimFunction)

I3_FORWARD_DECLARATION(I3RandomService)

file I3LightSourcePropagatorFromI3PropagatorService.cxx

#include “sim-services/I3LightSourcePropagatorFromI3PropagatorService.h”

#include “simclasses/I3LightSource.h”

file I3LightSourcePropagatorFromI3PropagatorService.h

#include <sim-services/I3LightSourcePropagator.h>

#include <sim-services/I3PropagatorService.h>

file I3LightSourceToStepConverter.cxx

#include <icetray/serialization.h>

#include <sim-services/I3LightSourceToStepConverter.h>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

file I3LightSourceToStepConverter.h

#include “icetray/I3TrayHeaders.h”

#include “phys-services/I3RandomService.h”

#include “simclasses/I3SimStep.h”

#include “simclasses/I3CLSimMediumProperties.h”

#include “sim-services/I3LightSourceParameterization.h”

#include “simclasses/function/I3CLSimFunction.h”

#include “simclasses/I3LightSource.h”

#include <boost/noncopyable.hpp>

#include <boost/variant.hpp>

#include <string>

#include <stdexcept>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

I3_POINTER_TYPEDEFS(I3LightSourceToStepConverter)

file I3LightSourceToStepConverterAsync.cxx

#include “sim-services/I3LightSourceToStepConverterAsync.h”

#include “sim-services/I3LightSourcePropagator.h”

#include “simclasses/I3CLSimQueue.h”

#include <boost/thread/locks.hpp>

#include <boost/foreach.hpp>

#include <limits>

#include <deque>

#include <boost/tuple/tuple.hpp>

#include <cmath>

#include “simclasses/I3SimStepStore.h”

#include <stdlib.h>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

file I3LightSourceToStepConverterAsync.h

#include “sim-services/I3LightSourceToStepConverter.h”

#include “dataclasses/physics/I3Particle.h”

#include “dataclasses/physics/I3MCTree.h”

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/locks.hpp>

#include “simclasses/I3CLSimQueue.h”

#include <map>

#include <string>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

I3_FORWARD_DECLARATION(I3LightSourcePropagator)

I3_POINTER_TYPEDEFS(I3LightSourceToStepConverterAsync)

file I3LightSourceToStepConverterPotemkin.cxx

#include “sim-services/I3LightSourceToStepConverterPotemkin.h”

file I3LightSourceToStepConverterPotemkin.h

#include “sim-services/I3LightSourceToStepConverter.h”

Copyright (c) 2023 Jakob van Santen jakob.van.santen@desy.de and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

I3_POINTER_TYPEDEFS(I3LightSourceToStepConverterPotemkin)

file I3MCEventHeaderGenerator.cxx

#include <icetray/I3Frame.h>

#include <icetray/I3Tray.h>

#include <icetray/I3Module.h>

#include <dataclasses/physics/I3EventHeader.h>

#include <dataclasses/I3Time.h>

#include <icetray/I3Bool.h>

#include <icetray/I3Units.h>

Functions

I3_MODULE(I3MCEventHeaderGenerator)

const int DEFAULT_MJD_SECONDS (0)

const double DEFAULT_MJD_NANOSECONDS (0.)

Variables

const int DEFAULT_YEAR = 2006

const int64_t DEFAULT_DAQTIME = 0

file I3MCPEConverters.cxx

#include <sim-services/I3MCPEConverters.h>

#include <dataclasses/physics/I3MCHit.h>

#include <simclasses/I3MCPE.h>

#include <boost/foreach.hpp>

file I3MCPEConverters.h

#include <icetray/I3PointerTypedefs.h>

#include <dataclasses/physics/I3MCHit.h>

#include <simclasses/I3MCPE.h>

file I3MCPESort.cxx

#include “sim-services/I3MCPESort.h”

#include <cmath>

#include <cassert>

#include <algorithm>

#include <icetray/OMKey.h>

#include <simclasses/I3MCPE.h>

file I3MCPESort.h

#include “icetray/I3Module.h”

file I3MCPEtoI3MCHitConverter.cxx

#include <string>

#include <vector>

#include “icetray/I3ConditionalModule.h”

#include “simclasses/I3MCPE.h”

#include “dataclasses/physics/I3MCHit.h”

Copyright (c) 2013 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

void pe_to_hit(const I3MCPE&, I3MCHit&)

I3_MODULE(I3MCPEtoI3MCHitConverter)

file I3MCTreeHybridSimulationSplitter.cxx

#include <string>

#include <icetray/I3Module.h>

#include <icetray/I3Units.h>

#include <dataclasses/physics/I3Particle.h>

#include <dataclasses/physics/I3MCTree.h>

#include <boost/foreach.hpp>

Functions

I3_MODULE(I3MCTreeHybridSimulationSplitter)

file I3ModifyEventID.cxx

#include “icetray/I3TrayHeaders.h”

#include “icetray/I3Tray.h”

#include “icetray/I3Module.h”

#include “dataclasses/I3Time.h”

#include “dataclasses/physics/I3EventHeader.h”

Functions

I3_MODULE(I3ModifyEventID)

const int DEFAULT_MJD_SECONDS (0)

const double DEFAULT_MJD_NANOSECONDS (0.)

const int DEFAULT_RUN_NUMBER (0)

const int DEFAULT_SUBRUN_NUMBER (0)

Variables

const int DEFAULT_YEAR = 2006

const int64_t DEFAULT_DAQTIME = 0ULL

file I3PhotonPropagationClientModule.cxx

#include <boost/range/iterator_range.hpp>

#include “dataclasses/geometry/I3ModuleGeo.h”

#include “phys-services/surfaces/ExtrudedPolygon.h”

#include “sim-services/I3PhotonPropagationClientModule.h”

#include “sim-services/I3PhotonPropagationServer.h”

#include “sim-services/I3LightSourceToStepConverterAsync.h”

#include “simclasses/I3CLSimEventStatistics.h”

#include “sim-services/I3CLSimPhotonToMCPEConverter.h”

#include <icetray/python/gil_holder.hpp>

Defines

__STDC_FORMAT_MACROS

Functions

I3_MODULE(I3PhotonPropagationClientModule)

template<typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &vec)

This thread takes care of passing steps from Geant4 to OpenCL

file I3PhotonPropagationClientModule.h

#include <atomic>

#include <deque>

#include <future>

#include <boost/bimap/bimap.hpp>

#include <boost/bimap/multiset_of.hpp>

#include <boost/thread.hpp>

#include “icetray/I3ConditionalModule.h”

#include “simclasses/I3CompressedPhoton.h”

#include “simclasses/I3Photon.h”

#include “sim-services/MCPEMCPulseTools.hpp”

#include “sim-services/I3CosmicEventGenerator.h”

#include “simclasses/I3FlasherPulse.h”

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

I3_FORWARD_DECLARATION(I3PhotonPropagationClient)

I3_FORWARD_DECLARATION(I3LightSource)

I3_FORWARD_DECLARATION(I3LightSourceToStepConverterAsync)

I3_FORWARD_DECLARATION(I3CLSimPhotonToMCPEConverter)

file I3PhotonPropagationServer.cxx

#include “icetray/I3Logging.h”

#include “sim-services/I3PhotonPropagationServer.h”

file I3PhotonPropagationServer.h

#include “simclasses/I3SimStep.h”

#include “sim-services/I3StepToPhotonConverter.h”

file I3PhotonToMCPEConverter.cxx

#include <inttypes.h>

#include <algorithm>

#include <cmath>

#include “sim-services/I3PhotonToMCPEConverter.h”

#include <boost/foreach.hpp>

#include “simclasses/I3Photon.h”

#include “simclasses/I3CompressedPhoton.h”

#include “phys-services/I3SummaryService.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “dataclasses/geometry/I3ModuleGeo.h”

#include “simclasses/I3MCPE.h”

#include “dataclasses/physics/I3ParticleID.h”

#include <sim-services/MCPEMCPulseTools.hpp>

#include “dataclasses/I3Constants.h”

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Defines

__STDC_FORMAT_MACROS

Functions

I3_MODULE(I3PhotonToMCPEConverter)

file I3PhotonToMCPEConverter.h

#include “icetray/I3Module.h”

#include “icetray/I3ConditionalModule.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “dataclasses/physics/I3MCTree.h”

#include “simclasses/I3MCPE.h”

#include <simclasses/I3ParticleIDMap.hpp>

#include “phys-services/I3RandomService.h”

#include “simclasses/function/I3CLSimFunction.h”

#include “sim-services/I3CLSimPhotonToMCPEConverter.h”

#include <string>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

file I3PrimaryInjector.cxx

#include “icetray/I3Module.h”

#include “dataclasses/physics/I3MCTreeUtils.h”

#include “phys-services/surfaces/Cylinder.h”

#include “simclasses/I3ShowerBias.h”

#include “simclasses/I3PrimaryInjectorInfo.h”

#include “simclasses/I3PowerLaw.h”

Functions

I3_MODULE(I3PrimaryInjector)

file I3PrimaryPulseMapper.cxx

#include “I3PrimaryPulseMapper.h”

#include <sim-services/MCPEMCPulseTools.hpp>

Copyright (c) 2013 Juan Carlos Diaz-Velez juancarlos@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Juan Carlos Diaz-Velez

Functions

I3_MODULE(I3PrimaryPulseMapper)

file I3PrimaryPulseMapper.h

#include <icetray/I3ConditionalModule.h>

#include <dataclasses/physics/I3MCTree.h>

file I3PropagatorModule.cxx

#include <deque>

#include <boost/foreach.hpp>

#include “icetray/I3ConditionalModule.h”

#include “dataclasses/physics/I3Particle.h”

#include “dataclasses/physics/I3MCTree.h”

#include “dataclasses/physics/I3MCTreeUtils.h”

#include “phys-services/I3RandomService.h”

#include “sim-services/I3PropagatorService.h”

Copyright (c) 2013 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Functions

I3_MODULE(I3PropagatorModule)

file I3PropagatorService.cxx

#include <sim-services/I3PropagatorService.h>

file I3PropagatorService.h

#include <map>

#include <icetray/I3PointerTypedefs.h>

#include <icetray/I3Frame.h>

#include <dataclasses/physics/I3Particle.h>

#include <phys-services/I3RandomService.h>

Typedefs

typedef std::map<I3Particle::ParticleType, I3PropagatorServicePtr> I3ParticleTypePropagatorServiceMap

Functions

I3_POINTER_TYPEDEFS(I3PropagatorService)

I3_POINTER_TYPEDEFS(I3ParticleTypePropagatorServiceMap)

file I3RemoveLargeDT.cxx

#include <boost/foreach.hpp>

#include <icetray/I3Units.h>

#include <icetray/I3Module.h>

#include <simclasses/I3MCPE.h>

Copyright (c) 2013 Juan Carlos Diaz-Velez juancarlos@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Juan Carlos Diaz-Velez

Functions

I3_MODULE(I3RemoveLargeDT)

file I3SimConstants.cxx

#include <sim-services/I3SimConstants.h>

file I3SimConstants.h

#include <icetray/I3Units.h>

#include <dataclasses/I3Constants.h>

#include <dataclasses/physics/I3Particle.h>

#include <cmath>

copyright (C) 2012 the icecube collaboration

Version

Rcs

I3SimConstants.h

Date

Rcs

file I3StepToPhotonConverter.h

#include “icetray/I3TrayHeaders.h”

#include “simclasses/I3SimpleGeometry.h”

#include “simclasses/I3SimStep.h”

#include “simclasses/I3CLSimPhoton.h”

#include “simclasses/I3CLSimPhotonHistory.h”

#include “simclasses/I3CLSimMediumProperties.h”

#include “simclasses/random_value/I3CLSimRandomValue.h”

#include “simclasses/function/I3CLSimFunction.h”

#include <boost/noncopyable.hpp>

#include <vector>

#include <map>

#include <string>

#include <stdexcept>

Copyright (c) 2011, 2012 Claudio Kopper claudio.kopper@icecube.wisc.edu and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Claudio Kopper

Typedefs

typedef std::vector<I3StepToPhotonConverterPtr> I3StepToPhotonConverterSeries

Functions

I3_POINTER_TYPEDEFS(I3StepToPhotonConverter)

file I3StepToPhotonConverterPotemkin.cxx

#include “sim-services/I3StepToPhotonConverterPotemkin.h”

#include <boost/make_shared.hpp>

#include <chrono>

#include <thread>

file I3StepToPhotonConverterPotemkin.h

#include “sim-services/I3StepToPhotonConverter.h”

#include “phys-services/I3RandomService.h”

#include “simclasses/I3CLSimQueue.h”

#include <chrono>

Copyright (c) 2020 Jakob van Santen jakob.van.santen@desy.de and the IceCube Collaboration http://www.icecube.wisc.edu

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

$Id$

Version

$Revision$

Date

$Date$

Author

Jakob van Santen

Functions

I3_POINTER_TYPEDEFS(I3StepToPhotonConverterPotemkin)

file I3SumGenerator.cxx

#include <iostream>

#include <cmath>

#include <string>

#include <sim-services/I3SumGenerator.h>

file I3SumGenerator.h

#include <vector>

#include <boost/function.hpp>

#include <phys-services/I3RandomService.h>

Functions

I3_POINTER_TYPEDEFS(I3SumGenerator)

file MCPEMCPulseTools.cxx

#include <sim-services/MCPEMCPulseTools.hpp>

#include <icetray/I3ConditionalModule.h>

file MCPEMCPulseTools.hpp

#include <simclasses/I3MCPulse.h>

#include <simclasses/I3MCPE.h>

#include <simclasses/I3ParticleIDMap.hpp>

file OnboardNoiseSuppression.cxx

#include <sim-services/OnboardNoiseSuppression.h>

#include <icetray/I3Units.h>

SPDX-FileCopyrightText: 2024 The IceTray Contributors SPDX-License-Identifier: BSD-2-Clause

An I3Module designed to mimic the onboard noise suppression features planned for the mDOMs in the IceCubeUpgrade. We take a set of hits on mDOMs and check whether any other hits occur on other PMTs within a SearchWindow time. If other PMTs are hit, we accept the hit. If we see more than one hit on a single PMT and no neighbors hit in SearchWindow time, then we initiate an artificial deadtime for the PMT.

Date

2024-02-21

Author

mlarson

Functions

I3_MODULE(OnboardNoiseSuppression)

file OnboardNoiseSuppression.h

#include <string>

#include <map>

#include <vector>

#include “icetray/I3ConditionalModule.h”

#include “icetray/OMKey.h”

#include “phys-services/I3RandomService.h”

#include “dataclasses/physics/I3RecoPulse.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “dataclasses/I3Map.h”

#include “dataclasses/I3TimeWindow.h”

SPDX-FileCopyrightText: 2024 The IceTray Contributors SPDX-License-Identifier: BSD-2-Clause

An I3Module designed to mimic the onboard noise suppression features planned for the mDOMs in the IceCubeUpgrade. We take a set of hits on mDOMs and check whether any other hits occur on other PMTs within a SearchWindow time. If other PMTs are hit, we accept the hit. If we see more than one hit on a single PMT and no neighbors hit in SearchWindow time, then we initiate an artificial deadtime for the PMT.

Date

2024-02-21

Author

mlarson

file zmq.hpp

#include <zmq.h>

#include <cassert>

#include <cstring>

#include <algorithm>

#include <exception>

#include <iomanip>

#include <sstream>

#include <string>

#include <vector>

Defines

CPPZMQ_LANG

ZMQ_NODISCARD

ZMQ_NOTHROW

ZMQ_EXPLICIT

ZMQ_OVERRIDE

ZMQ_NULLPTR

ZMQ_CONSTEXPR_FN

ZMQ_CONSTEXPR_VAR

ZMQ_CPP11_DEPRECATED(msg)

ZMQ_INLINE_VAR

CPPZMQ_HAS_INCLUDE_CPP17(X)

CPPZMQ_HAS_OPTIONAL

CPPZMQ_HAS_STRING_VIEW

CPPZMQ_VERSION_MAJOR

CPPZMQ_VERSION_MINOR

CPPZMQ_VERSION_PATCH

CPPZMQ_VERSION

ZMQ_DELETED_FUNCTION

ZMQ_NEW_MONITOR_EVENT_LAYOUT

ZMQ_HAS_PROXY_STEERABLE

ZMQ_ASSERT(expression)

file zmq_addon.hpp

#include “zmq.hpp”

#include <deque>

#include <iomanip>

#include <sstream>

#include <stdexcept>

dir cppzmq

dir icetray

dir private

dir public

dir sim-services

dir sim-services

dir sim-services

dir vendor