DOMLauncher C++ API Reference

class BufferedWaveformEvaluator

#include <domlauncherutils.h>

Public Functions

inline BufferedWaveformEvaluator(double timeBin = 25 * I3Units::ns, double padding = 200 * I3Units::ns, double cutoffTime = 500 * I3Units::microsecond, double bufferTime = 500 * I3Units::microsecond)

inline void SetPulses(const std::vector<I3MCPulse> &pulses)

inline double WaveFormAmplitude(double time, InterpolatedSPETemplate &templ)

inline void Buffer(double start_time)

inline void Clear()

Private Members

std::vector<I3MCPulse> pulseBuffer_

WaveformEvaluator currentWaveform_

WaveformEvaluator bufferedWaveform_

const std::vector<I3MCPulse> *currentPulses_

double bufferTime_

class CombinedSimulator : public I3ConditionalModule

#include <CombinedSimulator.h>

A module that combines simulation of the detector response with the PMT response simulator.

class: CombinedSimulator (Gyllenstierna)

Version

Rcs

Date

:

Rcs

Copyright (c) 2011,2012 IceCube Collaboration

Author

Matti Jansson matti.jansson@fysik.su.se

Public Functions

CombinedSimulator(const I3Context&)

inline ~CombinedSimulator()

void Configure()

void DAQ(I3FramePtr)

void Calibration(I3FramePtr)

void Geometry(I3FramePtr)

void DetectorStatus(I3FramePtr)

std::pair<std::vector<I3MCPulse>, ParticlePulseIndexMap> processHits(const std::vector<I3MCPE> &inputHits, OMKey dom, const I3DOMCalibration &cal, const I3DOMStatus &status, const ParticlePulseIndexMap &pePedigree)

Applies all transformations to a set of hits on a single DOM.

Parameters:

• inputHits – The raw hits on the DOM

• dom – The DOM on which the hits occur

• cal – The current calibration information for this DOM

• status – The current status information for this DOM

• pePedigree – The particle parentage

Returns:

A new set of time ordered hits with weighting applied, alternate pulse types generated, saturation applied, and time merging applied

void saturate(std::vector<I3MCPulse> &hits, double pmtVoltage, const I3DOMCalibration &cal)

Reweights the hits in the given series to mimic the effects of saturation in the PMT. The ‘inverse’ saturation parameterization from T. Waldenmeier is used.

Parameters:

• hits – The hit series to be reweighted

• pmtVoltage – The operating voltage of the PMT

• cal – The calibration data for the DOM

Pre:

The input hits must be time ordered

inline std::string getInputHitsName() const

inline void setInputHitsName(const std::string &in)

inline bool getUseSPEDistribution() const

inline void setUseSPEDistribution(bool use)

inline bool getUseJitter() const

inline void setUseJitter(bool use)

inline double getPrePulseProbability() const

inline void setPrePulseProbability(double prob)

inline double getLatePulseProbability() const

inline void setLatePulseProbability(double prob)

inline double getAfterPulseProbability() const

inline void setAfterPulseProbability(double prob)

inline bool getApplySaturation() const

inline void setApplySaturation(bool apply)

inline bool getMergeHits() const

inline void setMergeHits(bool merge)

inline bool getLowMem() const

inline void setLowMem(bool lowMem)

inline boost::shared_ptr<I3RandomService> getRandomService() const

inline void setRandomService(boost::shared_ptr<I3RandomService> randomService)

Public Static Functions

static void timeMergeHits(std::vector<I3MCPE> &hits)

Merges together pulses which are within some small time window, compacting the hit series if it is densely filled with hits. (Here, ‘small’ is intended to be relative to the resolution of the feature extractor.)

Parameters:

hits – The hit series to be compacted

Pre:

The input hits must be time ordered

static void timeMergeHits(std::vector<I3MCPulse> &hits, ParticlePulseIndexMap &aux)

Private Functions

void DOTOutput(I3FramePtr, const domlauncherutils::DCStream&)

Extracts Discriminator Over Threshold (DOT) times from triggerStream_ and puts in Frame as an MCPulseSeriesMap.

This function provides Discriminator Over Threshold (DOT) output, a feature which was asked by the sn-wg group as they base their analysis on discriminator crossings.

void InitilizeDOMMap()

double normalHitWeight(unsigned int w, const boost::shared_ptr<I3SumGenerator> &speDistribution)

Computes the amount of charge, relative to the charge produced by an ideal, single photoelectron, produced by a hit whose weight is an integer number of initial photoelectrons.

Parameters:

• w – The weight of the hit in photons

• speDistribution – The amplification distribution from which to sample

Returns:

The amount of charge produced by the PMT for this hit, in units of the ideal charge produced by a single photoelectron

double PMTJitter()

Generates a random time jitter value for a hit.

Fisher-Tippett variables for well behaved time distribtutions. These values were obtained by fits to Bricktop running at 1345 [V] during DFL studies by C. Wendt. The fits were performed by R. Porrata.

Returns:

A random time offset, in nanoseconds

double prePulseTimeShift(double voltage)

Computes the amount by which prepulses are early at a given voltage.

Parameters:

voltage – The operating voltage of the DOM

Returns:

A time offset, in nanoseconds

double prePulseWeight(double voltage)

Computes the charge of a prepulse, relative to an ideal s.p.e. at a given voltage.

Parameters:

voltage – The operating voltage of the DOM

Returns:

The amount of charge produced by the PMT for a prepulse, in units of the ideal charge produced by a single photoelectron

double earlyAfterPulseWeight()

Computes the charge of an early afterpulse, relative to an ideal s.p.e. at a given voltage.

Returns:

The amount of charge produced by the PMT for an early afterpulse, in units of the ideal charge produced by a single photoelectron

void createLatePulse(I3MCPulse &hit, const boost::shared_ptr<I3SumGenerator> &speDistribution, double voltage)

Alters the properies of the given hit to describe a late pulse.

Parameters:

• hit – The existing raw hit to be turned into a late pulse hit

• speDistribution – The speDistribution for the DOM on which the hit is being detected

• voltage – The operating voltage of the PMT

void createAfterPulse(I3MCPulse &hit, const boost::shared_ptr<I3SumGenerator> &speDistribution, double voltage)

Alters the properies of the given hit to describe an afterpulse.

Parameters:

• hit – The existing raw hit to be turned into an afterpulse hit

• speDistribution – The speDistribution for the DOM on which the hit is being detected

• voltage – The operating voltage of the PMT

double fisherTippett(double location, double scale, double logLowerBound, double logUpperBound)

Generate a Fisher-Tippet distributed (alias Gumbel distributed) random variate.

Parameters:

• location – The location parameter of the distribution from which to sample (mean = location + scale * euler_mascheroni)

• scale – The scale parameter of the distribution from which to sample (variance = (pi * scale)**2 / 6)

