# 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.

"""Interface to skymaps"""


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, '_skymaps')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_skymaps')
    _skymaps = 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('_skymaps', [dirname(__file__)])
        except ImportError:
            import _skymaps
            return _skymaps
        try:
            _mod = imp.load_module('_skymaps', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _skymaps = swig_import_helper()
    del swig_import_helper
else:
    import _skymaps
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__ = _skymaps.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        return _skymaps.svd_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _skymaps.svd___nonzero__(self)

    def __bool__(self):
        return _skymaps.svd___bool__(self)

    def __len__(self):
        return _skymaps.svd___len__(self)

    def __getslice__(self, i, j):
        return _skymaps.svd___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _skymaps.svd___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _skymaps.svd___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _skymaps.svd___delitem__(self, *args)

    def __getitem__(self, *args):
        return _skymaps.svd___getitem__(self, *args)

    def __setitem__(self, *args):
        return _skymaps.svd___setitem__(self, *args)

    def pop(self):
        return _skymaps.svd_pop(self)

    def append(self, x):
        return _skymaps.svd_append(self, x)

    def empty(self):
        return _skymaps.svd_empty(self)

    def size(self):
        return _skymaps.svd_size(self)

    def swap(self, v):
        return _skymaps.svd_swap(self, v)

    def begin(self):
        return _skymaps.svd_begin(self)

    def end(self):
        return _skymaps.svd_end(self)

    def rbegin(self):
        return _skymaps.svd_rbegin(self)

    def rend(self):
        return _skymaps.svd_rend(self)

    def clear(self):
        return _skymaps.svd_clear(self)

    def get_allocator(self):
        return _skymaps.svd_get_allocator(self)

    def pop_back(self):
        return _skymaps.svd_pop_back(self)

    def erase(self, *args):
        return _skymaps.svd_erase(self, *args)

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

    def push_back(self, x):
        return _skymaps.svd_push_back(self, x)

    def front(self):
        return _skymaps.svd_front(self)

    def back(self):
        return _skymaps.svd_back(self)

    def assign(self, n, x):
        return _skymaps.svd_assign(self, n, x)

    def resize(self, *args):
        return _skymaps.svd_resize(self, *args)

    def insert(self, *args):
        return _skymaps.svd_insert(self, *args)

    def reserve(self, n):
        return _skymaps.svd_reserve(self, n)

    def capacity(self):
        return _skymaps.svd_capacity(self)
    __swig_destroy__ = _skymaps.delete_svd
    __del__ = lambda self: None
svd_swigregister = _skymaps.svd_swigregister
svd_swigregister(svd)

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

    def iterator(self):
        return _skymaps.SkyDirVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _skymaps.SkyDirVector___nonzero__(self)

    def __bool__(self):
        return _skymaps.SkyDirVector___bool__(self)

    def __len__(self):
        return _skymaps.SkyDirVector___len__(self)

    def __getslice__(self, i, j):
        return _skymaps.SkyDirVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _skymaps.SkyDirVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _skymaps.SkyDirVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _skymaps.SkyDirVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _skymaps.SkyDirVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _skymaps.SkyDirVector___setitem__(self, *args)

    def pop(self):
        return _skymaps.SkyDirVector_pop(self)

    def append(self, x):
        return _skymaps.SkyDirVector_append(self, x)

    def empty(self):
        return _skymaps.SkyDirVector_empty(self)

    def size(self):
        return _skymaps.SkyDirVector_size(self)

    def swap(self, v):
        return _skymaps.SkyDirVector_swap(self, v)

    def begin(self):
        return _skymaps.SkyDirVector_begin(self)

    def end(self):
        return _skymaps.SkyDirVector_end(self)

    def rbegin(self):
        return _skymaps.SkyDirVector_rbegin(self)

    def rend(self):
        return _skymaps.SkyDirVector_rend(self)

    def clear(self):
        return _skymaps.SkyDirVector_clear(self)

    def get_allocator(self):
        return _skymaps.SkyDirVector_get_allocator(self)

    def pop_back(self):
        return _skymaps.SkyDirVector_pop_back(self)

    def erase(self, *args):
        return _skymaps.SkyDirVector_erase(self, *args)

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

    def push_back(self, x):
        return _skymaps.SkyDirVector_push_back(self, x)

    def front(self):
        return _skymaps.SkyDirVector_front(self)

    def back(self):
        return _skymaps.SkyDirVector_back(self)

    def assign(self, n, x):
        return _skymaps.SkyDirVector_assign(self, n, x)

    def resize(self, *args):
        return _skymaps.SkyDirVector_resize(self, *args)

    def insert(self, *args):
        return _skymaps.SkyDirVector_insert(self, *args)

    def reserve(self, n):
        return _skymaps.SkyDirVector_reserve(self, n)

    def capacity(self):
        return _skymaps.SkyDirVector_capacity(self)
    __swig_destroy__ = _skymaps.delete_SkyDirVector
    __del__ = lambda self: None
SkyDirVector_swigregister = _skymaps.SkyDirVector_swigregister
SkyDirVector_swigregister(SkyDirVector)

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 = _skymaps.new_DoublePair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _skymaps.DoublePair_first_set
    __swig_getmethods__["first"] = _skymaps.DoublePair_first_get
    if _newclass:
        first = _swig_property(_skymaps.DoublePair_first_get, _skymaps.DoublePair_first_set)
    __swig_setmethods__["second"] = _skymaps.DoublePair_second_set
    __swig_getmethods__["second"] = _skymaps.DoublePair_second_get
    if _newclass:
        second = _swig_property(_skymaps.DoublePair_second_get, _skymaps.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__ = _skymaps.delete_DoublePair
    __del__ = lambda self: None
DoublePair_swigregister = _skymaps.DoublePair_swigregister
DoublePair_swigregister(DoublePair)

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

    def iterator(self):
        return _skymaps.FloatVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _skymaps.FloatVector___nonzero__(self)

    def __bool__(self):
        return _skymaps.FloatVector___bool__(self)

    def __len__(self):
        return _skymaps.FloatVector___len__(self)

    def __getslice__(self, i, j):
        return _skymaps.FloatVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _skymaps.FloatVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _skymaps.FloatVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _skymaps.FloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _skymaps.FloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _skymaps.FloatVector___setitem__(self, *args)

    def pop(self):
        return _skymaps.FloatVector_pop(self)

    def append(self, x):
        return _skymaps.FloatVector_append(self, x)

    def empty(self):
        return _skymaps.FloatVector_empty(self)

    def size(self):
        return _skymaps.FloatVector_size(self)

    def swap(self, v):
        return _skymaps.FloatVector_swap(self, v)

    def begin(self):
        return _skymaps.FloatVector_begin(self)

    def end(self):
        return _skymaps.FloatVector_end(self)

    def rbegin(self):
        return _skymaps.FloatVector_rbegin(self)

    def rend(self):
        return _skymaps.FloatVector_rend(self)

    def clear(self):
        return _skymaps.FloatVector_clear(self)

    def get_allocator(self):
        return _skymaps.FloatVector_get_allocator(self)

    def pop_back(self):
        return _skymaps.FloatVector_pop_back(self)

    def erase(self, *args):
        return _skymaps.FloatVector_erase(self, *args)

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

    def push_back(self, x):
        return _skymaps.FloatVector_push_back(self, x)

    def front(self):
        return _skymaps.FloatVector_front(self)

    def back(self):
        return _skymaps.FloatVector_back(self)

    def assign(self, n, x):
        return _skymaps.FloatVector_assign(self, n, x)

    def resize(self, *args):
        return _skymaps.FloatVector_resize(self, *args)

    def insert(self, *args):
        return _skymaps.FloatVector_insert(self, *args)

    def reserve(self, n):
        return _skymaps.FloatVector_reserve(self, n)

    def capacity(self):
        return _skymaps.FloatVector_capacity(self)
    __swig_destroy__ = _skymaps.delete_FloatVector
    __del__ = lambda self: None
FloatVector_swigregister = _skymaps.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

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 = _skymaps.Hep3Vector_X
    Y = _skymaps.Hep3Vector_Y
    Z = _skymaps.Hep3Vector_Z
    NUM_COORDINATES = _skymaps.Hep3Vector_NUM_COORDINATES
    SIZE = _skymaps.Hep3Vector_SIZE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def rotate(self, *args):
        return _skymaps.Hep3Vector_rotate(self, *args)

    def __getitem__(self, i):
        return _skymaps.Hep3Vector___getitem__(self, i)

    def __len__(self):
        return _skymaps.Hep3Vector___len__(self)
Hep3Vector_swigregister = _skymaps.Hep3Vector_swigregister
Hep3Vector_swigregister(Hep3Vector)

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

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


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

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

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

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

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

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

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

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

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

def __mul__(*args):
    return _skymaps.__mul__(*args)
__mul__ = _skymaps.__mul__
class HepRotation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HepRotation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HepRotation, name)
    __repr__ = _swig_repr

    def __getitem__(self, i):
        return _skymaps.HepRotation___getitem__(self, i)

    def __len__(self):
        return _skymaps.HepRotation___len__(self)

    def set(self, colx, coly, colz):
        return _skymaps.HepRotation_set(self, colx, coly, colz)

    def setXYZ(self, x, y, z):
        return _skymaps.HepRotation_setXYZ(self, x, y, z)

    def inverse(self):
        return _skymaps.HepRotation_inverse(self)

    def __str__(self):  return ('HepRotation:'+ 3* ('\n\t'+3*'%9.5f')) % tuple([self[i] for i in range(9)])


    def __init__(self):
        this = _skymaps.new_HepRotation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_HepRotation
    __del__ = lambda self: None
HepRotation_swigregister = _skymaps.HepRotation_swigregister
HepRotation_swigregister(HepRotation)
cvar = _skymaps.cvar
HepXHat = cvar.HepXHat
HepYHat = cvar.HepYHat
HepZHat = cvar.HepZHat


def double2(x, y):
    return _skymaps.double2(x, y)
double2 = _skymaps.double2

def delete_double2(d):
    return _skymaps.delete_double2(d)
delete_double2 = _skymaps.delete_double2
ASTRO_D2R = _skymaps.ASTRO_D2R
ASTRO_R2D = _skymaps.ASTRO_R2D
ASTRO_PIOVER2 = _skymaps.ASTRO_PIOVER2
ASTRO_4PI = _skymaps.ASTRO_4PI

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

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

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

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

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

def thetaToLat_Rad(theta):
    return _skymaps.thetaToLat_Rad(theta)
thetaToLat_Rad = _skymaps.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 = _skymaps.ProjBase_WCS
    HEALPIX = _skymaps.ProjBase_HEALPIX
    UNKNOWN = _skymaps.ProjBase_UNKNOWN
    __swig_destroy__ = _skymaps.delete_ProjBase
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

    def setKeywords(self, header):
        return _skymaps.ProjBase_setKeywords(self, header)
ProjBase_swigregister = _skymaps.ProjBase_swigregister
ProjBase_swigregister(ProjBase)

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__ = _skymaps.delete_HealpixProj
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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__ = _skymaps.delete_SkyProj
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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 = _skymaps.SkyDir_GALACTIC
    EQUATORIAL = _skymaps.SkyDir_EQUATORIAL

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

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

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

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

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

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

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

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

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

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

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

    def cross(self, other):
        return _skymaps.SkyDir_cross(self, other)

    def dot(self, other):
        return _skymaps.SkyDir_dot(self, other)

    def __getitem__(self, i):
        return _skymaps.SkyDir___getitem__(self, i)

    def __len__(self):
        return _skymaps.SkyDir___len__(self)

    def __getstate__(self):  return (self.ra(),self.dec())
    def __setstate__(self,tup):
        self.this = _skymaps.new_SkyDir(tup[0],tup[1])
        self.thisown=1
    def __str__(self):  return 'SkyDir(%.3f,%.3f)' % (self.ra(),self.dec())
    def __repr__(self): return self.__str__()


    __swig_destroy__ = _skymaps.delete_SkyDir
    __del__ = lambda self: None
SkyDir_swigregister = _skymaps.SkyDir_swigregister
SkyDir_swigregister(SkyDir)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    if _newclass:
        Model = staticmethod(_skymaps.IGRField_Model)
    else:
        Model = _skymaps.IGRField_Model

    def compute(self, latitude, longitude, altitude, year=-1):
        return _skymaps.IGRField_compute(self, latitude, longitude, altitude, year)

    def dipoleMoment(self):
        return _skymaps.IGRField_dipoleMoment(self)

    def L(self):
        return _skymaps.IGRField_L(self)

    def B(self):
        return _skymaps.IGRField_B(self)

    def bNorth(self):
        return _skymaps.IGRField_bNorth(self)

    def bEast(self):
        return _skymaps.IGRField_bEast(self)

    def bDown(self):
        return _skymaps.IGRField_bDown(self)

    def bAbs(self):
        return _skymaps.IGRField_bAbs(self)

    def bEquator(self):
        return _skymaps.IGRField_bEquator(self)

    def verticalRigidityCutoff(self):
        return _skymaps.IGRField_verticalRigidityCutoff(self)

    def invariantLatitude(self):
        return _skymaps.IGRField_invariantLatitude(self)

    def R(self):
        return _skymaps.IGRField_R(self)

    def _lambda(self):
        return _skymaps.IGRField__lambda(self)
IGRField_swigregister = _skymaps.IGRField_swigregister
IGRField_swigregister(IGRField)

def IGRField_Model():
    return _skymaps.IGRField_Model()
IGRField_Model = _skymaps.IGRField_Model

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

    def getGregorianDate(self, *args):
        return _skymaps.JulianDate_getGregorianDate(self, *args)

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

    def seconds(self):
        return _skymaps.JulianDate_seconds(self)
    secondsPerDay = _skymaps.JulianDate_secondsPerDay
    if _newclass:
        missionStart = staticmethod(_skymaps.JulianDate_missionStart)
    else:
        missionStart = _skymaps.JulianDate_missionStart
    __swig_destroy__ = _skymaps.delete_JulianDate
    __del__ = lambda self: None
JulianDate_swigregister = _skymaps.JulianDate_swigregister
JulianDate_swigregister(JulianDate)

def JulianDate_missionStart():
    return _skymaps.JulianDate_missionStart()
JulianDate_missionStart = _skymaps.JulianDate_missionStart

class SolarSystem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SolarSystem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SolarSystem, name)
    __repr__ = _swig_repr
    MERCURY = _skymaps.SolarSystem_MERCURY
    VENUS = _skymaps.SolarSystem_VENUS
    EARTH = _skymaps.SolarSystem_EARTH
    MARS = _skymaps.SolarSystem_MARS
    JUPITER = _skymaps.SolarSystem_JUPITER
    SATURN = _skymaps.SolarSystem_SATURN
    URANUS = _skymaps.SolarSystem_URANUS
    NEPTUNE = _skymaps.SolarSystem_NEPTUNE
    PLUTO = _skymaps.SolarSystem_PLUTO
    MOON = _skymaps.SolarSystem_MOON
    SUN = _skymaps.SolarSystem_SUN

    def __init__(self, *args):
        this = _skymaps.new_SolarSystem(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_SolarSystem
    __del__ = lambda self: None

    def direction(self, *args):
        return _skymaps.SolarSystem_direction(self, *args)

    def distance(self, jd):
        return _skymaps.SolarSystem_distance(self, jd)

    def getBarycenter(self, jd):
        return _skymaps.SolarSystem_getBarycenter(self, jd)

    def getSolarVector(self, jd):
        return _skymaps.SolarSystem_getSolarVector(self, jd)
    if _newclass:
        vector = staticmethod(_skymaps.SolarSystem_vector)
    else:
        vector = _skymaps.SolarSystem_vector
SolarSystem_swigregister = _skymaps.SolarSystem_swigregister
SolarSystem_swigregister(SolarSystem)

def SolarSystem_vector(targ, cent, jd):
    return _skymaps.SolarSystem_vector(targ, cent, jd)
SolarSystem_vector = _skymaps.SolarSystem_vector

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    GLAST = _skymaps.GPS_GLAST
    LAT = _skymaps.GPS_LAT
    ZENITH = _skymaps.GPS_ZENITH
    CELESTIAL = _skymaps.GPS_CELESTIAL
    NADIR = _skymaps.GPS_NADIR
    NONE = _skymaps.GPS_NONE
    UPDOWN = _skymaps.GPS_UPDOWN
    SLEWING = _skymaps.GPS_SLEWING
    ONEPERORBIT = _skymaps.GPS_ONEPERORBIT
    EXPLICIT = _skymaps.GPS_EXPLICIT
    POINT = _skymaps.GPS_POINT
    HISTORY = _skymaps.GPS_HISTORY
    HISTORY_X_EAST = _skymaps.GPS_HISTORY_X_EAST

    def lat(self, *args):
        return _skymaps.GPS_lat(self, *args)

    def lon(self, *args):
        return _skymaps.GPS_lon(self, *args)

    def altitude(self, *args):
        return _skymaps.GPS_altitude(self, *args)

    def zAxisDir(self, *args):
        return _skymaps.GPS_zAxisDir(self, *args)

    def xAxisDir(self, *args):
        return _skymaps.GPS_xAxisDir(self, *args)

    def zenithDir(self, *args):
        return _skymaps.GPS_zenithDir(self, *args)

    def position(self, *args):
        return _skymaps.GPS_position(self, *args)

    def earthpos(self, *args):
        return _skymaps.GPS_earthpos(self, *args)

    def transformToGlast(self, seconds, index):
        return _skymaps.GPS_transformToGlast(self, seconds, index)

    def LATdirection(self, index, dir, met=-1):
        return _skymaps.GPS_LATdirection(self, index, dir, met)

    def toSky(self, latdir, met=-1):
        return _skymaps.GPS_toSky(self, latdir, met)

    def aberration(self, sdir, met=-1):
        return _skymaps.GPS_aberration(self, sdir, met)

    def correct(self, sdir, met=-1):
        return _skymaps.GPS_correct(self, sdir, met)

    def expansion(self, *args):
        return _skymaps.GPS_expansion(self, *args)

    def synch(self):
        return _skymaps.GPS_synch(self)

    def sampleintvl(self, *args):
        return _skymaps.GPS_sampleintvl(self, *args)

    def setPointingDirection(self, dir):
        return _skymaps.GPS_setPointingDirection(self, dir)

    def setPointingHistoryFile(self, fileName, offset=0, x_horizontal=False):
        return _skymaps.GPS_setPointingHistoryFile(self, fileName, offset, x_horizontal)

    def history(self):
        return _skymaps.GPS_history(self)

    def notifyObservers(self):
        return _skymaps.GPS_notifyObservers(self)

    def notification(self):
        return _skymaps.GPS_notification(self)
    if _newclass:
        instance = staticmethod(_skymaps.GPS_instance)
    else:
        instance = _skymaps.GPS_instance
    if _newclass:
        kill = staticmethod(_skymaps.GPS_kill)
    else:
        kill = _skymaps.GPS_kill

    def rockingDegrees(self, rockDegrees):
        return _skymaps.GPS_rockingDegrees(self, rockDegrees)

    def setRockType(self, rockType):
        return _skymaps.GPS_setRockType(self, rockType)

    def time(self, *args):
        return _skymaps.GPS_time(self, *args)

    def endTime(self):
        return _skymaps.GPS_endTime(self)
    if _newclass:
        test = staticmethod(_skymaps.GPS_test)
    else:
        test = _skymaps.GPS_test

    def setAlignmentRotation(self, r):
        return _skymaps.GPS_setAlignmentRotation(self, r)

    def enableAberration(self, flag=True):
        return _skymaps.GPS_enableAberration(self, flag)
GPS_swigregister = _skymaps.GPS_swigregister
GPS_swigregister(GPS)

def GPS_instance():
    return _skymaps.GPS_instance()
GPS_instance = _skymaps.GPS_instance

def GPS_kill():
    return _skymaps.GPS_kill()
GPS_kill = _skymaps.GPS_kill

def GPS_test():
    return _skymaps.GPS_test()
GPS_test = _skymaps.GPS_test

class Healpix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Healpix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Healpix, name)
    __repr__ = _swig_repr
    RING = _skymaps.Healpix_RING
    NESTED = _skymaps.Healpix_NESTED
    NEST = _skymaps.Healpix_NEST

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

    def nside(self):
        return _skymaps.Healpix_nside(self)

    def npix(self):
        return _skymaps.Healpix_npix(self)

    def size(self):
        return _skymaps.Healpix_size(self)

    def pixelArea(self):
        return _skymaps.Healpix_pixelArea(self)

    def ord(self):
        return _skymaps.Healpix_ord(self)

    def nested(self):
        return _skymaps.Healpix_nested(self)

    def coordsys(self):
        return _skymaps.Healpix_coordsys(self)

    def galactic(self):
        return _skymaps.Healpix_galactic(self)

    def findNeighbors(self, index, neighbors):
        return _skymaps.Healpix_findNeighbors(self, index, neighbors)

    def query_disc(self, dir, radius, v):
        return _skymaps.Healpix_query_disc(self, dir, radius, v)

    def pix2ang(self, index, theta, phi):
        return _skymaps.Healpix_pix2ang(self, index, theta, phi)

    def ang2pix(self, theta, phi, index):
        return _skymaps.Healpix_ang2pix(self, theta, phi, index)
    __swig_destroy__ = _skymaps.delete_Healpix
    __del__ = lambda self: None
