icecube.icetray – icetray

class icecube.icetray.I3Bool

value

class icecube.icetray.I3ConditionalModule

AddOutBox((I3ConditionalModule)arg1, (str)arg2) → None :

C++ signature :

void AddOutBox(PythonModule<I3ConditionalModule> {lvalue},std::string)

AddParameter((I3ConditionalModule)arg1, (str)arg2, (str)arg3[, (object)arg4]) → None :

C++ signature :

void AddParameter(PythonModule<I3ConditionalModule> {lvalue},std::string,std::string [,boost::python::api::object])

Calibration((I3ConditionalModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void Calibration(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

Configure((I3ConditionalModule)arg1) → None :

C++ signature :

void Configure(PythonModule<I3ConditionalModule> {lvalue})

DAQ((I3ConditionalModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void DAQ(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

DetectorStatus((I3ConditionalModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void DetectorStatus(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

Finish((I3ConditionalModule)arg1) → None :

C++ signature :

void Finish(PythonModule<I3ConditionalModule> {lvalue})

Geometry((I3ConditionalModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void Geometry(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

GetParameter((I3ConditionalModule)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object GetParameter(PythonModule<I3ConditionalModule> {lvalue},std::string)

Physics((I3ConditionalModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void Physics(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

PopFrame((I3ConditionalModule)arg1) → I3Frame :

C++ signature :

boost::shared_ptr<I3Frame> PopFrame(PythonModule<I3ConditionalModule> {lvalue})

Process((I3ConditionalModule)arg1) → None :

C++ signature :

void Process(PythonModule<I3ConditionalModule> {lvalue})

PushFrame((I3ConditionalModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void PushFrame(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

PushFrame( (I3ConditionalModule)arg1, (I3Frame)arg2, (str)arg3) -> None :

C++ signature :

void PushFrame(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>,std::string)

Register((I3ConditionalModule)arg1, (Stream)arg2, (object)arg3) → None :

C++ signature :

void Register(PythonModule<I3ConditionalModule> {lvalue},I3Frame::Stream,boost::python::api::object)

RequestSuspension((I3ConditionalModule)arg1) → None :

C++ signature :

void RequestSuspension(PythonModule<I3ConditionalModule> {lvalue})

ShouldDoCalibration((I3ConditionalModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoCalibration(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoDAQ((I3ConditionalModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoDAQ(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoDetectorStatus((I3ConditionalModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoDetectorStatus(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoGeometry((I3ConditionalModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoGeometry(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoPhysics((I3ConditionalModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoPhysics(PythonModule<I3ConditionalModule> {lvalue},boost::shared_ptr<I3Frame>)

configuration

context

name

class icecube.icetray.I3Configuration

ClassName

class DescriptionProxy

I3Configuration.InstanceName

I3Configuration.descriptions

I3Configuration.keys((I3Configuration)arg1) → vector_string :

C++ signature :

std::vector<std::string, std::allocator<std::string> > keys(I3Configuration {lvalue})

class icecube.icetray.I3Context

items((I3Context)arg1) → list :

C++ signature :

boost::python::list items(boost::shared_ptr<I3Context>)

keys((I3Context)arg1) → vector_string :

C++ signature :

std::vector<std::string, std::allocator<std::string> > keys(I3Context {lvalue})

values((I3Context)arg1) → list :

C++ signature :

boost::python::list values(boost::shared_ptr<I3Context>)

class icecube.icetray.I3Frame

Calibration = icetray.I3Frame.Calibration

DAQ = icetray.I3Frame.DAQ

Delete((I3Frame)arg1, (str)arg2) → None :

C++ signature :

void Delete(I3Frame {lvalue},std::string)

DetectorStatus = icetray.I3Frame.DetectorStatus

Geometry = icetray.I3Frame.Geometry

Get((I3Frame)arg1, (str)arg2) → I3FrameObject :

C++ signature :

boost::shared_ptr<I3FrameObject> Get(I3Frame const*,std::string)

Has((I3Frame)arg1, (str)arg2[, (Stream)arg3]) → bool :

C++ signature :

bool Has(I3Frame {lvalue},std::string [,I3Frame::Stream])

None = icetray.I3Frame.None

Physics = icetray.I3Frame.Physics

Put((I3Frame)arg1, (str)arg2, (object)arg3) → None :

C++ signature :

void Put(I3Frame {lvalue},std::string,boost::shared_ptr<I3FrameObject const>)

Put( (I3Frame)arg1, (str)arg2, (object)arg3, (Stream)arg4) -> None :

C++ signature :

void Put(I3Frame {lvalue},std::string,boost::shared_ptr<I3FrameObject const>,I3Frame::Stream)

Rename((I3Frame)arg1, (str)arg2, (str)arg3) → None :

C++ signature :

void Rename(I3Frame {lvalue},std::string,std::string)

Stop

class Stream

id

I3Frame.TrayInfo = icetray.I3Frame.TrayInfo

I3Frame.as_xml((I3Frame)arg1, (str)arg2) → str :

C++ signature :

std::string as_xml(I3Frame {lvalue},std::string)

I3Frame.assign((I3Frame)arg1, (I3Frame)arg2) → None :

C++ signature :

void assign(I3Frame {lvalue},I3Frame)

I3Frame.change_stream((I3Frame)arg1, (str)arg2, (Stream)arg3) → None :

C++ signature :

void change_stream(I3Frame {lvalue},std::string,I3Frame::Stream)

I3Frame.clear((I3Frame)arg1) → None :

C++ signature :

void clear(I3Frame {lvalue})

I3Frame.get_stop((I3Frame)arg1, (str)arg2) → Stream :

C++ signature :

I3Frame::Stream get_stop(I3Frame {lvalue},std::string)

I3Frame.items((I3Frame)arg1) → list :

C++ signature :

boost::python::list items(I3Frame)

I3Frame.keys((I3Frame)arg1) → list :

C++ signature :

boost::python::list keys(I3Frame)

I3Frame.merge((I3Frame)arg1, (I3Frame)arg2) → None :

C++ signature :

void merge(I3Frame {lvalue},I3Frame)

I3Frame.purge((I3Frame)arg1) → None :

C++ signature :

void purge(I3Frame {lvalue})

purge( (I3Frame)arg1, (Stream)arg2) -> None :

C++ signature :

void purge(I3Frame {lvalue},I3Frame::Stream)

I3Frame.size((I3Frame)arg1) → int :

C++ signature :

unsigned long size(I3Frame {lvalue})

size( (I3Frame)arg1, (str)arg2) -> int :

C++ signature :

unsigned long size(I3Frame {lvalue},std::string)

I3Frame.type_name((I3Frame)arg1, (str)arg2) → str :

C++ signature :

std::string type_name(I3Frame {lvalue},std::string)

I3Frame.values((I3Frame)arg1) → list :

C++ signature :

boost::python::list values(I3Frame)

class I3Frame.vector_I3Frame

append((vector_I3Frame)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<boost::shared_ptr<I3Frame>, std::allocator<boost::shared_ptr<I3Frame> > > {lvalue},boost::python::api::object)

extend((vector_I3Frame)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<boost::shared_ptr<I3Frame>, std::allocator<boost::shared_ptr<I3Frame> > > {lvalue},boost::python::api::object)

class icecube.icetray.I3FrameObject

Base class for all objects that live in the I3Frame

class icecube.icetray.I3Int

value

class icecube.icetray.I3LogLevel

LOG_DEBUG = icecube.icetray.I3LogLevel.LOG_DEBUG

LOG_ERROR = icecube.icetray.I3LogLevel.LOG_ERROR

LOG_FATAL = icecube.icetray.I3LogLevel.LOG_FATAL

LOG_INFO = icecube.icetray.I3LogLevel.LOG_INFO

LOG_NOTICE = icecube.icetray.I3LogLevel.LOG_NOTICE

LOG_TRACE = icecube.icetray.I3LogLevel.LOG_TRACE

LOG_WARN = icecube.icetray.I3LogLevel.LOG_WARN

values = {0: icecube.icetray.I3LogLevel.LOG_TRACE, 1: icecube.icetray.I3LogLevel.LOG_DEBUG, 2: icecube.icetray.I3LogLevel.LOG_INFO, 3: icecube.icetray.I3LogLevel.LOG_NOTICE, 4: icecube.icetray.I3LogLevel.LOG_WARN, 5: icecube.icetray.I3LogLevel.LOG_ERROR, 6: icecube.icetray.I3LogLevel.LOG_FATAL}

class icecube.icetray.I3Logger

Logging base class

get_level_for_unit((I3Logger)arg1, (str)arg2) → I3LogLevel :

C++ signature :

I3LogLevel get_level_for_unit(I3Logger {lvalue},std::string)

global_logger = <icecube.icetray.I3PrintfLogger object at 0x2fde578>

log((I3Logger)arg1, (I3LogLevel)arg2, (str)arg3, (str)arg4, (int)arg5, (str)arg6, (str)arg7) → None :

C++ signature :

void log(I3Logger {lvalue},I3LogLevel,std::string,std::string,int,std::string,std::string)

set_level((I3Logger)arg1, (I3LogLevel)arg2) → None :

C++ signature :

void set_level(I3Logger {lvalue},I3LogLevel)

set_level_for_unit((I3Logger)arg1, (str)arg2, (I3LogLevel)arg3) → None :

C++ signature :

void set_level_for_unit(I3Logger {lvalue},std::string,I3LogLevel)

class icecube.icetray.I3LoggerBase

C++ logging abstract base class

class icecube.icetray.I3Module

AddOutBox((I3Module)arg1, (str)arg2) → None :

C++ signature :

void AddOutBox(PythonModule<I3Module> {lvalue},std::string)

AddParameter((I3Module)arg1, (str)arg2, (str)arg3[, (object)arg4]) → None :

C++ signature :

void AddParameter(PythonModule<I3Module> {lvalue},std::string,std::string [,boost::python::api::object])

Calibration((I3Module)arg1, (I3Frame)arg2) → None :

C++ signature :

void Calibration(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

Configure((I3Module)arg1) → None :

C++ signature :

void Configure(PythonModule<I3Module> {lvalue})

DAQ((I3Module)arg1, (I3Frame)arg2) → None :

C++ signature :

void DAQ(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

DetectorStatus((I3Module)arg1, (I3Frame)arg2) → None :

C++ signature :

void DetectorStatus(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

Finish((I3Module)arg1) → None :

C++ signature :

void Finish(PythonModule<I3Module> {lvalue})

Geometry((I3Module)arg1, (I3Frame)arg2) → None :

C++ signature :

void Geometry(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

GetParameter((I3Module)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object GetParameter(PythonModule<I3Module> {lvalue},std::string)

Physics((I3Module)arg1, (I3Frame)arg2) → None :

C++ signature :

void Physics(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

PopFrame((I3Module)arg1) → I3Frame :

C++ signature :

boost::shared_ptr<I3Frame> PopFrame(PythonModule<I3Module> {lvalue})

Process((I3Module)arg1) → None :

C++ signature :

void Process(PythonModule<I3Module> {lvalue})

PushFrame((I3Module)arg1, (I3Frame)arg2) → None :

C++ signature :

void PushFrame(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

PushFrame( (I3Module)arg1, (I3Frame)arg2, (str)arg3) -> None :

C++ signature :

void PushFrame(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>,std::string)

Register((I3Module)arg1, (Stream)arg2, (object)arg3) → None :

C++ signature :

void Register(PythonModule<I3Module> {lvalue},I3Frame::Stream,boost::python::api::object)

RequestSuspension((I3Module)arg1) → None :

C++ signature :

void RequestSuspension(PythonModule<I3Module> {lvalue})

ShouldDoCalibration((I3Module)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoCalibration(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoDAQ((I3Module)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoDAQ(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoDetectorStatus((I3Module)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoDetectorStatus(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoGeometry((I3Module)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoGeometry(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoPhysics((I3Module)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoPhysics(PythonModule<I3Module> {lvalue},boost::shared_ptr<I3Frame>)

configuration

context

name

class icecube.icetray.I3NullLogger

Logger that does not log. Useful if you don’t want log messages

class icecube.icetray.I3PacketModule

AddOutBox((I3PacketModule)arg1, (str)arg2) → None :

C++ signature :

void AddOutBox(PythonModule<I3PacketModule> {lvalue},std::string)

AddParameter((I3PacketModule)arg1, (str)arg2, (str)arg3[, (object)arg4]) → None :

C++ signature :

void AddParameter(PythonModule<I3PacketModule> {lvalue},std::string,std::string [,boost::python::api::object])

Calibration((I3PacketModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void Calibration(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

Configure((I3PacketModule)arg1) → None :

C++ signature :

void Configure(PythonModule<I3PacketModule> {lvalue})

DAQ((I3PacketModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void DAQ(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

DetectorStatus((I3PacketModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void DetectorStatus(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

Finish((I3PacketModule)arg1) → None :

C++ signature :

void Finish(PythonModule<I3PacketModule> {lvalue})

FlushQueue((I3PacketModule)arg1) → None :

C++ signature :

void FlushQueue(I3PacketModule {lvalue})

FramePacket((I3PacketModule)arg1, (vector_I3Frame)arg2) → None :

C++ signature :

void FramePacket(PythonModule<I3PacketModule> {lvalue},std::vector<boost::shared_ptr<I3Frame>, std::allocator<boost::shared_ptr<I3Frame> > > {lvalue})

Geometry((I3PacketModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void Geometry(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

GetParameter((I3PacketModule)arg1, (str)arg2) → object :

C++ signature :

boost::python::api::object GetParameter(PythonModule<I3PacketModule> {lvalue},std::string)

Physics((I3PacketModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void Physics(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

PopFrame((I3PacketModule)arg1) → I3Frame :

C++ signature :

boost::shared_ptr<I3Frame> PopFrame(PythonModule<I3PacketModule> {lvalue})

Process((I3PacketModule)arg1) → None :

C++ signature :

void Process(PythonModule<I3PacketModule> {lvalue})

PushFrame((I3PacketModule)arg1, (I3Frame)arg2) → None :

C++ signature :

void PushFrame(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

PushFrame( (I3PacketModule)arg1, (I3Frame)arg2, (str)arg3) -> None :

C++ signature :

void PushFrame(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>,std::string)

Register((I3PacketModule)arg1, (Stream)arg2, (object)arg3) → None :

C++ signature :

void Register(PythonModule<I3PacketModule> {lvalue},I3Frame::Stream,boost::python::api::object)

RequestSuspension((I3PacketModule)arg1) → None :

C++ signature :

void RequestSuspension(PythonModule<I3PacketModule> {lvalue})

ShouldDoCalibration((I3PacketModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoCalibration(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoDAQ((I3PacketModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoDAQ(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoDetectorStatus((I3PacketModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoDetectorStatus(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoGeometry((I3PacketModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoGeometry(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

ShouldDoPhysics((I3PacketModule)arg1, (I3Frame)arg2) → bool :

C++ signature :

bool ShouldDoPhysics(PythonModule<I3PacketModule> {lvalue},boost::shared_ptr<I3Frame>)

configuration

context

name

packet_types

sentinel

class icecube.icetray.I3PhysicsUsage

ncall

systime

usertime

class icecube.icetray.I3PrintfLogger

Logger that prints error messages to stderr (in color, if stderr is a tty).

trim_file_names

class icecube.icetray.I3RUsage

SystemTime

UserTime

WallClockTime

class icecube.icetray.I3SyslogLogger

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

open((str)arg1) → None :

C++ signature :

void open(std::string)

class icecube.icetray.I3Tray

AddModule((I3Tray)arg1, (object)arg2, (str)arg3) → param_setter :

C++ signature :

I3Tray::param_setter AddModule(I3Tray {lvalue},boost::python::api::object,std::string)

AddService((I3Tray)arg1, (str)arg2, (str)arg3) → param_setter :

C++ signature :

I3Tray::param_setter AddService(I3Tray {lvalue},std::string,std::string)

ConnectBoxes((I3Tray)arg1, (str)arg2, (str)arg3, (str)arg4) → bool :

C++ signature :

bool ConnectBoxes(I3Tray {lvalue},std::string,std::string,std::string)

Execute((I3Tray)arg1) → None :

C++ signature :

void Execute(I3Tray {lvalue})

Execute( (I3Tray)arg1, (int)arg2) -> None :

C++ signature :

void Execute(I3Tray {lvalue},unsigned int)

Finish((I3Tray)arg1) → None :

C++ signature :

void Finish(I3Tray {lvalue})

MoveModule((I3Tray)self, (str)name, (str)anchor[, (bool)after=False]) → None :

C++ signature :

void MoveModule(I3Tray {lvalue},std::string,std::string [,bool=False])

SetParameter((I3Tray)arg1, (str)arg2, (str)arg3, (object)arg4) → bool :

C++ signature :

bool SetParameter(I3Tray {lvalue},std::string,std::string,boost::python::api::object)

TrayInfo((I3Tray)arg1) → I3TrayInfo :

C++ signature :

I3TrayInfo TrayInfo(I3Tray {lvalue})

Usage((I3Tray)arg1) → map_string_I3PhysicsUsage :

C++ signature :

std::map<std::string, I3PhysicsUsage, std::less<std::string>, std::allocator<std::pair<std::string const, I3PhysicsUsage> > > Usage(I3Tray {lvalue})

context

tray_info

class icecube.icetray.I3TrayInfo

factories_in_order

factory_configs

host_info

module_configs

modules_in_order

svn_externals

svn_revision

svn_url

class icecube.icetray.I3TrayInfoService

config

class icecube.icetray.I3Units

‘Namespace’ holding values for I3Units

A = 6241509744.511525

C = 6.241509744511525e+18

GeV = 1.0

MeV = 0.001

PeV = 1000000.0000000001

TeV = 1000.0000000000001

V = 1.0000000000000003e-09

ampere = 6241509744.511525

angstrom = 1e-10

bar = 624150974451152.6

barn = 1e-28

centimeter = 0.01

centimeter2 = 0.0001

centimeter3 = 1.0000000000000002e-06

cm = 0.01

cm2 = 0.0001

cm3 = 1.0000000000000002e-06

coulomb = 6.241509744511525e+18

day = 86400000000000.0

deg = 0.017453292519943295

degree = 0.017453292519943295

eSI = 1.602176462e-19

eV = 1e-09

electronvolt = 1e-09

eplus = 1.0

feet = 0.3048

fermi = 1e-15

ft = 0.3048

g = 6.241509744511526e+24

gigaelectronvolt = 1.0

gram = 6.241509744511526e+24

gregorianyear = 3.1556952e+16

hertz = 1e-09

hour = 3600000000000.0

joule = 6241509744.511526

julianyear = 3.15576e+16

kV = 1.0000000000000002e-06

keV = 1.0000000000000002e-06

kelvin = 1.0

kg = 6.241509744511526e+27

kiloelectronvolt = 1.0000000000000002e-06

kilogram = 6.241509744511526e+27

kilohertz = 1.0000000000000002e-06

kilometer = 1000.0

kilometer2 = 1000000.0

kilometer3 = 1000000000.0

kilovolt = 1.0000000000000002e-06

km = 1000.0

km2 = 1000000.0

km3 = 1000000000.0

m = 1.0

m2 = 1.0

m3 = 1.0

mA = 6241509.744511525

mV = 1.0000000000000002e-12

megaelectronvolt = 0.001

megahertz = 0.001

meter = 1.0

meter2 = 1.0

meter3 = 1.0

mg = 6.241509744511526e+21

microbarn = 1e-34

micrometer = 1e-06

micropascal = 6241.509744511526

microsecond = 1000.0

microvolt = 1.0000000000000003e-15

milliampere = 6241509.744511525

millibarn = 1e-31

milligram = 6.241509744511526e+21

millimeter = 0.001

millimeter2 = 1e-06

millimeter3 = 1e-09

millipascal = 6241509.744511526

milliradian = 0.001

millisecond = 1000000.0

millivolt = 1.0000000000000002e-12

minute = 60000000000.0

mm = 0.001

mm2 = 1e-06

mm3 = 1e-09

mrad = 0.001

ms = 1000000.0

nA = 6.241509744511526

nanoampere = 6.241509744511526

nanobarn = 1e-37

nanometer = 1e-09

nanopascal = 6.241509744511527

nanosecond = 1.0

newton = 6241509744.511526

ns = 1.0

ohm = 1.6021764620000006e-19

pC = 6241509.744511525

parsec = 3.0856775807e+16

pascal = 6241509744.511526

pc = 3.0856775807e+16

perCent = 0.01

perMillion = 1e-06

perThousand = 0.001

petaelectronvolt = 1000000.0000000001

picobarn = 1e-40

picocoulomb = 6241509.744511525

picosecond = 0.001

rad = 1.0

radian = 1.0

s = 1000000000.0

second = 1000000000.0

sr = 1.0

steradian = 1.0

teraelectronvolt = 1000.0000000000001

volt = 1.0000000000000003e-09

class icecube.icetray.MyService

class icecube.icetray.OMKey

om

pmt

string

icecube.icetray.create_module((str)arg1, (I3Context)arg2) → I3Module :

C++ signature :

boost::shared_ptr<I3Module> create_module(std::string,I3Context {lvalue})

icecube.icetray.fix_logging_crash()

icecube.icetray.get_log_level_for_unit((str)arg1) → I3LogLevel :

C++ signature :

I3LogLevel get_log_level_for_unit(std::string)

icecube.icetray.is_module((str)arg1) → bool :

C++ signature :

bool is_module(std::string)

icecube.icetray.is_service((str)arg1) → bool :

C++ signature :

bool is_service(std::string)

icecube.icetray.load((str)name[, (bool)verbose]) → None :

C++ signature :

void load(std::string [,bool])

class icecube.icetray.map_OMKey_int

class icecube.icetray.map_indexing_suite_map_OMKey_int_entry

data((map_indexing_suite_map_OMKey_int_entry)arg1) → int :

C++ signature :

int data(std::pair<OMKey const, int> {lvalue})

key((map_indexing_suite_map_OMKey_int_entry)arg1) → OMKey :

C++ signature :

OMKey key(std::pair<OMKey const, int> {lvalue})

class icecube.icetray.map_indexing_suite_map_int_int_entry

data((map_indexing_suite_map_int_int_entry)arg1) → int :

C++ signature :

int data(std::pair<int const, int> {lvalue})

key((map_indexing_suite_map_int_int_entry)arg1) → int :

C++ signature :

int key(std::pair<int const, int> {lvalue})

class icecube.icetray.map_indexing_suite_map_string_I3Configuration_entry

data((map_indexing_suite_map_string_I3Configuration_entry)arg1) → I3Configuration :

C++ signature :

boost::shared_ptr<I3Configuration> data(std::pair<std::string const, boost::shared_ptr<I3Configuration> > {lvalue})

key((map_indexing_suite_map_string_I3Configuration_entry)arg1) → str :

C++ signature :

std::string key(std::pair<std::string const, boost::shared_ptr<I3Configuration> > {lvalue})

class icecube.icetray.map_indexing_suite_map_string_I3PhysicsUsage_entry

data((map_indexing_suite_map_string_I3PhysicsUsage_entry)arg1) → I3PhysicsUsage :

C++ signature :

I3PhysicsUsage {lvalue} data(std::pair<std::string const, I3PhysicsUsage> {lvalue})

key((map_indexing_suite_map_string_I3PhysicsUsage_entry)arg1) → str :

C++ signature :

std::string key(std::pair<std::string const, I3PhysicsUsage> {lvalue})

class icecube.icetray.map_indexing_suite_map_string_pyobject_entry

data((map_indexing_suite_map_string_pyobject_entry)arg1) → object :

C++ signature :

boost::python::api::object data(std::pair<std::string const, boost::python::api::object> {lvalue})

key((map_indexing_suite_map_string_pyobject_entry)arg1) → str :

C++ signature :

std::string key(std::pair<std::string const, boost::python::api::object> {lvalue})

class icecube.icetray.map_int_int

keys((map_int_int)arg1) → list :

C++ signature :

boost::python::list keys(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >)

class icecube.icetray.map_string_I3Configuration

class icecube.icetray.map_string_I3PhysicsUsage

class icecube.icetray.map_string_pyobject

icecube.icetray.module_default_config((str)arg1) → I3Configuration :

C++ signature :

boost::shared_ptr<I3Configuration> module_default_config(std::string)

icecube.icetray.modules((str)project) → list :

C++ signature :

boost::python::list modules(std::string)

class icecube.icetray.param_setter

icecube.icetray.projects() → list :

C++ signature :

boost::python::list projects()

icecube.icetray.services((str)project) → list :

C++ signature :

boost::python::list services(std::string)

class icecube.icetray.vector_I3Frame_Stream

append((vector_I3Frame_Stream)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<I3Frame::Stream, std::allocator<I3Frame::Stream> > {lvalue},boost::python::api::object)

extend((vector_I3Frame_Stream)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<I3Frame::Stream, std::allocator<I3Frame::Stream> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_OMKey

append((vector_OMKey)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<OMKey, std::allocator<OMKey> > {lvalue},boost::python::api::object)

extend((vector_OMKey)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<OMKey, std::allocator<OMKey> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_char

append((vector_char)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<char, std::allocator<char> > {lvalue},boost::python::api::object)

extend((vector_char)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<char, std::allocator<char> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_double

append((vector_double)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<double, std::allocator<double> > {lvalue},boost::python::api::object)

extend((vector_double)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<double, std::allocator<double> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_int

append((vector_int)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<int, std::allocator<int> > {lvalue},boost::python::api::object)

extend((vector_int)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<int, std::allocator<int> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_short

append((vector_short)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<short, std::allocator<short> > {lvalue},boost::python::api::object)

extend((vector_short)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<short, std::allocator<short> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_string

append((vector_string)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<std::string, std::allocator<std::string> > {lvalue},boost::python::api::object)

extend((vector_string)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<std::string, std::allocator<std::string> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_ulong

append((vector_ulong)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<unsigned long, std::allocator<unsigned long> > {lvalue},boost::python::api::object)

extend((vector_ulong)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<unsigned long, std::allocator<unsigned long> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_unsigned

append((vector_unsigned)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<unsigned int, std::allocator<unsigned int> > {lvalue},boost::python::api::object)

extend((vector_unsigned)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<unsigned int, std::allocator<unsigned int> > {lvalue},boost::python::api::object)

class icecube.icetray.vector_vector_int

append((vector_vector_int)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > {lvalue},boost::python::api::object)

extend((vector_vector_int)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > {lvalue},boost::python::api::object)

class icecube.icetray.vector_vector_string

append((vector_vector_string)arg1, (object)arg2) → None :

C++ signature :

void append(std::vector<std::vector<std::string, std::allocator<std::string> >, std::allocator<std::vector<std::string, std::allocator<std::string> > > > {lvalue},boost::python::api::object)

extend((vector_vector_string)arg1, (object)arg2) → None :

C++ signature :

void extend(std::vector<std::vector<std::string, std::allocator<std::string> >, std::allocator<std::vector<std::string, std::allocator<std::string> > > > {lvalue},boost::python::api::object)