• logLowerBound – Indirectly determines the lower cutoff of the distribution

• logUpperBound – Indirectly determines the upper cutoff of the distribution

SET_LOGGER ("DOMLauncher")

Private Members

std::string inputHitsName_

The name of the I3MCPESeriesMap to process.

bool useSPEDistribution_

Whether the charges of hits should be randomized.

bool usePMTJitter_

Whether the times of hits should be randomly perturbed.

double prePulseProbability_

The probability that a pulse arrives early.

double latePulseProbability_

The probability that a pulse arrives late.

double afterPulseProbability_

The probability that a pulse produces an accompanying afterpulse.

bool applySaturation_

Whether the weights of the hits should be modified to account for saturation.

bool mergeHits_

Whether hits very close in time should be merged.

bool lowMem_

Whether to merge hits repeatedly during generation to attempt to limit transient memory use.

boost::shared_ptr<I3RandomService> randomService_

The random service fetched from the tray.

boost::shared_ptr<I3SumGenerator> genericChargeDistribution_

A generic distribution of charges produced by single photon hits.

std::map<OMKey, boost::shared_ptr<I3SumGenerator>> chargeDistributions_

The charge distributions to be used for each DOM for single photon hits.

boost::shared_ptr<const I3Calibration> lastCalibration_

The most recently seen calibration data.

bool domMapInitialized_

Is DOM Map initialized.

bool snMode_

SuperNova Mode : Outputs discriminator over threshold (DOT) times.

bool multiFrameEvents_

Does not reset the DOMs with each new frame.

bool tabulatePTs_

Pulse templates used in simulation are interpolated for better speed with the cost of worse precision and larger memory consumption.

bool mergePulses_

If pulses in the past should be merged. Speeds up considerably if the number of pulses to process per DOM and frame is large.

bool droopedPulseTemplates_

If drooped SPE pulse templates should be used.

bool beaconLaunches_

If beacon launches should be simulated.

double beaconLaunchRate_

Rate of beacon launches.

std::string domLaunchMapName_

The name of the DOMLaunchSeriesMaps to be produced.

std::string mcPulseSeriesName_

The name of the MCPulseSeriesMap to be processed.

I3Map<OMKey, I3OMGeo> domGeo_

std::map<OMKey, I3DOMCalibration> domCal_

std::map<OMKey, I3DOMStatus> domStatus_

std::map<OMKey, boost::shared_ptr<I3DOM>> domMap_

std::map<OMKey, boost::shared_ptr<I3DOM>> activeDOMsMap_

domlauncherutils::I3DOMGlobals globalSimState

std::string randomServiceName_

The ID of the random service to use.

Friends

friend class CombinedSimulatorTestSetup

struct DiscCross

#include <domlauncherutils.h>

The DiscCross is a representaion of a discriminator crossing.

Public Functions

inline DiscCross()

inline DiscCross(OMKey i, double s)

inline bool operator==(const domlauncherutils::detail::DiscCross &rhs)

Public Members

OMKey DOM

The DOM which the trigger belongs to.

double time

Trigger start time.

LaunchType type

Type of trigger.

struct DOM

#include <DOM.h>

This is the base class for for an DOM object used in DOMLauncher simulation. All different types of DOMs are derived from this class.

class: I3DOM

Version

Rcs

Date

:

Rcs

Copyright (c) 2012 IceCube Collaboration

Author

Samuel Flis samuel.d.flis@gmail.com

Subclassed by I3DOM

Public Functions

inline virtual ~DOM()

struct DOMCalibration

#include <I3DOM.h>

Public Functions

void Configure(const I3DOMCalibration&)

Public Members

double frontEndImpedance

double atwdGains[3]

double atwdDeltaT[2]

double atwdBinCalib[2][3][128]

double atwdBeaconBaseline[2][128]

double fadcGain

double fadcDeltaT

double fadcBeaconBaseline

class DOMLauncher : public I3ConditionalModule

#include <DOMLauncher.h>

A module that simulates the detector response.

class: DOMLauncher (Gyllenstierna)

Version

Rcs

Date

:

Rcs

Copyright (c) 2011,2012 IceCube Collaboration

Author

Samuel Flis samuel.d.flis@gmail.com

Public Functions

DOMLauncher(const I3Context&)

inline ~DOMLauncher()

void Configure()

void DAQ(I3FramePtr)

void Calibration(I3FramePtr)

void Geometry(I3FramePtr)

void DetectorStatus(I3FramePtr)

Private Functions

void DOTOutput(I3FramePtr, const domlauncherutils::DCStream&)

Extracts Discriminator Over Threshold (DOT) times from triggerStream_ and puts in Frame as an MCPulseSeriesMap.

This function provides Discriminator Over Threshold (DOT) output, a feature which was asked by the sn-wg group as they base their analysis on discriminator crossings.

void InitilizeDOMMap()

DOMLauncher()

DOMLauncher(const DOMLauncher&)

DOMLauncher &operator=(const DOMLauncher&)

SET_LOGGER ("DOMLauncher")

Private Members

bool domMapInitialized_

Is DOM Map initialized.

bool snMode_

SuperNova Mode : Outputs discriminator over threshold (DOT) times.

bool multiFrameEvents_

Does not reset the DOMs with each new frame.

bool tabulatePTs_

Pulse templates used in simulation are interpolated for better speed with the cost of worse precision and larger memory consumption.

bool mergePulses_

If pulses in the past should be merged. Speeds up considerably if the number of pulses to process per DOM and frame is large.

bool droopedPulseTemplates_

If drooped SPE pulse templates should be used.

bool beaconLaunches_

If beacon launches should be simulated.

double beaconLaunchRate_

Rate of beacon launches.

std::string domLaunchMapName_

The name of the DOMLaunchSeriesMaps to be produced.

std::string mcPulseSeriesName_

The name of the MCPulseSeriesMap to be processed.

I3Map<OMKey, I3OMGeo> domGeo_

std::map<OMKey, I3DOMCalibration> domCal_

std::map<OMKey, I3DOMStatus> domStatus_

I3RandomServicePtr randomService_

std::map<OMKey, boost::shared_ptr<I3DOM>> domMap_

std::map<OMKey, boost::shared_ptr<I3DOM>> activeDOMsMap_

I3Vector<OMKey> badDOMList_

domlauncherutils::I3DOMGlobals globalSimState

std::string randomServiceName_

The ID of the random service to use.

std::map<OMKey, bool> alreadyWarnedUnexpectedPulses_

Record of DOMs for which a warning message about unexpected pulses being ignored has already been issued.

struct DOMStatus

#include <I3DOM.h>

Public Functions

void Configure(const I3DOMStatus&)

Public Members

double lcWindowPre

double lcWindowPost

I3DOMStatus::OnOff statusATWDa

I3DOMStatus::OnOff statusATWDb

I3DOMStatus::LCMode lcMode

