frame_object_diff C++ API Reference

template<typename T, typename Orig = T, typename VectorType = std::vector<Orig>>
class FixedPositionVectorDiff

#include <I3FixedPositionVectorDiff.h>

Store the difference between two vectors where each object has a fixed position in the vector. This allows us to directly Diff two objects at the same position, like in a map with integer keys.

Public Functions

inline FixedPositionVectorDiff()

inline FixedPositionVectorDiff(const VectorType &base, const VectorType &cur)

Create a Diff against a base, for the cur object.

inline FixedPositionVectorDiff(VectorConstPtr base, VectorConstPtr cur)

inline virtual ~FixedPositionVectorDiff()

inline std::size_t size() const

Return the size of the Diff

inline VectorPtr Unpack(const VectorType &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originally provided to the constructor as input.

inline VectorPtr Unpack(VectorConstPtr base) const

Protected Functions

template<class Archive>
inline void serialize(Archive &ar, unsigned version)

Private Types

typedef boost::shared_ptr<VectorType> VectorPtr

typedef boost::shared_ptr<const VectorType> VectorConstPtr

Private Functions

inline void Pack_(const VectorType &base, const VectorType &cur)

Pack up the data. This is a shared function for the constructors.

Private Members

std::vector<T> diff_

Store the actual diff content

mutable VectorPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

template<typename T, typename Orig>
struct has_diff

#include <pack_helper.hpp>

Check if a class is a *Diff class

Public Types

typedef char yes[1]

typedef char no[2]

typedef boost::shared_ptr<Orig> OrigPtr

Public Static Functions

template<typename _1>
static yes &chk(type_check<OrigPtr (T::*)(const Orig&) const, &_1::Unpack>*)

template<typename>
static no &chk(...)

Public Static Attributes

static bool const value = (sizeof(chk<T>(0)) == sizeof(yes))

template<typename T, typename Orig>
struct has_diff_and_frameobj

#include <pack_helper.hpp>

Check if a class is a *Diff class and an I3FrameObject

Public Types

typedef char yes[1]

typedef char no[2]

typedef boost::shared_ptr<Orig> OrigPtr

Public Static Functions

template<typename _1>
static yes &chk(type_check<OrigPtr (T::*)(const Orig&) const, &_1::Unpack>*)

template<typename>
static no &chk(...)

Public Static Attributes

static bool const value = (sizeof(chk<T>(0)) == sizeof(yes) &&boost::is_base_of<I3FrameObject,T>::value)

template<typename T, typename Orig>
struct has_diff_no_frameobj

#include <pack_helper.hpp>

Check if a class is a *Diff class and not an I3FrameObject

Public Types

typedef char yes[1]

typedef char no[2]

typedef boost::shared_ptr<Orig> OrigPtr

Public Static Functions

template<typename _1>
static yes &chk(type_check<OrigPtr (T::*)(const Orig&) const, &_1::Unpack>*)

template<typename>
static no &chk(...)

Public Static Attributes

static bool const value = (sizeof(chk<T>(0)) == sizeof(yes) &&! boost::is_base_of<I3FrameObject,T>::value)

class I3CalibrationDiff : public I3FrameObject

#include <I3CalibrationDiff.h>

Public Functions

inline I3CalibrationDiff()

I3CalibrationDiff(const std::string filename, const I3Calibration &base, const I3Calibration &cal)

Create a Diff against a base, for the cur (cal) object.

I3CalibrationDiff(const std::string filename, I3CalibrationConstPtr base, I3CalibrationConstPtr cal)

I3CalibrationPtr Unpack(const I3Calibration &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originially provided to the constructor as input.

I3CalibrationPtr Unpack(I3CalibrationConstPtr base) const

Public Members

std::string base_filename

filename for base object

I3Time startTime

start time

I3Time endTime

end time

I3DOMCalibrationMapDiff domCal

DOMCal.

I3VEMCalibrationMapDiff vemCal

VEMCal.

Private Functions

template<class Archive>
void serialize(Archive &ar, unsigned version)

Private Members

mutable I3CalibrationPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

class I3DetectorStatusDiff : public I3FrameObject

#include <I3DetectorStatusDiff.h>

Store the difference between two I3DetectorStatus objects.

Public Functions

inline I3DetectorStatusDiff()

I3DetectorStatusDiff(const std::string filename, const I3DetectorStatus &base, const I3DetectorStatus &det)

Create a Diff against a base, for the cur (det) object.

I3DetectorStatusDiff(const std::string filename, I3DetectorStatusConstPtr base, I3DetectorStatusConstPtr det)

inline virtual ~I3DetectorStatusDiff()

I3DetectorStatusPtr Unpack(const I3DetectorStatus &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originally provided to the constructor as input.

I3DetectorStatusPtr Unpack(I3DetectorStatusConstPtr base) const

Public Members

std::string base_filename

filename of base object

I3Time startTime

start time

I3Time endTime

end time

I3DOMStatusMapDiff domStatus

dom status

I3TriggerStatusMapDiff triggerStatus

trigger status

std::string daqConfigurationName

daq configuration name

Private Functions

template<class Archive>
void serialize(Archive &ar, unsigned version)

Private Members

mutable I3DetectorStatusPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

class I3DOMCalibrationDiff

#include <I3DOMCalibrationDiff.h>

Store the difference between two I3DOMCalibration objects.

Public Functions

inline I3DOMCalibrationDiff()

I3DOMCalibrationDiff(const I3DOMCalibration &base, const I3DOMCalibration &cal)

Create a Diff against a bse, for the cur (cal) object.

I3DOMCalibrationDiff(I3DOMCalibrationConstPtr base, I3DOMCalibrationConstPtr cal)

I3DOMCalibrationPtr Unpack(const I3DOMCalibration &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originially provided to the constructor as input.

I3DOMCalibrationPtr Unpack(I3DOMCalibrationConstPtr base) const

bool operator==(const I3DOMCalibrationDiff &other) const

Public Members

std::bitset<29> bits

The bitset, listing which objects are different from the base. This also gets used during serialization, to tell what to save/load.

Private Functions

void Init_(const I3DOMCalibration &base, const I3DOMCalibration &cal)

Shared initialization between both constructors.

template<class Archive>
void serialize(Archive &ar, unsigned version)

Private Members

double droopTimeConstants_[2]

double temperature_

double fadcGain_

LinearFit fadcBaselineFit_

double fadcBeaconBaseline_

double fadcDeltaT_

double frontEndImpedance_

TauParam tauparameters_

double ampGains_[3]

QuadraticFit atwdFreq_[2]

double atwdBins_[2][I3DOMCalibration::N_ATWD_CHANNELS][I3DOMCalibration::N_ATWD_BINS]

LinearFit pmtTransitTime_

LinearFit hvGainRelation_

std::string domcalVersion_

double atwdBeaconBaselines_[2][I3DOMCalibration::N_ATWD_CHANNELS]

double atwdDeltaT_[2]

LinearFit speDiscrimCalib_

LinearFit mpeDiscrimCalib_

LinearFit pmtDiscrimCalib_

double relativeDomEff_

double noiseRate_

double noiseThermalRate_

double noiseDecayRate_

double noiseScintillationMean_

double noiseScintillationSigma_

double noiseScintillationHits_

SPEChargeDistribution combinedSPEFit_

double meanATWDCharge_

double meanFADCCharge_

mutable I3DOMCalibrationPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

friend std::ostream &operator<<(std::ostream &oss, const I3DOMCalibrationDiff &m)

template<typename T, typename Orig = T>
class I3FixedPositionVectorDiff : public I3FrameObject, public FixedPositionVectorDiff<T, Orig, I3Vector<Orig>>

#include <I3FixedPositionVectorDiff.h>

Store the difference between two fixed position I3Vectors.

This inherits from FixedPositionVectorDiff.

Public Functions

inline I3FixedPositionVectorDiff()

inline I3FixedPositionVectorDiff(const std::string filename, const I3Vector<Orig> &base, const I3Vector<Orig> &cur)

Create a Diff against a base, for the cur object. Store the filename that the base came from.

inline I3FixedPositionVectorDiff(const std::string filename, I3VectorConstPtr base, I3VectorConstPtr cur)

inline I3VectorPtr Unpack(const I3Vector<Orig> &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originally provided to the constructor as input.

Note that this is required for SFINAE detection of Diff objects, and cannot just be inherited.

inline I3VectorPtr Unpack(I3VectorConstPtr base) const

inline std::string GetFilename() const

Get the filename for the base.

Private Types

typedef boost::shared_ptr<I3Vector<Orig>> I3VectorPtr

typedef boost::shared_ptr<const I3Vector<Orig>> I3VectorConstPtr

Private Functions

template<class Archive>
inline void serialize(Archive &ar, unsigned version)

Private Members

std::string base_filename_

Filename where the base object came from.

Friends

friend class icecube::serialization::access

class I3GeometryDiff : public I3FrameObject

#include <I3GeometryDiff.h>

Store the difference between two I3Geometry objects.

Public Functions

inline I3GeometryDiff()

I3GeometryDiff(const std::string filename, const I3Geometry &base, const I3Geometry &geo)

Create a Diff against a base, for the cur (geo) object.

I3GeometryDiff(const std::string filename, I3GeometryConstPtr base, I3GeometryConstPtr geo)

I3GeometryPtr Unpack(const I3Geometry &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originally provided to the construtor as inpu.

I3GeometryPtr Unpack(I3GeometryConstPtr base) const

Public Members

std::string base_filename

filename of base object

I3OMGeoMapDiff omgeo

diff of I3OMGeoMap

I3StationMapDiff stationgeo

diff of I3StationMap

I3Time startTime

start time

I3Time endTime

end time

Private Functions

void InitStation_(const I3StationGeoMap &base, const I3StationGeoMap &cur)

Initialize the I3StationMap separately, because of the conversion from I3StationGeo to I3Station.

template<class Archive>
void serialize(Archive &ar, unsigned version)

Private Members

mutable I3GeometryPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

template<typename K, typename V, typename Orig = V>
class I3MapDiff : public I3FrameObject, public MapDiff<K, V, Orig, I3Map<K, Orig>>

#include <I3MapDiff.h>

Store the difference between two I3Maps

Public Functions

inline I3MapDiff()

inline I3MapDiff(const std::string filename, const I3Map<K, Orig> &base, const I3Map<K, Orig> &cur)

Create a diff against a base, for the cur object. Store the filename that the base came from.

inline I3MapDiff(const std::string filename, I3MapConstPtr base, I3MapConstPtr cur)

inline I3MapPtr Unpack(const I3Map<K, Orig> &base) const

Unpack the Diff, returning a shared pointer to the original opbject.

Takes the base that was originially provided to the constructor as input.

Note that this is required for SFINAE detection of Diff objects, and cannot just be inherited.

inline I3MapPtr Unpack(I3MapConstPtr base) const

inline std::string GetFilename() const

Get the filename for the base.

Private Types

typedef boost::shared_ptr<I3Map<K, Orig>> I3MapPtr

typedef boost::shared_ptr<const I3Map<K, Orig>> I3MapConstPtr

Private Functions

template<class Archive>
inline void serialize(Archive &ar, unsigned version)

Private Members

std::string base_filename_

Filename where the base object came from.

Friends

friend class icecube::serialization::access

class I3Station

#include <I3Station.h>

Each station has a number of tanks. Shared properties are listed as part of the station. Modified properties are listed for each tank.

Public Types

typedef I3TankGeo::TankType TankType

Public Functions

inline I3Station()

I3Station(const I3StationGeo &rhs)

Convert from I3StationGeo to I3Station.

virtual ~I3Station()

I3StationGeo GetStationGeo()

Convert back to I3StationGeo.

inline bool operator==(const I3Station &rhs) const

inline bool operator!=(const I3Station &rhs) const

Public Members

double orientation

relative angular rotation of tanks

double tankradius

tank radius (I3Units!)

double tankheight

tank height (I3Units!)

double fillheight

water/ice level height (I3Units!)

TankType tanktype

Type of tanks.

std::vector<station::Tank> tanks

Private Functions

template<class Archive>
void load(Archive &ar, unsigned version)

template<class Archive>
void save(Archive &ar, unsigned version) const

I3_SERIALIZATION_SPLIT_MEMBER()

Friends

friend class icecube::serialization::access

class I3StationDiff

#include <I3StationDiff.h>

Public Functions

inline I3StationDiff()

I3StationDiff(const I3Station &base, const I3Station &cur)

I3StationDiff(I3StationConstPtr base, I3StationConstPtr cur)

I3StationPtr Unpack(const I3Station &base) const

I3StationPtr Unpack(I3StationConstPtr base) const

Public Members

std::bitset<6> bits

Private Functions

void Init_(const I3Station &base, const I3Station &cur)

template<class Archive>
void serialize(Archive &ar, unsigned version)

Private Members

double orientation_

double tankradius_

double tankheight_

double fillheight_

I3Station::TankType tanktype_

VectorDiff<station::Tank> tanks_

mutable I3StationPtr unpacked_

Friends

friend class icecube::serialization::access

class I3TankGeoDiff

#include <I3TankGeoDiff.h>

This code is not currently used, and superceded by I3Station.h

TODO: Consider outright removal of this file. Diff of I3TankGeo

Public Functions

inline I3TankGeoDiff()

I3TankGeoDiff(const I3TankGeo &base, const I3TankGeo &cur)

I3TankGeoDiff(I3TankGeoConstPtr base, I3TankGeoConstPtr cur)

I3TankGeoPtr Unpack(const I3TankGeo &base) const

I3TankGeoPtr Unpack(I3TankGeoConstPtr base) const

Public Members

std::bitset<8> bits

Private Types

enum [anonymous]

Values:

enumerator PositionBit

enumerator OrientationBit

enumerator RadiusBit

enumerator HeightBit

enumerator FillBit

enumerator KeyListBit

enumerator SnowHeightBit

enumerator TankTypeBit

Private Functions

void Init_(const I3TankGeo &base, const I3TankGeo &cur)

template<class Archive>
void serialize(Archive &ar, unsigned version)

Private Members

I3Position position_

double orientation_

double tankradius_

double tankheight_

double fillheight_

I3VectorDiff<OMKey> omKeyList_

double snowheight_

I3TankGeo::TankType tanktype_

mutable I3TankGeoPtr unpacked_

Friends

friend class icecube::serialization::access

template<typename T>
class I3VectorDiff : public I3FrameObject, public VectorDiff<T, I3Vector<T>>

#include <I3VectorDiff.h>

Store the difference between two I3Vectors.

This inherits from VectorDiff.

Public Functions

inline I3VectorDiff()

inline I3VectorDiff(const std::string filename, const I3Vector<T> &base, const I3Vector<T> &cur)

Create a Diff against a base, for the cur object. Store the filename that the base came from.

inline I3VectorDiff(const std::string filename, I3VectorConstPtr base, I3VectorConstPtr cur)

inline I3VectorPtr Unpack(const I3Vector<T> &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originally provided to the constructor as input.

Note that this is required for SFINAE detection of Diff objects, and cannot just be inherited.

inline I3VectorPtr Unpack(I3VectorConstPtr base) const

inline std::string GetFilename() const

Get the filename for the base.

Private Types

typedef boost::shared_ptr<I3Vector<T>> I3VectorPtr

typedef boost::shared_ptr<const I3Vector<T>> I3VectorConstPtr

Private Functions

template<class Archive>
inline void serialize(Archive &ar, unsigned version)

Private Members

std::string base_filename_

Filename where the base object came from.

Friends

friend class icecube::serialization::access

template<typename K, typename V, typename Orig = V, typename MapType = std::map<K, Orig>>
class MapDiff

#include <I3MapDiff.h>

Store the difference between two maps

Public Types

typedef std::map<K, V>::iterator plus_iterator

typedef std::map<K, V>::value_type plus_value

Public Functions

inline MapDiff()

inline MapDiff(const MapType &base, const MapType &cur)

Create a Diff against a base, for the cur object.

inline MapDiff(MapConstPtr base, MapConstPtr cur)

inline virtual ~MapDiff()

inline std::size_t size() const

Return the sum of the additions and subtractions as the size.

inline MapPtr Unpack(const MapType &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originially provided to the constructor as input.

inline MapPtr Unpack(MapConstPtr base) const

inline plus_iterator begin_plus()

Return an iterator over the addition map.

inline plus_iterator end_plus()

Get the end of the addition map.

Protected Functions

template<class Archive>
inline void serialize(Archive &ar, unsigned version)

Private Types

typedef boost::shared_ptr<Orig> OrigPtr

typedef boost::shared_ptr<MapType> MapPtr

typedef boost::shared_ptr<const MapType> MapConstPtr

typedef MapType::value_type orig_value_type

typedef std::map<K, V>::value_type new_value_type

typedef MapType::iterator map_iterator

typedef MapType::const_iterator map_const_iterator

Private Functions

inline void Pack_(const MapType &base, const MapType &cur)

Pack up the data. This is a shared function for the constructors.

Private Members

std::map<K, V> plus_

A map of all additions to the base.

std::vector<K> minus_

A vector of all keys to be removed from the base.

mutable MapPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

class Tank

#include <I3Station.h>

Store the variables that change tank-to-tank.

Public Functions

inline bool operator==(const Tank &rhs) const

inline bool operator!=(const Tank &rhs) const

Public Members

I3Position position

tank x,y,z position

double snowheight

snow “overburden” (use I3Units)

std::vector<OMKey> oms

doms in tank

Private Functions

template<class Archive>
void serialize(Archive &ar, unsigned version)

Friends

friend class icecube::serialization::access

template<typename U, U>
struct type_check

#include <pack_helper.hpp>

template<typename U, U>
struct type_check

#include <pack_helper.hpp>

template<typename U, U>
struct type_check

#include <pack_helper.hpp>

template<typename T, typename VectorType = std::vector<T>>
class VectorDiff

#include <I3VectorDiff.h>

Store the difference between two vectors.

Clever users will note that VectorDiff<std::string> can be used to diff two files.

Public Functions

inline VectorDiff()

inline VectorDiff(const VectorType &base, const VectorType &cur)

Create a Diff against a base, for the cur object.

inline VectorDiff(VectorConstPtr base, VectorConstPtr cur)

inline virtual ~VectorDiff()

inline std::size_t size() const

Return the size of the Diff

inline VectorPtr Unpack(const VectorType &base) const

Unpack the Diff, returning a shared pointer to the original object.

Takes the base that was originally provided to the constructor as input.

inline VectorPtr Unpack(VectorConstPtr base) const

Protected Functions

template<class Archive>
inline void serialize(Archive &ar, unsigned version)

Private Types

typedef boost::shared_ptr<VectorType> VectorPtr

typedef boost::shared_ptr<const VectorType> VectorConstPtr

Private Functions

inline void Pack_(const VectorType &base, const VectorType &cur)

Pack up the data. This is a shared function for the constructors.

Private Members

bool raw_

Indicate whether this is a diff (false), or a complete copy of the current object (true). This is done in case the diff is inefficient.

boost::dynamic_bitset mask_

Store whether the diff is +/- at each index.

std::vector<std::size_t> pos_

Store the insertion/removal point relative to the base.

std::vector<T> diff_

Store the actual diff content

mutable VectorPtr unpacked_

A shared pointer to the unpacked data, so we don’t have to regenerate this for subsequent calls.

Friends

friend class icecube::serialization::access

namespace lcs

Typedefs

typedef std::vector<int> lengths

typedef std::vector<bool> members

Functions

template<typename it, typename ot>
void set_lcs(it x, members const &xs_in_lcs, ot lcs)

template<typename it>
void lcs_lens(it xlo, it xhi, it ylo, it yhi, lengths &lens)

template<typename it>
void calculate_lcs(it xo, it xlo, it xhi, it ylo, it yhi, members &xs_in_lcs)

template<typename seq>
void lcs(seq const &xs, seq const &ys, seq &an_lcs)

namespace pack_helper

Helper functions for packing and unpacking compressed objects.

Functions

template<typename T, typename B>
boost::enable_if_c<has_diff<T, B>::value, const B>::type Unpack(const T &data, const B &base)

Unpack the data from compressed format, if necessary.

template<typename T, typename B>
boost::disable_if_c<has_diff<T, B>::value, const B>::type Unpack(const T &data, const B &base)

template<typename T, typename B>
boost::enable_if_c<has_diff_and_frameobj<T, B>::value, T>::type Pack(const B &data, const B &base, const T &dummy)

Pack the data into compressed format, if necessary.

template<typename T, typename B>
boost::enable_if_c<has_diff_no_frameobj<T, B>::value, T>::type Pack(const B &data, const B &base, const T &dummy)

template<typename T, typename B>
boost::disable_if_c<has_diff<T, B>::value, T>::type Pack(const B &data, const B &base, const T &dummy)

namespace station

Variables

static const unsigned tank_version_ = 0

namespace std

STL namespace.

file I3CalibrationDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/calibration/I3CalibrationDiff.h>

Functions

I3_SERIALIZABLE(I3CalibrationDiff)

file I3CalibrationDiff.h

#include “icetray/I3FrameObject.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “frame_object_diff/calibration/I3DOMCalibrationDiff.h”

#include “frame_object_diff/calibration/I3VEMCalibrationDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3CalibrationDiff.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Functions

I3_DEFAULT_NAME(I3CalibrationDiff)

I3_POINTER_TYPEDEFS(I3CalibrationDiff)

I3_CLASS_VERSION(I3CalibrationDiff, i3calibrationdiff_version_)

Variables

static const unsigned i3calibrationdiff_version_ = 0

file I3DetectorStatusDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/status/I3DetectorStatusDiff.h>

Functions

I3_SERIALIZABLE(I3DetectorStatusDiff)

file I3DetectorStatusDiff.h

#include “icetray/I3FrameObject.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “frame_object_diff/status/I3DOMStatusDiff.h”

#include “frame_object_diff/status/I3TriggerStatusDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3DetectorStatus.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Functions

I3_DEFAULT_NAME(I3DetectorStatusDiff)

I3_POINTER_TYPEDEFS(I3DetectorStatusDiff)

I3_CLASS_VERSION(I3DetectorStatusDiff, i3detectorstatusdiff_version_)

Variables

static const unsigned i3detectorstatusdiff_version_ = 0

file I3DOMCalibrationDiff.cxx

#include <serialization/bitset.hpp>

#include <icetray/serialization.h>

#include <frame_object_diff/calibration/I3DOMCalibrationDiff.h>

Functions

std::ostream &operator<<(std::ostream &oss, const I3DOMCalibrationDiff &m)

I3_SERIALIZABLE(I3DOMCalibrationDiff)

I3_SERIALIZABLE(I3DOMCalibrationMapDiff)

file I3DOMCalibrationDiff.h

#include <bitset>

#include “dataclasses/calibration/I3Calibration.h”

#include “frame_object_diff/I3MapDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef MapDiff<OMKey, I3DOMCalibrationDiff, I3DOMCalibration> I3DOMCalibrationMapDiff

Functions

std::ostream &operator<<(std::ostream &oss, const I3DOMCalibrationDiff &m)

I3_POINTER_TYPEDEFS(I3DOMCalibrationDiff)

I3_CLASS_VERSION(I3DOMCalibrationDiff, i3domcalibrationdiff_version_)

I3_POINTER_TYPEDEFS(I3DOMCalibrationMapDiff)

I3_CLASS_VERSION(I3DOMCalibrationMapDiff, mapdiff_version_)

Variables

static const unsigned i3domcalibrationdiff_version_ = 0

file I3DOMStatusDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/status/I3DOMStatusDiff.h>

Functions

I3_SERIALIZABLE(I3DOMStatusMapDiff)

file I3DOMStatusDiff.h

#include “dataclasses/status/I3DetectorStatus.h”

#include “frame_object_diff/I3MapDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef MapDiff<OMKey, I3DOMStatus> I3DOMStatusMapDiff

Functions

I3_POINTER_TYPEDEFS(I3DOMStatusMapDiff)

I3_CLASS_VERSION(I3DOMStatusMapDiff, mapdiff_version_)

file I3FixedPositionVectorDiff.h

#include <cstddef>

#include <utility>

#include “icetray/I3FrameObject.h”

#include “dataclasses/I3Vector.h”

#include “frame_object_diff/pack_helper.hpp”

#include <boost/foreach.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/integral_constant.hpp>

#include <boost/type_traits/is_base_of.hpp>

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Variables

static const unsigned fixedpositionvectordiff_version_ = 0

file I3GeometryDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/geometry/I3GeometryDiff.h>

#include <boost/foreach.hpp>

Functions

I3_SERIALIZABLE(I3GeometryDiff)

file I3GeometryDiff.h

#include “icetray/I3FrameObject.h”

#include “dataclasses/geometry/I3Geometry.h”

#include “frame_object_diff/geometry/I3StationDiff.h”

#include “frame_object_diff/geometry/I3OMGeoDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Functions

I3_DEFAULT_NAME(I3GeometryDiff)

I3_POINTER_TYPEDEFS(I3GeometryDiff)

I3_CLASS_VERSION(I3GeometryDiff, i3geometrydiff_version_)

Variables

static const unsigned i3geometrydiff_version_ = 0

file I3MapDiff.h

#include <cstddef>

#include “icetray/I3FrameObject.h”

#include “dataclasses/I3String.h”

#include “dataclasses/I3Map.h”

#include “dataclasses/I3Vector.h”

#include “frame_object_diff/pack_helper.hpp”

#include <boost/foreach.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/is_base_of.hpp>

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Variables

static const unsigned mapdiff_version_ = 0

file I3OMGeoDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/geometry/I3OMGeoDiff.h>

Functions

I3_SERIALIZABLE(I3OMGeoMapDiff)

file I3OMGeoDiff.h

#include “dataclasses/geometry/I3OMGeo.h”

#include “frame_object_diff/I3MapDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef I3MapDiff<OMKey, I3OMGeo> I3OMGeoMapDiff

Functions

I3_POINTER_TYPEDEFS(I3OMGeoMapDiff)

I3_CLASS_VERSION(I3OMGeoMapDiff, mapdiff_version_)

file I3Station.cxx

#include <cstddef>

#include <icetray/serialization.h>

#include <frame_object_diff/geometry/I3Station.h>

#include <boost/foreach.hpp>

Functions

I3_SERIALIZABLE(station::Tank)

I3_SPLIT_SERIALIZABLE(I3Station)

file I3Station.h

#include <iostream>

#include <vector>

#include <map>

#include “dataclasses/I3Position.h”

#include “dataclasses/Utility.h”

#include “icetray/OMKey.h”

#include “dataclasses/geometry/I3TankGeo.h”

copyright (C) 2004 the icecube collaboration

Version

Rcs

I3Station.h 128631 2015-02-04 10:34:22Z jvansanten

Date

Rcs

2015-02-04 04:34:22 -0600 (Wed, 04 Feb 2015)

Typedefs

typedef std::map<int, I3Station> I3StationMap

Functions

I3_CLASS_VERSION(station::Tank, station::tank_version_)

I3_CLASS_VERSION(I3Station, i3station_version_)

I3_POINTER_TYPEDEFS(I3Station)

I3_POINTER_TYPEDEFS(I3StationMap)

Variables

static const unsigned i3station_version_ = 0

file I3StationDiff.cxx

#include <serialization/bitset.hpp>

#include <icetray/serialization.h>

#include <dataclasses/external/CompareFloatingPoint.h>

#include <frame_object_diff/geometry/I3StationDiff.h>

Functions

I3_SERIALIZABLE(I3StationDiff)

I3_SERIALIZABLE(I3StationMapDiff)

file I3StationDiff.h

#include “frame_object_diff/geometry/I3Station.h”

#include “frame_object_diff/I3MapDiff.h”

#include “frame_object_diff/I3VectorDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef MapDiff<int, I3StationDiff, I3Station> I3StationMapDiff

Functions

I3_POINTER_TYPEDEFS(I3StationDiff)

I3_CLASS_VERSION(I3StationDiff, i3stationdiff_version_)

I3_POINTER_TYPEDEFS(I3StationMapDiff)

I3_CLASS_VERSION(I3StationMapDiff, mapdiff_version_)

Variables

static const unsigned i3stationdiff_version_ = 0

file I3TankGeoDiff.cxx

#include <serialization/bitset.hpp>

#include <icetray/serialization.h>

#include <dataclasses/external/CompareFloatingPoint.h>

#include <frame_object_diff/geometry/I3TankGeoDiff.h>

Functions

I3_SERIALIZABLE(I3TankGeoDiff)

I3_SERIALIZABLE(I3StationGeoDiff)

I3_SERIALIZABLE(I3StationGeoMapDiff)

file I3TankGeoDiff.h

#include “dataclasses/geometry/I3TankGeo.h”

#include “frame_object_diff/I3MapDiff.h”

#include “frame_object_diff/I3VectorDiff.h”

#include “frame_object_diff/I3FixedPositionVectorDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef I3FixedPositionVectorDiff<I3TankGeoDiff, I3TankGeo> I3StationGeoDiff

typedef I3MapDiff<int, I3StationGeoDiff, I3StationGeo> I3StationGeoMapDiff

Functions

I3_POINTER_TYPEDEFS(I3TankGeoDiff)

I3_CLASS_VERSION(I3TankGeoDiff, i3tankgeodiff_version_)

I3_POINTER_TYPEDEFS(I3StationGeoDiff)

I3_CLASS_VERSION(I3StationGeoDiff, vectordiff_version_)

I3_POINTER_TYPEDEFS(I3StationGeoMapDiff)

I3_CLASS_VERSION(I3StationGeoMapDiff, mapdiff_version_)

Variables

static const unsigned i3tankgeodiff_version_ = 0

file I3TriggerStatusDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/status/I3TriggerStatusDiff.h>

Functions

I3_SERIALIZABLE(I3TriggerStatusMapDiff)

file I3TriggerStatusDiff.h

#include “dataclasses/status/I3DetectorStatus.h”

#include “frame_object_diff/I3MapDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef MapDiff<TriggerKey, I3TriggerStatus> I3TriggerStatusMapDiff

Functions

I3_POINTER_TYPEDEFS(I3TriggerStatusMapDiff)

I3_CLASS_VERSION(I3TriggerStatusMapDiff, mapdiff_version_)

file I3VectorDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/I3VectorDiff.h>

Functions

I3_SERIALIZABLE(I3VectorOMKeyDiff)

I3_SERIALIZABLE(I3VectorTankKeyDiff)

I3_SERIALIZABLE(I3VectorIntDiff)

file I3VectorDiff.h

#include <cstddef>

#include <utility>

#include “icetray/I3FrameObject.h”

#include “dataclasses/I3Vector.h”

#include <serialization/dynamic_bitset.hpp>

#include “frame_object_diff/pack_helper.hpp”

#include “frame_object_diff/external/lcs.hpp”

#include <boost/foreach.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/integral_constant.hpp>

#include <boost/type_traits/is_base_of.hpp>

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef I3VectorDiff<OMKey> I3VectorOMKeyDiff

typedef I3VectorDiff<TankKey> I3VectorTankKeyDiff

typedef I3VectorDiff<int> I3VectorIntDiff

Functions

I3_POINTER_TYPEDEFS(I3VectorOMKeyDiff)

I3_POINTER_TYPEDEFS(I3VectorTankKeyDiff)

I3_POINTER_TYPEDEFS(I3VectorIntDiff)

Variables

static const unsigned vectordiff_version_ = 0

file I3VEMCalibrationDiff.cxx

#include <icetray/serialization.h>

#include <frame_object_diff/calibration/I3VEMCalibrationDiff.h>

Functions

I3_SERIALIZABLE(I3VEMCalibrationMapDiff)

file I3VEMCalibrationDiff.h

#include “dataclasses/calibration/I3Calibration.h”

#include “frame_object_diff/I3MapDiff.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

I3Geometry.h 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

Typedefs

typedef MapDiff<OMKey, I3VEMCalibration> I3VEMCalibrationMapDiff

Functions

I3_POINTER_TYPEDEFS(I3VEMCalibrationMapDiff)

I3_CLASS_VERSION(I3VEMCalibrationMapDiff, mapdiff_version_)

file lcs.hpp

#include <algorithm>

#include <iterator>

#include <vector>

file pack_helper.hpp

#include <boost/foreach.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/is_base_of.hpp>

#include <boost/type_traits/is_same.hpp>

#include “icetray/I3FrameObject.h”

copyright (C) 2015 the icecube collaboration

Version

n

Rcs

pack_helper.hpp 88543 2012-05-22 04:54:48Z claudio.kopper

Date

Rcs

2012-05-21 23:54:48 -0500 (Mon, 21 May 2012)

dir calibration

dir external

dir frame_object_diff

dir frame_object_diff

dir geometry

dir icetray

dir private

dir status