# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_pyIrfLoader')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_pyIrfLoader')
    _pyIrfLoader = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_pyIrfLoader', [dirname(__file__)])
        except ImportError:
            import _pyIrfLoader
            return _pyIrfLoader
        try:
            _mod = imp.load_module('_pyIrfLoader', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _pyIrfLoader = swig_import_helper()
    del swig_import_helper
else:
    import _pyIrfLoader
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _pyIrfLoader.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _pyIrfLoader.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _pyIrfLoader.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _pyIrfLoader.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _pyIrfLoader.SwigPyIterator_equal(self, x)

    def copy(self):
        return _pyIrfLoader.SwigPyIterator_copy(self)

    def next(self):
        return _pyIrfLoader.SwigPyIterator_next(self)

    def __next__(self):
        return _pyIrfLoader.SwigPyIterator___next__(self)

    def previous(self):
        return _pyIrfLoader.SwigPyIterator_previous(self)

    def advance(self, n):
        return _pyIrfLoader.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _pyIrfLoader.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _pyIrfLoader.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _pyIrfLoader.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _pyIrfLoader.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _pyIrfLoader.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _pyIrfLoader.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _pyIrfLoader.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class DoublePair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoublePair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoublePair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _pyIrfLoader.new_DoublePair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _pyIrfLoader.DoublePair_first_set
    __swig_getmethods__["first"] = _pyIrfLoader.DoublePair_first_get
    if _newclass:
        first = _swig_property(_pyIrfLoader.DoublePair_first_get, _pyIrfLoader.DoublePair_first_set)
    __swig_setmethods__["second"] = _pyIrfLoader.DoublePair_second_set
    __swig_getmethods__["second"] = _pyIrfLoader.DoublePair_second_get
    if _newclass:
        second = _swig_property(_pyIrfLoader.DoublePair_second_get, _pyIrfLoader.DoublePair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _pyIrfLoader.delete_DoublePair
    __del__ = lambda self: None
DoublePair_swigregister = _pyIrfLoader.DoublePair_swigregister
DoublePair_swigregister(DoublePair)

class DoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _pyIrfLoader.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyIrfLoader.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _pyIrfLoader.DoubleVector___bool__(self)

    def __len__(self):
        return _pyIrfLoader.DoubleVector___len__(self)

    def __getslice__(self, i, j):
        return _pyIrfLoader.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyIrfLoader.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyIrfLoader.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyIrfLoader.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyIrfLoader.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyIrfLoader.DoubleVector___setitem__(self, *args)

    def pop(self):
        return _pyIrfLoader.DoubleVector_pop(self)

    def append(self, x):
        return _pyIrfLoader.DoubleVector_append(self, x)

    def empty(self):
        return _pyIrfLoader.DoubleVector_empty(self)

    def size(self):
        return _pyIrfLoader.DoubleVector_size(self)

    def swap(self, v):
        return _pyIrfLoader.DoubleVector_swap(self, v)

    def begin(self):
        return _pyIrfLoader.DoubleVector_begin(self)

    def end(self):
        return _pyIrfLoader.DoubleVector_end(self)

    def rbegin(self):
        return _pyIrfLoader.DoubleVector_rbegin(self)

    def rend(self):
        return _pyIrfLoader.DoubleVector_rend(self)

    def clear(self):
        return _pyIrfLoader.DoubleVector_clear(self)

    def get_allocator(self):
        return _pyIrfLoader.DoubleVector_get_allocator(self)

    def pop_back(self):
        return _pyIrfLoader.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _pyIrfLoader.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _pyIrfLoader.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _pyIrfLoader.DoubleVector_push_back(self, x)

    def front(self):
        return _pyIrfLoader.DoubleVector_front(self)

    def back(self):
        return _pyIrfLoader.DoubleVector_back(self)

    def assign(self, n, x):
        return _pyIrfLoader.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _pyIrfLoader.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _pyIrfLoader.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _pyIrfLoader.DoubleVector_reserve(self, n)

    def capacity(self):
        return _pyIrfLoader.DoubleVector_capacity(self)
    __swig_destroy__ = _pyIrfLoader.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _pyIrfLoader.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _pyIrfLoader.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyIrfLoader.StringVector___nonzero__(self)

    def __bool__(self):
        return _pyIrfLoader.StringVector___bool__(self)

    def __len__(self):
        return _pyIrfLoader.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _pyIrfLoader.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyIrfLoader.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyIrfLoader.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyIrfLoader.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyIrfLoader.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyIrfLoader.StringVector___setitem__(self, *args)

    def pop(self):
        return _pyIrfLoader.StringVector_pop(self)

    def append(self, x):
        return _pyIrfLoader.StringVector_append(self, x)

    def empty(self):
        return _pyIrfLoader.StringVector_empty(self)

    def size(self):
        return _pyIrfLoader.StringVector_size(self)

    def swap(self, v):
        return _pyIrfLoader.StringVector_swap(self, v)

    def begin(self):
        return _pyIrfLoader.StringVector_begin(self)

    def end(self):
        return _pyIrfLoader.StringVector_end(self)

    def rbegin(self):
        return _pyIrfLoader.StringVector_rbegin(self)

    def rend(self):
        return _pyIrfLoader.StringVector_rend(self)

    def clear(self):
        return _pyIrfLoader.StringVector_clear(self)

    def get_allocator(self):
        return _pyIrfLoader.StringVector_get_allocator(self)

    def pop_back(self):
        return _pyIrfLoader.StringVector_pop_back(self)

    def erase(self, *args):
        return _pyIrfLoader.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _pyIrfLoader.new_StringVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _pyIrfLoader.StringVector_push_back(self, x)

    def front(self):
        return _pyIrfLoader.StringVector_front(self)

    def back(self):
        return _pyIrfLoader.StringVector_back(self)

    def assign(self, n, x):
        return _pyIrfLoader.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _pyIrfLoader.StringVector_resize(self, *args)

    def insert(self, *args):
        return _pyIrfLoader.StringVector_insert(self, *args)

    def reserve(self, n):
        return _pyIrfLoader.StringVector_reserve(self, n)

    def capacity(self):
        return _pyIrfLoader.StringVector_capacity(self)
    __swig_destroy__ = _pyIrfLoader.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _pyIrfLoader.StringVector_swigregister
StringVector_swigregister(StringVector)

class IrfVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IrfVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IrfVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _pyIrfLoader.IrfVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyIrfLoader.IrfVector___nonzero__(self)

    def __bool__(self):
        return _pyIrfLoader.IrfVector___bool__(self)

    def __len__(self):
        return _pyIrfLoader.IrfVector___len__(self)

    def __getslice__(self, i, j):
        return _pyIrfLoader.IrfVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyIrfLoader.IrfVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyIrfLoader.IrfVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyIrfLoader.IrfVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyIrfLoader.IrfVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyIrfLoader.IrfVector___setitem__(self, *args)

    def pop(self):
        return _pyIrfLoader.IrfVector_pop(self)

    def append(self, x):
        return _pyIrfLoader.IrfVector_append(self, x)

    def empty(self):
        return _pyIrfLoader.IrfVector_empty(self)

    def size(self):
        return _pyIrfLoader.IrfVector_size(self)

    def swap(self, v):
        return _pyIrfLoader.IrfVector_swap(self, v)

    def begin(self):
        return _pyIrfLoader.IrfVector_begin(self)

    def end(self):
        return _pyIrfLoader.IrfVector_end(self)

    def rbegin(self):
        return _pyIrfLoader.IrfVector_rbegin(self)

    def rend(self):
        return _pyIrfLoader.IrfVector_rend(self)

    def clear(self):
        return _pyIrfLoader.IrfVector_clear(self)

    def get_allocator(self):
        return _pyIrfLoader.IrfVector_get_allocator(self)

    def pop_back(self):
        return _pyIrfLoader.IrfVector_pop_back(self)

    def erase(self, *args):
        return _pyIrfLoader.IrfVector_erase(self, *args)

    def __init__(self, *args):
        this = _pyIrfLoader.new_IrfVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _pyIrfLoader.IrfVector_push_back(self, x)

    def front(self):
        return _pyIrfLoader.IrfVector_front(self)

    def back(self):
        return _pyIrfLoader.IrfVector_back(self)

    def assign(self, n, x):
        return _pyIrfLoader.IrfVector_assign(self, n, x)

    def resize(self, *args):
        return _pyIrfLoader.IrfVector_resize(self, *args)

    def insert(self, *args):
        return _pyIrfLoader.IrfVector_insert(self, *args)

    def reserve(self, n):
        return _pyIrfLoader.IrfVector_reserve(self, n)

    def capacity(self):
        return _pyIrfLoader.IrfVector_capacity(self)
    __swig_destroy__ = _pyIrfLoader.delete_IrfVector
    __del__ = lambda self: None
IrfVector_swigregister = _pyIrfLoader.IrfVector_swigregister
IrfVector_swigregister(IrfVector)

class ConeVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConeVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConeVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _pyIrfLoader.ConeVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _pyIrfLoader.ConeVector___nonzero__(self)

    def __bool__(self):
        return _pyIrfLoader.ConeVector___bool__(self)

    def __len__(self):
        return _pyIrfLoader.ConeVector___len__(self)

    def __getslice__(self, i, j):
        return _pyIrfLoader.ConeVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _pyIrfLoader.ConeVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _pyIrfLoader.ConeVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _pyIrfLoader.ConeVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _pyIrfLoader.ConeVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _pyIrfLoader.ConeVector___setitem__(self, *args)

    def pop(self):
        return _pyIrfLoader.ConeVector_pop(self)

    def append(self, x):
        return _pyIrfLoader.ConeVector_append(self, x)

    def empty(self):
        return _pyIrfLoader.ConeVector_empty(self)

    def size(self):
        return _pyIrfLoader.ConeVector_size(self)

    def swap(self, v):
        return _pyIrfLoader.ConeVector_swap(self, v)

    def begin(self):
        return _pyIrfLoader.ConeVector_begin(self)

    def end(self):
        return _pyIrfLoader.ConeVector_end(self)

    def rbegin(self):
        return _pyIrfLoader.ConeVector_rbegin(self)

    def rend(self):
        return _pyIrfLoader.ConeVector_rend(self)

    def clear(self):
        return _pyIrfLoader.ConeVector_clear(self)

    def get_allocator(self):
        return _pyIrfLoader.ConeVector_get_allocator(self)

    def pop_back(self):
        return _pyIrfLoader.ConeVector_pop_back(self)

    def erase(self, *args):
        return _pyIrfLoader.ConeVector_erase(self, *args)

    def __init__(self, *args):
        this = _pyIrfLoader.new_ConeVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _pyIrfLoader.ConeVector_push_back(self, x)

    def front(self):
        return _pyIrfLoader.ConeVector_front(self)

    def back(self):
        return _pyIrfLoader.ConeVector_back(self)

    def assign(self, n, x):
        return _pyIrfLoader.ConeVector_assign(self, n, x)

    def resize(self, *args):
        return _pyIrfLoader.ConeVector_resize(self, *args)

    def insert(self, *args):
        return _pyIrfLoader.ConeVector_insert(self, *args)

    def reserve(self, n):
        return _pyIrfLoader.ConeVector_reserve(self, n)

    def capacity(self):
        return _pyIrfLoader.ConeVector_capacity(self)
    __swig_destroy__ = _pyIrfLoader.delete_ConeVector
    __del__ = lambda self: None
ConeVector_swigregister = _pyIrfLoader.ConeVector_swigregister
ConeVector_swigregister(ConeVector)

class Hep3Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hep3Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Hep3Vector, name)
    __repr__ = _swig_repr
    X = _pyIrfLoader.Hep3Vector_X
    Y = _pyIrfLoader.Hep3Vector_Y
    Z = _pyIrfLoader.Hep3Vector_Z
    NUM_COORDINATES = _pyIrfLoader.Hep3Vector_NUM_COORDINATES
    SIZE = _pyIrfLoader.Hep3Vector_SIZE

    def __init__(self, *args):
        this = _pyIrfLoader.new_Hep3Vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyIrfLoader.delete_Hep3Vector
    __del__ = lambda self: None

    def __call__(self, *args):
        return _pyIrfLoader.Hep3Vector___call__(self, *args)

    def x(self):
        return _pyIrfLoader.Hep3Vector_x(self)

    def y(self):
        return _pyIrfLoader.Hep3Vector_y(self)

    def z(self):
        return _pyIrfLoader.Hep3Vector_z(self)

    def setX(self, arg2):
        return _pyIrfLoader.Hep3Vector_setX(self, arg2)

    def setY(self, arg2):
        return _pyIrfLoader.Hep3Vector_setY(self, arg2)

    def setZ(self, arg2):
        return _pyIrfLoader.Hep3Vector_setZ(self, arg2)

    def set(self, x, y, z):
        return _pyIrfLoader.Hep3Vector_set(self, x, y, z)

    def phi(self):
        return _pyIrfLoader.Hep3Vector_phi(self)

    def mag2(self):
        return _pyIrfLoader.Hep3Vector_mag2(self)

    def mag(self):
        return _pyIrfLoader.Hep3Vector_mag(self)

    def setPhi(self, arg2):
        return _pyIrfLoader.Hep3Vector_setPhi(self, arg2)

    def setTheta(self, arg2):
        return _pyIrfLoader.Hep3Vector_setTheta(self, arg2)

    def setMag(self, arg2):
        return _pyIrfLoader.Hep3Vector_setMag(self, arg2)

    def setPerp(self, arg2):
        return _pyIrfLoader.Hep3Vector_setPerp(self, arg2)

    def setCylTheta(self, arg2):
        return _pyIrfLoader.Hep3Vector_setCylTheta(self, arg2)

    def perp2(self, *args):
        return _pyIrfLoader.Hep3Vector_perp2(self, *args)

    def perp(self, *args):
        return _pyIrfLoader.Hep3Vector_perp(self, *args)

    def __eq__(self, arg2):
        return _pyIrfLoader.Hep3Vector___eq__(self, arg2)

    def __ne__(self, arg2):
        return _pyIrfLoader.Hep3Vector___ne__(self, arg2)

    def isNear(self, *args):
        return _pyIrfLoader.Hep3Vector_isNear(self, *args)

    def howNear(self, v):
        return _pyIrfLoader.Hep3Vector_howNear(self, v)

    def deltaR(self, v):
        return _pyIrfLoader.Hep3Vector_deltaR(self, v)

    def __iadd__(self, arg2):
        return _pyIrfLoader.Hep3Vector___iadd__(self, arg2)

    def __isub__(self, arg2):
        return _pyIrfLoader.Hep3Vector___isub__(self, arg2)

    def __neg__(self):
        return _pyIrfLoader.Hep3Vector___neg__(self)

    def __itruediv__(self, *args):
        return _pyIrfLoader.Hep3Vector___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def unit(self):
        return _pyIrfLoader.Hep3Vector_unit(self)

    def orthogonal(self):
        return _pyIrfLoader.Hep3Vector_orthogonal(self)

    def dot(self, arg2):
        return _pyIrfLoader.Hep3Vector_dot(self, arg2)

    def cross(self, arg2):
        return _pyIrfLoader.Hep3Vector_cross(self, arg2)

    def pseudoRapidity(self):
        return _pyIrfLoader.Hep3Vector_pseudoRapidity(self)

    def setEta(self, p):
        return _pyIrfLoader.Hep3Vector_setEta(self, p)

    def setCylEta(self, p):
        return _pyIrfLoader.Hep3Vector_setCylEta(self, p)

    def rotateX(self, arg2):
        return _pyIrfLoader.Hep3Vector_rotateX(self, arg2)

    def rotateY(self, arg2):
        return _pyIrfLoader.Hep3Vector_rotateY(self, arg2)

    def rotateZ(self, arg2):
        return _pyIrfLoader.Hep3Vector_rotateZ(self, arg2)

    def rotateUz(self, arg2):
        return _pyIrfLoader.Hep3Vector_rotateUz(self, arg2)

    def __imul__(self, *args):
        return _pyIrfLoader.Hep3Vector___imul__(self, *args)

    def transform(self, arg2):
        return _pyIrfLoader.Hep3Vector_transform(self, arg2)

    def setRThetaPhi(self, r, theta, phi):
        return _pyIrfLoader.Hep3Vector_setRThetaPhi(self, r, theta, phi)

    def setREtaPhi(self, r, eta, phi):
        return _pyIrfLoader.Hep3Vector_setREtaPhi(self, r, eta, phi)

    def setRhoPhiZ(self, rho, phi, z):
        return _pyIrfLoader.Hep3Vector_setRhoPhiZ(self, rho, phi, z)

    def setRhoPhiTheta(self, rho, phi, theta):
        return _pyIrfLoader.Hep3Vector_setRhoPhiTheta(self, rho, phi, theta)

    def setRhoPhiEta(self, rho, phi, eta):
        return _pyIrfLoader.Hep3Vector_setRhoPhiEta(self, rho, phi, eta)

    def getX(self):
        return _pyIrfLoader.Hep3Vector_getX(self)

    def getY(self):
        return _pyIrfLoader.Hep3Vector_getY(self)

    def getZ(self):
        return _pyIrfLoader.Hep3Vector_getZ(self)

    def getR(self):
        return _pyIrfLoader.Hep3Vector_getR(self)

    def getTheta(self):
        return _pyIrfLoader.Hep3Vector_getTheta(self)

    def getPhi(self):
        return _pyIrfLoader.Hep3Vector_getPhi(self)

    def r(self):
        return _pyIrfLoader.Hep3Vector_r(self)

    def rho(self):
        return _pyIrfLoader.Hep3Vector_rho(self)

    def getRho(self):
        return _pyIrfLoader.Hep3Vector_getRho(self)

    def getEta(self):
        return _pyIrfLoader.Hep3Vector_getEta(self)

    def setR(self, s):
        return _pyIrfLoader.Hep3Vector_setR(self, s)

    def setRho(self, s):
        return _pyIrfLoader.Hep3Vector_setRho(self, s)

    def compare(self, v):
        return _pyIrfLoader.Hep3Vector_compare(self, v)

    def __gt__(self, v):
        return _pyIrfLoader.Hep3Vector___gt__(self, v)

    def __lt__(self, v):
        return _pyIrfLoader.Hep3Vector___lt__(self, v)

    def __ge__(self, v):
        return _pyIrfLoader.Hep3Vector___ge__(self, v)

    def __le__(self, v):
        return _pyIrfLoader.Hep3Vector___le__(self, v)

    def diff2(self, v):
        return _pyIrfLoader.Hep3Vector_diff2(self, v)
    if _newclass:
        setTolerance = staticmethod(_pyIrfLoader.Hep3Vector_setTolerance)
    else:
        setTolerance = _pyIrfLoader.Hep3Vector_setTolerance
    if _newclass:
        getTolerance = staticmethod(_pyIrfLoader.Hep3Vector_getTolerance)
    else:
        getTolerance = _pyIrfLoader.Hep3Vector_getTolerance

    def isParallel(self, *args):
        return _pyIrfLoader.Hep3Vector_isParallel(self, *args)

    def isOrthogonal(self, *args):
        return _pyIrfLoader.Hep3Vector_isOrthogonal(self, *args)

    def howParallel(self, v):
        return _pyIrfLoader.Hep3Vector_howParallel(self, v)

    def howOrthogonal(self, v):
        return _pyIrfLoader.Hep3Vector_howOrthogonal(self, v)
    ToleranceTicks = _pyIrfLoader.Hep3Vector_ToleranceTicks

    def beta(self):
        return _pyIrfLoader.Hep3Vector_beta(self)

    def gamma(self):
        return _pyIrfLoader.Hep3Vector_gamma(self)

    def coLinearRapidity(self):
        return _pyIrfLoader.Hep3Vector_coLinearRapidity(self)

    def angle(self, *args):
        return _pyIrfLoader.Hep3Vector_angle(self, *args)

    def theta(self, *args):
        return _pyIrfLoader.Hep3Vector_theta(self, *args)

    def cosTheta(self, *args):
        return _pyIrfLoader.Hep3Vector_cosTheta(self, *args)

    def cos2Theta(self, *args):
        return _pyIrfLoader.Hep3Vector_cos2Theta(self, *args)

    def project(self, *args):
        return _pyIrfLoader.Hep3Vector_project(self, *args)

    def perpPart(self, *args):
        return _pyIrfLoader.Hep3Vector_perpPart(self, *args)

    def rapidity(self, *args):
        return _pyIrfLoader.Hep3Vector_rapidity(self, *args)

    def eta(self, *args):
        return _pyIrfLoader.Hep3Vector_eta(self, *args)

    def deltaPhi(self, v2):
        return _pyIrfLoader.Hep3Vector_deltaPhi(self, v2)

    def polarAngle(self, *args):
        return _pyIrfLoader.Hep3Vector_polarAngle(self, *args)

    def azimAngle(self, *args):
        return _pyIrfLoader.Hep3Vector_azimAngle(self, *args)

    def rotate(self, *args):
        return _pyIrfLoader.Hep3Vector_rotate(self, *args)
Hep3Vector_swigregister = _pyIrfLoader.Hep3Vector_swigregister
Hep3Vector_swigregister(Hep3Vector)

def Hep3Vector_setTolerance(tol):
    return _pyIrfLoader.Hep3Vector_setTolerance(tol)
Hep3Vector_setTolerance = _pyIrfLoader.Hep3Vector_setTolerance

def Hep3Vector_getTolerance():
    return _pyIrfLoader.Hep3Vector_getTolerance()
Hep3Vector_getTolerance = _pyIrfLoader.Hep3Vector_getTolerance


def rotationXOf(vec, delta):
    return _pyIrfLoader.rotationXOf(vec, delta)
rotationXOf = _pyIrfLoader.rotationXOf

def rotationYOf(vec, delta):
    return _pyIrfLoader.rotationYOf(vec, delta)
rotationYOf = _pyIrfLoader.rotationYOf

def rotationZOf(vec, delta):
    return _pyIrfLoader.rotationZOf(vec, delta)
rotationZOf = _pyIrfLoader.rotationZOf

def rotationOf(*args):
    return _pyIrfLoader.rotationOf(*args)
rotationOf = _pyIrfLoader.rotationOf

def __lshift__(arg1, arg2):
    return _pyIrfLoader.__lshift__(arg1, arg2)
__lshift__ = _pyIrfLoader.__lshift__

def __rshift__(arg1, arg2):
    return _pyIrfLoader.__rshift__(arg1, arg2)
__rshift__ = _pyIrfLoader.__rshift__

def __truediv__(arg1, a):
    return _pyIrfLoader.__truediv__(arg1, a)
__truediv__ = _pyIrfLoader.__truediv__

def __add__(arg1, arg2):
    return _pyIrfLoader.__add__(arg1, arg2)
__add__ = _pyIrfLoader.__add__

def __sub__(arg1, arg2):
    return _pyIrfLoader.__sub__(arg1, arg2)
__sub__ = _pyIrfLoader.__sub__

def __mul__(*args):
    return _pyIrfLoader.__mul__(*args)
__mul__ = _pyIrfLoader.__mul__
ASTRO_D2R = _pyIrfLoader.ASTRO_D2R
ASTRO_R2D = _pyIrfLoader.ASTRO_R2D
ASTRO_PIOVER2 = _pyIrfLoader.ASTRO_PIOVER2
ASTRO_4PI = _pyIrfLoader.ASTRO_4PI

def degToRad(deg):
    return _pyIrfLoader.degToRad(deg)
degToRad = _pyIrfLoader.degToRad

def radToDeg(rad):
    return _pyIrfLoader.radToDeg(rad)
radToDeg = _pyIrfLoader.radToDeg

def latToTheta_Deg(lat):
    return _pyIrfLoader.latToTheta_Deg(lat)
latToTheta_Deg = _pyIrfLoader.latToTheta_Deg

def thetaToLat_Deg(theta):
    return _pyIrfLoader.thetaToLat_Deg(theta)
thetaToLat_Deg = _pyIrfLoader.thetaToLat_Deg

def latToTheta_Rad(lat):
    return _pyIrfLoader.latToTheta_Rad(lat)
latToTheta_Rad = _pyIrfLoader.latToTheta_Rad

def thetaToLat_Rad(theta):
    return _pyIrfLoader.thetaToLat_Rad(theta)
thetaToLat_Rad = _pyIrfLoader.thetaToLat_Rad
class ProjBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProjBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    WCS = _pyIrfLoader.ProjBase_WCS
    HEALPIX = _pyIrfLoader.ProjBase_HEALPIX
    UNKNOWN = _pyIrfLoader.ProjBase_UNKNOWN
    __swig_destroy__ = _pyIrfLoader.delete_ProjBase
    __del__ = lambda self: None

    def clone(self):
        return _pyIrfLoader.ProjBase_clone(self)

    def sph2pix(self, s1, s2):
        return _pyIrfLoader.ProjBase_sph2pix(self, s1, s2)

    def pix2pix(self, x1, x2, otherProjection):
        return _pyIrfLoader.ProjBase_pix2pix(self, x1, x2, otherProjection)

    def pix2sph(self, x1, x2):
        return _pyIrfLoader.ProjBase_pix2sph(self, x1, x2)

    def isGalactic(self):
        return _pyIrfLoader.ProjBase_isGalactic(self)

    def projType(self):
        return _pyIrfLoader.ProjBase_projType(self)

    def method(self):
        return _pyIrfLoader.ProjBase_method(self)

    def range(self, x1, xvar):
        return _pyIrfLoader.ProjBase_range(self, x1, xvar)

    def testpix2sph(self, x1, x2):
        return _pyIrfLoader.ProjBase_testpix2sph(self, x1, x2)

    def setKeywords(self, header):
        return _pyIrfLoader.ProjBase_setKeywords(self, header)
ProjBase_swigregister = _pyIrfLoader.ProjBase_swigregister
ProjBase_swigregister(ProjBase)
cvar = _pyIrfLoader.cvar
HepXHat = cvar.HepXHat
HepYHat = cvar.HepYHat
HepZHat = cvar.HepZHat

class SkyProj(ProjBase):
    __swig_setmethods__ = {}
    for _s in [ProjBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SkyProj, name, value)
    __swig_getmethods__ = {}
    for _s in [ProjBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SkyProj, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_SkyProj
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _pyIrfLoader.new_SkyProj(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        return _pyIrfLoader.SkyProj_clone(self)

    def sph2pix(self, s1, s2):
        return _pyIrfLoader.SkyProj_sph2pix(self, s1, s2)

    def pix2pix(self, x1, x2, otherProjection):
        return _pyIrfLoader.SkyProj_pix2pix(self, x1, x2, otherProjection)

    def pix2sph(self, x1, x2):
        return _pyIrfLoader.SkyProj_pix2sph(self, x1, x2)

    def range(self, x1, xvar):
        return _pyIrfLoader.SkyProj_range(self, x1, xvar)

    def testpix2sph(self, x1, x2):
        return _pyIrfLoader.SkyProj_testpix2sph(self, x1, x2)

    def setKeywords(self, header):
        return _pyIrfLoader.SkyProj_setKeywords(self, header)
SkyProj_swigregister = _pyIrfLoader.SkyProj_swigregister
SkyProj_swigregister(SkyProj)

class HealpixProj(ProjBase):
    __swig_setmethods__ = {}
    for _s in [ProjBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HealpixProj, name, value)
    __swig_getmethods__ = {}
    for _s in [ProjBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HealpixProj, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_HealpixProj
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _pyIrfLoader.new_HealpixProj(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        return _pyIrfLoader.HealpixProj_clone(self)

    def sph2pix(self, s1, s2):
        return _pyIrfLoader.HealpixProj_sph2pix(self, s1, s2)

    def pix2pix(self, x1, x2, otherProjection):
        return _pyIrfLoader.HealpixProj_pix2pix(self, x1, x2, otherProjection)

    def pix2sph(self, x1, x2):
        return _pyIrfLoader.HealpixProj_pix2sph(self, x1, x2)

    def range(self, x1, xvar):
        return _pyIrfLoader.HealpixProj_range(self, x1, xvar)

    def testpix2sph(self, x1, x2):
        return _pyIrfLoader.HealpixProj_testpix2sph(self, x1, x2)

    def setKeywords(self, header):
        return _pyIrfLoader.HealpixProj_setKeywords(self, header)

    def healpix(self):
        return _pyIrfLoader.HealpixProj_healpix(self)

    def convertToPointing(self, dir):
        return _pyIrfLoader.HealpixProj_convertToPointing(self, dir)
HealpixProj_swigregister = _pyIrfLoader.HealpixProj_swigregister
HealpixProj_swigregister(HealpixProj)

class SkyDir(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SkyDir, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SkyDir, name)
    __repr__ = _swig_repr
    GALACTIC = _pyIrfLoader.SkyDir_GALACTIC
    EQUATORIAL = _pyIrfLoader.SkyDir_EQUATORIAL

    def __init__(self, *args):
        this = _pyIrfLoader.new_SkyDir(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, *args):
        return _pyIrfLoader.SkyDir___call__(self, *args)

    def l(self):
        return _pyIrfLoader.SkyDir_l(self)

    def b(self):
        return _pyIrfLoader.SkyDir_b(self)

    def ra(self):
        return _pyIrfLoader.SkyDir_ra(self)

    def dec(self):
        return _pyIrfLoader.SkyDir_dec(self)

    def dir(self):
        return _pyIrfLoader.SkyDir_dir(self)

    def difference(self, other):
        return _pyIrfLoader.SkyDir_difference(self, other)

    def project(self, projection):
        return _pyIrfLoader.SkyDir_project(self, projection)

    def isValid(self):
        return _pyIrfLoader.SkyDir_isValid(self)

    def zenithCoords(self, zenithDir):
        return _pyIrfLoader.SkyDir_zenithCoords(self, zenithDir)

    def cross(self, *args):
        return _pyIrfLoader.SkyDir_cross(self, *args)

    def dot(self, *args):
        return _pyIrfLoader.SkyDir_dot(self, *args)
    __swig_destroy__ = _pyIrfLoader.delete_SkyDir
    __del__ = lambda self: None
SkyDir_swigregister = _pyIrfLoader.SkyDir_swigregister
SkyDir_swigregister(SkyDir)

class AcceptanceCone(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AcceptanceCone, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AcceptanceCone, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _pyIrfLoader.new_AcceptanceCone(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def center(self):
        return _pyIrfLoader.AcceptanceCone_center(self)

    def radius(self):
        return _pyIrfLoader.AcceptanceCone_radius(self)

    def __eq__(self, rhs):
        return _pyIrfLoader.AcceptanceCone___eq__(self, rhs)

    def __ne__(self, rhs):
        return _pyIrfLoader.AcceptanceCone___ne__(self, rhs)

    def inside(self, dir):
        return _pyIrfLoader.AcceptanceCone_inside(self, dir)

    def clone(self):
        return _pyIrfLoader.AcceptanceCone_clone(self)
    __swig_destroy__ = _pyIrfLoader.delete_AcceptanceCone
    __del__ = lambda self: None
AcceptanceCone_swigregister = _pyIrfLoader.AcceptanceCone_swigregister
AcceptanceCone_swigregister(AcceptanceCone)

class IAeff(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IAeff, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IAeff, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_IAeff
    __del__ = lambda self: None

    def value(self, *args):
        return _pyIrfLoader.IAeff_value(self, *args)

    def __call__(self, energy, srcDir, scZAxis, scXAxis, time=0):
        return _pyIrfLoader.IAeff___call__(self, energy, srcDir, scZAxis, scXAxis, time)

    def clone(self):
        return _pyIrfLoader.IAeff_clone(self)

    def upperLimit(self):
        return _pyIrfLoader.IAeff_upperLimit(self)

    def setPhiDependence(self, usePhiDependence):
        return _pyIrfLoader.IAeff_setPhiDependence(self, usePhiDependence)

    def usePhiDependence(self):
        return _pyIrfLoader.IAeff_usePhiDependence(self)
IAeff_swigregister = _pyIrfLoader.IAeff_swigregister
IAeff_swigregister(IAeff)

class IPsf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IPsf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IPsf, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_IPsf
    __del__ = lambda self: None

    def __call__(self, appDir, energy, srcDir, scZAxis, scXAxis, time=0):
        return _pyIrfLoader.IPsf___call__(self, appDir, energy, srcDir, scZAxis, scXAxis, time)

    def angularIntegral(self, *args):
        return _pyIrfLoader.IPsf_angularIntegral(self, *args)

    def angularContainment(self, *args):
        return _pyIrfLoader.IPsf_angularContainment(self, *args)

    def appDir(self, energy, srcDir, scZAxis, scXAxis, time=0):
        return _pyIrfLoader.IPsf_appDir(self, energy, srcDir, scZAxis, scXAxis, time)

    def clone(self):
        return _pyIrfLoader.IPsf_clone(self)
    if _newclass:
        psfIntegral = staticmethod(_pyIrfLoader.IPsf_psfIntegral)
    else:
        psfIntegral = _pyIrfLoader.IPsf_psfIntegral

    def app_dir(self, energy, inclination):
        return _pyIrfLoader.IPsf_app_dir(self, energy, inclination)

    def value(self, *args):
        return _pyIrfLoader.IPsf_value(self, *args)
IPsf_swigregister = _pyIrfLoader.IPsf_swigregister
IPsf_swigregister(IPsf)

def IPsf_psfIntegral(*args):
    return _pyIrfLoader.IPsf_psfIntegral(*args)
IPsf_psfIntegral = _pyIrfLoader.IPsf_psfIntegral

class IEdisp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IEdisp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IEdisp, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_IEdisp
    __del__ = lambda self: None

    def __call__(self, appEnergy, energy, srcDir, scZAxis, scXAxis, time=0):
        return _pyIrfLoader.IEdisp___call__(self, appEnergy, energy, srcDir, scZAxis, scXAxis, time)

    def appEnergy(self, energy, srcDir, scZAxis, scXAxis, time=0):
        return _pyIrfLoader.IEdisp_appEnergy(self, energy, srcDir, scZAxis, scXAxis, time)

    def integral(self, *args):
        return _pyIrfLoader.IEdisp_integral(self, *args)

    def meanAppEnergy(self, *args):
        return _pyIrfLoader.IEdisp_meanAppEnergy(self, *args)

    def meanTrueEnergy(self, *args):
        return _pyIrfLoader.IEdisp_meanTrueEnergy(self, *args)

    def clone(self):
        return _pyIrfLoader.IEdisp_clone(self)

    def value(self, *args):
        return _pyIrfLoader.IEdisp_value(self, *args)
IEdisp_swigregister = _pyIrfLoader.IEdisp_swigregister
IEdisp_swigregister(IEdisp)

class IEfficiencyFactor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IEfficiencyFactor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IEfficiencyFactor, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_IEfficiencyFactor
    __del__ = lambda self: None

    def __call__(self, energy, met):
        return _pyIrfLoader.IEfficiencyFactor___call__(self, energy, met)

    def value(self, *args):
        return _pyIrfLoader.IEfficiencyFactor_value(self, *args)

    def getLivetimeFactors(self, energy, factor1, factor2, met=0):
        return _pyIrfLoader.IEfficiencyFactor_getLivetimeFactors(self, energy, factor1, factor2, met)

    def clone(self):
        return _pyIrfLoader.IEfficiencyFactor_clone(self)

    def readFt2File(self, ft2file):
        return _pyIrfLoader.IEfficiencyFactor_readFt2File(self, ft2file)

    def clearFt2Data(self):
        return _pyIrfLoader.IEfficiencyFactor_clearFt2Data(self)
IEfficiencyFactor_swigregister = _pyIrfLoader.IEfficiencyFactor_swigregister
IEfficiencyFactor_swigregister(IEfficiencyFactor)

class Irfs(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Irfs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Irfs, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _pyIrfLoader.new_Irfs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyIrfLoader.delete_Irfs
    __del__ = lambda self: None

    def aeff(self):
        return _pyIrfLoader.Irfs_aeff(self)

    def psf(self):
        return _pyIrfLoader.Irfs_psf(self)

    def edisp(self):
        return _pyIrfLoader.Irfs_edisp(self)

    def efficiencyFactor(self):
        return _pyIrfLoader.Irfs_efficiencyFactor(self)

    def setEfficiencyFactor(self, eff):
        return _pyIrfLoader.Irfs_setEfficiencyFactor(self, eff)

    def setAeff(self, aeff):
        return _pyIrfLoader.Irfs_setAeff(self, aeff)

    def setPsf(self, psf):
        return _pyIrfLoader.Irfs_setPsf(self, psf)

    def setEdisp(self, edisp):
        return _pyIrfLoader.Irfs_setEdisp(self, edisp)

    def clone(self):
        return _pyIrfLoader.Irfs_clone(self)

    def irfID(self):
        return _pyIrfLoader.Irfs_irfID(self)

    def setIrfID(self, irfID):
        return _pyIrfLoader.Irfs_setIrfID(self, irfID)
Irfs_swigregister = _pyIrfLoader.Irfs_swigregister
Irfs_swigregister(Irfs)

class IrfsFactory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IrfsFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IrfsFactory, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(self, name):
        return _pyIrfLoader.IrfsFactory_create(self, name)

    def addIrfs(self, name, irfs, verbose=False):
        return _pyIrfLoader.IrfsFactory_addIrfs(self, name, irfs, verbose)

    def getIrfsNames(self, names):
        return _pyIrfLoader.IrfsFactory_getIrfsNames(self, names)
    if _newclass:
        instance = staticmethod(_pyIrfLoader.IrfsFactory_instance)
    else:
        instance = _pyIrfLoader.IrfsFactory_instance
    if _newclass:
        delete_instance = staticmethod(_pyIrfLoader.IrfsFactory_delete_instance)
    else:
        delete_instance = _pyIrfLoader.IrfsFactory_delete_instance

    def irfNames(self, *args):
        return _pyIrfLoader.IrfsFactory_irfNames(self, *args)
IrfsFactory_swigregister = _pyIrfLoader.IrfsFactory_swigregister
IrfsFactory_swigregister(IrfsFactory)

def IrfsFactory_instance():
    return _pyIrfLoader.IrfsFactory_instance()
IrfsFactory_instance = _pyIrfLoader.IrfsFactory_instance

def IrfsFactory_delete_instance():
    return _pyIrfLoader.IrfsFactory_delete_instance()
IrfsFactory_delete_instance = _pyIrfLoader.IrfsFactory_delete_instance

class Loader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Loader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Loader, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    if _newclass:
        go = staticmethod(_pyIrfLoader.Loader_go)
    else:
        go = _pyIrfLoader.Loader_go
    if _newclass:
        respIds = staticmethod(_pyIrfLoader.Loader_respIds)
    else:
        respIds = _pyIrfLoader.Loader_respIds
Loader_swigregister = _pyIrfLoader.Loader_swigregister
Loader_swigregister(Loader)

def Loader_go(*args):
    return _pyIrfLoader.Loader_go(*args)
Loader_go = _pyIrfLoader.Loader_go

def Loader_respIds():
    return _pyIrfLoader.Loader_respIds()
Loader_respIds = _pyIrfLoader.Loader_respIds

class Bilinear(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bilinear, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Bilinear, name)
    __repr__ = _swig_repr

    def __init__(self, x, y, values, xlo, xhi, ylo, yhi):
        this = _pyIrfLoader.new_Bilinear(x, y, values, xlo, xhi, ylo, yhi)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, x, y):
        return _pyIrfLoader.Bilinear___call__(self, x, y)

    def getCorners(self, x, y, tt, uu, corner_xvals, corner_yvals, zvals):
        return _pyIrfLoader.Bilinear_getCorners(self, x, y, tt, uu, corner_xvals, corner_yvals, zvals)
    if _newclass:
        evaluate = staticmethod(_pyIrfLoader.Bilinear_evaluate)
    else:
        evaluate = _pyIrfLoader.Bilinear_evaluate

    def getPar(self, i, j):
        return _pyIrfLoader.Bilinear_getPar(self, i, j)

    def setPar(self, i, j, value):
        return _pyIrfLoader.Bilinear_setPar(self, i, j, value)
    __swig_destroy__ = _pyIrfLoader.delete_Bilinear
    __del__ = lambda self: None
Bilinear_swigregister = _pyIrfLoader.Bilinear_swigregister
Bilinear_swigregister(Bilinear)

def Bilinear_evaluate(tt, uu, zvals):
    return _pyIrfLoader.Bilinear_evaluate(tt, uu, zvals)
Bilinear_evaluate = _pyIrfLoader.Bilinear_evaluate

class ParTables(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParTables, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ParTables, name)
    __repr__ = _swig_repr

    def __init__(self, fitsfile, extname, nrow=0):
        this = _pyIrfLoader.new_ParTables(fitsfile, extname, nrow)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def parNames(self):
        return _pyIrfLoader.ParTables_parNames(self)

    def getParVector(self, parName, pars):
        return _pyIrfLoader.ParTables_getParVector(self, parName, pars)

    def getCornerPars(self, logE, costh, tt, uu, cornerEnergies, parVectors):
        return _pyIrfLoader.ParTables_getCornerPars(self, logE, costh, tt, uu, cornerEnergies, parVectors)

    def logEnergies(self):
        return _pyIrfLoader.ParTables_logEnergies(self)

    def costhetas(self):
        return _pyIrfLoader.ParTables_costhetas(self)

    def ebounds(self):
        return _pyIrfLoader.ParTables_ebounds(self)

    def tbounds(self):
        return _pyIrfLoader.ParTables_tbounds(self)

    def getPars(self, *args):
        return _pyIrfLoader.ParTables_getPars(self, *args)

    def setPars(self, ilogE, icosth, pars):
        return _pyIrfLoader.ParTables_setPars(self, ilogE, icosth, pars)

    def params(self, indx):
        return _pyIrfLoader.ParTables_params(self, indx)

    def setParams(self, indx, params):
        return _pyIrfLoader.ParTables_setParams(self, indx, params)
    __swig_destroy__ = _pyIrfLoader.delete_ParTables
    __del__ = lambda self: None
ParTables_swigregister = _pyIrfLoader.ParTables_swigregister
ParTables_swigregister(ParTables)

class Aeff(IAeff):
    __swig_setmethods__ = {}
    for _s in [IAeff]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Aeff, name, value)
    __swig_getmethods__ = {}
    for _s in [IAeff]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Aeff, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _pyIrfLoader.new_Aeff(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyIrfLoader.delete_Aeff
    __del__ = lambda self: None

    def value(self, *args):
        return _pyIrfLoader.Aeff_value(self, *args)

    def clone(self):
        return _pyIrfLoader.Aeff_clone(self)

    def upperLimit(self):
        return _pyIrfLoader.Aeff_upperLimit(self)

    def max_phi_modulation(self):
        return _pyIrfLoader.Aeff_max_phi_modulation(self)

    def pars(self, logE, costh, interpolate=False):
        return _pyIrfLoader.Aeff_pars(self, logE, costh, interpolate)

    def phi_modulation(self, logE, costheta, phi, interpolate):
        return _pyIrfLoader.Aeff_phi_modulation(self, logE, costheta, phi, interpolate)

    def logEnergies(self):
        return _pyIrfLoader.Aeff_logEnergies(self)

    def costhetas(self):
        return _pyIrfLoader.Aeff_costhetas(self)

    def values(self):
        return _pyIrfLoader.Aeff_values(self)

    def setValues(self, values):
        return _pyIrfLoader.Aeff_setValues(self, values)
    if _newclass:
        cast = staticmethod(_pyIrfLoader.Aeff_cast)
    else:
        cast = _pyIrfLoader.Aeff_cast
Aeff_swigregister = _pyIrfLoader.Aeff_swigregister
Aeff_swigregister(Aeff)

def Aeff_cast(iaeff):
    return _pyIrfLoader.Aeff_cast(iaeff)
Aeff_cast = _pyIrfLoader.Aeff_cast

class PsfBase(IPsf):
    __swig_setmethods__ = {}
    for _s in [IPsf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PsfBase, name, value)
    __swig_getmethods__ = {}
    for _s in [IPsf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PsfBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyIrfLoader.delete_PsfBase
    __del__ = lambda self: None

    def scaleFactor(self, energy, isFront):
        return _pyIrfLoader.PsfBase_scaleFactor(self, energy, isFront)
PsfBase_swigregister = _pyIrfLoader.PsfBase_swigregister
PsfBase_swigregister(PsfBase)

class Psf3(PsfBase):
    __swig_setmethods__ = {}
    for _s in [PsfBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Psf3, name, value)
    __swig_getmethods__ = {}
    for _s in [PsfBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Psf3, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _pyIrfLoader.new_Psf3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyIrfLoader.delete_Psf3
    __del__ = lambda self: None

    def value(self, *args):
        return _pyIrfLoader.Psf3_value(self, *args)

    def angularIntegral(self, *args):
        return _pyIrfLoader.Psf3_angularIntegral(self, *args)

    def nparams(self):
        return _pyIrfLoader.Psf3_nparams(self)

    def params(self, indx):
        return _pyIrfLoader.Psf3_params(self, indx)

    def energies(self):
        return _pyIrfLoader.Psf3_energies(self)

    def logEnergies(self):
        return _pyIrfLoader.Psf3_logEnergies(self)

    def costhetas(self):
        return _pyIrfLoader.Psf3_costhetas(self)

    def thetas(self):
        return _pyIrfLoader.Psf3_thetas(self)

    def clone(self):
        return _pyIrfLoader.Psf3_clone(self)

    def setParams(self, indx, params):
        return _pyIrfLoader.Psf3_setParams(self, indx, params)
    if _newclass:
        findIndex = staticmethod(_pyIrfLoader.Psf3_findIndex)
    else:
        findIndex = _pyIrfLoader.Psf3_findIndex
    if _newclass:
        cast = staticmethod(_pyIrfLoader.Psf3_cast)
    else:
        cast = _pyIrfLoader.Psf3_cast
Psf3_swigregister = _pyIrfLoader.Psf3_swigregister
Psf3_swigregister(Psf3)

def Psf3_findIndex(xx, x):
    return _pyIrfLoader.Psf3_findIndex(xx, x)
Psf3_findIndex = _pyIrfLoader.Psf3_findIndex

def Psf3_cast(ipsf):
    return _pyIrfLoader.Psf3_cast(ipsf)
Psf3_cast = _pyIrfLoader.Psf3_cast

class EdispInterpolator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EdispInterpolator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EdispInterpolator, name)
    __repr__ = _swig_repr

    def __init__(self, fitsfile, extname, nrow):
        this = _pyIrfLoader.new_EdispInterpolator(fitsfile, extname, nrow)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyIrfLoader.delete_EdispInterpolator
    __del__ = lambda self: None

    def fitsfile(self):
        return _pyIrfLoader.EdispInterpolator_fitsfile(self)

    def extname(self):
        return _pyIrfLoader.EdispInterpolator_extname(self)

    def nrow(self):
        return _pyIrfLoader.EdispInterpolator_nrow(self)

    def nparams(self):
        return _pyIrfLoader.EdispInterpolator_nparams(self)

    def params(self, indx):
        return _pyIrfLoader.EdispInterpolator_params(self, indx)

    def energies(self):
        return _pyIrfLoader.EdispInterpolator_energies(self)

    def logEnergies(self):
        return _pyIrfLoader.EdispInterpolator_logEnergies(self)

    def costhetas(self):
        return _pyIrfLoader.EdispInterpolator_costhetas(self)

    def thetas(self):
        return _pyIrfLoader.EdispInterpolator_thetas(self)

    def setParams(self, indx, params):
        return _pyIrfLoader.EdispInterpolator_setParams(self, indx, params)
EdispInterpolator_swigregister = _pyIrfLoader.EdispInterpolator_swigregister
EdispInterpolator_swigregister(EdispInterpolator)

class Edisp3(IEdisp):
    __swig_setmethods__ = {}
    for _s in [IEdisp]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Edisp3, name, value)
    __swig_getmethods__ = {}
    for _s in [IEdisp]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Edisp3, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _pyIrfLoader.new_Edisp3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pyIrfLoader.delete_Edisp3
    __del__ = lambda self: None

    def value(self, *args):
        return _pyIrfLoader.Edisp3_value(self, *args)

    def clone(self):
        return _pyIrfLoader.Edisp3_clone(self)

    def scaleFactor(self, energy, costheta):
        return _pyIrfLoader.Edisp3_scaleFactor(self, energy, costheta)

    def evaluate(self, emeas, energy, theta, phi, time, pars):
        return _pyIrfLoader.Edisp3_evaluate(self, emeas, energy, theta, phi, time, pars)

    def renormalize(self, logE, costh, params):
        return _pyIrfLoader.Edisp3_renormalize(self, logE, costh, params)

    def interpolator(self):
        return _pyIrfLoader.Edisp3_interpolator(self)

    def nparams(self):
        return _pyIrfLoader.Edisp3_nparams(self)

    def params(self, indx):
        return _pyIrfLoader.Edisp3_params(self, indx)

    def energies(self):
        return _pyIrfLoader.Edisp3_energies(self)

    def logEnergies(self):
        return _pyIrfLoader.Edisp3_logEnergies(self)

    def costhetas(self):
        return _pyIrfLoader.Edisp3_costhetas(self)

    def thetas(self):
        return _pyIrfLoader.Edisp3_thetas(self)

    def parTables(self):
        return _pyIrfLoader.Edisp3_parTables(self)

    def setParams(self, indx, params):
        return _pyIrfLoader.Edisp3_setParams(self, indx, params)
    if _newclass:
        cast = staticmethod(_pyIrfLoader.Edisp3_cast)
    else:
        cast = _pyIrfLoader.Edisp3_cast
Edisp3_swigregister = _pyIrfLoader.Edisp3_swigregister
Edisp3_swigregister(Edisp3)

def Edisp3_cast(iedisp):
    return _pyIrfLoader.Edisp3_cast(iedisp)
Edisp3_cast = _pyIrfLoader.Edisp3_cast

# This file is compatible with both classic and new-style classes.