I3DOMStatus::LCMode txMode

unsigned lcSpan

I3DOMStatus::DOMGain domGainType

class genericLOM_PMT : public PMT

#include <PMT.h>

Public Functions

inline genericLOM_PMT(double prePulseProbability, double latePulseProbability, double afterPulseProbability, const I3RandomServicePtr &r, const I3DOMCalibration &calibration)

inline virtual double GetPrePulseTimeShift(double voltage)

inline virtual double GetPrePulseWeight(double voltage)

inline virtual const unsigned int GetNumLatePulseComponents()

inline virtual const pulseComponent *GetLatePulseComponents()

inline virtual const unsigned int GetNumAfterPulseComponents()

inline virtual const pulseComponent *GetAfterPulseComponents()

inline virtual double PMTJitter()

inline virtual void SetSaturationParams(double log10Gain)

inline virtual bool SkipSaturation()

inline virtual bool SkipMergeHits()

class HamamatsuR15458_02PMT : public PMT

#include <PMT.h>

Public Functions

inline HamamatsuR15458_02PMT(double prePulseProbability, double latePulseProbability, double afterPulseProbability, const I3RandomServicePtr &r, const I3DOMCalibration &calibration)

inline virtual double GetPrePulseTimeShift(double voltage)

inline virtual double GetPrePulseWeight(double voltage)

inline virtual const unsigned int GetNumLatePulseComponents()

inline virtual const pulseComponent *GetLatePulseComponents()

inline virtual const unsigned int GetNumAfterPulseComponents()

inline virtual const pulseComponent *GetAfterPulseComponents()

inline virtual double PMTJitter()

inline virtual void SetSaturationParams(double log10Gain)

inline virtual bool SkipSaturation()

inline virtual bool SkipMergeHits()

class HamamatsuR5912_100PMT : public PMT

#include <PMT.h>

Public Functions

inline HamamatsuR5912_100PMT(double prePulseProbability, double latePulseProbability, double afterPulseProbability, const I3RandomServicePtr &r, const I3DOMCalibration &calibration)

inline virtual double GetPrePulseTimeShift(double voltage)

inline virtual double GetPrePulseWeight(double voltage)

inline virtual const unsigned int GetNumLatePulseComponents()

inline virtual const pulseComponent *GetLatePulseComponents()

inline virtual const unsigned int GetNumAfterPulseComponents()

inline virtual const pulseComponent *GetAfterPulseComponents()

inline virtual void SetSaturationParams(double log10Gain)

inline virtual bool SkipSaturation()

inline virtual bool SkipMergeHits()

inline virtual double PMTJitter()

class HamamatsuR7081_02PMT : public PMT

#include <PMT.h>

Public Functions

inline HamamatsuR7081_02PMT(double prePulseProbability, double latePulseProbability, double afterPulseProbability, const I3RandomServicePtr &r, const I3DOMCalibration &calibration)

inline virtual double GetPrePulseTimeShift(double voltage)

inline virtual double GetPrePulseWeight(double voltage)

inline virtual const unsigned int GetNumLatePulseComponents()

inline virtual const pulseComponent *GetLatePulseComponents()

inline virtual const unsigned int GetNumAfterPulseComponents()

inline virtual const pulseComponent *GetAfterPulseComponents()

inline virtual void SetSaturationParams(double log10Gain)

inline virtual bool SkipSaturation()

inline virtual bool SkipMergeHits()

inline virtual double PMTJitter()

Fisher-Tippett variables for well behaved time distribtutions. These values were obtained by fits to Bricktop running at 1345 [V] during DFL studies by C. Wendt. The fits were performed by R. Porrata.

class I3DOM : private DOM

#include <I3DOM.h>

This is the base class for for an IceCube DOM used in DOMLauncher simulation. The InIce and IceTop DOMS are derived from this class.

class: I3DOM

Version

Rcs

Date

:

Rcs

Copyright (c) 2012 IceCube Collaboration

Author

Samuel Flis samuel.d.flis@gmail.com

Subclassed by I3IceTopDOM, I3InIceDOM

Public Functions

I3DOM()

Default constructor. Thread-unsafe. No random sercice is set.

I3DOM(I3RandomServicePtr rng, const OMKey &om)

Constructor mostly for python convenience. NOTE: It is thread-unsafe since the state of the simulation and the is static pulse template map are static. It will in particular not work if one wants two I3DOMs to be identical except one having tabulated pulse templates and the other non-tabulated pulse templates.

Parameters:

• rng – a pointer to an I3RandomService

• om – the OMKey/om number of the particular DOM.

I3DOM(boost::shared_ptr<I3RandomService> rng, const OMKey &om, double &globalTime, domlauncherutils::PulseTemplateMap &speTemplateMap)

This is the preferred constructor since it is threadsafe. The user have to provide references to the state variables.

Parameters:

• rng – a pointer to an I3RandomService

• om – the OMKey/om number of the particular DOM.

• globalTime – a reference to a double that holds the globalTime state.

• speTemplateMap – a reference to a PulseTemplateMap that stores the pulse templates.

inline virtual ~I3DOM()

bool Configure(const I3DOMCalibration&, const I3DOMStatus&, double)

This function provides a configuration method for an I3DOM. Here all internal properties and variables should be set using information from the G,C and D frames.

virtual void CreateLCLinks(const std::map<OMKey, boost::shared_ptr<I3DOM>> &domMap, const I3OMGeoMap &domGeo) = 0

virtual void MakeCoarseChargeStamp(const dlud::DiscCross&, int chip, I3DOMLaunch&) = 0

inline double GetDiscriminatorThreshold()

inline double GetDiscriminatorThresholdFraction()

inline double GetRapCalTimeShift()

inline void SetRapCalTimeShift(double shift)

inline void SetUseTabulation(bool tabulation)

inline void SetMergePulses(bool merge)

inline void SetUseDroopedTemplate(bool droop)

inline bool GetUseTabulation()

inline bool GetMergePulses()

inline bool GetUseDroopedTemplate()

void Discriminator(const std::vector<I3MCPulse>&, dlutils::DCStream &dcStream)

This function holds the discriminator simulation. From the input of I3MCPulses, discriminator crossings are determined. This can in general be done.

The I3DOM::Discriminator is responsible to simulate the discriminator by creating DiscCrosss for each clockCycle the input signal is above threshold. These are then put in a global discriminator crossings stream that defines the time evolution of the event.

void AddTrigger(dlud::DiscCross&)

A function to feed back triggers previuosly simulated by Discriminator().

To simulate inter-DOM behavior where the DOMs signal each other, local coincidence (LC) for instance, this function is used. Triggers are fed back to the I3DOMs in a time ordered stream.

inline void TriggerLaunch(bool force)