Healpix_swigregister = _skymaps.Healpix_swigregister
Healpix_swigregister(Healpix)

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

    def __init__(self, level=8):
        this = _skymaps.new_HealpixMap(level)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_HealpixMap
    __del__ = lambda self: None

    def save(self, filename):
        return _skymaps.HealpixMap_save(self, filename)

    def load(self, filename):
        return _skymaps.HealpixMap_load(self, filename)

    def level(self):
        return _skymaps.HealpixMap_level(self)

    def __getitem__(self, i):
        return _skymaps.HealpixMap___getitem__(self, i)

    def __call__(self, *args):
        return _skymaps.HealpixMap___call__(self, *args)

    def __len__(self):
        return _skymaps.HealpixMap___len__(self)

    def __setitem__(self, i, v):
        return _skymaps.HealpixMap___setitem__(self, i, v)
HealpixMap_swigregister = _skymaps.HealpixMap_swigregister
HealpixMap_swigregister(HealpixMap)

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

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

    def value(self, dir, e):
        return _skymaps.BinnedPhotonData_value(self, dir, e)

    def counts(self, dir, emin, emax):
        return _skymaps.BinnedPhotonData_counts(self, dir, emin, emax)

    def integral(self, dir, a, b):
        return _skymaps.BinnedPhotonData_integral(self, dir, a, b)

    def addPhoton(self, gamma, count=1):
        return _skymaps.BinnedPhotonData_addPhoton(self, gamma, count)

    def addBand(self, gamma):
        return _skymaps.BinnedPhotonData_addBand(self, gamma)

    def add(self, other):
        return _skymaps.BinnedPhotonData_add(self, other)

    def density(self, sd):
        return _skymaps.BinnedPhotonData_density(self, sd)

    def smoothDensity(self, sd, mincount=0):
        return _skymaps.BinnedPhotonData_smoothDensity(self, sd, mincount)

    def info(self, *args):
        return _skymaps.BinnedPhotonData_info(self, *args)

    def write(self, outputFile, clobber=True):
        return _skymaps.BinnedPhotonData_write(self, outputFile, clobber)

    def addgti(self, other):
        return _skymaps.BinnedPhotonData_addgti(self, other)

    def writegti(self, outputFile):
        return _skymaps.BinnedPhotonData_writegti(self, outputFile)

    def gti(self):
        return _skymaps.BinnedPhotonData_gti(self)

    def photonCount(self):
        return _skymaps.BinnedPhotonData_photonCount(self)

    def pixelCount(self):
        return _skymaps.BinnedPhotonData_pixelCount(self)

    def gtiReject(self):
        return _skymaps.BinnedPhotonData_gtiReject(self)

    def updateIrfs(self, *args):
        return _skymaps.BinnedPhotonData_updateIrfs(self, *args)

    def __getitem__(self, i):
        return _skymaps.BinnedPhotonData___getitem__(self, i)

    def __len__(self):
        return _skymaps.BinnedPhotonData___len__(self)
    __swig_destroy__ = _skymaps.delete_BinnedPhotonData
    __del__ = lambda self: None
