icetray C++ API Reference¶

class AddNulls : public I3Module, public I3ConditionalModule ¶

#include <AddNulls.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

AddNulls(const I3Context &context)¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Physics(I3FramePtr frame)¶: Called when the frame was generated by a new Physics record.

AddNulls(const I3Context &context)

virtual void Configure()

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

Private Members

std::vector<std::string> keys_¶

struct AllParametersModule : public I3Module ¶

Public Functions

inline AllParametersModule(const I3Context &context)¶

inline virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

inline virtual void Process()¶

inline virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

struct anyx¶

#include <has_operator.h>

Public Functions

template<class T> anyx(const T&)¶

struct archive_filter¶

#include <archive_filter.hpp>

Public Types

typedef char char_type¶

typedef boost::iostreams::multichar_input_filter_tag category¶

Public Functions

archive_filter(const std::string &filename)¶

template<typename Source> std::streamsize read(Source &src, char_type *s, std::streamsize n)¶

Public Members

std::string basename_¶

boost::shared_ptr<struct archive> reader_¶

struct archive_entry *current_entry_¶

client_data source_info_¶

bool header_read_¶

bool raw_archive_¶

ssize_t bytes_read_¶

struct blob_t¶

This is the type of the map with which the I3Frame is implemented. It maps strings to shared-pointers-to-I3FrameObjects.

Public Functions

inline void reset()¶

Public Members

std::string type_name¶

std::vector<char> buf¶

struct BottomlessSource : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline BottomlessSource(const I3Context &context)¶

inline virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

inline virtual void Process()¶

Public Members

I3Frame::Stream stream_¶

struct case_insensitive_lt¶

Public Functions

inline bool operator()(const std::string &lhs, const std::string &rhs) const¶

Public Static Functions

static inline int lowercase(int c)¶

struct category : public source_tag, public closable_tag¶: #include <http_source.hpp>

struct category : public output_filter_tag, public multichar_tag, public closable_tag¶: #include <zstd_filter.hpp>

struct client_data¶

#include <archive_filter.hpp>

Public Members

void *source¶

char_type buffer[BOOST_IOSTREAMS_DEFAULT_DEVICE_BUFFER_SIZE]¶

class const_iterator : public deserialize_iterator ¶

#include <I3Frame.h>

Public Functions

inline const_iterator()¶

inline const_iterator(const map_t::const_iterator &iter, const I3Frame *frame)¶

inline const_iterator &operator=(const const_iterator &rhs)¶

template<typename ServiceType> class context_suite : public boost::python::def_visitor<context_suite<ServiceType>>¶

#include <context_suite.hpp>

Public Static Functions

template<typename Class> static inline void visit(Class &cl)¶

Private Types

typedef boost::shared_ptr<ServiceType> ServicePtr¶

Private Static Functions

static inline ServicePtr GetFromContext(const I3Context &ctx, const std::string &name)¶

static inline bool PutInContext(ServicePtr self, I3Context &ctx, const std::string &name)¶

struct ContextFreeServiceTestModule : public I3Module ¶

Public Functions

inline ContextFreeServiceTestModule(const I3Context &context)¶

inline virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

inline virtual void Process()¶

inline virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

class Copy : public I3ConditionalModule ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause Copyies things from frame. Has special privileges granted by I3Frame.

Public Functions

Copy(const I3Context &ctx)¶

inline virtual ~Copy()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

SET_LOGGER ("Copy")

Private Functions

Copy()¶

Copy(const Copy&)¶

Copy &operator=(const Copy&)¶

Private Members

std::vector<std::string> copy_keys_¶

class CountFrames : public I3ConditionalModule ¶

An icetray module which will check whether a configurable set of frame elements is (or is not) present on each stream.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

CountFrames(const I3Context &context)¶

virtual ~CountFrames()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

Private Members

std::map<I3Frame::Stream, unsigned> required_framecounts_¶

std::map<I3Frame::Stream, unsigned> actual_framecounts_¶

class CountObject : public I3Module ¶

#include <CountObject.h>

An icetray module which will count the number of frame objects at some location and verify against some expected number passed as an argument.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

CountObject(const I3Context &context)¶

virtual ~CountObject()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Physics(I3FramePtr)¶: Called when the frame was generated by a new Physics record.

virtual void Calibration(I3FramePtr)¶: Called when the frame was generated by a new Calibration record.

virtual void DetectorStatus(I3FramePtr)¶: Called when the frame was generated by a new DetectorStatus record

virtual void Geometry(I3FramePtr)¶: Called when the frame was generated by a new Geometry record.

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

Private Members

std::string where_¶

unsigned expected_¶

unsigned seen_¶

class CreateBlobs : public I3ConditionalModule ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline CreateBlobs(const I3Context &context)¶

inline virtual ~CreateBlobs()¶

inline virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

inline virtual void Process()¶

Private Functions

CreateBlobs(const CreateBlobs&)¶

CreateBlobs &operator=(const CreateBlobs&)¶

Private Members

bool dropMemoryData_¶

class Delete : public I3ConditionalModule ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause Deletes things from frame. Has special privileges granted by I3Frame.

Public Functions

Delete(const I3Context &ctx)¶

inline virtual ~Delete()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

SET_LOGGER ("Delete")

Private Functions

Delete()¶

Delete(const Delete&)¶

Delete &operator=(const Delete&)¶

Private Members

std::vector<std::string> delete_keys_¶

std::vector<std::string> delete_key_starts_¶

class deserialize_transform¶

#include <I3Frame.h>

Public Types

typedef const pair_t &result_type¶

Public Functions

inline deserialize_transform()¶

inline explicit deserialize_transform(const I3Frame *frame)¶

inline result_type operator()(map_t::const_reference pr) const¶

Private Types

typedef std::pair<std::string, I3FrameObjectConstPtr> pair_t¶

Private Members

const I3Frame *frame_¶

mutable pair_t result¶

class Dump : public I3ConditionalModule ¶

Public Functions

inline Dump(const I3Context &context)¶

inline virtual ~Dump()¶

inline virtual void Process()¶

Private Functions

Dump(const Dump&)¶

Dump &operator=(const Dump&)¶

Private Members

uint64_t frameCount_¶

template<class T> struct extended_type_info_impl¶

#include <i3_extended_type_info.h>

Public Types

typedef ::i3_extended_type_info<T> type¶

class Fork : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

Fork(const I3Context &context)¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

Private Members

std::vector<std::string> outboxes_¶

class FrameCheck : public I3Module ¶

#include <FrameCheck.h>

An icetray module which will check whether a configurable set of frame elements is (or is not) present on each stream.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

FrameCheck(const I3Context &context)¶

virtual ~FrameCheck()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void DAQ(I3FramePtr frame)¶: Called when the frame was generated by a new DAQ record.

virtual void Physics(I3FramePtr frame)¶: Called when the frame was generated by a new Physics record.

virtual void DetectorStatus(I3FramePtr frame)¶: Called when the frame was generated by a new DetectorStatus record

virtual void Calibration(I3FramePtr frame)¶: Called when the frame was generated by a new Calibration record.

virtual void Geometry(I3FramePtr frame)¶: Called when the frame was generated by a new Geometry record.

Private Types

typedef std::map<I3Frame::Stream, predicates> streammap_t¶

Private Functions

void CheckFrameForKeys(I3FramePtr frame, const I3Frame::Stream &stream)¶

Private Members

streammap_t keys_¶

class FunctionModule : public I3ConditionalModule ¶

#include <FunctionModule.h>

A wrapper class which turns a callable object into an I3Module. The wrapped callable may return nothing or a boolean, and in the latter case the processed frame is dropped if the result is false.

Public Functions

FunctionModule(const I3Context &context, std::function<void(boost::shared_ptr<I3Frame>)>)¶

FunctionModule(const I3Context &context, std::function<bool(boost::shared_ptr<I3Frame>)>)¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

Private Functions

FunctionModule(const I3Context &context)¶

Private Members

std::function<void(boost::shared_ptr<I3Frame>)> func¶: The wrapped function.

std::set<I3Frame::Stream> streams¶: The streams on which this module should run.

class Get : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

Get(const I3Context &context)¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

Private Functions

void impl(I3FramePtr frame)¶

Private Members

std::vector<std::string> keys_¶

std::vector<I3Frame::Stream> streams_¶

bool get_all_¶

struct hash¶

#include <OMKey.h>

Public Functions

inline size_t operator()(const OMKey &key) const¶

struct hashed_str_t¶

Public Functions

inline hashed_str_t(const std::string &str)¶

inline bool operator==(const hashed_str_t &b) const¶

inline hashed_str_t &operator=(const hashed_str_t &b)¶

Public Members

std::string string¶

size_t hash¶

struct hashed_str_t_hash¶

Public Functions

inline size_t operator()(const hashed_str_t &h) const¶

struct http_source¶

#include <http_source.hpp>

Public Types

typedef char char_type¶

Public Functions

http_source(const std::string &url)¶

std::streamsize read(char *s, std::streamsize size)¶

inline void close()¶

Public Members

boost::shared_ptr<boost::asio::io_service> io_service_¶

boost::shared_ptr<boost::asio::ip::tcp::socket> socket_¶

boost::shared_ptr<boost::asio::streambuf> buffer_¶

template<class T> struct i3_export_key_setter¶

#include <i3_extended_type_info.h>

Public Functions

inline i3_export_key_setter(const char *name)¶

Public Members

const char *guid¶

template<class T> class i3_extended_type_info : public extended_type_info_typeid_0, public icecube::serialization::singleton<i3_extended_type_info<T>>¶

#include <i3_extended_type_info.h>

Public Functions

inline i3_extended_type_info()¶

inline ~i3_extended_type_info()¶

inline const extended_type_info *get_derived_extended_type_info(const T &t) const¶

inline virtual void *construct(unsigned int count, ...) const¶

inline virtual void destroy(void const *const p) const¶

Private Functions

inline void set_key(const char *guid)¶

Private Members

char guid_buffer[255]¶

bool registered¶

Friends

friend struct i3_export_key_setter< T >

class I3ConditionalModule : public I3Module ¶

#include <I3ConditionalModule.h>

This class is meant to be a wedge between an I3Module and any module that wants to take advantage of conditional execution functionality. That functionality resides here because the very general I3Module class doesn’t want to get too specialized.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Subclassed by AddNulls, Copy, CountFrames, CreateBlobs, Delete, Dump, FunctionModule, Keep, PythonFunction, Rename

Public Functions

I3ConditionalModule(const I3Context &context)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

~I3ConditionalModule()¶

virtual bool ShouldDoProcess(I3FramePtr frame)¶: The function where frames are sent to IcePicks installed in the context in order to determine whether the module should run.

inline bool ShouldProcess(I3FramePtr frame)¶

SET_LOGGER ("I3ConditionalModule")

Protected Functions

inline unsigned GetTimesExecuted()¶: Simple method that allows derived modules to access information about how many times their Physics() function has been executed.

inline unsigned GetTimesSkipped()¶: Simple method that allows derived modules to access information about how many times their Physics() function has been skipped due to conditional execution.

virtual void Configure_()¶

Private Members

I3IcePickPtr pick_¶

boost::python::object if_¶

unsigned nexecuted_¶

unsigned nskipped_¶

bool use_if_¶

bool use_pick_¶

class I3Configuration¶

#include <I3Configuration.h>

Public Functions

virtual ~I3Configuration()¶

I3Configuration()¶

I3Configuration(const I3Configuration&)¶

I3Configuration &operator=(const I3Configuration&)¶

void Set(const std::string &key, const boost::python::object &value)¶

bool Has(const std::string &name) const¶

void Add(const std::string &name, const std::string &description, const boost::python::object &default_value)¶

void Add(const std::string &name, const std::string &description)¶

template<typename T> inline void Add(const std::string &name, const std::string &description, const T &default_value)¶

boost::python::object Get(const std::string &name) const¶

std::string GetDescription(const std::string &name) const¶

template<typename T> inline boost::enable_if<is_shared_ptr<T>, T>::type Get(const std::string &name) const¶: This allows NoneType on the python side to translate to a Null pointer on the C++ side

template<typename T> inline boost::disable_if<is_shared_ptr<T>, T>::type Get(const std::string &name) const¶

std::string ClassName() const¶

void ClassName(const std::string &s)¶

std::string InstanceName() const¶

void InstanceName(const std::string &s)¶

bool is_ok() const¶

std::string inspect() const¶: prints in xml format for consumption by xsltproc. You can’t just use the icecube::serialization xml since this isn’t well formed due to <px class_id=”9” class_name=”typeholder<bool>” …

std::vector<std::string> keys() const¶

void merge(const I3Configuration &rhs)¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

boost::scoped_ptr<I3ConfigurationImpl> impl_¶

Friends

friend class icecube::serialization::access

friend std::ostream &operator<<(std::ostream&, const I3Configuration&)¶

class I3ConfigurationImpl¶

#include <I3ConfigurationImpl.h>

This class holds the configuration.

Public Types

typedef boost::multi_index_container<I3Parameter, boost::multi_index::indexed_by<boost::multi_index::ordered_unique<boost::multi_index::const_mem_fun<I3Parameter, const std::string&, &I3Parameter::name>, case_insensitive_lt>>> parameters_t¶: these are the new parameters. I3Parameter saves the full type information.

Public Functions

virtual ~I3ConfigurationImpl()¶

I3ConfigurationImpl()¶

void Set(const std::string &key, const boost::python::object &value)¶

bool Has(const std::string &name) const¶

void Add(const std::string &name, const std::string &description, const boost::python::object &default_value)¶

void Add(const std::string &name, const std::string &description)¶

boost::python::object Get(const std::string &name) const¶

I3Parameter GetParameter(const std::string &name) const¶

inline std::string ClassName() const¶

inline void ClassName(const std::string &s)¶

inline std::string InstanceName() const¶

inline void InstanceName(const std::string &s)¶

bool is_ok() const¶

std::string inspect() const¶: prints in xml format for consumption by xsltproc. You can’t just use the icecube::serialization xml since this isn’t well formed due to <px class_id=”9” class_name=”typeholder<bool>” …

std::vector<std::string> keys() const¶

void merge(const I3ConfigurationImpl &rhs)¶

Private Functions

template<typename Archive> void serialize(Archive&, unsigned)¶

Private Members

std::string classname¶

std::string instancename¶

boost::shared_ptr<parameters_t> parameters¶

Friends

friend class icecube::serialization::access

friend class I3Configuration

friend std::ostream &operator<<(std::ostream&, const I3ConfigurationImpl&)¶

class I3Context¶

#include <I3Context.h>

This class defines the interface used by I3ContextAccess to gain type-safe access to a module’s context.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause Users should not directly access data using this class, but should hand instances of this class to I3ContextAccess to handle such issues.

Version: $Id$
Author: patton

Public Types

typedef hash_map<std::string, boost::any> map_t¶

typedef map_t::const_iterator const_iterator¶

Public Functions

inline I3Context()¶

inline virtual ~I3Context()¶

std::vector<std::string> keys() const¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

template<typename Service> inline bool Has(const std::string &where = I3DefaultName<Service>::value(), typename boost::disable_if<is_shared_ptr<Service>, bool>::type *enabler = 0) const¶