This function triggers DOMs that have potential triggers left which would cause a launch (only SLC). In general the launch decision can’t be made at the time when the trigger is received if no neighbor DOMs are in LC. If the I3DOM object doesn’t receive more triggers or LC signals in a frame, the trigger will not result in a DOM launch unless this function is called. If force is true all potential triggers will cause a launch given that the DOM isn’t busy.

bool AddBeaconLaunches(double startTime, double endTime, dlutils::DCStream &dcStream)

This function will add beacon launches between in a specified time window to the dc-stream according to the beacon launch rate which is set.

Parameters:

• startTime – the start time of the window

• endTime – the end time of the window

• dcStream – the discriminator crossing stream

void Reset(bool full = true)

Resets all dynamic properties such as deadtimes, stored triggers and launches giving you a ‘fresh DOM. No DOM specific configuration settings are reset!

Parameters:

full – when true a full reset is done, i.e all properties are reset. Otherwise only the launches are cleared

inline bool IsActive()

inline const std::vector<dlud::DiscCross> &GetTriggers() const

inline const std::vector<I3DOMLaunch> &GetDOMLaunches() const

inline const std::vector<I3DOM*> &GetNeighbors() const

inline std::vector<dlud::DiscCross> &GetTriggers()

inline std::vector<I3DOMLaunch> &GetDOMLaunches()

inline std::vector<I3DOM*> &GetNeighbors()

inline const OMKey &GetOMKey() const

Returns the DOM id (an OMKey)

Public Members

double speMean_

double transitTime_

double atwdSamplingRate_[2]

DOMCalibration domCal_

DOMStatus domStat_

domlauncherutils::BufferedWaveformEvaluator waveform_

Public Static Attributes

static const double ATWDReadoutDigitizeTime = 29000 * I3Units::ns

The time it takes to readout and digitize one ATWD channel.

static const double HLCReadoutTime = 6400 * I3Units::ns

This is the time it takes the DOM to readout the FADC after an HLC launch. It is roughly the deadtime of the DOM after an HLC launch if in ping-pong mode.

static const double ATWDRestartTime = 225 * I3Units::ns

The time it takes to restart the ATWD after a recording.

static const double ATWDClearTime = 950 * I3Units::ns

The time it takes to reset one ATWD channel.

static const double clockCycle = 25 * I3Units::ns

Length of an FPGA clock cycle.

static const double delayLine = 75 * I3Units::ns

Length of the DOM delay line in ns.

static const double lcWait = 350 * I3Units::ns

Length of the dead time for LC signals.

static const unsigned int nFADCBins = 256

Number of samples/bins in FADC digitization.

static const unsigned int nATWDBins = 128

Number of samples/bins in ATWD digitization.

static const unsigned int nFADCCoarseChargeStampBins = 16

Number of samples/bins to compute coarse charge stamp.

static const unsigned int ATWDThreshold = 768

Threshold in number of counts to trigger digitization of the next ATWD channel.

static const unsigned int digitizerBits = 10

The number of bitswhich can be read out by digitizers.

static const unsigned int digitizerDynamicRange = (1u << I3DOM::digitizerBits) - 1

The dynamic range of the FADC and ATWD digitization in number of counts.

static const double FADCNoiseMean = 0

Mean of the gaussian electronic noise for the FADC, taken from DOMsimulator.

static const double FADCNoiseVariance = 0.5

Variance of the gaussian electronic noise for the FADC, taken from DOMsimulator.

static const double ATWDNoiseMean = 0

Mean of the gaussian electronic noise for the ATWD, taken from DOMsimulator.

static const double ATWDNoiseVariance = 0.8

Variance of the gaussian electronic noise for the ATWD, taken from DOMsimulator.

static double beaconLaunchRate = 0.6 * I3Units::hertz

Protected Functions

bool ATWDDigitization(const dlud::DiscCross &trigger, int channel, int chip, std::vector<int> &digitizedReadOut)

Simulates the ATWD digitization and readout.

Parameters:

• trigger – The trigger which the launch is based on.

• channel – The ATWD channel which is to be digitized

• chip – The ATWD chip

• digitizedReadOut – The vector in which to put the digitized waveform

Returns:

returns a bool. If true the ATWD waveform crossed the 2/3 threshold which should initiate digitization of the next channel.

Protected Attributes

boost::shared_ptr<I3RandomService> rng_

OMKey domId_

double cableCorrection_

Stores the actual cable correction used by this particular I3InIceDOM.

bool mergePulses_

std::vector<I3DOM*> domNeighbors_

Vector containing pointers to DOMs that are physical DOM neighbors of this DOM.

InterpolatedSPETemplatePtr discSPETemplatePtr_

Pointer to discriminator pulse template.

InterpolatedSPETemplatePtr atwdSPETemplatePtr_[3]

Pointers to ATWD pulse templates.

InterpolatedSPETemplatePtr fadcSPETemplatePtr_

Pointer to FADC pulse template.

const std::vector<I3MCPulse> *pulses_

Stores I3MCPulses for FADC and ATWD digitization.

Private Functions

inline double CheckLCHigh()

This is where most of the launch decisions will be made. This function also returns the time of the last LC condition of that DOM. DOMs use this function to check their neighbors if they are in LC. While returning the LC status it will also go through the DiscCrosss to find out whether the I3InIceDOM can make any new launch decisions. Therefore DOMs also use this method on themselves when an added trigger results in LC with another DOMobject but older potential triggers still haven’t got a decision.

Returns:

time of the last LC condition.

void EvaluateLaunchPossibility(bool dom, bool force)

void FetchSPETemplates(const I3DOMCalibration&)

Sets the DroopedSPETemplates and the interpolated templates of the I3InIceDOM.

To save memory when tabulating the DroopedSPETemplates each unique tabulation is only saved once in a static map: std::map<I3DOMCalibration::DroopedSPETemplate, InterpolatedSPETemplate*> speTemplateMap, containing all unique DroopedSPETemplates. For each DroopedSPETemplate it checks if that template isn’t already in the map. If it isn’t, it’s added to the map and a pointer is set to it so the I3InIceDOM can utilize it, otherwise only the pointer is set.

void UpdateState(double t)

Update the state of the DOM with respect to time ‘t’.

Updates the state of the DOM by checking if the DOM is still busy doing with digitization or any other DOM operation with respect to the time t.

void Launch(const dlud::DiscCross &trigger)

This function is called when the DOM has taken the decision to launch. The function processes the launch by calling the appropriate digitization functions and also calculates how long the DOM and the specific ATWD chip will be busy.

Parameters:

trigger – the trigger which caused the launch. The type of launch (HLC,SLC) and which ATWD if(HLC) should be set in the trigger.

Returns:

no return.

void FADCDigitization(const dlud::DiscCross &trigger, std::vector<int> &digitizedReadOut)

Simulates the FADC digitization and readout.

Parameters:

• trigger – The trigger which the launch is based on.