BinnedPhotonData_swigregister = _skymaps.BinnedPhotonData_swigregister
BinnedPhotonData_swigregister(BinnedPhotonData)

class HealpixDiffuseFunc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HealpixDiffuseFunc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HealpixDiffuseFunc, name)
    __repr__ = _swig_repr
    COUNTS = _skymaps.HealpixDiffuseFunc_COUNTS
    DIFFCOUNTS = _skymaps.HealpixDiffuseFunc_DIFFCOUNTS
    DENSITY = _skymaps.HealpixDiffuseFunc_DENSITY
    DIFFDENSITY = _skymaps.HealpixDiffuseFunc_DIFFDENSITY
    FLUX = _skymaps.HealpixDiffuseFunc_FLUX

    def __init__(self, *args):
        this = _skymaps.new_HealpixDiffuseFunc(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_HealpixDiffuseFunc
    __del__ = lambda self: None

    def isotropicFlux(self, energy):
        return _skymaps.HealpixDiffuseFunc_isotropicFlux(self, energy)

    def value(self, dir, e):
        return _skymaps.HealpixDiffuseFunc_value(self, dir, e)

    def name(self):
        return _skymaps.HealpixDiffuseFunc_name(self)

    def integral(self, *args):
        return _skymaps.HealpixDiffuseFunc_integral(self, *args)

    def layers(self):
        return _skymaps.HealpixDiffuseFunc_layers(self)
HealpixDiffuseFunc_swigregister = _skymaps.HealpixDiffuseFunc_swigregister
HealpixDiffuseFunc_swigregister(HealpixDiffuseFunc)

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

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

    def value(self, dir, e):
        return _skymaps.PhotonMap_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.PhotonMap_integral(self, dir, a, b)

    def name(self):
        return _skymaps.PhotonMap_name(self)

    def setName(self, name):
        return _skymaps.PhotonMap_setName(self, name)

    def addPhoton(self, gamma):
        return _skymaps.PhotonMap_addPhoton(self, gamma)

    def addPixel(self, px, count):
        return _skymaps.PhotonMap_addPixel(self, px, count)

    def density(self, sd):
        return _skymaps.PhotonMap_density(self, sd)

    def __call__(self, sd):
        return _skymaps.PhotonMap___call__(self, sd)

    def pixel(self, gamma):
        return _skymaps.PhotonMap_pixel(self, gamma)

    def extract(self, dir, radius, vec, summary_level=-1, select_level=-1):
        return _skymaps.PhotonMap_extract(self, dir, radius, vec, summary_level, select_level)

    def extract_level(self, dir, radius, vec, select_level=-1, include_all=False):
        return _skymaps.PhotonMap_extract_level(self, dir, radius, vec, select_level, include_all)

    def photonCount(self, *args):
        return _skymaps.PhotonMap_photonCount(self, *args)

    def pixelCount(self):
        return _skymaps.PhotonMap_pixelCount(self)

    def minLevel(self):
        return _skymaps.PhotonMap_minLevel(self)

    def levels(self):
        return _skymaps.PhotonMap_levels(self)

    def energyBins(self):
        return _skymaps.PhotonMap_energyBins(self)

    def write(self, *args):
        return _skymaps.PhotonMap_write(self, *args)

    def addgti(self, other):
        return _skymaps.PhotonMap_addgti(self, other)

    def writegti(self, outputFile):
        return _skymaps.PhotonMap_writegti(self, outputFile)

    def gti(self):
        return _skymaps.PhotonMap_gti(self)
    __swig_destroy__ = _skymaps.delete_PhotonMap
    __del__ = lambda self: None
PhotonMap_swigregister = _skymaps.PhotonMap_swigregister
PhotonMap_swigregister(PhotonMap)

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

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

    def addPoint(self, dir, delta=1.0, layer=0):
        return _skymaps.SkyImage_addPoint(self, dir, delta, layer)

    def save(self):
        return _skymaps.SkyImage_save(self)
    __swig_destroy__ = _skymaps.delete_SkyImage
    __del__ = lambda self: None

    def setLayer(self, newlayer):
        return _skymaps.SkyImage_setLayer(self, newlayer)

    def getEnergies(self, energy):
        return _skymaps.SkyImage_getEnergies(self, energy)

    def energies(self):
        return _skymaps.SkyImage_energies(self)

    def setEnergies(self, energies):
        return _skymaps.SkyImage_setEnergies(self, energies)

    def writeEnergies(self):
        return _skymaps.SkyImage_writeEnergies(self)

    def fill(self, *args):
        return _skymaps.SkyImage_fill(self, *args)

    def clear(self):
        return _skymaps.SkyImage_clear(self)

    def total(self):
        return _skymaps.SkyImage_total(self)

    def minimum(self):
        return _skymaps.SkyImage_minimum(self)

    def maximum(self):
        return _skymaps.SkyImage_maximum(self)

    def count(self):
        return _skymaps.SkyImage_count(self)

    def pixelValue(self, pos, layer=0):
        return _skymaps.SkyImage_pixelValue(self, pos, layer)

    def getNeighbors(self, pos, neighbors):
        return _skymaps.SkyImage_getNeighbors(self, pos, neighbors)

    def __call__(self, s):
        return _skymaps.SkyImage___call__(self, s)

    def layers(self):
        return _skymaps.SkyImage_layers(self)

    def projector(self):
        return _skymaps.SkyImage_projector(self)

    def setupImage(self, outputFile, clobber=True):
        return _skymaps.SkyImage_setupImage(self, outputFile, clobber)

    def naxis1(self):
        return _skymaps.SkyImage_naxis1(self)

    def naxis2(self):
        return _skymaps.SkyImage_naxis2(self)

    def image(self):
        return _skymaps.SkyImage_image(self)

    def get_wsdl(self, layer=0):
        return _skymaps.SkyImage_get_wsdl(self, layer)

    def set_wsdl(self, wsdl):
        return _skymaps.SkyImage_set_wsdl(self, wsdl)

    def reimage(self, *args):
        return _skymaps.SkyImage_reimage(self, *args)
    if _newclass:
        setNaN = staticmethod(_skymaps.SkyImage_setNaN)
    else:
        setNaN = _skymaps.SkyImage_setNaN

    def interpolate(self):
        return _skymaps.SkyImage_interpolate(self)
SkyImage_swigregister = _skymaps.SkyImage_swigregister
SkyImage_swigregister(SkyImage)

def SkyImage_setNaN(nan):
    return _skymaps.SkyImage_setNaN(nan)
SkyImage_setNaN = _skymaps.SkyImage_setNaN

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

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

    def createConv(self, *args):
        return _skymaps.Convolution_createConv(self, *args)

    def layer(self, e, front):
        return _skymaps.Convolution_layer(self, e, front)

    def value(self, *args):
        return _skymaps.Convolution_value(self, *args)

    def integral(self, dir, a, b):
        return _skymaps.Convolution_integral(self, dir, a, b)

    def name(self):
        return _skymaps.Convolution_name(self)
    __swig_destroy__ = _skymaps.delete_Convolution
    __del__ = lambda self: None
Convolution_swigregister = _skymaps.Convolution_swigregister
Convolution_swigregister(Convolution)

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

    def __init__(self, g=2.0):
        this = _skymaps.new_PsfFunction(g)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, *args):
        return _skymaps.PsfFunction___call__(self, *args)

    def gamma(self):
        return _skymaps.PsfFunction_gamma(self)

    def integral(self, umax):
        return _skymaps.PsfFunction_integral(self, umax)

    def integralSquare(self, umax):
        return _skymaps.PsfFunction_integralSquare(self, umax)

    def mc(self, rand, umax):
        return _skymaps.PsfFunction_mc(self, rand, umax)
    __swig_destroy__ = _skymaps.delete_PsfFunction
    __del__ = lambda self: None