template<typename Service> inline bool Has(const std::string &where = I3DefaultName<typename Service::element_type>::value(), typename boost::enable_if<is_shared_ptr<Service>, bool>::type *enabler = 0) const¶

inline bool Has(const std::string &where) const¶

template<typename T> inline bool Put(boost::shared_ptr<T> what, const std::string &where = I3DefaultName<T>::value())¶

template<typename T> inline bool Put(const std::string &where, boost::shared_ptr<T> what)¶

inline bool Put(const std::string &where, boost::python::object what)¶

template<typename T> inline T &Get(const std::string &where = I3DefaultName<T>::value(), typename boost::disable_if<is_shared_ptr<T>, bool>::type *enabler = 0) const¶

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

inline boost::python::object Get(const std::string &where) const¶

inline const_iterator begin() const¶

inline const_iterator end() const¶

std::string dump() const¶

Private Functions

I3Context(const I3Context &rhs)¶

I3Context &operator=(const I3Context &rhs)¶

Private Members

map_t map_¶

template<typename T> struct I3DefaultName¶

#include <I3DefaultName.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

template<typename T> struct I3DefaultName<const T>¶

#include <I3DefaultName.h>

Public Static Functions

static inline const char *value()¶

template<class Product, typename FactoryFn> class I3Factory : private noncopyable¶

#include <I3Factory.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Types

typedef FactoryFn factory_fn_t¶

typedef std::map<std::string, product_info_t> product_map_t¶

typedef product_map_t::const_iterator const_iterator¶

typedef product_map_t::iterator iterator¶

typedef product_map_t::const_reference const_reference¶

typedef product_map_t::reference reference¶

Public Functions

inline const_iterator begin() const¶

inline const_iterator end() const¶

inline iterator begin()¶

inline iterator end()¶

inline const_iterator find(const std::string &key) const¶

inline iterator find(const std::string &key)¶

inline void Register(std::string name, std::string project, factory_fn_t fn)¶

inline FactoryFn Create(std::string name) const¶

inline I3Factory()¶

Private Members

product_map_t product_map¶

Friends

friend class I3::Singleton< I3Factory >

class I3FileLogger : public I3Logger¶

#include <I3SimpleLoggers.h>

A logger which writes messages to a file.

Public Functions

inline explicit I3FileLogger(std::string path)¶

Construct a file logger. The chosen output file will be overwritten.

Parameters:: path – the filesystem path to which to write the log

void Log(I3LogLevel level, const std::string &unit, const std::string &file, int line, const std::string &func, const std::string &message)¶

Private Members

std::string path¶

std::ofstream out¶

bool TrimFileNames¶

class I3Frame¶

#include <I3Frame.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause The I3Frame is the container that I3Modules use to communicate with one another. It is passed from I3Module to I3Module by the icetray framework.

Public Types

typedef map_t::size_type size_type¶

typedef boost::transform_iterator<typename_transform, map_t::const_iterator, const std::pair<std::string, std::string>&> typename_iterator_t¶

typedef boost::transform_iterator<deserialize_transform, map_t::const_iterator, const std::pair<std::string, I3FrameObjectConstPtr>&> deserialize_iterator¶

Public Functions

explicit I3Frame(Stream stop = I3Frame::None)¶

explicit I3Frame(char stop)¶

inline ~I3Frame()¶

I3Frame(const I3Frame &rhs)¶

I3Frame &operator=(const I3Frame &rhs)¶

inline Stream GetStop() const¶

Stream GetStop(const std::string &key) const¶

inline void SetStop(Stream newstop)¶

inline bool drop_blobs() const¶

inline void drop_blobs(bool drop)¶

Determine policy: Drop the blobs after deserialization?

Parameters:: drop – True corresponds to drop blobs.

inline size_type size() const¶

inline void clear()¶

inline const_iterator begin() const¶

inline const_iterator end() const¶

inline typename_iterator typename_begin() const¶

inline typename_iterator typename_end() const¶

inline typename_iterator typename_find(const std::string &key) const¶

size_type size(const std::string &key) const¶

inline size_type count(const std::string &key) const¶

inline const_iterator find(const std::string &key) const¶

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

Test, if a frame object exists at a given “slot”.

Parameters:: key – The “slot” in the frame to check.
Returns:: true, if something exists in the frame at slot key, otherwise false.

void merge(const I3Frame &rhs)¶

void purge(const Stream &what)¶

void purge()¶

void take(const I3Frame &rhs, const std::string &what, const std::string &as)¶

inline void take(const I3Frame &rhs, const std::string &what)¶

template<typename T> inline T Get(const std::string &name = I3DefaultName<typename T::element_type>::value(), typename boost::enable_if<is_shared_ptr<T>>::type* = 0, typename boost::enable_if<boost::is_const<typename T::element_type>>::type* = 0) const¶

Get a frame object.

Note

This version of Get is called when the template argument is a shared_ptr.

Parameters:: name – This is the name of the object in the frame. That is, the key into the map under which the object is stored. This is not necessarily the same as the name of the type of the object… e.g. there might be multiple I3Particles stored at different names like “linefit” and “dipolefit”, and there might be only one I3Geometry stored at “I3Geometry”.
Returns:: shared_ptr<const T::value_type>. That is, if Get is called as Get<shared_ptr<const T> >(name), or the equivalent Get<I3SomethingConstPtr>(name), this function returns shared_ptr<const T> or I3SomethingConstPtr. If T is a nonconst shared_ptr, const is added: e.g. Get<I3SomethingPtr>(name) returns I3SomethingConstPtr. More generally, Get<shared_ptr<T> >(name) returns shared_ptr<const T>.

template<typename T> inline const T &Get(const std::string &name = I3DefaultName<T>::value(), typename boost::disable_if<is_shared_ptr<T>>::type* = 0) const¶: Get a frame object.

Note

This version of Get is called when the template argument is not a shared pointer. It returns a const reference to T.

void Put(const std::string &name, boost::shared_ptr<const I3FrameObject> element, const I3Frame::Stream &stream)¶

Puts something into the frame.

Parameters:

name – Where to put it.
element – What to put in there. Must be a shared_ptr to something that inherits from I3FrameObject.
stream – The stream to act on.

Throws:

If – something exists already in the frame at key name, this function will throw via log_fatal.

void Put(const std::string &name, boost::shared_ptr<const I3FrameObject> element)¶

template<typename T> inline void Put(boost::shared_ptr<T> element)¶

Puts something into the frame at its “default” location.

Parameters:: element – What to put in there.
Throws:: Throws – via log_fatal if something is already in the frame at the default location for T.

void Replace(const std::string &name, boost::shared_ptr<const I3FrameObject> element)¶

Puts something into the frame, even if there is already something else there

Parameters:

name – Where to put it.
element – What to put in there.

void Rename(const std::string &from, const std::string &to)¶: Renames something.

void ChangeStream(const std::string &key, Stream stream)¶: Changes a frame object’s stream.

void Delete(const std::string &key)¶: Deletes something.

std::string as_xml(const std::string &key) const¶

const std::type_info *type_id(const std::string &key) const¶

std::string type_name(const std::string &key) const¶

std::vector<std::string> keys() const¶

void create_blob(bool drop_memory_data, const std::string &key) const¶

void create_blobs(bool drop_memory_data, const std::vector<std::string> &skip = std::vector<std::string>()) const¶

template<typename OStreamT> void save(OStreamT &os, const std::vector<std::string> &skip = std::vector<std::string>()) const¶

Serialize the frame to an output stream.

Parameters:

os – the stream to which to write
skip – a collection of keys which should not be written

template<typename IStreamT> bool load(IStreamT &is, const std::vector<std::string> &skip = std::vector<std::string>(), bool verify_checksums = true)¶

Deserialize a frame from an input stream, replacing the current contents of this frame.

Parameters:

is – the stream from which to read
skip – a collection of keys which should not be read
verify_checksums – whether to verify that the data being read matches the saved checksum

std::string Dump() const¶

template<class IStream> bool load_old(IStream &is, const vector<string> &skip, uint32_t versionRead)¶

Public Static Functions

static inline bool is_user_defined(const Stream &s)¶

Public Static Attributes

static const Stream None¶

static const Stream Geometry¶

static const Stream Calibration¶

static const Stream DetectorStatus¶

static const Stream Simulation¶

static const Stream DAQ¶

static const Stream Physics¶

static const Stream TrayInfo¶

Private Types

typedef hash_map<hashed_str_t, boost::shared_ptr<value_t>, hashed_str_t_hash> map_t¶

Private Functions

I3FrameObjectConstPtr get_impl(map_t::const_reference value) const¶: Internal implementation of Get, where the actual deserialization is done.

inline size_type size(const value_t &value) const¶

void validate_name(const std::string &name)¶

Checks whether a name is acceptable for use as a key in the frame

Throws:: std::runtime_error – if the name is not allowed

template<typename IStreamT> bool load_old(IStreamT &ifs, const std::vector<std::string> &skip, unsigned version)¶: these are used from unit tests to be sure frame is (de)serializing properly

template<typename IStreamT> bool load_v4(IStreamT &ifs, const std::vector<std::string> &skip)¶

template<typename IStreamT> bool load_v56(IStreamT &ifs, const std::vector<std::string> &skip, bool v6, bool verify_checksums)¶

Private Members

Stream stop_¶

bool drop_blobs_¶: Policy: Drop the blobs after you deserialize them. Do this if you’re low on memory. You would not do this (as in the JEB), that you’re just going to have to serialize them again.

mutable map_t map_¶

Private Static Functions

static std::string type_name(const value_t&)¶: may change type_name field in value

static void create_blob_impl(value_t &value)¶

Friends

friend std::ostream &operator<<(std::ostream &o, const I3Frame &frame)¶

class I3FrameMixer¶

#include <I3FrameMixing.h>

When I3Frames are processed keys are mixed to subsequent frames on different streams. This class encapsulates the necessary logic in one place, and provides and interface to retrieve the frames which currently have been or would be mixed into a frame of a given type.

Public Functions

inline explicit I3FrameMixer(bool track_order = false, bool disable_mixing = false)¶

Construct a frame mixer.

Parameters:

track_order – whether the order of mixed frames is recorded. Tracking has some runtime overhead, but enables MostRecentMixedStream
disable_mixing – whether the object will be used only to track frame dependencies, without performing actual mixing. This setting cannot be changed after construction.

void Mix(I3Frame &frame)¶

Mix keys from previous frames into frame, and if necessary update the internal cache so that keys from frame can be mixed into subsequent frames.

Pre:: disable_mixing must have been set to false on construction

std::vector<boost::shared_ptr<I3Frame>> GetMixedFrames(I3Frame::Stream stop)¶

Retrieve the frames which were most recently mixed into a frame of the given stream, or if the given frame type does not appear in the cache (because it is immiscable or has not been encountered), the frames which would be mixed into such a frame were it encountered at this time.

If stream order tracking is turned on, the mixed frames will be returned in the order that they appeared in the sequence, otherwise they will be returned in an arbitrary order.

boost::optional<I3Frame::Stream> MostRecentMixedStream(I3Frame::Stream stop) const¶

Get the stop type of the most recent frame to be mixed which has been or will eligible for mixing into the given stream. Note that the stream in question should generally be the one for which Mix() has most recently been called.

Parameters:: stop – The stream into which mixing is to be considered.
Pre:: Order tracking must be active
Returns:: The most recently seen miscable stream, if any

void UpdateDependencies(const I3Frame &frame)¶

Update the frame cache as if mixing this frame, but without performing any mixing. This allows GetMixedFrames to give correct results, but is incompatible with Mix. (Mix requires that only purged frames be added to the cache, which this function does not enforce.)

Parameters:: frame – the frame to possibly add to the frame cache
Pre:: disable_mixing must have been set to true on construction

inline bool TrackOrder() const¶

inline void TrackOrder(bool t)¶

inline bool MixingDisabled() const¶

inline void Reset()¶

Private Functions

std::vector<boost::shared_ptr<I3Frame>>::iterator UpdateDependenciesImpl(const I3Frame &frame)¶

The internal implementation of UpdateDependencies which assumes that the frame has been purged and performs no error checking.

Parameters:: frame – the frame to possibly add to the frame cache
Returns:: the iterator to the new or updated entry in the parent cache

Private Members

bool track_order_¶

const bool disable_mixing_¶

std::vector<boost::shared_ptr<I3Frame>> parent_cache_¶

class I3FrameObject¶

#include <I3FrameObject.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause This is the mother of all classes that can live in the I3Frame. Exists strictly to provide a common base class for objects that live in the frame

Subclassed by I3PODHolder< T >, I3RUsage, I3TrayInfo

Public Functions

virtual ~I3FrameObject()¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

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

virtual std::ostream &Print(std::ostream &os) const¶

Print a human-readable representation of the object.

Parameters:: os – the stream to which the representation is written

class I3IcePick : public I3ServiceBase ¶

#include <I3IcePick.h>

This class is the base ‘selection’ class. Provides the same ‘configuration’ interface that an I3Module does so you can configure IcePicks.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause It is expected that every new kind of selection would inherit from this class. Currently, the user would then be able to use their selection in three ways: I3IcePickModule<XXX>, I3IceForkModule<XXX>, and I3IcePickInstaller<XXX> where XXX is your new kind of selection.

Public Functions

I3IcePick(const I3Context &context)¶

the constructor takes an I3Context as an argument.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

void ConfigureInterface()¶: This function configures the parameters that the I3IcePick base class contains. From here, Configure is then called to give the derived classes a chance to configure themselves.

virtual void Configure()¶: This can be overridden like for I3Module’s It is called after the constructor but before the ‘SelectFrame’ method so that these can be configured like I3Modules.

virtual ~I3IcePick()¶

bool SelectFrameInterface(I3Frame &frame)¶: This function is meant to be the interface between the users of the IcePick and the derived IcePicks. Here, quantities important to the base class, I3IcePick, are dealt with before the derived classes SelectFrame() method is called.

virtual bool SelectFrame(I3Frame &frame) = 0¶: This is the meaty method. Derived classes need to write this method. It should return ‘true’ if the event is interesting.

inline unsigned GetFramesPassed()¶: Simple method to get the number of frames deemed interesting by this IcePick.

inline unsigned GetFramesFailed()¶: Simple method to get the number of frames deemed not interesting by this IcePick.

Private Members

bool cache_¶

unsigned npassed_¶

std::string cachename_¶

unsigned nfailed_¶

Friends

friend class I3IcePickModule

friend class I3IceForkModule

template<class IcePick> class I3IcePickInstaller : public I3SingleServiceFactory<IcePick, I3IcePick>¶

#include <I3IcePickInstaller.h>

This service factory is meant to install an I3IcePick object into the context. The specific I3IcePick being installed is used as a template throughout this class.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause If you’ve written a new I3IcePick, be sure to add the appropriate I3_SERVICE_FACTORY() macro to a .cxx file.

Public Functions

inline I3IcePickInstaller(const I3Context &context)¶

The constructor. The context is then passed to the constructor of the I3IcePick object being installed.

Parameters:: context – the I3Context where the I3IcePick should be installed

inline virtual void Configure()¶: The configure method where servicename_ is set from the steering file.

class I3Module¶

#include <I3Module.h>