• digitizedReadOut – The vector in which to put the digitized waveform

Returns:

no return

Private Members

std::map<I3DOMCalibration::DroopedSPETemplate, InterpolatedSPETemplatePtr> &speTemplateMap_

double lcHighTime_

Time of the last LC signal.

double &globalTime_

This is the global time which is the time of the last added trigger from the trigger stream.

double domTime_

This is “local” time which is set with.

See also

UpdateState() when the DOM iterates through triggers.

bool ATWDa_alive_

Indicates if the ATWD-A chip is busy or not with respect to global or DOMtime.

bool ATWDb_alive_

Indicates if the ATWD-B chip is busy or not with respect to global or DOMtime.

bool busy_

If true the DOM (I3InIceDOM) is busy and cannot initiate another launch at this time.

double busyTo_

The time at which the I3InIceDOM gets idle. Is used to determine if the DOM can initiate a launch.

double ATWDaDeadTo_

ATWDa is busy/dead to time = ATWDaDeadTo_;.

double ATWDbDeadTo_

ATWDb is busy/dead to time = ATWDbDeadTo_;.

double timeOfPulseTemplatePeak_

The time at which the pulse template has it’s maximum.

double discriminatorThreshold_

The threshold of the discriminator. Should be given as a fraction of a PE.

double discriminatorThresholdFraction_

double discriminatorDelay_

double rapCalUncertainty_

The uncertainty of the RapCal time calibration for this DOM.

double rapCalShift_

The actual shift due to the RapCal uncertainty.

double currentClockPhase_

double beaconLaunchPhase_

std::vector<dlud::DiscCross> discrXings_

Stores discriminator crossing that which haven’t caused launch yet.

std::vector<I3DOMLaunch> domLaunches_

Stores DOMLaunches.

bool useTabulation_

bool droopedPulseTemplates_

Private Static Attributes

static std::map<I3DOMCalibration::DroopedSPETemplate, InterpolatedSPETemplatePtr> speTemplateMapStatic_

If no pulse template map is provided it will fall back to the static one.

static double globalTimeStatic_ = NAN

If no global time object (double) is provided at construction it will fallback to this static one. NOTE: this is thread-unsafe.

struct I3DOMGlobals

#include <domlauncherutils.h>

A struct to store global state variable for the DOMLauncher simulation.

Public Members

PulseTemplateMap speTemplateMap_

double globalTime_

class I3IceTopDOM : public I3DOM

#include <I3IceTopDOM.h>

A class that provides a software representation of a DOM for the purpose of a detector response simulation. Copyright (c) 2011,2012 IceCube Collaboration.

class: I3IceTopDOM

Version

Rcs

Date

:

Rcs

Author

Samuel Flis samuel.d.flis@gmail.com

Public Functions

I3IceTopDOM()

I3IceTopDOM(I3RandomServicePtr, const OMKey&)

I3IceTopDOM(boost::shared_ptr<I3RandomService> rng, const OMKey &om, double &globlaTime, domlauncherutils::PulseTemplateMap &speTemplateMap)

bool Configure(const I3DOMCalibration&, const I3DOMStatus&)

void CreateLCLinks(const I3DOMMap&, const I3OMGeoMap&)

Public Static Attributes

static const double cableCorrectionIceTop = 1650 * I3Units::ns

Correction time of the LC time window due to finite LC signal speed for regular IceTop DOMs.

class: I3InIceDOMObject

Version

Rcs

Date

:

Rcs

Copyright (c) 2011,2012 IceCube Collaboration

Author

Samuel Flis samuel.d.flis@gmail.com

Protected Functions

virtual void MakeCoarseChargeStamp(const dlud::DiscCross&, int chip, I3DOMLaunch&)

class I3InIceDOM : public I3DOM

#include <I3InIceDOM.h>

A class that provides a software representation of a DOM for the purpose of a detector response simulation. Copyright (c) 2011,2012 IceCube Collaboration.

class: I3InIceDOM

Version

Rcs

Date

:

Rcs

Author

Samuel Flis samuel.d.flis@gmail.com

Public Functions

I3InIceDOM()

I3InIceDOM(I3RandomServicePtr, const OMKey &om)

I3InIceDOM(boost::shared_ptr<I3RandomService> rng, const OMKey &om, double &globlaTime, domlauncherutils::PulseTemplateMap &speTemplateMap)

bool Configure(const I3DOMCalibration&, const I3DOMStatus&)

Configures the I3InIceDOM with information from the GCD file.

void CreateLCLinks(const I3DOMMap&, const I3OMGeoMap&)

Public Static Attributes

static const double cableCorrectionInIce = 2325 * I3Units::ns

Correction time of the LC time window due to finite LC signal speed for regular InIce DOMs.

class: I3InIceDOMObject

Version

Rcs

Date

:

Rcs

Copyright (c) 2011,2012 IceCube Collaboration

Author

Samuel Flis samuel.d.flis@gmail.com

static const double cableCorrectionDeepCore = 2250 * I3Units::ns

Correction time of the LC time window due to finite LC signal speed for DeepCore DOMs.

Protected Functions

virtual void MakeCoarseChargeStamp(const dlud::DiscCross&, int chip, I3DOMLaunch&)

class InterpolatedSPETemplate

#include <InterpolatedSPETemplate.h>

This class provides an interpolation of an I3DOMCalibration::DroopedSPETemplate which gives a significant speedup when evaluating DroopedSPETemplates.

class: InterpolatedSPETemplate

Version

Rcs

Date

:

Rcs

The InterpolatedSPETemplate class acts as a wrapper of an I3DOMCalibration::DroopedSPETemplate and from the point of template evaluation has the same interface as an I3DOMCalibration::DroopedSPETemplate. The class is initialized with an I3DOMCalibration::DroopedSPETemplate.

Author

Samuel Flis samuel.d.flis@gmail.com

Linear interpolation is used to interpolate the pulse because of its simple implementation and fast speed. To capture the pulse template with sufficient precision efficiently over the range of 1 s (1e9 ns) three different interpolation step lengths are used. A dense region of linear steps covering the pulse peak itself after which a coarse (sparse) region of linear steps comes where the droop recovery is still significant. At a couple of micro seconds after the pulse peak the interpolation uses quadratic steps until the end of the interpolation range. Copyright (c) 2012 IceCube Collaboration

Public Functions

inline InterpolatedSPETemplate()

Initializes pulseTemplate with made up numbers.

inline InterpolatedSPETemplate(const I3DOMCalibration::DroopedSPETemplate &base)

A constructor that initializes the pulse template with base.

inline void SetTemplate(I3DOMCalibration::DroopedSPETemplate pulseTemplate)

Provides a method to set the SPETemplate.

Parameters:

pulseTemplate – the I3DOMCalibration::DroopedSPETemplate to be interpolated.