PsfFunction_swigregister = _skymaps.PsfFunction_swigregister
PsfFunction_swigregister(PsfFunction)

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

    def __init__(self, roi_dir, gamma, sigma):
        this = _skymaps.new_PsfSkyFunction(roi_dir, gamma, sigma)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, r):
        return _skymaps.PsfSkyFunction___call__(self, r)

    def average(self, dir, angle, tolerance):
        return _skymaps.PsfSkyFunction_average(self, dir, angle, tolerance)

    def level_ave(self, dir, angle, level):
        return _skymaps.PsfSkyFunction_level_ave(self, dir, angle, level)

    def wsdl_vector_value(self, wsdl):
        return _skymaps.PsfSkyFunction_wsdl_vector_value(self, wsdl)
    __swig_destroy__ = _skymaps.delete_PsfSkyFunction
    __del__ = lambda self: None
PsfSkyFunction_swigregister = _skymaps.PsfSkyFunction_swigregister
PsfSkyFunction_swigregister(PsfSkyFunction)

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

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

    def setEnergy(self, e):
        return _skymaps.SkySpectrum_setEnergy(self, e)

    def setEnergyRange(self, emin, emax):
        return _skymaps.SkySpectrum_setEnergyRange(self, emin, emax)

    def value(self, dir, e):
        return _skymaps.SkySpectrum_value(self, dir, e)

    def vector_value(self, dir, energies):
        return _skymaps.SkySpectrum_vector_value(self, dir, energies)

    def band_value(self, dir, band):
        return _skymaps.SkySpectrum_band_value(self, dir, band)

    def integral(self, dir, a, b):
        return _skymaps.SkySpectrum_integral(self, dir, a, b)

    def name(self):
        return _skymaps.SkySpectrum_name(self)

    def setName(self, name):
        return _skymaps.SkySpectrum_setName(self, name)

    def __call__(self, *args):
        return _skymaps.SkySpectrum___call__(self, *args)

    def average(self, dir, angle, tolerance):
        return _skymaps.SkySpectrum_average(self, dir, angle, tolerance)

    def level_ave(self, dir, angle, level):
        return _skymaps.SkySpectrum_level_ave(self, dir, angle, level)
SkySpectrum_swigregister = _skymaps.SkySpectrum_swigregister
SkySpectrum_swigregister(SkySpectrum)

class PySkyFunction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySkyFunction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySkyFunction, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _skymaps.delete_PySkyFunction
    __del__ = lambda self: None

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

    def __call__(self, dir):
        return _skymaps.PySkyFunction___call__(self, dir)

    def average(self, dir, angle, tolerance):
        return _skymaps.PySkyFunction_average(self, dir, angle, tolerance)

    def level_ave(self, dir, angle, level):
        return _skymaps.PySkyFunction_level_ave(self, dir, angle, level)
PySkyFunction_swigregister = _skymaps.PySkyFunction_swigregister
PySkyFunction_swigregister(PySkyFunction)

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

    def __init__(self, value, integral):
        this = _skymaps.new_PySkySpectrum(value, integral)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def value(self, dir, e):
        return _skymaps.PySkySpectrum_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.PySkySpectrum_integral(self, dir, a, b)
    __swig_destroy__ = _skymaps.delete_PySkySpectrum
    __del__ = lambda self: None