Subclassed by AddNulls, AllParametersModule, BottomlessSource, ContextFreeServiceTestModule, CountObject, Fork, FrameCheck, Get, I3ConditionalModule, I3PacketModule, IntGenerator, LoggingExampleModule, MaintainInitialValuesModule, ManyStreamsSource, PhysicsBuffer, TrashCan

Public Functions

I3Module(const I3Context &context)¶

Constructor.

Parameters:: context – the I3Context object containing this objects services, configuration, outboxes and so forth. Since a module is useless without a context, no default constructor is provided.

virtual ~I3Module()¶: Destructor.

void Do(void (I3Module::* f)())¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Configure_()¶

virtual bool ShouldDoProcess(I3FramePtr)¶

void Process_()¶

virtual void Process()¶

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

inline const std::string GetName() const¶

Get the name of a module

Returns:: the module name

inline virtual void SetName(const std::string &name)¶

Set the name of a module

Parameters:: name – name of the module

inline const I3Context &GetContext() const¶

inline I3Configuration &GetConfiguration()¶

inline const I3Configuration &GetConfiguration() const¶

void ConnectOutBox(const std::string &outBoxName, I3ModulePtr targetModule)¶

Connect one of this module’s outboxes to another module.

Parameters:

outBoxName – the outbox to be connected
targetModule – the module to which the outbox will connect

bool AllOutBoxesConnected() const¶: Check whether all of this module’s outboxes connect to other modules.

bool HasOutBox(const std::string &outBoxName) const¶

Test whether this module has a particular outbox.

Parameters:: outBoxName – the name for which to check

bool HasInBox() const¶: Test whether this module has a valid inbox from which it can receive frames.

SET_LOGGER ("I3Module")

I3PhysicsUsage ReportUsage()¶

Protected Functions

void Register(const I3Frame::Stream &when, boost::function<void(I3FramePtr)>)¶

template<class T> inline void Register(const I3Frame::Stream &when, void (T::* m_fn)(I3FramePtr))¶

virtual void DAQ(I3FramePtr frame)¶: Called when the frame was generated by a new DAQ record.