void Tabulate(int nDenseSteps, int nCoarseSteps, double startPoint, double changePointLinear, double changePointQuadratic, double endPoint)

Tabulates the DroopedSPETemplate which have been provided so it can be later interpolated. If this is not done a call to the ()-operator will just evaluate the pulse template directly.

Parameters:

• nDenseSteps – the number of dense linear bins in the interpolation

• nCoarseSteps – the number of coarse linear bins in the interpolation

• startPoint – the time for the last bin in the interpolation.

• changePointLinear – the time at which the bin size changes from dense to coarse

• changePointQuadratic – the time at which the bin size changes from coarse to quadratic

• endPoint – the time for the last bin in the interpolation. After this time the pulse template will be evaluated directly instead

inline double operator()(double t)

This member function returns the amplitude of the pulse at time.

Parameters:

t –

double TabulationError()

A testing function that prints out the square sum of the difference between the interpolated pulse template and the real pulse template.

Private Functions

inline double Interpolate(double t)

This is the actual interpolation function which is called by double operator()(double t)

Private Members

std::vector<float> tabulatedPulse_

Stores the tabulated pulse template.

std::vector<float> tabulatedPulseDerivative_

Stores the derivatives of the tabulated pulse template (linear approx.)

I3DOMCalibration::DroopedSPETemplate pulseTemplate_

double denseStepSize_

double invDenseStepSize_

The inverse (1/denseStepSize_) is also stored which eliminates unnecessary divisions and therefore speeds up the lookup in the interpolation.

double coarseStepSize_

double invCoarseStepSize_

The inverse (1/coarseStepSize_) is also stored which eliminates unnecessary divisions and therefore speeds up the lookup in the interpolation.

double quadraticStepScale_

double invQuadraticStepScale_

double startPoint_

double changePointLinear_

double changePointQuadratic_

double endPoint_

uint64_t nDenseSteps_

uint64_t nCoarseSteps_

uint64_t nQuadraticSteps_

bool hasTabulated_

struct MergedPulse : public I3MCPulse

Public Functions

inline MergedPulse()

Public Members

uint lastIndex

class PMT

#include <PMT.h>

Subclassed by genericLOM_PMT, HamamatsuR15458_02PMT, HamamatsuR5912_100PMT, HamamatsuR7081_02PMT

Public Functions

inline PMT(double prePulseProbability, double latePulseProbability, double afterPulseProbability, const I3RandomServicePtr &r)

inline double GetPrePulseProbability()

virtual double GetPrePulseTimeShift(double voltage) = 0

virtual double GetPrePulseWeight(double voltage) = 0

inline double GetLatePulseProbability()

virtual const unsigned int GetNumLatePulseComponents() = 0

virtual const pulseComponent *GetLatePulseComponents() = 0

inline double GetAfterPulseProbability()

virtual const unsigned int GetNumAfterPulseComponents() = 0

virtual const pulseComponent *GetAfterPulseComponents() = 0

virtual double PMTJitter() = 0

virtual bool SkipSaturation() = 0

virtual bool SkipMergeHits() = 0

virtual ~PMT() = default

virtual void SetSaturationParams(double log10Gain) = 0

inline double saturate(double I)

inline double SampleCharge(unsigned int npe) const

Public Members

double prePulseProbability_

double latePulseProbability_

double afterPulseProbability_

const I3RandomServicePtr random_

std::unique_ptr<SPEChargeDistribution> speDist_

Protected Attributes

double gain_

double A_

double B_

double Ap_

class PMTResponseSimulator : public I3ConditionalModule

#include <PMTResponseSimulator.h>

A module which simulates the behaviour of a PMT.

This module converts ‘raw’ MC PEs (representing integer numbers of photoelectrons ejected from the photocathode of the PMT) into MC Pulses whose weights are proportional to the amount of current produced by the PMT at the anode and with times randomly shifted according to appropriate probability distributions. The hits produced by this module are sorted in time order.

Author

Chris Weaver chris.weaver@icecube.wisc.edu

The weights of the processed hits are still in units of photoelectrons, and so must be multiplied by the PMT gain when convolved with digitizer pulse templates to produce electronics readouts. Similarly, the times of the hits do not include the ‘transit time’ of the DOM (which includes both the PMT transit time and delays in the mainboard) so this time must be added when computing digitizer outputs.

Note: This module is intended for use with the I3PhotonicsHitMaker and DOMLauncher modules; it is not compatible with I3HitMaker and I3DOMsimulator.

Public Functions

PMTResponseSimulator(const I3Context &context)

~PMTResponseSimulator()

void Configure()

void DAQ(I3FramePtr frame)

std::pair<std::vector<I3MCPulse>, ParticlePulseIndexMap> processHits(const std::vector<I3MCPE> &inputHits, OMKey dom, const I3DOMCalibration &cal, const I3DOMStatus &status, const ParticlePulseIndexMap &pePedigree, const I3OMGeo::OMType domType)

Applies all transformations to a set of hits on a single DOM.

Parameters:

• inputHits – The raw hits on the DOM

• dom – The DOM on which the hits occur

• cal – The current calibration information for this DOM

• status – The current status information for this DOM

• pePedigree – The particle parantage

• domType – DOM type

Returns:

A new set of time ordered hits with weighting applied, alternate pulse types generated, saturation applied, and time merging applied

void saturate(std::vector<I3MCPulse> &hits, double pmtVoltage, const I3DOMCalibration &cal)

Reweights the hits in the given series to mimic the effects of saturation in the PMT. The ‘inverse’ saturation parameterization from T. Waldenmeier is used.

Parameters:

• hits – The hit series to be reweighted

• pmtVoltage – The operating voltage of the PMT

• cal – The calibration data for the DOM

Pre:

The input hits must be time ordered

inline std::string getInputHitsName() const

inline void setInputHitsName(const std::string &in)

inline std::string getOutputHitsName() const

inline void setOutputHitsName(const std::string &out)

inline bool getUseSPEDistribution() const

inline void setUseSPEDistribution(bool use)

inline bool getUseJitter() const

inline void setUseJitter(bool use)

inline double getPrePulseProbability() const

inline void setPrePulseProbability(double prob)

inline double getLatePulseProbability() const

inline void setLatePulseProbability(double prob)

inline double getAfterPulseProbability() const

inline void setAfterPulseProbability(double prob)

inline bool getApplySaturation() const

inline void setApplySaturation(bool apply)

inline bool getMergeHits() const

inline void setMergeHits(bool merge)

inline bool getLowMem() const

inline void setLowMem(bool lowMem)

inline boost::shared_ptr<I3RandomService> getRandomService() const

inline void setRandomService(boost::shared_ptr<I3RandomService> randomService)

Public Static Functions

static void timeMergeHits(std::vector<I3MCPE> &hits)

Merges together pulses which are within some small time window, compacting the hit series if it is densely filled with hits. (Here, ‘small’ is intended to be relative to the resolution of the feature extractor.)