PySkySpectrum_swigregister = _skymaps.PySkySpectrum_swigregister
PySkySpectrum_swigregister(PySkySpectrum)

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

    def __init__(self, *args):
        this = _skymaps.new_Background(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_Background
    __del__ = lambda self: None

    def value(self, dir, e):
        return _skymaps.Background_value(self, dir, e)

    def band_value(self, dir, band):
        return _skymaps.Background_band_value(self, dir, band)

    def integral(self, dir, a, b):
        return _skymaps.Background_integral(self, dir, a, b)

    def __call__(self, dir):
        return _skymaps.Background___call__(self, dir)

    def set_skyfun(self, conversion_type, energy):
        return _skymaps.Background_set_skyfun(self, conversion_type, energy)

    def set_event_class(self, n):
        return _skymaps.Background_set_event_class(self, n)

    def setEnergy(self, e):
        return _skymaps.Background_setEnergy(self, e)

    def exposures(self):
        return _skymaps.Background_exposures(self)

    def name(self):
        return _skymaps.Background_name(self)
    if _newclass:
        set_simpson = staticmethod(_skymaps.Background_set_simpson)
    else:
        set_simpson = _skymaps.Background_set_simpson

    def wsdl_vector_value(self, wsdl):
        return _skymaps.Background_wsdl_vector_value(self, wsdl)
    if _newclass:
        rot_grid = staticmethod(_skymaps.Background_rot_grid)
    else:
        rot_grid = _skymaps.Background_rot_grid
    if _newclass:
        val_grid = staticmethod(_skymaps.Background_val_grid)
    else:
        val_grid = _skymaps.Background_val_grid

    def grid_values(self, rvals, lons, lats, coordsys):
        return _skymaps.Background_grid_values(self, rvals, lons, lats, coordsys)
Background_swigregister = _skymaps.Background_swigregister
Background_swigregister(Background)

def Background_set_simpson(n):
    return _skymaps.Background_set_simpson(n)
Background_set_simpson = _skymaps.Background_set_simpson

def Background_rot_grid(rlons, rlats, lons, lats, roi_center):
    return _skymaps.Background_rot_grid(rlons, rlats, lons, lats, roi_center)
Background_rot_grid = _skymaps.Background_rot_grid

def Background_val_grid(rvals, lons, lats, roi_center, myfunc):
    return _skymaps.Background_val_grid(rvals, lons, lats, roi_center, myfunc)
Background_val_grid = _skymaps.Background_val_grid

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

    def __init__(self, *args):
        this = _skymaps.new_Band(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_Band
    __del__ = lambda self: None

    def __call__(self, dir):
        return _skymaps.Band___call__(self, dir)

    def add(self, *args):
        return _skymaps.Band_add(self, *args)

    def dir(self, index):
        return _skymaps.Band_dir(self, index)

    def index(self, dir):
        return _skymaps.Band_index(self, dir)

    def query_disk(self, *args):
        return _skymaps.Band_query_disk(self, *args)

    def total_pix(self, dir, radius):
        return _skymaps.Band_total_pix(self, dir, radius)

    def findNeighbors(self, index, neighbors):
        return _skymaps.Band_findNeighbors(self, index, neighbors)

    def density(self, dir, smooth=False, mincount=0, kernel=0, smooth_radius=3):
        return _skymaps.Band_density(self, dir, smooth, mincount, kernel, smooth_radius)

    def pixelArea(self):
        return _skymaps.Band_pixelArea(self)

    def photons(self):
        return _skymaps.Band_photons(self)

    def nside(self):
        return _skymaps.Band_nside(self)

    def event_class(self):
        return _skymaps.Band_event_class(self)

    def emin(self):
        return _skymaps.Band_emin(self)

    def emax(self):
        return _skymaps.Band_emax(self)

    def sigma(self):
        return _skymaps.Band_sigma(self)

    def gamma(self):
        return _skymaps.Band_gamma(self)

    def sigma2(self):
        return _skymaps.Band_sigma2(self)

    def gamma2(self):
        return _skymaps.Band_gamma2(self)

    def frac2(self):
        return _skymaps.Band_frac2(self)
    if _newclass:
        cache_pix = staticmethod(_skymaps.Band_cache_pix)
    else:
        cache_pix = _skymaps.Band_cache_pix
    if _newclass:
        enable_cache = staticmethod(_skymaps.Band_enable_cache)
    else:
        enable_cache = _skymaps.Band_enable_cache

    def setSigma(self, s):
        return _skymaps.Band_setSigma(self, s)

    def setGamma(self, g):
        return _skymaps.Band_setGamma(self, g)

    def setSigma2(self, s):
        return _skymaps.Band_setSigma2(self, s)

    def setGamma2(self, g):
        return _skymaps.Band_setGamma2(self, g)

    def setFrac2(self, f):
        return _skymaps.Band_setFrac2(self, f)

    def begin(self, *args):
        return _skymaps.Band_begin(self, *args)

    def end(self, *args):
        return _skymaps.Band_end(self, *args)

    def size(self):
        return _skymaps.Band_size(self)

    def add_source(self, source_id):
        return _skymaps.Band_add_source(self, source_id)

    def source(self):
        return _skymaps.Band_source(self)

    def density_cache_size(self):
        return _skymaps.Band_density_cache_size(self)
Band_swigregister = _skymaps.Band_swigregister
Band_swigregister(Band)

def Band_cache_pix():
    return _skymaps.Band_cache_pix()
Band_cache_pix = _skymaps.Band_cache_pix

def Band_enable_cache(b):
    return _skymaps.Band_enable_cache(b)
Band_enable_cache = _skymaps.Band_enable_cache

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

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

    def weight(self):
        return _skymaps.WeightedSkyDir_weight(self)

    def set_weight(self, weight):
        return _skymaps.WeightedSkyDir_set_weight(self, weight)
    __swig_destroy__ = _skymaps.delete_WeightedSkyDir
    __del__ = lambda self: None
WeightedSkyDir_swigregister = _skymaps.WeightedSkyDir_swigregister
WeightedSkyDir_swigregister(WeightedSkyDir)

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

    def arclength(self, sdir, output):
        return _skymaps.BaseWeightedSkyDirList_arclength(self, sdir, output)

    def __getitem__(self, i):
        return _skymaps.BaseWeightedSkyDirList___getitem__(self, i)

    def __len__(self):
        return _skymaps.BaseWeightedSkyDirList___len__(self)

    def __init__(self):
        this = _skymaps.new_BaseWeightedSkyDirList()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_BaseWeightedSkyDirList
    __del__ = lambda self: None
BaseWeightedSkyDirList_swigregister = _skymaps.BaseWeightedSkyDirList_swigregister
BaseWeightedSkyDirList_swigregister(BaseWeightedSkyDirList)

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

    def __init__(self, band, sdir, radius, include_empty=False):
        this = _skymaps.new_WeightedSkyDirList(band, sdir, radius, include_empty)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, sdir):
        return _skymaps.WeightedSkyDirList___call__(self, sdir)

    def total_pix(self):
        return _skymaps.WeightedSkyDirList_total_pix(self)

    def counts(self):
        return _skymaps.WeightedSkyDirList_counts(self)
    __swig_destroy__ = _skymaps.delete_WeightedSkyDirList
    __del__ = lambda self: None
WeightedSkyDirList_swigregister = _skymaps.WeightedSkyDirList_swigregister
WeightedSkyDirList_swigregister(WeightedSkyDirList)

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

    def __init__(self, sf, energy=1000):
        this = _skymaps.new_SmoothedSkySpectrum(sf, energy)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def value(self, dir, e):
        return _skymaps.SmoothedSkySpectrum_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.SmoothedSkySpectrum_integral(self, dir, a, b)
    if _newclass:
        set_pixel_scale = staticmethod(_skymaps.SmoothedSkySpectrum_set_pixel_scale)
    else:
        set_pixel_scale = _skymaps.SmoothedSkySpectrum_set_pixel_scale
    if _newclass:
        set_smoothing_radius = staticmethod(_skymaps.SmoothedSkySpectrum_set_smoothing_radius)
    else:
        set_smoothing_radius = _skymaps.SmoothedSkySpectrum_set_smoothing_radius
    if _newclass:
        set_event_class = staticmethod(_skymaps.SmoothedSkySpectrum_set_event_class)
    else:
        set_event_class = _skymaps.SmoothedSkySpectrum_set_event_class
    if _newclass:
        set_max_resolution = staticmethod(_skymaps.SmoothedSkySpectrum_set_max_resolution)
    else:
        set_max_resolution = _skymaps.SmoothedSkySpectrum_set_max_resolution

    def setEnergy(self, e):
        return _skymaps.SmoothedSkySpectrum_setEnergy(self, e)
    __swig_destroy__ = _skymaps.delete_SmoothedSkySpectrum
    __del__ = lambda self: None
SmoothedSkySpectrum_swigregister = _skymaps.SmoothedSkySpectrum_swigregister
SmoothedSkySpectrum_swigregister(SmoothedSkySpectrum)

def SmoothedSkySpectrum_set_pixel_scale(p):
    return _skymaps.SmoothedSkySpectrum_set_pixel_scale(p)
SmoothedSkySpectrum_set_pixel_scale = _skymaps.SmoothedSkySpectrum_set_pixel_scale

def SmoothedSkySpectrum_set_smoothing_radius(s):
    return _skymaps.SmoothedSkySpectrum_set_smoothing_radius(s)
SmoothedSkySpectrum_set_smoothing_radius = _skymaps.SmoothedSkySpectrum_set_smoothing_radius

def SmoothedSkySpectrum_set_event_class(e):
    return _skymaps.SmoothedSkySpectrum_set_event_class(e)
SmoothedSkySpectrum_set_event_class = _skymaps.SmoothedSkySpectrum_set_event_class

def SmoothedSkySpectrum_set_max_resolution(r):
    return _skymaps.SmoothedSkySpectrum_set_max_resolution(r)
SmoothedSkySpectrum_set_max_resolution = _skymaps.SmoothedSkySpectrum_set_max_resolution

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

    def __init__(self, roi_dir):
        this = _skymaps.new_PsfSkySpectrum(roi_dir)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def value(self, r, energy):
        return _skymaps.PsfSkySpectrum_value(self, r, energy)

    def integral(self, dir, a, b):
        return _skymaps.PsfSkySpectrum_integral(self, dir, a, b)

    def set_skydir(self, nd):
        return _skymaps.PsfSkySpectrum_set_skydir(self, nd)

    def set_event_class(self, ec):
        return _skymaps.PsfSkySpectrum_set_event_class(self, ec)

    def set_jacobean(self, b):
        return _skymaps.PsfSkySpectrum_set_jacobean(self, b)
    __swig_destroy__ = _skymaps.delete_PsfSkySpectrum
    __del__ = lambda self: None
PsfSkySpectrum_swigregister = _skymaps.PsfSkySpectrum_swigregister
PsfSkySpectrum_swigregister(PsfSkySpectrum)

class PythonUtilities(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonUtilities, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PythonUtilities, name)
    __repr__ = _swig_repr
    if _newclass:
        val_grid = staticmethod(_skymaps.PythonUtilities_val_grid)
    else:
        val_grid = _skymaps.PythonUtilities_val_grid
    if _newclass:
        rot_grid = staticmethod(_skymaps.PythonUtilities_rot_grid)
    else:
        rot_grid = _skymaps.PythonUtilities_rot_grid
    if _newclass:
        arclength = staticmethod(_skymaps.PythonUtilities_arclength)
    else:
        arclength = _skymaps.PythonUtilities_arclength
    if _newclass:
        get_float_col = staticmethod(_skymaps.PythonUtilities_get_float_col)
    else:
        get_float_col = _skymaps.PythonUtilities_get_float_col
    if _newclass:
        tdb2met = staticmethod(_skymaps.PythonUtilities_tdb2met)
    else:
        tdb2met = _skymaps.PythonUtilities_tdb2met
    if _newclass:
        met2tdb = staticmethod(_skymaps.PythonUtilities_met2tdb)
    else:
        met2tdb = _skymaps.PythonUtilities_met2tdb
    if _newclass:
        met2geo = staticmethod(_skymaps.PythonUtilities_met2geo)
    else:
        met2geo = _skymaps.PythonUtilities_met2geo
    if _newclass:
        get_wsdl_weights = staticmethod(_skymaps.PythonUtilities_get_wsdl_weights)
    else:
        get_wsdl_weights = _skymaps.PythonUtilities_get_wsdl_weights
    if _newclass:
        set_wsdl_weights = staticmethod(_skymaps.PythonUtilities_set_wsdl_weights)
    else:
        set_wsdl_weights = _skymaps.PythonUtilities_set_wsdl_weights

    def __init__(self):
        this = _skymaps.new_PythonUtilities()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_PythonUtilities
    __del__ = lambda self: None
PythonUtilities_swigregister = _skymaps.PythonUtilities_swigregister
PythonUtilities_swigregister(PythonUtilities)

def PythonUtilities_val_grid(rvals, lons, lats, roi_center, myfunc):
    return _skymaps.PythonUtilities_val_grid(rvals, lons, lats, roi_center, myfunc)
PythonUtilities_val_grid = _skymaps.PythonUtilities_val_grid

def PythonUtilities_rot_grid(rvals, sdirs, roi_center):
    return _skymaps.PythonUtilities_rot_grid(rvals, sdirs, roi_center)
PythonUtilities_rot_grid = _skymaps.PythonUtilities_rot_grid

def PythonUtilities_arclength(rvals, sdirs, roi_center):
    return _skymaps.PythonUtilities_arclength(rvals, sdirs, roi_center)
PythonUtilities_arclength = _skymaps.PythonUtilities_arclength

def PythonUtilities_get_float_col(rvals, file_name, table_name, col_name):
    return _skymaps.PythonUtilities_get_float_col(rvals, file_name, table_name, col_name)
PythonUtilities_get_float_col = _skymaps.PythonUtilities_get_float_col

def PythonUtilities_tdb2met(rvals, ra, dec, sc_file, tol):
    return _skymaps.PythonUtilities_tdb2met(rvals, ra, dec, sc_file, tol)
PythonUtilities_tdb2met = _skymaps.PythonUtilities_tdb2met

def PythonUtilities_met2tdb(rvals, ra, dec, sc_file):
    return _skymaps.PythonUtilities_met2tdb(rvals, ra, dec, sc_file)
PythonUtilities_met2tdb = _skymaps.PythonUtilities_met2tdb

def PythonUtilities_met2geo(rvals, ra, dec, sc_file):
    return _skymaps.PythonUtilities_met2geo(rvals, ra, dec, sc_file)
PythonUtilities_met2geo = _skymaps.PythonUtilities_met2geo

def PythonUtilities_get_wsdl_weights(rvals, wsdl):
    return _skymaps.PythonUtilities_get_wsdl_weights(rvals, wsdl)
PythonUtilities_get_wsdl_weights = _skymaps.PythonUtilities_get_wsdl_weights

def PythonUtilities_set_wsdl_weights(weights, wsdl):
    return _skymaps.PythonUtilities_set_wsdl_weights(weights, wsdl)
PythonUtilities_set_wsdl_weights = _skymaps.PythonUtilities_set_wsdl_weights

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

    def __init__(self, *args):
        this = _skymaps.new_PythonPsf(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_PythonPsf
    __del__ = lambda self: None

    def __call__(self, *args):
        return _skymaps.PythonPsf___call__(self, *args)

    def integral(self, dmax, dmin=0):
        return _skymaps.PythonPsf_integral(self, dmax, dmin)

    def integral_from_zero(self, delta):
        return _skymaps.PythonPsf_integral_from_zero(self, delta)

    def inverse_integral_on_axis(self, frac):
        return _skymaps.PythonPsf_inverse_integral_on_axis(self, frac)

    def overlap_circle(self, center, radius, src_pos):
        return _skymaps.PythonPsf_overlap_circle(self, center, radius, src_pos)

    def overlap_healpix(self, nside_base, index, nside_sub, src_pos):
        return _skymaps.PythonPsf_overlap_healpix(self, nside_base, index, nside_sub, src_pos)

    def array_val(self, rvals):
        return _skymaps.PythonPsf_array_val(self, rvals)

    def wsdl_val(self, rvals, src_pos, data_pos):
        return _skymaps.PythonPsf_wsdl_val(self, rvals, src_pos, data_pos)
    if _newclass:
        set_density = staticmethod(_skymaps.PythonPsf_set_density)
    else:
        set_density = _skymaps.PythonPsf_set_density
    if _newclass:
        get_density = staticmethod(_skymaps.PythonPsf_get_density)
    else:
        get_density = _skymaps.PythonPsf_get_density

    def print_parameters(self):
        return _skymaps.PythonPsf_print_parameters(self)
PythonPsf_swigregister = _skymaps.PythonPsf_swigregister
PythonPsf_swigregister(PythonPsf)

def PythonPsf_set_density(dens):
    return _skymaps.PythonPsf_set_density(dens)
PythonPsf_set_density = _skymaps.PythonPsf_set_density

def PythonPsf_get_density():
    return _skymaps.PythonPsf_get_density()
PythonPsf_get_density = _skymaps.PythonPsf_get_density

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

    def __init__(self, dir, energy, time, event_class=-1, source=-1, event_type=-1):
        this = _skymaps.new_Photon(dir, energy, time, event_class, source, event_type)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def event_type(self):
        return _skymaps.Photon_event_type(self)
    __swig_destroy__ = _skymaps.delete_Photon
    __del__ = lambda self: None
Photon_swigregister = _skymaps.Photon_swigregister
Photon_swigregister(Photon)

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

    def __init__(self, *args):
        this = _skymaps.new_PhotonBinner(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_PhotonBinner
    __del__ = lambda self: None

    def __call__(self, photon):
        return _skymaps.PhotonBinner___call__(self, photon)

    def get_band_key(self, photon):
        return _skymaps.PhotonBinner_get_band_key(self, photon)

    def event_type_index(self, event_type):
        return _skymaps.PhotonBinner_event_type_index(self, event_type)
    if _newclass:
        set_max_nside = staticmethod(_skymaps.PhotonBinner_set_max_nside)
    else:
        set_max_nside = _skymaps.PhotonBinner_set_max_nside
    if _newclass:
        get_max_nside = staticmethod(_skymaps.PhotonBinner_get_max_nside)
    else:
        get_max_nside = _skymaps.PhotonBinner_get_max_nside
    if _newclass:
        set_min_nside = staticmethod(_skymaps.PhotonBinner_set_min_nside)
    else:
        set_min_nside = _skymaps.PhotonBinner_set_min_nside
    if _newclass:
        get_min_nside = staticmethod(_skymaps.PhotonBinner_get_min_nside)
    else:
        get_min_nside = _skymaps.PhotonBinner_get_min_nside
    if _newclass:
        set_sigma_scale = staticmethod(_skymaps.PhotonBinner_set_sigma_scale)
    else:
        set_sigma_scale = _skymaps.PhotonBinner_set_sigma_scale
    if _newclass:
        get_sigma_scale = staticmethod(_skymaps.PhotonBinner_get_sigma_scale)
    else:
        get_sigma_scale = _skymaps.PhotonBinner_get_sigma_scale
    if _newclass:
        event_type_name = staticmethod(_skymaps.PhotonBinner_event_type_name)
    else:
        event_type_name = _skymaps.PhotonBinner_event_type_name
PhotonBinner_swigregister = _skymaps.PhotonBinner_swigregister
PhotonBinner_swigregister(PhotonBinner)

def PhotonBinner_set_max_nside(new_nside):
    return _skymaps.PhotonBinner_set_max_nside(new_nside)
PhotonBinner_set_max_nside = _skymaps.PhotonBinner_set_max_nside

def PhotonBinner_get_max_nside():
    return _skymaps.PhotonBinner_get_max_nside()
PhotonBinner_get_max_nside = _skymaps.PhotonBinner_get_max_nside

def PhotonBinner_set_min_nside(new_nside):
    return _skymaps.PhotonBinner_set_min_nside(new_nside)
PhotonBinner_set_min_nside = _skymaps.PhotonBinner_set_min_nside

def PhotonBinner_get_min_nside():
    return _skymaps.PhotonBinner_get_min_nside()
PhotonBinner_get_min_nside = _skymaps.PhotonBinner_get_min_nside

def PhotonBinner_set_sigma_scale(sigscale):
    return _skymaps.PhotonBinner_set_sigma_scale(sigscale)
PhotonBinner_set_sigma_scale = _skymaps.PhotonBinner_set_sigma_scale

def PhotonBinner_get_sigma_scale():
    return _skymaps.PhotonBinner_get_sigma_scale()
PhotonBinner_get_sigma_scale = _skymaps.PhotonBinner_get_sigma_scale

def PhotonBinner_event_type_name(index):
    return _skymaps.PhotonBinner_event_type_name(index)
PhotonBinner_event_type_name = _skymaps.PhotonBinner_event_type_name

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

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

    def accept(self, time):
        return _skymaps.Gti_accept(self, time)

    def writeExtension(self, filename):
        return _skymaps.Gti_writeExtension(self, filename)

    def applyTimeRangeCut(self, start, stop):
        return _skymaps.Gti_applyTimeRangeCut(self, start, stop)

    def minValue(self):
        return _skymaps.Gti_minValue(self)

    def maxValue(self):
        return _skymaps.Gti_maxValue(self)

    def computeOntime(self):
        return _skymaps.Gti_computeOntime(self)

    def getNumIntervals(self):
        return _skymaps.Gti_getNumIntervals(self)

    def __len__(self):
        return _skymaps.Gti___len__(self)

    def insertInterval(self, tstart, tstop):
        return _skymaps.Gti_insertInterval(self, tstart, tstop)

    def intersection(self, other):
        return _skymaps.Gti_intersection(self, other)

    def combine(self, other):
        return _skymaps.Gti_combine(self, other)

    def __getitem__(self, i):
        return _skymaps.Gti___getitem__(self, i)

    def __eq__(self, other):
        return _skymaps.Gti___eq__(self, other)

    def __neq__(self, other):
        return _skymaps.Gti___neq__(self, other)

    def get_edges(self, starts):
        return _skymaps.Gti_get_edges(self, starts)

    def __getstate__(self):
        starts = self.get_edges(True)
        stops = self.get_edges(False)
        return [starts,stops]
    def __setstate__(self,intervals):
        starts,stops = intervals
        self.this = _skymaps.new_Gti(starts,stops)
    def __str__(self):  return 'Gti: %d intervals from %d to %d, on time %.0f'% (self.getNumIntervals(), self.minValue(),self.maxValue(), self.computeOntime())
    def __repr__(self): return self.__str__()

    __swig_destroy__ = _skymaps.delete_Gti
    __del__ = lambda self: None
Gti_swigregister = _skymaps.Gti_swigregister
Gti_swigregister(Gti)

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

    def __init__(self, diffuse=None, norm=1.):
        this = _skymaps.new_CompositeSkySpectrum(diffuse, norm)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add(self, component, norm=1.):
        return _skymaps.CompositeSkySpectrum_add(self, component, norm)

    def value(self, dir, energy):
        return _skymaps.CompositeSkySpectrum_value(self, dir, energy)

    def band_value(self, dir, band):
        return _skymaps.CompositeSkySpectrum_band_value(self, dir, band)

    def integral(self, dir, a, b):
        return _skymaps.CompositeSkySpectrum_integral(self, dir, a, b)

    def name(self):
        return _skymaps.CompositeSkySpectrum_name(self)

    def setName(self, name):
        return _skymaps.CompositeSkySpectrum_setName(self, name)

    def average(self, dir, angle, tolerance):
        return _skymaps.CompositeSkySpectrum_average(self, dir, angle, tolerance)
    __swig_destroy__ = _skymaps.delete_CompositeSkySpectrum
    __del__ = lambda self: None
CompositeSkySpectrum_swigregister = _skymaps.CompositeSkySpectrum_swigregister
CompositeSkySpectrum_swigregister(CompositeSkySpectrum)

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

    def __init__(self, component, norm=1.):
        this = _skymaps.new_CompositeSkyFunction(component, norm)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add(self, component, norm=1.):
        return _skymaps.CompositeSkyFunction_add(self, component, norm)

    def __call__(self, bincenter):
        return _skymaps.CompositeSkyFunction___call__(self, bincenter)

    def average(self, *args):
        return _skymaps.CompositeSkyFunction_average(self, *args)
    __swig_destroy__ = _skymaps.delete_CompositeSkyFunction
    __del__ = lambda self: None
CompositeSkyFunction_swigregister = _skymaps.CompositeSkyFunction_swigregister
CompositeSkyFunction_swigregister(CompositeSkyFunction)

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

    def __init__(self, *args):
        this = _skymaps.new_SpectralFunction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_SpectralFunction
    __del__ = lambda self: None

    def __call__(self, energy):
        return _skymaps.SpectralFunction___call__(self, energy)

    def value(self, energy):
        return _skymaps.SpectralFunction_value(self, energy)

    def expected(self, dir, band):
        return _skymaps.SpectralFunction_expected(self, dir, band)

    def name(self):
        return _skymaps.SpectralFunction_name(self)

    def pars(self):
        return _skymaps.SpectralFunction_pars(self)

    def get_parameters(self):
        return _skymaps.SpectralFunction_get_parameters(self)

    def set_parameters(self, pars):
        return _skymaps.SpectralFunction_set_parameters(self, pars)

    def set_exposures(self, front, back):
        return _skymaps.SpectralFunction_set_exposures(self, front, back)

    def exposure(self, n):
        return _skymaps.SpectralFunction_exposure(self, n)
    if _newclass:
        set_simpson = staticmethod(_skymaps.SpectralFunction_set_simpson)
    else:
        set_simpson = _skymaps.SpectralFunction_set_simpson
    if _newclass:
        e0 = staticmethod(_skymaps.SpectralFunction_e0)
    else:
        e0 = _skymaps.SpectralFunction_e0
SpectralFunction_swigregister = _skymaps.SpectralFunction_swigregister
SpectralFunction_swigregister(SpectralFunction)

def SpectralFunction_set_simpson(n):
    return _skymaps.SpectralFunction_set_simpson(n)
SpectralFunction_set_simpson = _skymaps.SpectralFunction_set_simpson

def SpectralFunction_e0():
    return _skymaps.SpectralFunction_e0()
SpectralFunction_e0 = _skymaps.SpectralFunction_e0

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

    def __init__(self, *args):
        this = _skymaps.new_Exposure(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_Exposure
    __del__ = lambda self: None

    def value(self, dir, e):
        return _skymaps.Exposure_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.Exposure_integral(self, dir, a, b)

    def diff_value(self, dir, e, costh):
        return _skymaps.Exposure_diff_value(self, dir, e, costh)

    def name(self):
        return _skymaps.Exposure_name(self)

    def gti(self):
        return _skymaps.Exposure_gti(self)

    def vector_value(self, dir, energies):
        return _skymaps.Exposure_vector_value(self, dir, energies)
    if _newclass:
        set_simpson = staticmethod(_skymaps.Exposure_set_simpson)
    else:
        set_simpson = _skymaps.Exposure_set_simpson
    if _newclass:
        set_cutoff = staticmethod(_skymaps.Exposure_set_cutoff)
    else:
        set_cutoff = _skymaps.Exposure_set_cutoff

    def healpix(self):
        return _skymaps.Exposure_healpix(self)
Exposure_swigregister = _skymaps.Exposure_swigregister
Exposure_swigregister(Exposure)

def Exposure_set_simpson(n):
    return _skymaps.Exposure_set_simpson(n)
Exposure_set_simpson = _skymaps.Exposure_set_simpson

def Exposure_set_cutoff(cutoff):
    return _skymaps.Exposure_set_cutoff(cutoff)
Exposure_set_cutoff = _skymaps.Exposure_set_cutoff

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

    def __init__(self, exp, energy):
        this = _skymaps.new_ExposureMap(exp, energy)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, sdir):
        return _skymaps.ExposureMap___call__(self, sdir)
    __swig_destroy__ = _skymaps.delete_ExposureMap
    __del__ = lambda self: None
ExposureMap_swigregister = _skymaps.ExposureMap_swigregister
ExposureMap_swigregister(ExposureMap)

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

    def __init__(self, exp, energy):
        this = _skymaps.new_CacheExposureMap(exp, energy)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, sdir):
        return _skymaps.CacheExposureMap___call__(self, sdir)
    __swig_destroy__ = _skymaps.delete_CacheExposureMap
    __del__ = lambda self: None
CacheExposureMap_swigregister = _skymaps.CacheExposureMap_swigregister
CacheExposureMap_swigregister(CacheExposureMap)

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

    def __init__(self, filename):
        this = _skymaps.new_IsotropicSpectrum(filename)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_IsotropicSpectrum
    __del__ = lambda self: None

    def value(self, dir, e):
        return _skymaps.IsotropicSpectrum_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.IsotropicSpectrum_integral(self, dir, a, b)

    def name(self):
        return _skymaps.IsotropicSpectrum_name(self)
IsotropicSpectrum_swigregister = _skymaps.IsotropicSpectrum_swigregister
IsotropicSpectrum_swigregister(IsotropicSpectrum)

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

    def __init__(self, diffuse_cube_file, energy=1000., interpolate=True):
        this = _skymaps.new_DiffuseFunction(diffuse_cube_file, energy, interpolate)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_DiffuseFunction
    __del__ = lambda self: None

    def extraGal(self, energy):
        return _skymaps.DiffuseFunction_extraGal(self, energy)

    def value(self, dir, e):
        return _skymaps.DiffuseFunction_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.DiffuseFunction_integral(self, dir, a, b)

    def name(self):
        return _skymaps.DiffuseFunction_name(self)

    def integrals(self, dir, energies):
        return _skymaps.DiffuseFunction_integrals(self, dir, energies)

    def layers(self):
        return _skymaps.DiffuseFunction_layers(self)

    def image(self):
        return _skymaps.DiffuseFunction_image(self)

    def energies(self):
        return _skymaps.DiffuseFunction_energies(self)
DiffuseFunction_swigregister = _skymaps.DiffuseFunction_swigregister
DiffuseFunction_swigregister(DiffuseFunction)

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

    def __init__(self, *args, **kwargs):
        this = _skymaps.new_SkyImageSpectrum(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_SkyImageSpectrum
    __del__ = lambda self: None

    def value(self, dir, e):
        return _skymaps.SkyImageSpectrum_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.SkyImageSpectrum_integral(self, dir, a, b)

    def skyimage(self):
        return _skymaps.SkyImageSpectrum_skyimage(self)

    def filename(self):
        return _skymaps.SkyImageSpectrum_filename(self)

    def extension(self):
        return _skymaps.SkyImageSpectrum_extension(self)

    def interpolate(self):
        return _skymaps.SkyImageSpectrum_interpolate(self)
SkyImageSpectrum_swigregister = _skymaps.SkyImageSpectrum_swigregister
SkyImageSpectrum_swigregister(SkyImageSpectrum)

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

    def __init__(self, *args, **kwargs):
        this = _skymaps.new_LivetimeCube(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def fill(self, dirz, deltat):
        return _skymaps.LivetimeCube_fill(self, dirz, deltat)

    def write(self, *args, **kwargs):
        return _skymaps.LivetimeCube_write(self, *args, **kwargs)

    def load(self, *args, **kwargs):
        return _skymaps.LivetimeCube_load(self, *args, **kwargs)

    def load_table(self, *args, **kwargs):
        return _skymaps.LivetimeCube_load_table(self, *args, **kwargs)

    def lost(self):
        return _skymaps.LivetimeCube_lost(self)

    def useZenith(self):
        return _skymaps.LivetimeCube_useZenith(self)

    def value(self, dir, costh, phi=-1):
        return _skymaps.LivetimeCube_value(self, dir, costh, phi)

    def total(self):
        return _skymaps.LivetimeCube_total(self)

    def gti(self):
        return _skymaps.LivetimeCube_gti(self)
    __swig_destroy__ = _skymaps.delete_LivetimeCube
    __del__ = lambda self: None
LivetimeCube_swigregister = _skymaps.LivetimeCube_swigregister
LivetimeCube_swigregister(LivetimeCube)

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

    def __init__(self, *args, **kwargs):
        this = _skymaps.new_EffectiveArea(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_EffectiveArea
    __del__ = lambda self: None

    def value(self, energy=1000, costh=1.0):
        return _skymaps.EffectiveArea_value(self, energy, costh)

    def __call__(self, energy=1000, costh=1.0):
        return _skymaps.EffectiveArea___call__(self, energy, costh)

    def getLivetimeFactors(self, energy):
        return _skymaps.EffectiveArea_getLivetimeFactors(self, energy)
    if _newclass:
        set_CALDB = staticmethod(_skymaps.EffectiveArea_set_CALDB)
    else:
        set_CALDB = _skymaps.EffectiveArea_set_CALDB
    if _newclass:
        enable_cache = staticmethod(_skymaps.EffectiveArea_enable_cache)
    else:
        enable_cache = _skymaps.EffectiveArea_enable_cache
EffectiveArea_swigregister = _skymaps.EffectiveArea_swigregister
EffectiveArea_swigregister(EffectiveArea)

def EffectiveArea_set_CALDB(CALDB):
    return _skymaps.EffectiveArea_set_CALDB(CALDB)
EffectiveArea_set_CALDB = _skymaps.EffectiveArea_set_CALDB

def EffectiveArea_enable_cache(value=True):
    return _skymaps.EffectiveArea_enable_cache(value)
EffectiveArea_enable_cache = _skymaps.EffectiveArea_enable_cache

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

    def __init__(self, flux=1.5e-5, index=2.1):
        this = _skymaps.new_IsotropicPowerLaw(flux, index)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_IsotropicPowerLaw
    __del__ = lambda self: None

    def value(self, dir, e):
        return _skymaps.IsotropicPowerLaw_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.IsotropicPowerLaw_integral(self, dir, a, b)

    def flux(self):
        return _skymaps.IsotropicPowerLaw_flux(self)

    def index(self):
        return _skymaps.IsotropicPowerLaw_index(self)
IsotropicPowerLaw_swigregister = _skymaps.IsotropicPowerLaw_swigregister
IsotropicPowerLaw_swigregister(IsotropicPowerLaw)

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

    def __init__(self, constant=1):
        this = _skymaps.new_IsotropicConstant(constant)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_IsotropicConstant
    __del__ = lambda self: None

    def value(self, dir, e):
        return _skymaps.IsotropicConstant_value(self, dir, e)

    def integral(self, dir, a, b):
        return _skymaps.IsotropicConstant_integral(self, dir, a, b)

    def constant(self):
        return _skymaps.IsotropicConstant_constant(self)
IsotropicConstant_swigregister = _skymaps.IsotropicConstant_swigregister
IsotropicConstant_swigregister(IsotropicConstant)

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    if _newclass:
        sigma = staticmethod(_skymaps.IParams_sigma)
    else:
        sigma = _skymaps.IParams_sigma
    if _newclass:
        gamma = staticmethod(_skymaps.IParams_gamma)
    else:
        gamma = _skymaps.IParams_gamma
    if _newclass:
        effaWeight = staticmethod(_skymaps.IParams_effaWeight)
    else:
        effaWeight = _skymaps.IParams_effaWeight
    if _newclass:
        set_fp = staticmethod(_skymaps.IParams_set_fp)
    else:
        set_fp = _skymaps.IParams_set_fp
    if _newclass:
        set_bp = staticmethod(_skymaps.IParams_set_bp)
    else:
        set_bp = _skymaps.IParams_set_bp
    if _newclass:
        set_fsig = staticmethod(_skymaps.IParams_set_fsig)
    else:
        set_fsig = _skymaps.IParams_set_fsig
    if _newclass:
        set_bsig = staticmethod(_skymaps.IParams_set_bsig)
    else:
        set_bsig = _skymaps.IParams_set_bsig
    if _newclass:
        set_fgam = staticmethod(_skymaps.IParams_set_fgam)
    else:
        set_fgam = _skymaps.IParams_set_fgam
    if _newclass:
        set_bgam = staticmethod(_skymaps.IParams_set_bgam)
    else:
        set_bgam = _skymaps.IParams_set_bgam
    if _newclass:
        set_fwght = staticmethod(_skymaps.IParams_set_fwght)
    else:
        set_fwght = _skymaps.IParams_set_fwght
    if _newclass:
        set_bwght = staticmethod(_skymaps.IParams_set_bwght)
    else:
        set_bwght = _skymaps.IParams_set_bwght
    if _newclass:
        set_elist = staticmethod(_skymaps.IParams_set_elist)
    else:
        set_elist = _skymaps.IParams_set_elist
    if _newclass:
        init = staticmethod(_skymaps.IParams_init)
    else:
        init = _skymaps.IParams_init
    if _newclass:
        set_CALDB = staticmethod(_skymaps.IParams_set_CALDB)
    else:
        set_CALDB = _skymaps.IParams_set_CALDB
    if _newclass:
        set_livetimefile = staticmethod(_skymaps.IParams_set_livetimefile)
    else:
        set_livetimefile = _skymaps.IParams_set_livetimefile
    if _newclass:
        set_skydir = staticmethod(_skymaps.IParams_set_skydir)
    else:
        set_skydir = _skymaps.IParams_set_skydir
    if _newclass:
        params = staticmethod(_skymaps.IParams_params)
    else:
        params = _skymaps.IParams_params
    if _newclass:
        scale = staticmethod(_skymaps.IParams_scale)
    else:
        scale = _skymaps.IParams_scale
    if _newclass:
        print_parameters = staticmethod(_skymaps.IParams_print_parameters)
    else:
        print_parameters = _skymaps.IParams_print_parameters
    __swig_destroy__ = _skymaps.delete_IParams
    __del__ = lambda self: None
IParams_swigregister = _skymaps.IParams_swigregister
IParams_swigregister(IParams)

def IParams_sigma(energy, event_class):
    return _skymaps.IParams_sigma(energy, event_class)
IParams_sigma = _skymaps.IParams_sigma

def IParams_gamma(energy, event_class):
    return _skymaps.IParams_gamma(energy, event_class)
IParams_gamma = _skymaps.IParams_gamma

def IParams_effaWeight(energy, event_class):
    return _skymaps.IParams_effaWeight(energy, event_class)
IParams_effaWeight = _skymaps.IParams_effaWeight

def IParams_set_fp(params):
    return _skymaps.IParams_set_fp(params)
IParams_set_fp = _skymaps.IParams_set_fp

def IParams_set_bp(params):
    return _skymaps.IParams_set_bp(params)
IParams_set_bp = _skymaps.IParams_set_bp

def IParams_set_fsig(sigs):
    return _skymaps.IParams_set_fsig(sigs)
IParams_set_fsig = _skymaps.IParams_set_fsig

def IParams_set_bsig(sigs):
    return _skymaps.IParams_set_bsig(sigs)
IParams_set_bsig = _skymaps.IParams_set_bsig

def IParams_set_fgam(gams):
    return _skymaps.IParams_set_fgam(gams)
IParams_set_fgam = _skymaps.IParams_set_fgam

def IParams_set_bgam(gams):
    return _skymaps.IParams_set_bgam(gams)
IParams_set_bgam = _skymaps.IParams_set_bgam

def IParams_set_fwght(wght):
    return _skymaps.IParams_set_fwght(wght)
IParams_set_fwght = _skymaps.IParams_set_fwght

def IParams_set_bwght(wght):
    return _skymaps.IParams_set_bwght(wght)
IParams_set_bwght = _skymaps.IParams_set_bwght

def IParams_set_elist(elist):
    return _skymaps.IParams_set_elist(elist)
IParams_set_elist = _skymaps.IParams_set_elist

def IParams_init(*args, **kwargs):
    return _skymaps.IParams_init(*args, **kwargs)
IParams_init = _skymaps.IParams_init

def IParams_set_CALDB(dir):
    return _skymaps.IParams_set_CALDB(dir)
IParams_set_CALDB = _skymaps.IParams_set_CALDB

def IParams_set_livetimefile(ltfile):
    return _skymaps.IParams_set_livetimefile(ltfile)
IParams_set_livetimefile = _skymaps.IParams_set_livetimefile

def IParams_set_skydir(dir):
    return _skymaps.IParams_set_skydir(dir)
IParams_set_skydir = _skymaps.IParams_set_skydir

def IParams_params(event_class):
    return _skymaps.IParams_params(event_class)
IParams_params = _skymaps.IParams_params

def IParams_scale(energy, event_class):
    return _skymaps.IParams_scale(energy, event_class)
IParams_scale = _skymaps.IParams_scale

def IParams_print_parameters():
    return _skymaps.IParams_print_parameters()
IParams_print_parameters = _skymaps.IParams_print_parameters

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

    def __init__(self, background, band):
        this = _skymaps.new_BandBackground(background, band)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_BandBackground
    __del__ = lambda self: None

    def __call__(self, dir):
        return _skymaps.BandBackground___call__(self, dir)

    def average(self, dir, angle, tolerance):
        return _skymaps.BandBackground_average(self, dir, angle, tolerance)
    if _newclass:
        set_verbose = staticmethod(_skymaps.BandBackground_set_verbose)
    else:
        set_verbose = _skymaps.BandBackground_set_verbose

    def level_ave(self, dir, angle, level):
        return _skymaps.BandBackground_level_ave(self, dir, angle, level)
BandBackground_swigregister = _skymaps.BandBackground_swigregister
BandBackground_swigregister(BandBackground)

def BandBackground_set_verbose(q=True):
    return _skymaps.BandBackground_set_verbose(q)
BandBackground_set_verbose = _skymaps.BandBackground_set_verbose

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

    def __init__(self):
        this = _skymaps.new_SkyIntegrator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_SkyIntegrator
    __del__ = lambda self: None
    if _newclass:
        ap_int = staticmethod(_skymaps.SkyIntegrator_ap_int)
    else:
        ap_int = _skymaps.SkyIntegrator_ap_int
    if _newclass:
        average = staticmethod(_skymaps.SkyIntegrator_average)
    else:
        average = _skymaps.SkyIntegrator_average
    if _newclass:
        ss_average = staticmethod(_skymaps.SkyIntegrator_ss_average)
    else:
        ss_average = _skymaps.SkyIntegrator_ss_average
    if _newclass:
        level_ave = staticmethod(_skymaps.SkyIntegrator_level_ave)
    else:
        level_ave = _skymaps.SkyIntegrator_level_ave
    if _newclass:
        ss_level_ave = staticmethod(_skymaps.SkyIntegrator_ss_level_ave)
    else:
        ss_level_ave = _skymaps.SkyIntegrator_ss_level_ave
    if _newclass:
        nside_ave = staticmethod(_skymaps.SkyIntegrator_nside_ave)
    else:
        nside_ave = _skymaps.SkyIntegrator_nside_ave
    if _newclass:
        ss_nside_ave = staticmethod(_skymaps.SkyIntegrator_ss_nside_ave)
    else:
        ss_nside_ave = _skymaps.SkyIntegrator_ss_nside_ave
    if _newclass:
        pix_int = staticmethod(_skymaps.SkyIntegrator_pix_int)
    else:
        pix_int = _skymaps.SkyIntegrator_pix_int
    if _newclass:
        level_pix_int = staticmethod(_skymaps.SkyIntegrator_level_pix_int)
    else:
        level_pix_int = _skymaps.SkyIntegrator_level_pix_int
    if _newclass:
        set_simpson = staticmethod(_skymaps.SkyIntegrator_set_simpson)
    else:
        set_simpson = _skymaps.SkyIntegrator_set_simpson
    if _newclass:
        set_verbose = staticmethod(_skymaps.SkyIntegrator_set_verbose)
    else:
        set_verbose = _skymaps.SkyIntegrator_set_verbose
    if _newclass:
        set_tolerance = staticmethod(_skymaps.SkyIntegrator_set_tolerance)
    else:
        set_tolerance = _skymaps.SkyIntegrator_set_tolerance
    if _newclass:
        set_adaptive = staticmethod(_skymaps.SkyIntegrator_set_adaptive)
    else:
        set_adaptive = _skymaps.SkyIntegrator_set_adaptive
SkyIntegrator_swigregister = _skymaps.SkyIntegrator_swigregister
SkyIntegrator_swigregister(SkyIntegrator)

def SkyIntegrator_ap_int(func, center, radius):
    return _skymaps.SkyIntegrator_ap_int(func, center, radius)
SkyIntegrator_ap_int = _skymaps.SkyIntegrator_ap_int

def SkyIntegrator_average(func, dir, radius):
    return _skymaps.SkyIntegrator_average(func, dir, radius)
SkyIntegrator_average = _skymaps.SkyIntegrator_average

def SkyIntegrator_ss_average(func, dir, radius):
    return _skymaps.SkyIntegrator_ss_average(func, dir, radius)
SkyIntegrator_ss_average = _skymaps.SkyIntegrator_ss_average

def SkyIntegrator_level_ave(func, dir, radius, level):
    return _skymaps.SkyIntegrator_level_ave(func, dir, radius, level)
SkyIntegrator_level_ave = _skymaps.SkyIntegrator_level_ave

def SkyIntegrator_ss_level_ave(func, dir, radius, level):
    return _skymaps.SkyIntegrator_ss_level_ave(func, dir, radius, level)
SkyIntegrator_ss_level_ave = _skymaps.SkyIntegrator_ss_level_ave

def SkyIntegrator_nside_ave(func, dir, radius, nside):
    return _skymaps.SkyIntegrator_nside_ave(func, dir, radius, nside)
SkyIntegrator_nside_ave = _skymaps.SkyIntegrator_nside_ave

def SkyIntegrator_ss_nside_ave(func, dir, radius, nside):
    return _skymaps.SkyIntegrator_ss_nside_ave(func, dir, radius, nside)
SkyIntegrator_ss_nside_ave = _skymaps.SkyIntegrator_ss_nside_ave

def SkyIntegrator_pix_int(func, pix_center, nside):
    return _skymaps.SkyIntegrator_pix_int(func, pix_center, nside)
SkyIntegrator_pix_int = _skymaps.SkyIntegrator_pix_int

def SkyIntegrator_level_pix_int(func, pix_center, level):
    return _skymaps.SkyIntegrator_level_pix_int(func, pix_center, level)
SkyIntegrator_level_pix_int = _skymaps.SkyIntegrator_level_pix_int

def SkyIntegrator_set_simpson(n):
    return _skymaps.SkyIntegrator_set_simpson(n)
SkyIntegrator_set_simpson = _skymaps.SkyIntegrator_set_simpson

def SkyIntegrator_set_verbose(q=True):
    return _skymaps.SkyIntegrator_set_verbose(q)
SkyIntegrator_set_verbose = _skymaps.SkyIntegrator_set_verbose

def SkyIntegrator_set_tolerance(tol):
    return _skymaps.SkyIntegrator_set_tolerance(tol)
SkyIntegrator_set_tolerance = _skymaps.SkyIntegrator_set_tolerance

def SkyIntegrator_set_adaptive(q=True):
    return _skymaps.SkyIntegrator_set_adaptive(q)
SkyIntegrator_set_adaptive = _skymaps.SkyIntegrator_set_adaptive

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

    def __init__(self, name, relation, elem):
        this = _skymaps.new_ComplexSkySpectrum(name, relation, elem)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def insert(self, pos, component, norm=1.):
        return _skymaps.ComplexSkySpectrum_insert(self, pos, component, norm)

    def value(self, dir, energy):
        return _skymaps.ComplexSkySpectrum_value(self, dir, energy)

    def band_value(self, dir, band):
        return _skymaps.ComplexSkySpectrum_band_value(self, dir, band)

    def integral(self, dir, a, b):
        return _skymaps.ComplexSkySpectrum_integral(self, dir, a, b)

    def name(self):
        return _skymaps.ComplexSkySpectrum_name(self)

    def setName(self, name):
        return _skymaps.ComplexSkySpectrum_setName(self, name)
    __swig_destroy__ = _skymaps.delete_ComplexSkySpectrum
    __del__ = lambda self: None
ComplexSkySpectrum_swigregister = _skymaps.ComplexSkySpectrum_swigregister
ComplexSkySpectrum_swigregister(ComplexSkySpectrum)

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

    def __init__(self, *args, **kwargs):
        this = _skymaps.new_ExposureWeighter(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _skymaps.delete_ExposureWeighter
    __del__ = lambda self: None

    def __call__(self, c_lo, c_hi, e_lo, e_hi, event_class, dir):
        return _skymaps.ExposureWeighter___call__(self, c_lo, c_hi, e_lo, e_hi, event_class, dir)
ExposureWeighter_swigregister = _skymaps.ExposureWeighter_swigregister
ExposureWeighter_swigregister(ExposureWeighter)

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

    def __init__(self, c_lo, c_hi):
        this = _skymaps.new_TopHat(c_lo, c_hi)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __call__(self, costh):
        return _skymaps.TopHat___call__(self, costh)
    __swig_setmethods__["m_clo"] = _skymaps.TopHat_m_clo_set
    __swig_getmethods__["m_clo"] = _skymaps.TopHat_m_clo_get
    if _newclass:
        m_clo = _swig_property(_skymaps.TopHat_m_clo_get, _skymaps.TopHat_m_clo_set)
    __swig_setmethods__["m_chi"] = _skymaps.TopHat_m_chi_set
    __swig_getmethods__["m_chi"] = _skymaps.TopHat_m_chi_get
    if _newclass:
        m_chi = _swig_property(_skymaps.TopHat_m_chi_get, _skymaps.TopHat_m_chi_set)
    __swig_destroy__ = _skymaps.delete_TopHat
    __del__ = lambda self: None
TopHat_swigregister = _skymaps.TopHat_swigregister
TopHat_swigregister(TopHat)

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