virtual bool ShouldDoDAQ(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the DAQ(), etc and push the frame out early if not interested.

virtual void Physics(I3FramePtr frame)¶: Called when the frame was generated by a new Physics record.

virtual bool ShouldDoPhysics(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the Physics(), etc and push the frame out early if not interested.

virtual void Geometry(I3FramePtr frame)¶: Called when the frame was generated by a new Geometry record.

virtual bool ShouldDoGeometry(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the Physics(), etc and push the frame out early if not interested.

virtual void Calibration(I3FramePtr frame)¶: Called when the frame was generated by a new Calibration record.

virtual bool ShouldDoCalibration(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the Physics(), etc and push the frame out early if not interested.

virtual void DetectorStatus(I3FramePtr frame)¶: Called when the frame was generated by a new DetectorStatus record

virtual bool ShouldDoDetectorStatus(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the Physics(), etc and push the frame out early if not interested.

virtual void Simulation(I3FramePtr frame)¶: Called when the frame was generated by a new Simulation record

virtual bool ShouldDoSimulation(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the Physics(), etc and push the frame out early if not interested.

virtual void OtherStops(I3FramePtr frame)¶: Called when the frame was generated by a new record which is none of the above records.

virtual bool ShouldDoOtherStops(I3FramePtr frame)¶: ShouldDo* will be reimplemented. Probably better if you don’t implement. Instead, just put any predicates like this in the Physics(), etc and push the frame out early if not interested.

void RequestSuspension() const¶: Requests that the Framework change from the current ‘Processing’ state to a “Suspened’ state.

virtual void Flush()¶: If this module buffers frames, when it receives a Finish() it must push all remaining frames and then Flush() to be sure the various stop methods get called downstream.

I3FramePtr PopFrame()¶

Returns the next I3Frame in the default InBox and removes the frame from the box.

Returns:: the next I3Frame in the specified InBox.

I3FramePtr PeekFrame()¶

void AddOutBox(const std::string &name)¶

void PushFrame(I3FramePtr frame, const std::string &name)¶

Puts the specified I3Frame into the specified OutBox.

Parameters:

frame – the I3Frame to put into the OutBox.
name – the name associated with the OutBox.

void PushFrame(I3FramePtr frame)¶

Pushes the specified I3Frame onto all outboxes

Parameters:: frame – the frame to push

template<typename T> inline void AddParameter(const std::string &parameter, const std::string &description, T defaultValue)¶

void AddParameter(const std::string &name, const std::string &description)¶

template<typename T> inline boost::disable_if<boost::is_const<T>, void>::type GetParameter(const std::string &name, T &value) const¶

template<typename T> inline T &GetService(const std::string &where = I3DefaultName<T>::value(), typename boost::disable_if<is_shared_ptr<T>, bool>::type *enabler = 0)¶

template<typename T> inline T GetService(const std::string &where = I3DefaultName<typename T::element_type>::value(), typename boost::enable_if<is_shared_ptr<T>, bool>::type *enabler = 0)¶

Protected Attributes

const I3Context &context_¶: The context wherein my configuration, outboxes, and so forth can be found.

outboxmap_t outboxes_¶

I3Configuration configuration_¶

methods_t methods_¶

FrameFifoPtr inbox_¶

Private Types

typedef std::map<std::string, std::pair<FrameFifoPtr, I3ModulePtr>> outboxmap_t¶

typedef std::map<I3Frame::Stream, boost::function<void(I3FramePtr)>> methods_t¶

Private Functions

I3Module()¶: Default constructor disabled.

I3Module(const I3Module &rhs)¶: Copy operations make no sense for modules.

I3Module operator=(const I3Module &rhs)¶: Assignment operations make no sense for modules.

inline void SyncCache(std::string outbox, I3FramePtr frame)¶

Private Members

std::string name_¶: module name

unsigned nphyscall_¶

unsigned ndaqcall_¶

double systime_¶

double usertime_¶

std::map<std::string, boost::shared_ptr<I3FrameMixer>> cachemap_¶

Private Static Attributes

static const double min_report_time_ = 10¶

only report usage times if greater than this

$Id$

Copyright (C) 2004 - 2008 Troy D. Straszheim troy@icecube.umd.edu Copyright (C) 2004 - 2008 Simon Patton Copyright (C) 2004 - 2008 John Pretz, Copyright (C) 2004 - 2008 the IceCube Collaboration http://www.icecube.wisc.edu

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

class I3NullLogger : public I3Logger¶

#include <I3SimpleLoggers.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline virtual void Log(I3LogLevel level, const std::string &unit, const std::string &file, int line, const std::string &func, const std::string &message)¶

class I3PacketModule : public I3Module ¶

#include <I3PacketModule.h>

This class is meant to be a wedge between an I3Module and any module that wants to process a “packet” of frames related to the same detector configuration, in some generalized sense. The usual use is for a module that wants to act on a DAQ trigger (DAQ frame) followed by its split subevents (Physics frames) as a single unit.

Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause Packet processing will send a packet starting with a frame of type sentinel (or stream start) and ending with either another frame of type sentinel, or a frame type not found in the packet_types vector. Receipt of a frame not in packet_types will cause FramePacket() to be called with the current buffer and the frame to be handled by I3Module::Process() (i.e. Geometry()/Calibration()/etc.)

NB: If packet_types is empty, packets will only be terminated by a new sentinel frame. If sentinel is set to I3Frame::DAQ in the constructor, packet_types will be initialized to [I3Frame::DAQ, I3Frame::Physics]. Otherwise it will be left blank by default.

Public Functions

I3PacketModule(const I3Context &context, I3Frame::Stream sentinel = I3Frame::DAQ)¶: Copyright (C) 2011 Nathan Whitehorn nwhitehorn@icecube.wisc.edu Copyright (C) 2011 the IceCube Collaboration http://www.icecube.wisc.edu SPDX-License-Identifier: BSD-2-Clause

~I3PacketModule()¶

virtual void Configure_()¶

virtual void Process()¶

void FlushQueue()¶

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

virtual void FramePacket(std::vector<I3FramePtr> &packet)¶

Protected Attributes

I3Frame::Stream sentinel¶

std::vector<I3Frame::Stream> packet_types¶

Private Members

std::vector<I3FramePtr> queue_¶

boost::python::object if_¶

struct I3Parameter¶

#include <I3Parameter.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

I3Parameter()¶

I3Parameter(const I3Parameter &rhs)¶

I3Parameter &operator=(const I3Parameter&)¶

~I3Parameter()¶

inline const std::string &name() const¶

inline void name(const std::string &newname)¶

inline std::string description() const¶

inline void description(const std::string &d)¶

std::string default_value_str() const¶

std::string configured_value_str() const¶

inline bool has_default() const¶

inline bool has_configured() const¶

inline bool got_by_module() const¶

void set_configured(const boost::python::object &t)¶

void set_default(const boost::python::object &t)¶

boost::python::object value() const¶

Public Members

std::string name_¶

std::string description_¶

mutable bool got_by_module_¶

boost::optional<boost::python::object> default_¶

boost::optional<boost::python::object> configured_¶

Private Functions

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

Friends

friend class icecube::serialization::access

class I3PhysicsTimer¶

#include <I3PhysicsTimer.h>

Public Functions

I3PhysicsTimer(I3FramePtr frame, const std::string &module_name)¶

~I3PhysicsTimer()¶

Private Functions

double delta(const struct timeval &starttime, const struct timeval &stoptime)¶

Private Members

struct rusage start_rusage_ end_rusage_

struct timeval start_wallclock_ end_wallclock_

I3FramePtr frame_¶

std::string module_name_¶

struct I3PhysicsUsage¶

#include <I3PhysicsUsage.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline I3PhysicsUsage()¶

Public Members

double systime¶

double usertime¶

unsigned ncall¶

template<typename T> struct I3PODHolder : public I3FrameObject ¶

#include <I3PODHolder.h>

Public Functions

inline I3PODHolder()¶

inline I3PODHolder(T v)¶

inline I3PODHolder(const I3PODHolder<T> &rhs)¶

inline I3PODHolder &operator=(const I3PODHolder<T> &rhs)¶

inline virtual std::ostream &Print(std::ostream &os) const override¶

Print a human-readable representation of the object.

Parameters:: os – the stream to which the representation is written

unsigned version ar & make_nvp ("I3FrameObject", base_object< I3FrameObject >(*this))

ar & make_nvp ("value", value)

Public Members

T value¶

class I3PrintfLogger : public I3Logger¶

#include <I3SimpleLoggers.h>

Public Functions

I3PrintfLogger(I3LogLevel default_level = I3DefaultLogLevel)¶

virtual void Log(I3LogLevel level, const std::string &unit, const std::string &file, int line, const std::string &func, const std::string &message)¶

Public Members

bool TrimFileNames¶

Private Members

bool tty_¶

template<class FactoryProductType, class ActualDerivedType, template<class, class> class Creator> struct I3Registrator : public noncopyable¶

#include <I3Factory.h>

Public Functions

inline I3Registrator & key_register (const char *productname, const char *projectname) I3_USED

inline I3Registrator()¶

Friends

friend class I3::Singleton< I3Registrator >

struct I3RUsage : public I3FrameObject ¶

#include <I3PhysicsTimer.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

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

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Members

double systemtime¶

double usertime¶

double wallclocktime¶

class I3ServiceBase¶

#include <I3ServiceBase.h>

Auxiliary base class for service classes.

When you derive your service classes from this base class then you can configure them in exactly the same way as modules. You make a factory class by doing a template instantiation of I3SingleServiceFactory, e.g.:

typedef I3SingleServiceFactory<I3EventLogLikelihoodCombiner,I3EventLogLikelihoodBase> I3EventLogLikelihoodCombinerFactory; I3_SERVICE_FACTORY( I3EventLogLikelihoodCombinerFactory );

It is recommended that you provide at least two constructors for your service class: one which takes only a context and adds parameters and uses the “factory” I3ServiceBase constructor, and another one (using the “dummy” I3ServiceBase constructor) allows instantiating a service object such that all configurable parameters are directly set to specific values. The former is for regular icetray usage through python scripts, the latter makes it easier to write unit tests.

See also

I3MultiServiceFactory, I3ServiceFactory, I3Context, I3Configuration

Public Functions

inline I3SingleServiceFactory(const I3Context &context)¶: standard factory constructor with context

inline virtual void Configure()¶: Let the datamember instance of the service configure itself.

inline virtual bool InstallService(I3Context &context)¶: install the service object in a given context

Protected Attributes

boost::shared_ptr<MyService> myService_¶: the instance of the service (one per factory object)

Private Functions

SET_LOGGER ("I3SingleServiceFactory"): logging configuration thingy

class I3SyslogLogger : public I3Logger¶

#include <I3SimpleLoggers.h>

Logger that generates log messages, which will be distributed by syslogd.

Note

I3SyslogLogger is thread-safe, however system calls openlog and closelog must not be used from any other program location. Violations may result in an undefined behavior.

Public Functions

explicit I3SyslogLogger(I3LogLevel default_level = I3DefaultLogLevel)¶

Constructor.

Parameters:: default_level – The log level that is assigned to any logging unit (cf. I3Logger) that has no explicit log level set (cf. I3Logger::SetLogLevelForUnit) (optional; default value is I3DefaultLogLevel).

virtual ~I3SyslogLogger()¶: Destructor.

virtual void Log(I3LogLevel level, const std::string &unit, const std::string &file, int line, const std::string &func, const std::string &message)¶

Public Static Functions

static void Open(const std::string &ident)¶

Opens a connection to the system logger for all I3SyslogLogger instances.

The connection is opened automatically during the first call to I3SyslogLogger::Log - however, an empty identification string is used in that case.

Attention: The connection to the system logger must not be opened twice.

Note

I3SyslogLogger uses the LOG_USER log facility. It writes directly to system console if there is an error while sending to syslogd, it opens the connection immediately and not just before the first message is logged, and it includes PID with each message.

Parameters:: ident – is prepended to every message, and is typically set to the program name. If ident is “”, the default identification string used in syslog messages will be the program name, taken from argv[0].
Throws:: std::logic_error – in case of subsequent calls to Open.

Private Static Functions

static inline bool IsOpen()¶

static void Openlog(const std::string &ident, bool doThrow)¶

Private Static Attributes

static bool isOpen = false¶

static std::string id¶

class I3Tray¶

#include <I3Tray.h>

This is I3Tray.

The I3Tray provides a certain configuration interface:

I3Tray tray;

tray.AddService("TestServiceFactory", "service")
   ("boolParam", true)
   ("intParam",  52)
   ("floatParam", 1.2)
   ("doubleParam", 4.14159)
   ("longParam", 68);

 tray.AddModule("TestModule", "test")
   ("boolParam", false)
   ("intParam", 53)
   ("floatParam", 1.1)
   ("doubleParam", 3.14159)
   ("stringParam", "it puts the lotion in the basket")
   ("longParam", 67);

 tray.Execute();

The modules and service will be created and added to the tray in the order that they appear. The parenthesized (“variable-name”, variable-value) pairs will become calls to SetParameter for the module that they are associated with, e.g. “TestServiceFactory”, above will have it’s “doubleParam” set to 4.14159.

If, as above, tray.ConnectBoxes() is not called by the user, each module’s OutBox will be connected to the following Module’s InBox, in the order they appear, before Execute() begins. If it is called at all, no default ConnectBoxes will be performed.

Public Functions

I3Tray()¶

~I3Tray()¶

param_setter AddService(const std::string &clazz, std::string name = "")¶

Adds the specified I3ServiceFactory to the framework.

Parameters:

clazz – the class of the I3ServiceFactory.
name – the name associated with services the created by the factory.

template<class Type> param_setter AddService(std::string name = "")¶: Adds the specified I3ServiceFactory to the framework.

template<class Type> boost::enable_if<boost::is_base_of<I3Module, Type>, param_setter>::type AddModule(std::string name = "")¶

param_setter AddModule(boost::python::object obj, std::string instancename = "")¶

param_setter AddModule(const std::string &name, std::string instancename = "")¶

param_setter AddModule(I3ModulePtr module, std::string instancename = "")¶

template<typename Type> boost::disable_if<boost::mpl::or_<boost::is_base_of<I3Module, Type>, boost::is_same<boost::python::object, Type>, boost::is_convertible<Type, std::string>, is_shared_ptr<Type>>, param_setter>::type AddModule(Type func, std::string instancename = "")¶: Adds an arbitrary object as a module which is callable with an I3FramePtr and returns nothing or a boolean result.

void MoveModule(const std::string &name, const std::string &anchor, bool before = true)¶

bool ConnectBoxes(const std::string &fromModule, const std::string &fromOutBox, const std::string &toModule)¶

Connects the specified OutBox to the specified InBox. If not name is specified for the InBox then the OutBox will be connected to the default InBox of the module associated with the ‘toModule’ name.

Parameters:

fromModule – the name to associated with the OutBox’s module.
fromOutBox – the name of the OutBox.
toModule – the name to associated with the InBox’s module.

void Execute()¶: Executes a processing loop which will continue until there is no more data to process (that is, a module invokes RequestSuspension).

void Execute(unsigned maxCount)¶

Runs the tray until the specified maximum count is reached, or a module invokes RequestSuspension();

Parameters:: maxCount – the maximum process transitions for the driving module.

std::map<std::string, I3PhysicsUsage> Usage()¶: Report per-module physics ncalls/system/user time usage. Have to call this after* Execute()

void Finish()¶: Finishes everything. It is assumed that if the modules are to be used again that they will be freshly ‘Configured’

I3TrayInfo TrayInfo()¶: Get the tray info object for this tray.

I3Context &GetContext()¶: Return the tray’s master context. This allows manual inspection and addition of services.

bool SetParameter(const std::string &module, const std::string &parameter, const char *value)¶

bool SetParameter(const std::string &module, const std::string &parameter, boost::python::object value)¶

template<class Type> inline bool SetParameter(const std::string &module, const std::string &parameter, const Type &value)¶

inline void RequestSuspension()¶

Private Functions

I3Tray(const I3Tray &rhs)¶

I3Tray &operator=(const I3Tray &rhs)¶

boost::shared_ptr<I3Module> CreateModule(I3Context &context, const std::string &clazz)¶

boost::shared_ptr<I3ServiceFactory> CreateService(I3Context &context, const std::string &clazz)¶

void ConnectBoxesInOrderTheyWereAdded()¶: Connects modules in a simple chain, each’s outbox to the next’s default inbox, for use in simple module chain situaitons so that the order of AddModule can also be used to set the outbox connections.

bool SetParameterFailure(const std::string &module, const std::string &parameter)¶

void Configure()¶: called just before Execute starts.

void Execute(bool executeForever, unsigned maxCount)¶

called by Execute() or Execute(unsigned maxCount)

Note

Calling Execute(std::numeric_limits<unsigned>::max()) from Execute() may look like a good idea - a huge maxCount means more or less ‘forever’ - but it isn’t. It’s like O(10 days) run-time for some trays only! Add a boolean parameter to disable the testing of maxCount against the number of frames that have been processed so far.

Parameters:

executeForever – disable maxCount and run/execute forever if true.
maxCount – the maximum number of frames to process.

void Abort()¶: Generates an Abort transition in the main module if it is in the appropriate state. Otherwise it does nothing.

std::string CreateName(const std::string &type, const std::string &kind, const std::vector<std::string> &existingNames)¶

Generate a new name for a module or service which had none specified.

Parameters:

type – the type of object being added (e.g. I3Reader)
kind – the category of object being added (e.g. Module or Service)
existingNames – the names already in use by objects of the same kind

template<typename RetType> param_setter AddFunctionModule(std::function<RetType(boost::shared_ptr<I3Frame>)>, const std::string &instancename)¶

SET_LOGGER ("I3Tray")

template<> I3Tray::param_setter AddFunctionModule(std::function<void(boost::shared_ptr<I3Frame>)> func, const std::string &instancename)¶

template<> I3Tray::param_setter AddFunctionModule(std::function<bool(boost::shared_ptr<I3Frame>)> func, const std::string &instancename)¶

template<> I3Tray::param_setter AddFunctionModule(std::function<void(boost::shared_ptr<I3Frame>)>, const std::string &instancename)

template<> I3Tray::param_setter AddFunctionModule(std::function<bool(boost::shared_ptr<I3Frame>)>, const std::string &instancename)

Private Members

I3Context master_context¶: Context, modules, and factories: oh my!

std::map<std::string, I3ServiceFactoryPtr> factories¶

std::vector<std::string> factories_in_order¶

std::map<std::string, I3ModulePtr> modules¶

std::vector<std::string> modules_in_order¶

I3ModulePtr driving_module¶

bool boxes_connected¶

bool configure_called¶

bool execute_called¶

bool suspension_requested¶

Private Static Functions

static void set_suspend_flag(int sig)¶

static void die_messily(int sig)¶

static void report_usage(int sig)¶

Private Static Attributes

static sig_atomic_t global_suspension_requested¶

Friends

friend class I3TrayInfoService

friend void Do(void (I3Module::*)())¶

struct I3TrayInfo : public I3FrameObject ¶

#include <I3TrayInfo.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

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

virtual std::ostream &Print(std::ostream&) const override¶

Print a human-readable representation of the object.

Parameters:: os – the stream to which the representation is written

std::string PrintCompact()¶: Print the factory/module parameters in a way which is more compact than the normal print method.

I3TrayInfo()¶

Public Members

std::map<std::string, std::string> host_info¶

std::string svn_url¶

std::string svn_externals¶

unsigned svn_revision¶

std::vector<std::string> modules_in_order¶

std::vector<std::string> factories_in_order¶

std::map<std::string, I3ConfigurationPtr> module_configs¶

std::map<std::string, I3ConfigurationPtr> factory_configs¶

class I3TrayInfoService¶

#include <I3TrayInfoService.h>

Public Functions

inline I3TrayInfoService(const I3Tray *tray)¶

I3TrayInfo GetConfig()¶

Private Members

const I3Tray &tray_¶

template<typename StreamType, typename T> struct insertion¶

#include <has_operator.h>

Determine whether a type can be output to a stream.

Template Parameters:

StreamType – the type of stream which is the target
T – the ype to be inserted into the stream

Public Static Attributes

static StreamType &stream¶

static T &x¶

static const bool value = sizeof(check(stream << x)) == sizeof(yes)¶

class IntGenerator : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline IntGenerator(const I3Context &context)¶

inline virtual void Process()¶

Private Members

int i¶

template<typename T> struct is_shared_ptr : public false_¶

#include <is_shared_ptr.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause traits classes that identify if a template parameter is a shared_ptr or not

Template Parameters:: T – typename to evaluate

class Keep : public I3ConditionalModule ¶

#include <Keep.h>

Clean up frame and keep only objects with names that match any some given keys.

Keep supports two parameters:

Keys (keep frame objects with names that match any of these keys (default value is “I3Calibration”, “I3DetectorStatus”, “I3Geometry”, “DrivingTime”, “I3EventHeader”)) and
KeyStarts (keep frame objects with names that start with any of these strings (default is an empty list)).

Public Functions

Keep(const I3Context &context)¶

Constructor.

Parameters:: context – the I3Context object containing this objects services.

virtual ~Keep()¶: Destructor.

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

Private Functions

Keep(const Keep&)¶

Keep &operator=(const Keep&)¶

SET_LOGGER ("Keep")

Private Members

std::vector<std::string> keysParam_¶

std::set<std::string> keys_¶

std::set<std::string> keyStarts_¶

std::set<I3Frame::Stream> streams_¶

struct LoggingExampleModule : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline LoggingExampleModule(const I3Context &context)¶

inline virtual ~LoggingExampleModule()¶

inline virtual void Process()¶

SET_LOGGER ("LoggingExampleModule")

struct MaintainInitialValuesModule : public I3Module ¶

Public Functions

inline MaintainInitialValuesModule(const I3Context &context)¶

inline virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

inline virtual void Process()¶

inline virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

Public Members

boost::shared_ptr<MyService> service_ptr_param¶

struct ManyStreamsSource : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline ManyStreamsSource(const I3Context &context)¶

inline virtual void Process()¶

Public Members

unsigned index¶

std::string frame_types¶

class ModuleTimer¶

Public Functions

inline ModuleTimer(double &s, double &u)¶

inline ~ModuleTimer()¶

Private Members

double &sys¶

double &user¶

struct rusage stop start

bool fail¶

struct MyService¶

struct no¶

#include <has_operator.h>

Public Members

char array[2]¶

class OMKey¶

#include <OMKey.h>

A small class which is the string number, om number and pmt number for a specific PMT inside a DOM.

For IceCube, the PMT number will always be 0 and “PMT” is equivalent to “DOM”. For IceTop, the PMT number can be 0 or 1.

Public Functions

inline OMKey()¶

inline OMKey(int str, unsigned int om)¶

inline OMKey(int str, unsigned int om, unsigned char pmt)¶

virtual ~OMKey()¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

inline int GetString() const¶: retrieves the string number for this OMKey

inline void SetString(int str)¶: Sets the string number for this OM

inline unsigned int GetOM() const¶: gets the OM number on the string

inline void SetOM(unsigned int om)¶: sets the OM number on the string

inline unsigned char GetPMT() const¶: gets the PMT number in the DOM

inline void SetPMT(unsigned char pmt)¶: sets the PMT number in the DOM

inline bool operator==(const OMKey &rhs) const¶

equality operator.

Parameters:: rhs – the OMKey to compare this one to.
Returns:: true if the string and om numbers of the two OMKey’s match

inline bool operator!=(const OMKey &rhs) const¶

inequality operator

Parameters:: rhs – the OMKey to compare this one to.
Returns:: false if the string or om numbers are different

std::string str() const¶

Private Functions

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

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

Private Members

int stringNumber_¶

unsigned int omNumber_¶

unsigned char pmtNumber_¶

Friends

friend class icecube::serialization::access

class param_setter¶

#include <I3Tray.h>

local convenience class: functor that eats pairs of arguments and calls SetParameter. For terseness in creating/configuring I3Trays.

Public Functions

inline param_setter(I3Tray &tray, const std::string &module_name)¶

inline param_setter(const param_setter &rhs)¶

template<typename T> inline param_setter &operator()(const std::string &param, T value)¶

Private Members

I3Tray &tray_¶

const std::string module_name_¶

class PhysicsBuffer : public I3Module ¶

#include <PhysicsBuffer.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause This module buffers physics frames. The important thing about a

Public Functions

PhysicsBuffer(const I3Context &context)¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Physics(I3FramePtr frame)¶: Called when the frame was generated by a new Physics record.

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

Private Members

std::deque<I3FramePtr> buffer_¶

unsigned desired_buffersize_¶

unsigned batchpush_n_¶

unsigned n_¶

struct predicates¶

Public Members

std::vector<std::string> has¶

std::vector<std::string> hasnt¶

struct product_info_t¶

#include <I3Factory.h>

Public Members

factory_fn_t fn¶

std::string project¶

class PythonFunction : public I3ConditionalModule ¶

#include <PythonFunction.h>

Public Functions

PythonFunction(const I3Context &context, boost::python::object func)¶

virtual ~PythonFunction()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

Private Functions

PythonFunction(const PythonFunction&)¶

PythonFunction &operator=(const PythonFunction&)¶

SET_LOGGER ("PythonFunction")

Private Members

boost::python::object obj¶

std::set<I3Frame::Stream> streams¶

boost::python::dict paramsd¶

std::vector<std::string> configkeys¶

boost::python::handle numpy_bool_type¶

boost::python::handle numpy_true¶

boost::python::handle numpy_false¶

template<typename Base> struct PythonModule : public Base, public boost::python::wrapper<Base>¶

#include <PythonModule.h>

Public Functions

PythonModule(const I3Context &ctx)¶

PythonModule(const I3Context &ctx, I3Frame::Stream)¶

void PyConfigure()¶

void Configure()¶

void PyProcess()¶

void Process()¶

void PyFinish()¶

void Finish()¶

void AddParameter(const std::string &name, const std::string &description, const boost::python::object &value)¶

void AddParameter(const std::string &name, const std::string &description)¶

boost::python::object GetParameter(const std::string &name)¶

void Register(const I3Frame::Stream&, const boost::python::object &method)¶

bool ShouldDoGeometry(I3FramePtr frame)¶

void Geometry(I3FramePtr frame)¶

bool ShouldDoCalibration(I3FramePtr frame)¶

void Calibration(I3FramePtr frame)¶

bool ShouldDoDetectorStatus(I3FramePtr frame)¶

void DetectorStatus(I3FramePtr frame)¶

bool ShouldDoSimulation(I3FramePtr frame)¶

void Simulation(I3FramePtr frame)¶

bool ShouldDoDAQ(I3FramePtr frame)¶

void DAQ(I3FramePtr frame)¶

bool ShouldDoPhysics(I3FramePtr frame)¶

void Physics(I3FramePtr frame)¶

void PushFrame(I3FramePtr frame)¶

void PushFrame(I3FramePtr frame, const std::string &where)¶

void RequestSuspension()¶

void AddOutBox(const std::string &name)¶

I3FramePtr PopFrame()¶

inline const I3Context &GetContext() const¶

inline const I3Configuration &GetConfiguration() const¶

void FramePacket(std::vector<I3FramePtr>&)¶

I3Frame::Stream GetSentinel()¶

void SetSentinel(I3Frame::Stream)¶

const std::vector<I3Frame::Stream> &GetPacketTypes()¶

void SetPacketTypes(const std::vector<I3Frame::Stream>&)¶

SET_LOGGER ("PythonModule")

template<> PythonModule(const I3Context &ctx)¶

template<> PythonModule(const I3Context &ctx, I3Frame::Stream stream)¶

template<> void FramePacket(std::vector<I3FramePtr> &frames)¶

template<> I3Frame::Stream GetSentinel()¶

template<> void SetSentinel(I3Frame::Stream sent)¶

template<> const std::vector<I3Frame::Stream> &GetPacketTypes()¶

template<> void SetPacketTypes(const std::vector<I3Frame::Stream> &types)¶

class Rename : public I3ConditionalModule ¶

#include <Rename.h>

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause Renames things in the frame. Has special privileges granted by I3Frame.

Public Functions

Rename(const I3Context &ctx)¶

inline virtual ~Rename()¶

virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

virtual void Process()¶

virtual void Finish()¶: The purpose of this transition is to give this object the opportunity to wind up gracefully. For example a module can use this transition to create a summary of its activities during the execution of the job. Note that after this transition the module is still in existence.

Private Functions

Rename()¶

Rename(const Rename&)¶

Rename &operator=(const Rename&)¶

void do_rename(I3FramePtr frame)¶

Private Members

std::vector<std::string> rename_keys_¶: A vector of things to rename. Goes from_1, to_1, from_2, to_2… from_n, to_n. Obviously must have an even number of elements.

class sigint_exception : public std::exception¶

#include <I3Tray.h>

Public Functions

inline virtual const char *what() const¶

template<class T> class Singleton : public I3::SingletonModule ¶

#include <Singleton.h>

Public Static Functions

static inline I3_DLLEXPORT T & get_mutable_instance ()

static inline I3_DLLEXPORT const T & get_const_instance ()

static inline I3_DLLEXPORT bool is_destroyed ()

Private Static Functions

static inline void use(T const&)¶

static inline I3_DLLEXPORT T & get_instance ()

Private Static Attributes

static I3_DLLEXPORT T & instance = Singleton<T>::get_instance()

class SingletonModule : public noncopyable¶

#include <Singleton.h>

Subclassed by I3::Singleton< T >

Public Static Functions

static inline void lock()¶

static inline void unlock()¶

static inline bool is_locked()¶

Private Static Functions

static inline bool &get_lock()¶

template<class FactoryProductType, class ModuleType> struct StandardCreate¶

#include <I3Factory.h>

Public Static Functions

static inline boost::shared_ptr<FactoryProductType> Create(const I3Context &c)¶

struct Stream¶

#include <I3Frame.h>

The I3Frame takes these in the constructor. They indicate what stream this frame is on (in other words, which I3Module functions should get called as this frame goes downstream: Physics(), Geometry(), Calibration(), etc.

These were just an enum… But if streams change in the future, we want to be backwards-compatible with how we serialize these guys, and that means incrementing the version number on the serialization method for these.

Public Functions

inline Stream()¶

inline Stream(char c)¶

inline Stream(const Stream &rhs)¶

inline Stream &operator=(const Stream &rhs)¶

std::string str() const¶

template<typename Archive> void serialize(Archive &ar, unsigned)¶

inline bool operator==(const Stream &rhs) const¶

inline bool operator!=(const Stream &rhs) const¶

inline bool operator<(const Stream &rhs) const¶

inline char id() const¶

Private Members

char value¶

struct TrashCan : public I3Module ¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Public Functions

inline TrashCan(const I3Context &context)¶

inline virtual void Configure()¶

The purpose of this transition is to give this object an opportunity to access all of its parameters so that it will be able to process data. This transition is executed immediately before the first ‘Process’ transition, thus any parameters that has been set, either by a person or a steering file, will be available to this object before it starts processing data frames.

This transition also gives this object an opportunity to reserve any resources it will need to use during the subsequent ‘Process’ transitions.

inline virtual void Process()¶

SET_LOGGER ("TrashCan")

struct type_info_ptr_hash¶

Public Functions

inline size_t operator()(const std::type_info *p) const¶

struct typename_iterator : public typename_iterator_t ¶

#include <I3Frame.h>

Public Functions

inline typename_iterator(const map_t::const_iterator &iter)¶

struct typename_transform¶

#include <I3Frame.h>

Public Types

typedef std::pair<std::string, std::string> pair_t¶

typedef const pair_t &result_type¶

Public Functions

inline result_type operator()(map_t::const_reference pr) const¶

Public Members

mutable pair_t result¶

class TypenameCache¶

Public Functions

inline TypenameCache()¶: Default constructor.

inline ~TypenameCache()¶: Destructor.

inline const std::string &GetName(const std::type_info &ti)¶

Get a human-readable name for a type.

Todo:: Use a multiple-reader / single-write model. Does it work, if mixing boost threads and ZThread?

Note

…

Parameters:: ti – The type.
Returns:: The name.

Private Types

typedef hash_map<const std::type_info*, std::string, type_info_ptr_hash> typename_map_t¶

Private Functions

TypenameCache(const TypenameCache&)¶

TypenameCache &operator=(const TypenameCache&)¶

Private Members

boost::mutex mtx_¶

typename_map_t names_¶

Private Static Attributes

static const unsigned int N_BUCKETS = 1024¶

static const unsigned int HASH_MASK = N_BUCKETS - 1¶

static const char *TYPENAME_NOT_AVAILABLE = "N/A"¶

struct value_t¶

Public Members

blob_t blob¶

size_t size¶

I3FrameObjectConstPtr ptr¶

I3Frame::Stream stream¶

class Wrapper : public T¶

Public Functions

inline ~Wrapper()¶

Public Static Attributes

static bool m_is_destroyed = false¶

class zstd_compressor¶

#include <zstd_filter.hpp>

Public Types

using char_type = char¶

Public Functions

inline zstd_compressor(int compressionLevel)¶

inline zstd_compressor(const zstd_compressor &other)¶

inline zstd_compressor(zstd_compressor &&other)¶

~zstd_compressor() = default¶

zstd_compressor &operator=(const zstd_compressor&) = delete¶

inline zstd_compressor &operator=(zstd_compressor &&other)¶

template<typename Sink> inline std::streamsize write(Sink &dest, const char *src, std::streamsize n)¶

template<typename Sink> inline bool flush(Sink &dest)¶

template<typename Sink> inline void close(Sink &dest)¶

Private Functions

inline void initStream()¶

Private Members

std::unique_ptr<ZSTD_CStream, void (*)(ZSTD_CStream*)> cstream¶

int compressionLevel¶

bool streamInitialized¶

std::unique_ptr<char_type[]> ibuf¶

std::unique_ptr<char_type[]> obuf¶

std::size_t ibufSize¶

std::size_t ibufUsed¶

Private Static Functions

static inline void stream_delete(ZSTD_CStream *stream)¶

class zstd_decompressor : public multichar_input_filter¶

#include <zstd_filter.hpp>

Public Types

using char_type = char¶

Public Functions

inline zstd_decompressor()¶

inline zstd_decompressor(const zstd_decompressor &other)¶

inline zstd_decompressor(zstd_decompressor &&other)¶

~zstd_decompressor() = default¶

zstd_decompressor &operator=(const zstd_decompressor&) = delete¶

inline zstd_decompressor &operator=(zstd_decompressor &&other)¶

template<typename Source> inline std::streamsize read(Source &src, char_type *dest, std::streamsize n)¶

template<typename Source> inline void close(Source &src)¶

Private Functions

inline void initStream()¶

Private Members

std::unique_ptr<ZSTD_DStream, void (*)(ZSTD_DStream*)> dstream¶

bool streamInitialized¶

std::unique_ptr<char_type[]> ibuf¶

std::size_t ibufSize¶

ZSTD_inBuffer zibuf¶

bool inputEnd¶

Private Static Functions

static inline void stream_delete(ZSTD_DStream *stream)¶

namespace [anonymous]: Legacy Code: A “Frame Event”, such as Get, Put, Delete, Rename.

namespace [anonymous]

namespace [anonymous]¶

namespace [anonymous]¶

namespace [anonymous]¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

namespace [anonymous]¶

namespace has_operator¶

Type traits for detecting whether types can be used with particular operators.

Typedefs

typedef char yes¶

Functions

no operator<<(const anyx&, const anyx&)¶

template<class T> yes check(T const&)¶

no check(no)¶

namespace I3

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Functions

void init_icetray_lib()¶

Initialize the icetray library. This function will initialize Python, if not already done, and load the icetray module into it; this ensures that icetray code that interacts with python data structures will work correctly.

This function should be called near the beginning of any C++ program that uses libicetray. Python scripts don’t need to worry about this.

namespace dataio

Functions

std::string GetScratchDirectory()¶

Attempt to get a path to a directory where large temporary files can be written. The order of directories which will be tried is:

The path manually set by SetScratchDirectory
The value of the _CONDOR_SCRATCH_DIR environment variable, if set
The value of the TMPDIR environment variable, if set
/scratch/<real user name>
/global/scratch/<real user name>
The current working directory

The first directory which exists or can be created will be returned. That value will then be cached and returned on subsequent calls (so even if the current working directory was selected, calling chdir and then calling GetScratchDirectory again will continue to yield the original directory. However, directly calling SetScratchDirectory will replace the cached value, so users should not depend on the result of this function never changing.

void SetScratchDirectory(std::string path)¶

Manually set the path which should be returned by GetScratchDirectory. This makes most sense before the first call to GetScratchDirectory, but is not currently forbidden at later times.

Parameters:: path – the scratch directory path

void UnsetScratchDirectory()¶: Unsets any cached directory path, forcing the next call to GetScratchDirectory to recompute its value. This function is intended primarily for testing.

void open(io::filtering_istream &ifs, const std::string &filename)¶

void open(io::filtering_ostream &ofs, const std::string &filename, int compression_level, std::ios::openmode mode)¶

void open(boost::iostreams::filtering_istream&, const std::string &filename)¶

void open(boost::iostreams::filtering_ostream&, const std::string &filename, int compression_level_ = 0, std::ios::openmode mode = std::ios::binary)¶

Open an output file using compression if indicated by an extension on the file name.

Parameters:

filename – the path to which the file must be written
compression_level_ – the compression level to use if writing a compressed format. The default value of zero will be interpreted in a format dependent way, being replaced by: 6 for gzip (.gz) 6 for bzip2 (.bz2) 4 for zstd (.zst)
mode – the mode to use when writing

namespace [anonymous]¶

namespace detail

Functions

template<class T> inline void to_vector(const T &element, std::vector<char> &blobBuffer)¶

template<class T> inline void from_buffer(T &element, const char *buffer, std::size_t size)¶

template<> inline void to_vector(const I3Frame &element, std::vector<char> &blobBuffer)¶

template<> inline void from_buffer(I3Frame &element, const char *buffer, std::size_t size)¶

namespace I3Units

Unit definitions for the dataclasses.

The I3Units namespace contains a bunch of “static const double’s” which define the units that are used in the dataclasses. The header originally comes from Geant4, and wrapping it in and I3Units namespace is an IceCube modification.

The basic units are those of the International System:

meter

second

kilogram

ampere

kelvin

the amount of substance (mole)

luminous intensity (candela)

radian

steradian

The SI numerical value of the positron charge is defined here, as it is needed for conversion factor : positron charge = e_SI (coulomb)

This clearly needs more docs. In general, you want to “add units” when you store them in container, and “remove” them when you fetch them. This ensures that all data is stored uniformly. For example: double myvoltage = 45.00*I3UnitsV; myContainerPtr->SetVoltage(myvoltage);

….. readvoltage = myContainerPtr->GetVoltage()/I3UnitsV;

Variables

static const double meter = 1.¶: meter

static const double meter2 = meter * meter ¶: square meter

static const double meter3 = meter * meter * meter ¶: cubic meter

static const double millimeter = 0.001 * meter ¶: millimeter

static const double millimeter2 = millimeter * millimeter ¶: square millimeter

static const double millimeter3 = millimeter * millimeter * millimeter ¶: cubic millimeter

static const double centimeter = 10. * millimeter ¶: centimeter

static const double centimeter2 = centimeter * centimeter ¶: square centimeter

static const double centimeter3 = centimeter * centimeter * centimeter ¶: cubic centimeter

static const double kilometer = 1000. * meter ¶: kilometer

static const double kilometer2 = kilometer * kilometer ¶: square kilometer

static const double kilometer3 = kilometer * kilometer * kilometer ¶: cubic kilometer

static const double parsec = 3.0856775807e+16 * meter ¶: parsec

static const double micrometer = 1.e-6 * meter ¶: micrometer

static const double nanometer = 1.e-9 * meter ¶: nanometer

static const double angstrom = 1.e-10 * meter ¶: angstrom

static const double fermi = 1.e-15 * meter ¶: fermi

static const double barn = 1.e-28 * meter2 ¶: barn

static const double millibarn = 1.e-3 * barn ¶: millibarn

static const double microbarn = 1.e-6 * barn ¶: microbarn

static const double nanobarn = 1.e-9 * barn ¶: nanobarn

static const double picobarn = 1.e-12 * barn ¶: picobarn

static const double feet = 0.3048 * meter ¶: feet

static const double mm = millimeter ¶: millimeter

static const double mm2 = millimeter2 ¶: square millimeter

static const double mm3 = millimeter3 ¶: cubic millimeter

static const double cm = centimeter ¶: centimeter

static const double cm2 = centimeter2 ¶: square centimeter

static const double cm3 = centimeter3 ¶: cubic centimeter

static const double m = meter ¶: meter

static const double m2 = meter2 ¶: square meter

static const double m3 = meter3 ¶: cubic meter

static const double km = kilometer ¶: kilometer

static const double km2 = kilometer2 ¶: square kilometer

static const double km3 = kilometer3 ¶: cubic kilometer

static const double pc = parsec ¶: parsec

static const double ft = feet ¶: feet

static const double radian = 1.¶: radian

static const double milliradian = 1.e-3 * radian ¶: milliradian

static const double degree = (M_PI / 180.0) * radian ¶: degree

static const double steradian = 1.¶: steradian

static const double rad = radian ¶: radian

static const double mrad = milliradian ¶: milliradian

static const double sr = steradian ¶: steradian

static const double deg = degree ¶: degree

static const double second = 1.e9¶: second

static const double millisecond = 1.e-3 * second ¶: millisecond

static const double microsecond = 1.e-6 * second ¶: microsecond

static const double nanosecond = 1.e-9 * second ¶: nanosecond

static const double picosecond = 1.e-12 * second ¶: picosecond

static const double minute = 60 * second ¶: minute

static const double hour = 60 * minute ¶: hour

static const double day = 24 * hour ¶: day

static const double gregorianyear = 365.2425 * day ¶: Gregorian Year

static const double julianyear = 365.25 * day ¶: Julian Year

static const double hertz = 1. / second ¶: hertz

static const double kilohertz = 1.e+3 * hertz ¶: kilohertz

static const double megahertz = 1.e+6 * hertz ¶: megahertz

static const double ns = nanosecond ¶: nanosecond

static const double s = second ¶: second

static const double ms = millisecond ¶: millisecond

static const double electronvolt = 1.0e-9¶: eV

static const double kiloelectronvolt = 1.e+3 * electronvolt ¶: keV

static const double megaelectronvolt = 1.e+6 * electronvolt ¶: MeV

static const double gigaelectronvolt = 1.e+9 * electronvolt ¶: GeV

static const double teraelectronvolt = 1.e+12 * electronvolt ¶: TeV

static const double petaelectronvolt = 1.e+15 * electronvolt ¶: PeV

static const double MeV = megaelectronvolt ¶: MeV

static const double eV = electronvolt ¶: eV

static const double keV = kiloelectronvolt ¶: keV

static const double GeV = gigaelectronvolt ¶: GeV

static const double TeV = teraelectronvolt ¶: TeV

static const double PeV = petaelectronvolt ¶: PeV

static const double eplus = 1.¶: Charge

static const double eSI = 1.602176462e-19¶

static const double coulomb = eplus / eSI ¶: Coulomb

static const double C = coulomb ¶

static const double picocoulomb = 1.e-12 * coulomb ¶: Picocoulomb

static const double pC = picocoulomb ¶

static const double joule = electronvolt / eSI ¶: joule

static const double ampere = coulomb / second ¶

static const double A = ampere ¶

static const double milliampere = 1.e-3 * ampere ¶

static const double mA = milliampere ¶

static const double nanoampere = 1.e-9 * ampere ¶

static const double nA = nanoampere ¶

static const double millivolt = (electronvolt * 1.e-3) / eplus ¶: Millivolt

static const double mV = millivolt ¶

static const double volt = 1.e3 * millivolt ¶: Volt

static const double V = volt ¶

static const double microvolt = 1.e-6 * volt ¶: Microvolt

static const double kilovolt = 1.e3 * volt ¶: Kilovolt

static const double kV = kilovolt ¶

static const double statvolt = 299792458. / 1.e6 * volt ¶: Voltage in cgs is the statvolt. [statV] = c_light (in m/s) / 10^6 [Volt]

static const double watt = joule / second ¶: Watt

static const double milliwatt = 1.e-3 * watt ¶: Milliwatt

static const double mW = milliwatt ¶

static const double ohm = volt / ampere ¶: Ohm

static const double kelvin = 1.0¶: Kelvin

static const double kilogram = joule * second * second / (meter * meter)¶: Kilogram

static const double kg = kilogram ¶

static const double gram = 1.e-3 * kilogram ¶: Gram

static const double g = gram ¶

static const double milligram = 1.e-3 * gram ¶: Milligram

static const double mg = milligram ¶

static const double newton = joule / meter ¶: Force

static const double pascal = newton / (meter * meter)¶: Pressure

static const double bar = 1.e5 * pascal ¶

static const double millipascal = 1.e-3 * pascal ¶

static const double micropascal = 1.e-6 * pascal ¶

static const double nanopascal = 1.e-9 * pascal ¶

static const double tesla = volt * second / m2 ¶: Magnetic Field Strength

static const double Tesla = tesla ¶

static const double millitesla = 1.e-3 * tesla ¶

static const double mT = 1.e-3 * tesla ¶

static const double microtesla = 1.e-6 * tesla ¶

static const double uT = 1.e-6 * tesla ¶

static const double nanotesla = 1.e-9 * tesla ¶

static const double nT = 1.e-9 * tesla ¶

static const double perCent = 0.01¶: percent

static const double perThousand = 0.001¶: perThousand

static const double perMillion = 0.000001¶: perMillion

namespace icecube

namespace serialization

Functions

template<class Archive> void save(Archive &ar, const I3ConfigurationImpl::parameters_t &params, unsigned)¶

template<class Archive> void load(Archive &ar, I3ConfigurationImpl::parameters_t &params, unsigned)¶

namespace icetray¶

Functions

const std::string &name_of(const std::type_info &ti)¶

template<typename T> const std::string &name_of()¶

namespace detail¶

namespace python¶

namespace memory¶

Functions

void set_scope(std::string s)¶: Set the current scope (label).

namespace std: STL namespace.

file AddNulls.cxx

#include <icetray/Utility.h>

#include <icetray/I3Frame.h>

#include <icetray/I3ConditionalModule.h>

#include <string>

#include <vector>

Functions

I3_MODULE(AddNulls)¶

file AddNulls.h: #include <icetray/I3Module.h>

#include <string>

#include <vector>

file AllParametersModule.cxx

#include <icetray/I3Tray.h>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <icetray/OMKey.h>

#include <boost/assign/std/vector.hpp>

Functions

I3_MODULE(AllParametersModule)¶

Variables

static bool bool_param¶

static unsigned char uchar_param¶

static int int_param¶

static long long_param¶

static double double_param¶

static std::string string_param¶

static std::vector<int> intvec_param¶

static std::vector<double> doublevec_param¶

static std::vector<std::string> stringvec_param¶

static OMKey omkey_param¶

static std::vector<OMKey> omkeyvec_param¶

static boost::shared_ptr<MyService> service_ptr_param¶

file archive_filter.hpp

#include <boost/iostreams/filtering_stream.hpp>

#include <archive.h>

#include <archive_entry.h>

#include <boost/algorithm/string.hpp>

#include <icetray/I3Logging.h>

Defines

archive_read_free¶

Rcs: open.cxx 2595 2016-06-01 18:26:57Z cweaver

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

archive_read_support_filter_all¶

archive_read_support_filter_gzip¶

archive_read_support_filter_bzip2¶

archive_read_support_filter_lzma¶

archive_read_support_filter_xz¶

Enums

enum compression_type¶: Values:

file boost_serializable_pickle_suite.hpp: #include <vector>

#include “icetray/serialization.h”

#include “icetray/I3Frame.h”

#include <boost/iostreams/stream.hpp>

#include <boost/iostreams/device/array.hpp>

#include <boost/iostreams/device/back_inserter.hpp>

#include <boost/iostreams/copy.hpp>

#include <boost/iostreams/filtering_stream.hpp>

#include <boost/python/tuple.hpp>

#include <boost/python/str.hpp>

#include <boost/python/dict.hpp>

#include <boost/python/extract.hpp>

#include <boost/python/object/pickle_support.hpp>

file BottomlessSource.cxx

#include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

Functions

I3_MODULE(BottomlessSource)¶

file context_suite.hpp: #include <boost/python/def_visitor.hpp>

#include <icetray/I3Context.h>

#include <icetray/name_of.h>

file ContextFreeServiceTestModule.cxx

#include <icetray/I3Tray.h>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <icetray/OMKey.h>

#include <boost/assign/std/vector.hpp>

Functions

I3_MODULE(ContextFreeServiceTestModule)¶

Variables

static boost::shared_ptr<MyService> service_ptr_param

file Copy.cxx

#include <boost/regex.hpp>

#include <fstream>

#include <string>

#include <set>

#include “icetray/I3Tray.h”

#include “icetray/I3TrayInfo.h”

#include “icetray/I3TrayInfoService.h”

#include “icetray/Utility.h”

#include “icetray/I3ConditionalModule.h”

#include “icetray/I3TrayHeaders.h”

#include “icetray/I3Logging.h”

Functions

I3_MODULE(Copy)¶

file copy_suite.hpp: #include <stdint.h>

#include <boost/python/object.hpp>

#include <boost/python/dict.hpp>

#include <boost/python/init.hpp>

#include <boost/python/extract.hpp>

#include <boost/python/import.hpp>

#include <boost/python/manage_new_object.hpp>

#include <boost/python/def_visitor.hpp>

file counter64.hpp: #include <algorithm>

#include <boost/iostreams/categories.hpp>

#include <boost/iostreams/char_traits.hpp>

#include <boost/iostreams/operations.hpp>

#include <boost/iostreams/pipeline.hpp>

#include <boost/iostreams/detail/config/disable_warnings.hpp>

#include <boost/iostreams/detail/config/enable_warnings.hpp>

file CountFrames.cxx

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3Frame.h>

#include <icetray/Utility.h>

#include <map>

#include <boost/assign/list_inserter.hpp>

Functions

I3_MODULE(CountFrames)¶

file CountObject.cxx

#include “icetray/modules/CountObject.h”

#include “icetray/Utility.h”

#include “icetray/I3Frame.h”

#include <boost/assign/list_inserter.hpp>

#include <boost/foreach.hpp>

Functions

I3_MODULE(CountObject)¶

file CountObject.h: #include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

#include <map>

file crc-ccitt.h

Functions

static inline uint16_t crc_ccitt_byte(uint16_t crc, const uint8_t c)¶

static inline uint16_t crc_ccitt(uint16_t crc, uint8_t const *buffer, size_t len)¶

Variables

uint16_t const crc_ccitt_table[256]¶

file CreateBlobs.cxx

#include <iostream>

#include <icetray/I3Context.h>

#include <icetray/I3Frame.h>

#include <icetray/I3ConditionalModule.h>

Functions

I3_MODULE(CreateBlobs)¶

file dataclass_suite.hpp

#include <typeinfo>

#include <boost/python/def_visitor.hpp>

#include <icetray/has_operator.h>

#include <icetray/python/copy_suite.hpp>

#include <icetray/python/stream_to_string.hpp>

#include <icetray/python/boost_serializable_pickle_suite.hpp>

#include <icetray/python/std_map_indexing_suite.hpp>

#include <icetray/python/list_indexing_suite.hpp>

#include <icetray/python/tree_indexing_suite.hpp>

#include <icetray/python/operator_suite.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/mpl/if.hpp>

#include <boost/mpl/or.hpp>

#include <boost/static_assert.hpp>

#include <boost/typeof/typeof.hpp>

Defines

HAS_TYPEDEF(def, name)¶

file Delete.cxx

#include <string>

#include <vector>

#include <boost/algorithm/string.hpp>

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3TrayHeaders.h>

Functions

I3_MODULE(Delete)¶

file Dump.cxx

#include <iostream>

#include <icetray/I3Context.h>

#include <icetray/I3Frame.h>

#include <icetray/I3ConditionalModule.h>

Functions

I3_MODULE(Dump)¶

file Fork.cxx

#include <icetray/I3Module.h>

#include <icetray/Utility.h>

#include <icetray/I3Frame.h>

#include <string>

#include <set>

Functions

I3_MODULE(Fork)¶

file FrameCheck.cxx

#include “icetray/modules/FrameCheck.h”

#include “icetray/Utility.h”

#include “icetray/I3Frame.h”

#include <boost/assign/list_inserter.hpp>

#include <boost/foreach.hpp>

Functions

I3_MODULE(FrameCheck)¶

file FrameCheck.h: #include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

#include <map>

file function.hpp

#include <boost/python.hpp>

#include <boost/function.hpp>

#include <boost/preprocessor/repetition/enum_binary_params.hpp>

#include <boost/preprocessor/repetition/enum_params.hpp>

#include <boost/preprocessor/repetition/repeat.hpp>

#include <boost/preprocessor/repetition/repeat_from_to.hpp>

Defines

MAKE_PYOBJECT_INVOKER(z, n, data)¶

file FunctionModule.cxx: #include “FunctionModule.h”

file FunctionModule.h: #include <set>

#include <functional>

#include <icetray/I3ConditionalModule.h>

file Get.cxx

#include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

#include <boost/foreach.hpp>

#include <vector>

#include <string>

Functions

I3_MODULE(Get)¶

file get_class.hpp: #include “pybindings.hpp”

#include <boost/python/converter/registry.hpp>

#include <set>

file gil_holder.hpp: #include “pybindings.hpp”

file has_operator.h

file http_source.cpp

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <boost/asio.hpp>

#include <boost/iostreams/filtering_stream.hpp>

#include <boost/algorithm/string.hpp>

#include <archive/iterators/base64_from_binary.hpp>

#include <archive/iterators/transform_width.hpp>

#include <icetray/I3Logging.h>

#include “http_source.hpp”

Functions

std::string base64_encode(std::string::const_iterator begin, std::string::const_iterator &end)¶

Variables

const std::string base64_padding[] = {"", "==", "="}¶

file http_source.hpp: #include <boost/asio.hpp>

file i3_extended_type_info.h

#include <cstring>

#include <cassert>

#include <serialization/extended_type_info_typeid.hpp>

Defines

I3_SERIALIZATION_DEFAULT_TYPE_INFO¶

$Id$

(C) Copyright 2002 Robert Ramey - http://www.rrsd.com . SPDX-License-Identifier: BSL-1.0 Use, modification and distribution is subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

See http://www.boost.org for updates, documentation, and revision history.

I3_SERIALIZATION_DEFAULT_TYPE_INFO

$Id$

(C) Copyright 2002 Robert Ramey - http://www.rrsd.com . SPDX-License-Identifier: BSL-1.0 Use, modification and distribution is subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

See http://www.boost.org for updates, documentation, and revision history.

file I3Bool.cxx

#include <icetray/serialization.h>

#include <icetray/I3Bool.h>

Functions

I3_SERIALIZABLE(I3Bool)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

file I3Bool.h

#include <icetray/I3DefaultName.h>

#include <icetray/I3PODHolder.h>

Typedefs

typedef I3PODHolder<bool> I3Bool¶

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Functions

I3_POINTER_TYPEDEFS(I3Bool)¶

I3_DEFAULT_NAME(I3Bool)¶

file I3ConditionalModule.cxx: #include “icetray/I3ConditionalModule.h”

#include “icetray/I3Context.h”

#include “icetray/impl.h”

file I3ConditionalModule.h: #include “icetray/I3Module.h”

#include “icetray/I3IcePick.h”

file I3Configuration.cxx

#include <icetray/I3Logging.h>

#include <icetray/I3Configuration.h>

#include <icetray/I3ConfigurationImpl.h>

#include <icetray/serialization.h>

#include <serialization/scoped_ptr.hpp>

#include <icetray/Utility.h>

#include <boost/preprocessor.hpp>

#include <algorithm>

#include <cctype>

#include <boost/python/object.hpp>

#include <boost/foreach.hpp>

#include <iomanip>

Functions

I3_BASIC_SERIALIZABLE(I3Configuration)¶

ostream &operator<<(ostream &os, const I3Configuration &config)¶

file I3Configuration.h

#include <string>

#include <map>

#include <iosfwd>

#include <boost/scoped_ptr.hpp>

#include <icetray/IcetrayFwd.h>

#include <icetray/I3DefaultName.h>

#include <icetray/serialization.h>

#include <icetray/is_shared_ptr.h>

#include <boost/python/extract.hpp>

Functions

std::ostream &operator<<(std::ostream&, const I3Configuration&)¶

I3_DEFAULT_NAME(I3Configuration)¶

I3_POINTER_TYPEDEFS(I3Configuration)¶

file I3ConfigurationImpl.cxx

#include <icetray/I3Logging.h>

#include <icetray/I3ConfigurationImpl.h>

#include <I3/name_of.h>

#include <icetray/serialization.h>

#include <icetray/I3Parameter.h>

#include <icetray/Utility.h>

#include <boost/preprocessor.hpp>

#include <algorithm>

#include <cctype>

#include <boost/multi_index_container.hpp>

#include <boost/multi_index/ordered_index.hpp>

#include <boost/python.hpp>

#include <boost/python/object.hpp>

#include <boost/foreach.hpp>

#include <serialization/split_free.hpp>

#include <iomanip>

Functions

I3_SERIALIZATION_SPLIT_FREE(I3ConfigurationImpl::parameters_t)¶

I3_BASIC_SERIALIZABLE(I3ConfigurationImpl)¶

ostream &operator<<(ostream &os, const I3ConfigurationImpl &config)¶

file I3ConfigurationImpl.h

#include <string>

#include <map>

#include <set>

#include <algorithm>

#include <icetray/IcetrayFwd.h>

#include <icetray/I3DefaultName.h>

#include <icetray/I3Parameter.h>

#include <icetray/serialization.h>

#include <iosfwd>

#include <boost/multi_index_container_fwd.hpp>

#include <boost/multi_index/ordered_index_fwd.hpp>

#include <boost/multi_index/mem_fun.hpp>

Functions

std::ostream &operator<<(std::ostream&, const I3ConfigurationImpl&)¶

I3_POINTER_TYPEDEFS(I3ConfigurationImpl)¶

I3_CLASS_VERSION (I3ConfigurationImpl, 2)

file I3Context.cxx: #include <icetray/I3Module.h>

#include <icetray/I3Context.h>

file I3Context.h

#include <string>

#include <vector>

#include <icetray/IcetrayFwd.h>

#include <icetray/I3Logging.h>

#include <icetray/I3DefaultName.h>

#include <icetray/is_shared_ptr.h>

#include <I3/name_of.h>

#include <I3/hash_map.h>

#include <boost/any.hpp>

#include <boost/python.hpp>

#include <boost/utility/enable_if.hpp>

Typedefs

typedef boost::shared_ptr<I3Context> I3ContextPtr¶

typedef boost::shared_ptr<const I3Context> I3ContextConstPtr¶

file I3DefaultName.h

#include <boost/shared_ptr.hpp>

#include <boost/preprocessor/stringize.hpp>

Defines

I3_DEFAULT_NAME(TYPE)¶

file I3Factory.h

#include <icetray/Singleton.h>

#include <icetray/I3TrayInfo.h>

#include <icetray/I3Module.h>

#include <icetray/I3Logging.h>

#include <boost/function.hpp>

#include <map>

#include <boost/preprocessor/stringize.hpp>

#include <boost/utility.hpp>

Defines

I3_REGISTER(PRODUCT, TYPE, CREATOR)¶

I3_MODULE(TYPE)¶

I3_SERVICE_FACTORY(TYPE)¶

Typedefs

boost::function< boost::shared_ptr< I3Module >const I3Context &)> I3Module_ffn_t

boost::function< boost::shared_ptr< I3ServiceFactory >const I3Context &)> I3ServiceFactory_ffn_t

typedef I3Factory<I3Module, I3Module_ffn_t> I3ModuleFactory¶

typedef I3Factory<I3ServiceFactory, I3ServiceFactory_ffn_t> I3ServiceFactoryFactory¶

file I3FileLogger.cxx: #include <icetray/I3SimpleLoggers.h>

file I3Frame.cxx

#include <algorithm>

#include <fstream>

#include <boost/iostreams/stream.hpp>

#include <boost/iostreams/device/array.hpp>

#include <boost/iostreams/device/back_inserter.hpp>

#include <boost/iostreams/copy.hpp>

#include <boost/iostreams/filtering_stream.hpp>

#include <boost/interprocess/streams/bufferstream.hpp>

#include <boost/interprocess/streams/vectorstream.hpp>

#include <boost/foreach.hpp>

#include <boost/regex.hpp>

#include <boost/format.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/is_pod.hpp>

#include <icetray/serialization.h>

#include <icetray/Utility.h>

#include <icetray/I3Frame.h>

#include “crc-ccitt.h”

Typedefs

typedef uint64_t i3frame_size_t¶

typedef uint32_t i3frame_checksum_t¶

typedef uint32_t i3frame_version_t¶

typedef uint32_t i3frame_nslots_t¶

typedef char i3frame_tag_t[4]¶

Functions

I3_BASIC_SERIALIZABLE(I3Frame::Stream)¶

unsigned long crc32c(unsigned long crc, const uint8_t *buf, unsigned int len)¶

ostream &operator<<(ostream &os, const I3Frame::Stream &stream)¶

ostream &operator<<(ostream &os, const I3Frame &frame)¶

Variables

static const i3frame_tag_t tag = {'[', 'i', '3', ']'}¶

static const i3frame_version_t version = 6¶

file I3Frame.h

#include <deque>

#include <string>

#include <vector>

#include <I3/hash_map.h>

#include <stdint.h>

#include <boost/iterator/transform_iterator.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/is_const.hpp>

#include “icetray/serialization.h”

#include <icetray/I3DefaultName.h>

#include <icetray/I3FrameObject.h>

#include <icetray/I3Logging.h>

#include <icetray/IcetrayFwd.h>

#include <icetray/is_shared_ptr.h>

#include <I3/name_of.h>

Typedefs

typedef std::deque<I3FramePtr> FrameFifo¶

Functions

std::ostream &operator<<(std::ostream &os, const I3Frame::Stream &stream)¶

std::ostream &operator<<(std::ostream &os, const I3Frame &frame)¶

I3_POINTER_TYPEDEFS(I3Frame)¶

I3_POINTER_TYPEDEFS(FrameFifo)¶

file I3FrameMixing.cxx: #include “icetray/I3FrameMixing.h”

#include <boost/make_shared.hpp>

file I3FrameMixing.h: #include <boost/optional.hpp>

#include “icetray/I3Frame.h”

file I3FrameObject.cxx

#include <icetray/serialization.h>

#include <icetray/I3FrameObject.h>

#include <icetray/Utility.h>

#include <cxxabi.h>

Functions

I3_BASIC_SERIALIZABLE(I3FrameObject)¶

I3_SERIALIZATION_SHARED_PTR(I3FrameObject)¶

file I3FrameObject.h

#include <icetray/I3PointerTypedefs.h>

Functions

I3_POINTER_TYPEDEFS(I3FrameObject)¶

file I3IcePick.cxx: #include <icetray/I3IcePick.h>

#include <icetray/I3Bool.h>

file I3IcePick.h

#include <icetray/I3Context.h>

#include <icetray/I3Configuration.h>

#include <icetray/I3ServiceBase.h>

#include <icetray/I3Frame.h>

#include <boost/python.hpp>

Functions

I3_POINTER_TYPEDEFS(I3IcePick)¶

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

#include <icetray/I3IcePick.h>

file I3Int.cxx

#include <icetray/I3Int.h>

Functions

I3_SERIALIZABLE(I3Int)¶

file I3Int.h

#include <icetray/I3DefaultName.h>

#include <icetray/I3PODHolder.h>

Typedefs

typedef I3PODHolder<int> I3Int¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Functions

I3_POINTER_TYPEDEFS(I3Int)¶

I3_DEFAULT_NAME(I3Int)¶

file I3Logging.cxx

#include <cstdio>

#include <cstdarg>

#include “icetray/I3Logging.h”

#include “icetray/I3SimpleLoggers.h”

Functions

I3LoggerPtr GetIcetrayLogger()¶

void SetIcetrayLogger(I3LoggerPtr logger)¶

std::string I3LoggingStringF(const char *format, ...)¶

void i3_clogger(I3LogLevel level, const char *unit, const char *file, int line, const char *func, const char *format, ...)¶

Variables

static I3LoggerPtr icetray_global_logger¶

file I3Logging.h

#include <signal.h>

Defines

I3_LOGGER¶

SET_LOGGER(X)¶

log_custom(level, format, ...)¶

log_custom_unit(level, unit, format, ...)¶

log_trace(format, ...)¶

log_debug(format, ...)¶

log_info(format, ...)¶

log_notice(format, ...)¶

log_warn(format, ...)¶

log_error(format, ...)¶

log_fatal(format, ...)¶

i3_assert(cond)¶

i3_debug_assert(cond)¶

Enums

enum I3LogLevel¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Values:

enumerator I3LOG_TRACE¶

enumerator I3LOG_DEBUG¶

enumerator I3LOG_INFO¶

enumerator I3LOG_NOTICE¶

enumerator I3LOG_WARN¶

enumerator I3LOG_ERROR¶

enumerator I3LOG_FATAL¶

Functions

void i3_clogger (I3LogLevel level, const char *unit, const char *file, int line, const char *func, const char *format,...) __attribute__((__format__(__printf__

SET_LOGGER ("Unknown")

file I3Module.cxx: #include “icetray/I3Module.h”

#include <sys/time.h>

#include <sys/resource.h>

#include <boost/bind.hpp>

#include <boost/preprocessor.hpp>

#include <boost/foreach.hpp>

#include <boost/python.hpp>

#include <boost/make_shared.hpp>

#include “icetray/I3TrayInfo.h”

#include “icetray/I3Context.h”

#include “icetray/I3Tray.h”

#include “icetray/I3PhysicsUsage.h”

#include “icetray/IcetrayFwd.h”

#include “icetray/I3Frame.h”

#include “icetray/I3FrameMixing.h”

#include “icetray/impl.h”

file I3Module.h

#include <cstdlib>

#include <string>

#include <set>

#include <icetray/Version.h>

#include <icetray/I3Logging.h>

#include <icetray/I3Context.h>

#include <icetray/I3PointerTypedefs.h>

#include <icetray/I3Frame.h>

#include <icetray/I3Configuration.h>

#include <icetray/I3PhysicsUsage.h>

#include <boost/type_traits/is_const.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/python/object.hpp>

#include <boost/python/extract.hpp>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include “icetray/I3Factory.h”

Functions

I3_POINTER_TYPEDEFS(I3Module)¶

file I3PacketModule.cxx: #include <icetray/I3PacketModule.h>

#include <boost/foreach.hpp>

file I3PacketModule.h: #include <icetray/I3Module.h>

#include <vector>

file I3Parameter.cxx

#include <I3/name_of.h>

#include <icetray/I3Parameter.h>

#include <icetray/serialization.h>

#include <icetray/Utility.h>

#include <serialization/optional.hpp>

#include <boost/python.hpp>

#include <boost/python/extract.hpp>

#include <icetray/impl.h>

#include <boost/numeric/conversion/cast.hpp>

#include <boost/mpl/and.hpp>

#include <boost/mpl/logical.hpp>

Functions

template<typename Archive> static void save_python(Archive &ar, boost::optional<boost::python::object> &obj)¶

I3_BASIC_SERIALIZABLE(I3Parameter)¶

ostream &operator<<(ostream &os, const I3Parameter &pb)¶

file I3Parameter.h

#include <icetray/IcetrayFwd.h>

#include <boost/python/object.hpp>

#include <boost/optional.hpp>

#include <string>

#include <icetray/serialization.h>

Functions

std::ostream &operator<<(std::ostream&, const I3Parameter&)¶

file I3PhysicsTimer.cxx

#include <icetray/serialization.h>

#include <icetray/I3PhysicsTimer.h>

#include <icetray/I3Units.h>

#include <icetray/I3Frame.h>

Functions

I3_SERIALIZABLE(I3RUsage)¶

file I3PhysicsTimer.h

#include <sys/time.h>

#include <sys/resource.h>

#include <string>

#include <icetray/I3Frame.h>

#include <icetray/I3PointerTypedefs.h>

Functions

I3_POINTER_TYPEDEFS(I3RUsage)¶

file I3PhysicsUsage.cxx

#include <icetray/I3PhysicsUsage.h>

#include <ostream>

Functions

std::ostream &operator<<(std::ostream &os, const I3PhysicsUsage &ru)¶

file I3PhysicsUsage.h

#include <string>

#include <icetray/I3PointerTypedefs.h>

Functions

std::ostream &operator<<(std::ostream &os, const I3PhysicsUsage &ru)

I3_POINTER_TYPEDEFS(I3PhysicsUsage)¶

file I3PODHolder.h

#include <boost/preprocessor/seq/for_each.hpp>

#include <icetray/IcetrayFwd.h>

#include <icetray/I3FrameObject.h>

#include <icetray/serialization.h>

Defines

REGISTER_PODHOLDER_OPERATORS(r, data, OP)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

Functions

template<typename T> std::ostream &operator<<(std::ostream &os, const I3PODHolder<T> &t)¶

file I3PointerTypedefs.h

#include <boost/shared_ptr.hpp>

Defines

I3_POINTER_TYPEDEFS(C)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

I3_FORWARD_DECLARATION(C)¶

file I3PrintfLogger.cxx: #include <cstdio>

#include <icetray/I3Logging.h>

#include <icetray/I3SimpleLoggers.h>

file I3ServiceBase.h: #include “icetray/I3Context.h”

#include “icetray/I3Configuration.h”

file I3ServiceFactory.cxx: #include “icetray/I3ServiceFactory.h”

file I3ServiceFactory.h

#include <icetray/I3Context.h>

#include <icetray/I3Configuration.h>

#include <boost/python/object.hpp>

#include <boost/python/extract.hpp>

#include <string>

#include <icetray/I3Factory.h>

Typedefs

typedef boost::shared_ptr<I3ServiceFactory> I3ServiceFactoryPtr¶

file I3SimpleLoggers.h: #include <stdexcept>

#include <fstream>

#include <icetray/I3Logging.h>

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

#include <string>

file I3SyslogLogger.cxx

#include <syslog.h>

#include <cstdio>

#include <boost/filesystem/path.hpp>

#include “icetray/I3Logging.h”

#include “icetray/I3SimpleLoggers.h”

Version: $Revision$
Date: $Date$
Author: tschmidt

file I3Tray.cxx

#include <signal.h>

#include <string>

#include <map>

#include <iostream>

#include <exception>

#include <deque>

#include <boost/python.hpp>

#include <boost/foreach.hpp>

#include <boost/make_shared.hpp>

#include <icetray/I3Tray.h>

#include <icetray/I3TrayInfoService.h>

#include <icetray/I3Module.h>

#include <icetray/I3Context.h>

#include <icetray/I3Frame.h>

#include <icetray/I3PhysicsUsage.h>

#include <icetray/serialization.h>

#include “PythonFunction.h”

#include “FunctionModule.h”

Functions

void noOpDeleter(I3Tray*)¶

std::ostream &operator<<(std::ostream &os, I3Tray &tray)¶

Variables

I3Tray *executing_tray = NULL¶

file I3Tray.h

#include <signal.h>

#include <map>

#include <string>

#include <exception>

#include <functional>

#include <iostream>

#include <icetray/IcetrayFwd.h>

#include <icetray/I3Configuration.h>

#include <icetray/I3TrayInfo.h>

#include <icetray/I3Module.h>

#include <icetray/I3Context.h>

#include <icetray/init.h>

#include <icetray/is_shared_ptr.h>

#include <boost/mpl/or.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/utility/result_of.hpp>

#include <boost/type_traits/is_base_of.hpp>

Functions

std::ostream &operator<<(std::ostream &os, I3Tray &tray)

file I3TrayHeaders.h: #include <icetray/I3Frame.h>

#include <icetray/I3Context.h>

#include <icetray/I3Logging.h>

#include <icetray/I3Configuration.h>

#include <icetray/I3DefaultName.h>

file I3TrayInfo.cxx

#include <icetray/I3TrayInfo.h>

#include <icetray/impl.h>

Functions

template<typename K, typename V, typename K2> const V &at(const map<K, V> &m, const K2 &k)¶

ostream &operator<<(ostream &os, const I3TrayInfo &config)¶

I3_SERIALIZABLE(I3TrayInfo)¶

file I3TrayInfo.h

#include <map>

#include <string>

#include <iostream>

#include <sstream>

#include <vector>

#include <icetray/I3Configuration.h>

#include <icetray/I3FrameObject.h>

Functions

std::ostream &operator<<(std::ostream &os, const I3TrayInfo &config)¶

I3_DEFAULT_NAME(I3TrayInfo)¶

I3_POINTER_TYPEDEFS(I3TrayInfo)¶

I3_CLASS_VERSION (I3TrayInfo, 2)

file I3TrayInfoService.cxx

#include <icetray/serialization.h>

#include <icetray/I3Logging.h>

#include <icetray/I3Tray.h>

#include <icetray/I3TrayInfoService.h>

#include <icetray/I3TrayInfo.h>

#include <icetray/I3Factory.h>

#include <sys/types.h>

#include <limits.h>

#include <unistd.h>

#include <pwd.h>

#include <time.h>

Functions

template<class T> static std::map<std::string, I3ConfigurationPtr> get_configs(const T &from)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

file I3TrayInfoService.h: #include <icetray/I3ServiceFactory.h>

file I3Units.h: #include <cmath>

file IcetrayFwd.h

#include <stdint.h>

#include <icetray/I3Logging.h>

#include <icetray/I3PointerTypedefs.h>

Functions

I3_POINTER_TYPEDEFS(I3Module)

I3_POINTER_TYPEDEFS(I3Context)¶

I3_POINTER_TYPEDEFS(I3ServiceFactory)¶

I3_POINTER_TYPEDEFS(I3Configuration)

I3_POINTER_TYPEDEFS(I3Frame)

file impl.h

#include <boost/python.hpp>

#include <icetray/I3Logging.h>

Defines

i3_log(format, ...)¶

Functions

inline std::string repr(const boost::python::object &obj)¶

file indexed_property.hpp: #include <boost/python/def_visitor.hpp>

#include <boost/python/scope.hpp>

#include <boost/python/signature.hpp>

#include <boost/mpl/at.hpp>

#include <boost/mpl/size.hpp>

#include <boost/mpl/pop_front.hpp>

#include <boost/mpl/less.hpp>

#include <boost/mpl/greater.hpp>

#include <boost/mpl/begin_end.hpp>

#include <boost/mpl/advance.hpp>

#include <boost/mpl/push_back.hpp>

#include <boost/mpl/vector.hpp>

#include <boost/mpl/for_each.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/type_traits/is_same.hpp>

#include “pybindings.hpp”

#include <icetray/python/get_class.hpp>

file init.cxx: #include <boost/python.hpp>

#include <icetray/init.h>

file init.h

file IntGenerator.cxx

#include <icetray/I3Int.h>

#include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

Functions

I3_MODULE(IntGenerator)¶

file is_shared_ptr.h: #include <boost/mpl/bool.hpp>

file Keep.cxx

#include <icetray/modules/Keep.h>

#include <boost/algorithm/string.hpp>

#include <icetray/I3Context.h>

#include <icetray/I3DefaultName.h>

Functions

I3_MODULE(Keep)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

file Keep.h: #include <set>

#include <string>

#include <vector>

#include <icetray/I3Frame.h>

#include <icetray/I3Logging.h>

#include <icetray/I3ConditionalModule.h>

file list_indexing_suite.hpp: #include <boost/python/suite/indexing/indexing_suite.hpp>

#include <boost/python/suite/indexing/container_utils.hpp>

#include <boost/python/iterator.hpp>

#include <boost/next_prior.hpp>

#include “pybindings.hpp”

#include <icetray/python/get_class.hpp>

#include <type_traits>

file load_project.cxx

#include <dlfcn.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <stdexcept>

#include <cstdlib>

#include <boost/filesystem.hpp>

Functions

void load_icecube_library(const std::string &project_name)¶

Dynamically load an icetray project.

This takes the project_name…and when I say project name, I mean PROJECT NAME…it’s the name of the project, not the library. There’s no ‘.so’ suffix nor is there a ‘lib’ prefix, unless that’s actually part of the project’s name. For example, if the project name is ‘librarians_rock’ then it’s entirely appropriate to look for and load the library called liblibrarians_rock.so (on linux).

int load_project(std::string path, bool verbose)¶: This should typically just thunk to ‘load_icecube_library’ but has two functions: 1) Maintain the interface, so no downstream code has to change. 2) Provide functionality for any projects out there that might be constructing their own paths and using this function to dynamically load a (possibly) non-IceCube project.

file load_project.h

#include <string>

Functions

void load_icecube_library(const std::string &project_name)

Dynamically load an icetray project.

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

This takes the project_name…and when I say project name, I mean PROJECT NAME…it’s the name of the project, not the library. There’s no ‘.so’ suffix nor is there a ‘lib’ prefix, unless that’s actually part of the project’s name. For example, if the project name is ‘librarians_rock’ then it’s entirely appropriate to look for and load the library called liblibrarians_rock.so (on linux).

Parameters:: project_name – The name of the project to be loaded.
Throws:: std::runtime_error – if loading does not succeed

int load_project(std::string project_name, __attribute__((unused)) bool verbose = false)

Dynamically load an icetray project.

Parameters:

project_name – the name of the project to be loaded. No filename extension should be included, and the ‘lib’ prefix is optional.
verbose – unused

Throws:

std::runtime_error – if loading does not succeed

Returns:

0 on success

file LoggingExampleModule.cxx

#include <iostream>

#include <icetray/I3Module.h>

#include <icetray/I3Logging.h>

Functions

I3_MODULE(LoggingExampleModule)¶

file MaintainInitialValuesModule.cxx

#include <icetray/I3Tray.h>

#include <icetray/I3Frame.h>

#include <icetray/I3Module.h>

#include <icetray/OMKey.h>

#include <boost/assign/std/vector.hpp>

Functions

I3_MODULE(MaintainInitialValuesModule)¶

Variables

static bool bool_param

static unsigned char uchar_param

static int int_param

static long long_param

static double double_param

static std::string string_param

static OMKey omkey_param

file ManyStreamsSource.cxx

#include <icetray/I3Module.h>

#include <icetray/I3Frame.h>

Functions

I3_MODULE(ManyStreamsSource)¶

file memory.cxx: #include <string>

#include “icetray/memory.h”

file memory.h: #include <string>

file name_of.cxx: #include <icetray/name_of.h>

#include <cxxabi.h>

#include <boost/thread/locks.hpp>

#include <boost/thread/mutex.hpp>

#include <I3/hash_map.h>

#include <icetray/Utility.h>

file name_of.h: #include <string>

#include <typeinfo>

file OMKey.cxx

#include <icetray/serialization.h>

#include <icetray/OMKey.h>

#include <sstream>

#include <icetray/I3FrameObject.h>

#include <boost/regex.hpp>

#include <boost/lexical_cast.hpp>

Functions

I3_SPLIT_SERIALIZABLE(OMKey)¶

ostream &operator<<(ostream &os, const OMKey &key)¶: streams an OMKey to an arbitrary ostream. These are important, the tray uses these conversion internally.

istream &operator>>(istream &is, OMKey &key)¶

file OMKey.h

#include <utility>

#include “Utility.h”

#include <iostream>

#include <icetray/IcetrayFwd.h>

#include <icetray/serialization.h>

Functions

I3_CLASS_VERSION(OMKey, omkey_version_)¶

inline bool operator<(const OMKey &lhs, const OMKey &rhs)¶

comparison operator. First compares the string numbers, then compares the om numbers. Required to put OMKeys as the key of a map

Parameters:

lhs – the left-hand OMKey
rhs – the right-hand OMKey

Returns:

true if the lhs should be ordered before the rhs

std::ostream &operator<<(std::ostream&, const OMKey &key)¶: streams an OMKey to an arbitrary ostream. These are important, the tray uses these conversion internally.

std::istream &operator>>(std::istream&, OMKey&)¶

I3_POINTER_TYPEDEFS(OMKey)¶

Variables

static const unsigned omkey_version_ = 2¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

file open.cxx

#include <string>

#include <boost/iostreams/filtering_stream.hpp>

#include <boost/iostreams/filter/gzip.hpp>

#include <boost/iostreams/filter/bzip2.hpp>

#include <boost/iostreams/constants.hpp>

#include <boost/iostreams/categories.hpp>

#include <boost/iostreams/device/file.hpp>

#include <boost/iostreams/device/file_descriptor.hpp>

#include <boost/algorithm/string.hpp>

#include <icetray/I3Logging.h>

#include <icetray/counter64.hpp>

#include “http_source.hpp”

#include “socket_source.hpp”

Variables

const auto ARCHIVE_FILES = std::vector<std::string>({".tar", ".tar.gz", ".tgz", ".tar.bz2", ".tbz2", ".tar.zst", ".tzst", ".pax.gz", ".pax.bz2", ".pax.zstd", ".cpio.gz", ".cpio.bz2", ".cpio.zstd"})¶

file open.h: #include <string>

#include <boost/iostreams/filtering_stream.hpp>

file operator_suite.hpp

#include <boost/preprocessor/cat.hpp>

#include <boost/python/def_visitor.hpp>

#include <boost/python/operators.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/is_enum.hpp>

#include <boost/mpl/if.hpp>

#include <boost/mpl/not.hpp>

#include <boost/mpl/or.hpp>

#include <boost/mpl/and.hpp>

#include “pybindings.hpp”

Defines

BASIC_TYPES¶

SPECIALIZE_TYPE(r, data, type)¶

HAS_OPERATOR(func, ret, name)¶

LIST_OF_OPERATORS¶

MAP_OF_OPERATORS(T)¶

OPERATOR_CALL(r, data, OP)¶

OPERATOR_DEF(r, data, OP)¶

OPERATOR_TYPE_SUITE(NAME, TYPE)¶

file ostream_pair.hpp

#include <iostream>

Functions

template<typename T, typename U> std::ostream &operator<<(std::ostream &oss, std::pair<T, U> p)¶

file PhysicsBuffer.cxx

#include <icetray/modules/PhysicsBuffer.h>

#include <icetray/Utility.h>

Functions

I3_MODULE(PhysicsBuffer)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

file PhysicsBuffer.h: #include <icetray/I3Module.h>

#include <string>

#include <deque>

file PythonFunction.cxx: #include “PythonFunction.h”

file PythonFunction.h: #include <iostream>

#include <set>

#include <icetray/I3Context.h>

#include <icetray/I3Frame.h>

#include <icetray/I3ConditionalModule.h>

#include <icetray/impl.h>

#include <boost/python.hpp>

#include <boost/python/raw_function.hpp>

file PythonModule.cxx: #include <vector>

#include <icetray/I3Module.h>

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3PacketModule.h>

#include <icetray/I3Logging.h>

#include <icetray/I3TrayHeaders.h>

#include <icetray/OMKey.h>

#include <icetray/PythonModule.h>

#include <icetray/impl.h>

#include <boost/python/import.hpp>

file PythonModule.h: #include <vector>

#include <icetray/I3Module.h>

#include <icetray/I3Logging.h>

#include <icetray/I3TrayHeaders.h>

#include <icetray/OMKey.h>

#include <boost/python.hpp>

file Rename.cxx

#include <boost/regex.hpp>

#include <icetray/I3Tray.h>

#include <icetray/I3TrayInfo.h>

#include <icetray/I3TrayInfoService.h>

#include <icetray/Utility.h>

#include <icetray/modules/Rename.h>

Functions

I3_MODULE(Rename)¶

file Rename.h: #include <fstream>

#include <string>

#include <set>

#include <icetray/I3ConditionalModule.h>

#include <icetray/I3TrayHeaders.h>

#include <icetray/I3Logging.h>

file scratch.cxx: #include <icetray/scratch.h>

#include <icetray/I3Logging.h>

#include <cstdlib>

#include <cstring>

#include <sys/errno.h>

#include <sys/stat.h>

#include <unistd.h>

#include <pwd.h>

#include <sys/param.h>

file scratch.h: #include <string>

file serialization.h

#include <boost/version.hpp>

#include <icetray/i3_extended_type_info.h>

#include <archive/xml_iarchive.hpp>

#include <archive/xml_oarchive.hpp>

#include <archive/portable_binary_archive.hpp>

#include <serialization/serialization.hpp>

#include <serialization/nvp.hpp>

#include <serialization/base_object.hpp>

#include <serialization/access.hpp>

#include <serialization/export.hpp>

#include <serialization/vector.hpp>

#include <serialization/string.hpp>

#include <serialization/map.hpp>

#include <serialization/shared_ptr.hpp>

#include <serialization/utility.hpp>

#include <serialization/split_member.hpp>

#include <serialization/version.hpp>

#include <icetray/is_shared_ptr.h>

#include <boost/utility/enable_if.hpp>

#include <sstream>

Defines

I3_BASIC_SERIALIZABLE(T)¶

I3_EXPORT(T)¶

I3_SERIALIZABLE(T)¶

I3_SPLIT_SERIALIZABLE(T)¶

Functions

template<typename T> std::string AsXML(const T &t)

file Singleton.h: #include <cassert>

#include <boost/noncopyable.hpp>

#include <serialization/force_include.hpp>

file socket_source.hpp

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <boost/iostreams/device/file_descriptor.hpp>

#include <boost/version.hpp>

Functions

boost::iostreams::file_descriptor_source create_socket_source(const std::string filename)¶

file std_map_indexing_suite.hpp

#include <boost/python/suite/indexing/indexing_suite.hpp>

#include <boost/python/iterator.hpp>

#include <boost/python/call_method.hpp>

#include <boost/python/tuple.hpp>

#include <boost/python/overloads.hpp>

#include <boost/iterator/transform_iterator.hpp>

#include <icetray/python/get_class.hpp>

Defines

HAS_TYPEDEF(def, name)

HAS_FUNCTION(func, result_type, name)¶

file std_vector_indexing_suite.hpp

file stream_to_string.hpp

#include <sstream>

Functions

template<class T> std::string stream_to_string(T t)¶

file TrashCan.cxx

#include <icetray/I3Module.h>

#include <icetray/I3Logging.h>

Functions

I3_MODULE(TrashCan)¶

file tree_indexing_suite.hpp: #include <boost/python/iterator.hpp>

#include <boost/python/call_method.hpp>

#include <boost/python/tuple.hpp>

#include <boost/python/object/iterator_core.hpp>

#include <boost/mpl/vector.hpp>

#include <boost/mpl/deref.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/mpl/begin_end.hpp>

#include <boost/mpl/next_prior.hpp>

#include <boost/mpl/at.hpp>

#include <boost/mpl/insert.hpp>

#include <boost/mpl/erase.hpp>

#include <boost/mpl/replace.hpp>

#include <icetray/python/get_class.hpp>

file Utility.cxx

#include <icetray/Utility.h>

#include <vector>

#include <boost/regex.hpp>

#include <glob.h>

Functions

string stlfilt(const string &what)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

string prettify_xml(const string &what)¶

int glob(const string &expression, vector<string> &results)¶

string encode_entities(const string &encode_me)¶

file Utility.h

#include <string>

#include <vector>

#include <set>

#include <iostream>

#include <sstream>

Functions

std::string stlfilt(const std::string &s)¶

$Id$

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS’’ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SPDX-License-Identifier: BSD-2-Clause

std::string prettify_xml(const std::string &s)¶

int glob(const std::string &expression, std::vector<std::string> &results)¶

std::string encode_entities(const std::string &encode_me)¶

file Version.h

Defines

ICETRAY_VERSION¶

file zstd_filter.hpp: #include <boost/iostreams/filtering_stream.hpp>

#include <zstd.h>

#include <algorithm>

page todo

Member icetray::detail::TypenameCache::GetName (const std::type_info &ti): Use a multiple-reader / single-write model. Does it work, if mixing boost threads and ZThread?

dir icetray

dir icetray

dir icetray

dir icetray

dir modules

dir modules

dir open

dir private

dir public

dir python

icetray C++ API Reference¶

Table of Contents

Previous topic

Next topic

This Page