Parameters:

hits – The hit series to be compacted

Pre:

The input hits must be time ordered

static void timeMergeHits(std::vector<I3MCPulse> &hits, ParticlePulseIndexMap &aux)

Private Functions

double normalHitWeight(unsigned int w)

Computes the amount of charge, relative to the charge produced by an ideal, single photoelectron, produced by a hit whose weight is an integer number of initial photoelectrons.

Parameters:

w – The weight of the hit in photons

Returns:

The amount of charge produced by the PMT for this hit, in units of the ideal charge produced by a single photoelectron

double prePulseTimeShift(double voltage)

Computes the amount by which prepulses are early at a given voltage.

Parameters:

voltage – The operating voltage of the DOM

Returns:

A time offset, in nanoseconds

double prePulseWeight(double voltage)

Computes the charge of a prepulse, relative to an ideal s.p.e. at a given voltage.

Parameters:

voltage – The operating voltage of the DOM

Returns:

The amount of charge produced by the PMT for a prepulse, in units of the ideal charge produced by a single photoelectron

double earlyAfterPulseWeight()

Computes the charge of an early afterpulse, relative to an ideal s.p.e. at a given voltage.

Returns:

The amount of charge produced by the PMT for an early afterpulse, in units of the ideal charge produced by a single photoelectron

void createLatePulse(I3MCPulse &hit, double voltage)

Alters the properties of the given hit to describe a late pulse.

Parameters:

• hit – The existing raw hit to be turned into a late pulse hit

• voltage – The operating voltage of the PMT

void createAfterPulse(I3MCPulse &hit, double voltage)

Alters the properties of the given hit to describe an afterpulse.

Parameters:

• hit – The existing raw hit to be turned into an afterpulse hit

• voltage – The operating voltage of the PMT

double fisherTippett(double location, double scale, double logLowerBound, double logUpperBound)

Generate a Fisher-Tippet distributed (alias Gumbel distributed) random variate.

Parameters:

• location – The location parameter of the distribution from which to sample (mean = location + scale * euler_mascheroni)

• scale – The scale parameter of the distribution from which to sample (variance = (pi * scale)**2 / 6)

• logLowerBound – Indirectly determines the lower cutoff of the distribution

• logUpperBound – Indirectly determines the upper cutoff of the distribution

SET_LOGGER ("PMTResponseSimulator")

Private Members

std::string inputHitsName_

The name of the I3MCPESeriesMap to process.

std::string outputHitsName_

The name of the I3MCPESeriesMap to be produced.

bool useSPEDistribution_

Whether the charges of hits should be randomized.

bool usePMTJitter_

Whether the times of hits should be randomly perturbed.

double prePulseProbability_

The probability that a pulse arrives early.

double latePulseProbability_

The probability that a pulse arrives late.

double afterPulseProbability_

The probability that a pulse produces an accompanying afterpulse.

bool applySaturation_

Whether the weights of the hits should be modified to account for saturation.

bool mergeHits_

Whether hits very close in time should be merged.

bool lowMem_

Whether to merge hits repeatedly during generation to attempt to limit transient memory use.

std::string randomServiceName_

The ID of the random service to use.

bool eheApproximation_

Whether to use an approximation for high weight hits.

boost::shared_ptr<I3RandomService> randomService_

The random service fetched from the tray.

boost::shared_ptr<const I3Calibration> lastCalibration_

The most recently seen calibration data.

boost::shared_ptr<PMT> pmt

Friends

friend class PMTResponseSimulatorTestSetup

struct pulseComponent

#include <PMT.h>

Public Functions

inline double weight() const

inline double weight() const

Public Members

I3MCPulse::PulseSource source

double amp

double scale

double location

struct saturationParams

Public Functions

inline saturationParams(double log10Gain, bool newParameterization = true)

inline double saturate(double I)

Private Members

double gain

double A

double B

double Ap

class WaveformEvaluator

#include <domlauncherutils.h>

A helper class that efficiantly evaluates the waveform composed out of a sereis of MCPulses. To speed up waveform evaluation, pulses in the past (default is set to 200 ns) are merged together.

Author

Samuel Flis <samuel.d.flis@gmail.com

Public Functions

inline WaveformEvaluator(double timeBin = 25 * I3Units::ns, double padding = 200 * I3Units::ns, double cutoffTime = 500 * I3Units::microsecond)

Constructor that defines the properties of the WaveformEvaluator.

Parameters:

• timeBin – the size of the bins for the merged pulses

• padding – the time window in which pulses are directly evaluated (instead of merged)

• cutoffTime – the time window in which pulses will be evaluated. Pulses further in the past will be discarded.

inline void SetPulses(const std::vector<I3MCPulse> &pulses)

inline void Clear()

inline double WaveFormAmplitude(double time, InterpolatedSPETemplate &templ)

Private Members

double timeBin_

double padding_

const std::vector<I3MCPulse> *currentPulses_

std::vector<MergedPulse> mergedPulses_

double cutoffTime_

uint64_t lastCutoffindex_

uint64_t pulsesSize_

class workaround_discrete_distribution

#include <discreteDistribution.h>

A really dumb implementation of a discrete distribution with given probabilities which takes time linear in the number of entries, rather than constant like the boost implementation.

Public Functions

template<class Iterator>
inline workaround_discrete_distribution(Iterator first, Iterator last)

inline unsigned int operator()(random_adapter rand)

Private Types

typedef std::vector<std::pair<double, unsigned int>> tableType

Private Members

tableType table

The mapping of cumulative probabilities to result values.

namespace domlauncherutils

Provides tools and objects for DOMLauncher simulation. Copyright (c) 2012 IceCube Collaboration.

namespace: domlauncherutils

Version

Rcs

Date

:

Rcs

Author

Samuel Flis samuel.d.flis@gmail.com

Typedefs

typedef std::map<I3DOMCalibration::DroopedSPETemplate, InterpolatedSPETemplatePtr> PulseTemplateMap

typedef std::vector<detail::DiscCross> DCStream

namespace detail

Enums

enum LaunchType

Trigger types for the DiscCross object.

Values:

enumerator HLC

enumerator SLC

enumerator Discriminator

enumerator CPU_REQUESTED

enum ATWDChip

ATWD chip selector.

Values:

enumerator ATWDa

enumerator ATWDb

Functions

inline bool dcCompare(DiscCross dc1, DiscCross dc2)

A helper function to sort DiscCrosss in ascending time (time ordered)

namespace std

STL namespace.

file CombinedSimulator.cxx

#include “DOMLauncher/CombinedSimulator.h”

#include <cmath>

#include <cassert>

#include <numeric>

#include <limits>

#include <algorithm>

#include <stack>

#include <boost/make_shared.hpp>

#include <boost/math/constants/constants.hpp>

#include <icetray/I3Units.h>

#include <simclasses/I3MCPE.h>

#include <simclasses/I3MCPulse.h>

#include <sim-services/MCPEMCPulseTools.hpp>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/calibration/I3Calibration.h>

#include “discreteDistribution.h”

#include <iostream>

#include <fstream>

#include <boost/foreach.hpp>

#include <simclasses/I3ParticleIDMap.hpp>

#include “DOMLauncher/DOMLauncher.h”

#include “DOMLauncher/I3DOM.h”

#include “DOMLauncher/I3InIceDOM.h”

#include “DOMLauncher/I3IceTopDOM.h”

Defines

used_var(var)

Functions

I3_MODULE(CombinedSimulator)

file CombinedSimulator.h

#include “icetray/I3ConditionalModule.h”

#include “icetray/OMKey.h”

#include “sim-services/I3SumGenerator.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “dataclasses/physics/I3DOMLaunch.h”

#include “phys-services/I3GSLRandomService.h”

#include “simclasses/I3MCPulse.h”

#include <simclasses/I3MCPE.h>

#include <dataclasses/physics/I3ParticleID.h>

#include <simclasses/I3ParticleIDMap.hpp>

#include “domlauncherutils.h”

file discreteDistribution.h

#include <boost/version.hpp>

Defines

USE_BOOST_DISCRETE_RANDOM

Helper code for generating discrete distributions with non-uniform probabilities, using an I3RandomService as the underlying random engine. With a new version of Boost,boost::random::discrete_distribution does all the work quite nicely. However, as long as icetray uses an old version where this isn’t available a simplistic work-around is used.

Typedefs

typedef I3RandomService *random_adapter

typedef workaround_discrete_distribution discrete_distribution

Functions

template<typename PairType>
bool compareFirst(PairType p1, PairType p2)

file DOM.h

file DOMLauncher.cxx

#include <iostream>

#include <fstream>

#include <cmath>

#include <boost/foreach.hpp>

#include <simclasses/I3ParticleIDMap.hpp>

#include “DOMLauncher/DOMLauncher.h”

#include “DOMLauncher/I3DOM.h”

#include “DOMLauncher/I3InIceDOM.h”

#include “DOMLauncher/I3IceTopDOM.h”

Functions

I3_MODULE(DOMLauncher)

file DOMLauncher.h

#include “icetray/I3ConditionalModule.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “dataclasses/physics/I3DOMLaunch.h”

#include “phys-services/I3GSLRandomService.h”

#include “simclasses/I3MCPulse.h”

#include “domlauncherutils.h”

file domlauncherutils.h

#include “InterpolatedSPETemplate.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “simclasses/I3MCPulse.h”

#include “icetray/OMKey.h”

#include <boost/shared_ptr.hpp>

#include <map>

#include <algorithm>

#include <list>

#include <queue>

#include <iostream>

file I3DOM.cxx

#include <cfloat>

#include <queue>

#include <boost/foreach.hpp>

#include “phys-services/I3RandomService.h”

#include “dataclasses/I3DOMFunctions.h”

#include “dataclasses/physics/I3DOMLaunch.h”

#include “dataclasses/calibration/I3DOMCalibration.h”

#include “dataclasses/status/I3DOMStatus.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “DOMLauncher/I3DOM.h”

file I3DOM.h

#include “dataclasses/physics/I3DOMLaunch.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “dataclasses/geometry/I3OMGeo.h”

#include “dataclasses/calibration/I3DOMCalibration.h”

#include “phys-services/I3RandomService.h”

#include “simclasses/I3MCPulse.h”

#include <vector>

#include <boost/weak_ptr.hpp>

#include “domlauncherutils.h”

#include “DOM.h”

#include “InterpolatedSPETemplate.h”

Typedefs

typedef boost::shared_ptr<I3DOM> I3DOMPtr

typedef std::vector<I3DOMPtr> I3DOMVector

typedef std::map<OMKey, I3DOMPtr> I3DOMMap

file I3IceTopDOM.cxx

#include <cfloat>

#include <queue>

#include <boost/foreach.hpp>

#include “phys-services/I3RandomService.h”

#include “dataclasses/I3DOMFunctions.h”

#include “dataclasses/physics/I3DOMLaunch.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “I3IceTopDOM.h”

file I3IceTopDOM.h

#include “DOMLauncher/I3DOM.h”

Typedefs

typedef boost::shared_ptr<I3IceTopDOM> I3IceTopDOMPtr

file I3InIceDOM.cxx

#include <cfloat>

#include <queue>

#include <boost/foreach.hpp>

#include “phys-services/I3RandomService.h”

#include “dataclasses/I3DOMFunctions.h”

#include “dataclasses/physics/I3DOMLaunch.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “I3InIceDOM.h”

file I3InIceDOM.h

#include “DOMLauncher/I3DOM.h”

Typedefs

typedef boost::shared_ptr<I3InIceDOM> I3InIceDOMPtr

file InterpolatedSPETemplate.cxx

#include “DOMLauncher/InterpolatedSPETemplate.h”

file InterpolatedSPETemplate.h

#include “dataclasses/calibration/I3Calibration.h”

#include “icetray/I3Units.h”

#include <iostream>

#include <vector>

#include <cfloat>

Typedefs

typedef boost::shared_ptr<InterpolatedSPETemplate> InterpolatedSPETemplatePtr

file PMT.h

#include <dataclasses/I3Constants.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/calibration/I3DOMCalibration.h>

#include <simclasses/I3MCPulse.h>

#include “phys-services/I3RandomService.h”

#include <chrono>

file PMTResponseSimulator.cxx

#include “DOMLauncher/PMTResponseSimulator.h”

#include <cmath>

#include <cassert>

#include <numeric>

#include <limits>

#include <algorithm>

#include <stack>

#include <boost/make_shared.hpp>

#include <boost/math/constants/constants.hpp>

#include <icetray/I3Units.h>

#include <simclasses/I3MCPE.h>

#include <simclasses/I3MCPulse.h>

#include <sim-services/MCPEMCPulseTools.hpp>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <dataclasses/calibration/I3Calibration.h>

#include “discreteDistribution.h”

#include “PMT.h”

Functions

bool earlierHit(const I3MCPE &h1, const I3MCPE &h2)

file PMTResponseSimulator.h

#include “icetray/I3ConditionalModule.h”

#include “icetray/OMKey.h”

#include “phys-services/I3RandomService.h”

#include <simclasses/I3MCPE.h>

#include <simclasses/I3MCPulse.h>

#include <dataclasses/physics/I3ParticleID.h>

#include <simclasses/I3ParticleIDMap.hpp>

#include “dataclasses/geometry/I3OMGeo.h”

#include “DOMLauncher/PMT.h”

dir DOMLauncher

dir DOMLauncher

dir DOMLauncher

dir icetray

dir private

dir public